diff --git a/UnitTests/Philadelphia/structure-size-test.cpp b/UnitTests/Philadelphia/structure-size-test.cpp index 93986da7bf..7cccca5f60 100644 --- a/UnitTests/Philadelphia/structure-size-test.cpp +++ b/UnitTests/Philadelphia/structure-size-test.cpp @@ -67,7 +67,7 @@ BOOST_AUTO_TEST_CASE (tst_basic_elements) { BOOST_CHECK_EQUAL(8, sizeof(TRI_shape_size_t)); BOOST_CHECK_EQUAL(8, sizeof(TRI_voc_cid_t)); BOOST_CHECK_EQUAL(4, sizeof(TRI_voc_crc_t)); - BOOST_CHECK_EQUAL(8, sizeof(TRI_voc_eid_t)); + BOOST_CHECK_EQUAL(8, sizeof(TRI_voc_tid_t)); BOOST_CHECK_EQUAL(8, sizeof(TRI_voc_rid_t)); BOOST_CHECK_EQUAL(4, sizeof(TRI_voc_size_t)); BOOST_CHECK_EQUAL(8, sizeof(TRI_voc_tick_t)); @@ -174,7 +174,7 @@ BOOST_AUTO_TEST_CASE (tst_doc_document_key_marker) { BOOST_CHECK_EQUAL( 0, offsetof(struct TRI_doc_document_key_marker_s, base)); BOOST_CHECK_EQUAL(24, offsetof(struct TRI_doc_document_key_marker_s, _rid)); - BOOST_CHECK_EQUAL(32, offsetof(struct TRI_doc_document_key_marker_s, _sid)); + BOOST_CHECK_EQUAL(32, offsetof(struct TRI_doc_document_key_marker_s, _tid)); BOOST_CHECK_EQUAL(40, offsetof(struct TRI_doc_document_key_marker_s, _shape)); BOOST_CHECK_EQUAL(48, offsetof(struct TRI_doc_document_key_marker_s, _offsetKey)); BOOST_CHECK_EQUAL(50, offsetof(struct TRI_doc_document_key_marker_s, _offsetJson)); @@ -204,7 +204,7 @@ BOOST_AUTO_TEST_CASE (tst_doc_edge_key_marker) { BOOST_AUTO_TEST_CASE (tst_doc_begin_transaction_marker) { size_t s = sizeof(TRI_doc_begin_transaction_marker_t); - BOOST_CHECK_EQUAL(24 + 8, s); // base + own size + BOOST_CHECK_EQUAL(24 + 8 + 8, s); // base + own size BOOST_CHECK_EQUAL(true, s % 8 == 0); BOOST_CHECK_EQUAL( 0, offsetof(struct TRI_doc_begin_transaction_marker_s, base)); diff --git a/arangod/Ahuacatl/ahuacatl-access-optimiser.c b/arangod/Ahuacatl/ahuacatl-access-optimiser.c index c2516dca9e..09aaf3359d 100644 --- a/arangod/Ahuacatl/ahuacatl-access-optimiser.c +++ b/arangod/Ahuacatl/ahuacatl-access-optimiser.c @@ -236,8 +236,8 @@ static or_element_t* FindOrElement (const TRI_vector_pointer_t* const vector, const char* const name) { size_t i, n; - TRI_ASSERT_DEBUG(vector != NULL); - TRI_ASSERT_DEBUG(name != NULL); + TRI_ASSERT_MAINTAINER(vector != NULL); + TRI_ASSERT_MAINTAINER(name != NULL); n = vector->_length; for (i = 0; i < n; ++i) { @@ -245,7 +245,7 @@ static or_element_t* FindOrElement (const TRI_vector_pointer_t* const vector, current = (or_element_t*) TRI_AtVectorPointer(vector, i); - TRI_ASSERT_DEBUG(current != NULL); + TRI_ASSERT_MAINTAINER(current != NULL); if (TRI_EqualString(name, current->_name)) { return current; @@ -275,8 +275,8 @@ static bool InsertOrs (TRI_aql_context_t* const context, fieldAccess = (TRI_aql_field_access_t*) TRI_AtVectorPointer(source, i); - TRI_ASSERT_DEBUG(fieldAccess != NULL); - TRI_ASSERT_DEBUG(fieldAccess->_fullName != NULL); + TRI_ASSERT_MAINTAINER(fieldAccess != NULL); + TRI_ASSERT_MAINTAINER(fieldAccess->_fullName != NULL); orElement = FindOrElement(dest, fieldAccess->_fullName); if (orElement == NULL) { @@ -336,8 +336,8 @@ static bool InsertOrs (TRI_aql_context_t* const context, static void SetNameLength (TRI_aql_field_access_t* const fieldAccess) { char* dotPosition; - TRI_ASSERT_DEBUG(fieldAccess != NULL); - TRI_ASSERT_DEBUG(fieldAccess->_fullName != NULL); + TRI_ASSERT_MAINTAINER(fieldAccess != NULL); + TRI_ASSERT_MAINTAINER(fieldAccess->_fullName != NULL); dotPosition = strchr(fieldAccess->_fullName, '.'); if (dotPosition == NULL) { @@ -354,7 +354,7 @@ static void SetNameLength (TRI_aql_field_access_t* const fieldAccess) { //////////////////////////////////////////////////////////////////////////////// static void FreeAccessMembers (TRI_aql_field_access_t* const fieldAccess) { - TRI_ASSERT_DEBUG(fieldAccess != NULL); + TRI_ASSERT_MAINTAINER(fieldAccess != NULL); switch (fieldAccess->_type) { case TRI_AQL_ACCESS_EXACT: @@ -428,8 +428,8 @@ static TRI_aql_field_access_t* CreateFieldAccess (TRI_aql_context_t* const conte bool IsSameReference (const TRI_aql_field_access_t* const lhs, const TRI_aql_field_access_t* const rhs) { - TRI_ASSERT_DEBUG(lhs->_type == TRI_AQL_ACCESS_REFERENCE); - TRI_ASSERT_DEBUG(rhs->_type == TRI_AQL_ACCESS_REFERENCE); + TRI_ASSERT_MAINTAINER(lhs->_type == TRI_AQL_ACCESS_REFERENCE); + TRI_ASSERT_MAINTAINER(rhs->_type == TRI_AQL_ACCESS_REFERENCE); if (lhs->_value._reference._type == TRI_AQL_REFERENCE_VARIABLE && rhs->_value._reference._type == TRI_AQL_REFERENCE_VARIABLE) { @@ -469,7 +469,7 @@ static TRI_aql_field_access_t* MergeAndImpossible (TRI_aql_context_t* const cont TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { // impossible merged with anything just returns impossible - TRI_ASSERT_DEBUG(lhs->_type == TRI_AQL_ACCESS_IMPOSSIBLE); + TRI_ASSERT_MAINTAINER(lhs->_type == TRI_AQL_ACCESS_IMPOSSIBLE); TRI_FreeAccessAql(rhs); return lhs; @@ -485,7 +485,7 @@ static TRI_aql_field_access_t* MergeAndAll (TRI_aql_context_t* const context, TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { // all merged with anything just returns the other side - TRI_ASSERT_DEBUG(lhs->_type == TRI_AQL_ACCESS_ALL); + TRI_ASSERT_MAINTAINER(lhs->_type == TRI_AQL_ACCESS_ALL); TRI_FreeAccessAql(lhs); return rhs; @@ -501,7 +501,7 @@ static TRI_aql_field_access_t* MergeAndAll (TRI_aql_context_t* const context, static TRI_aql_field_access_t* MergeAndExact (TRI_aql_context_t* const context, TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { - TRI_ASSERT_DEBUG(lhs->_type == TRI_AQL_ACCESS_EXACT); + TRI_ASSERT_MAINTAINER(lhs->_type == TRI_AQL_ACCESS_EXACT); if (rhs->_type == TRI_AQL_ACCESS_EXACT) { // check if values are identical @@ -623,7 +623,7 @@ static TRI_aql_field_access_t* MergeAndExact (TRI_aql_context_t* const context, static TRI_aql_field_access_t* MergeAndList (TRI_aql_context_t* const context, TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { - TRI_ASSERT_DEBUG(lhs->_type == TRI_AQL_ACCESS_LIST); + TRI_ASSERT_MAINTAINER(lhs->_type == TRI_AQL_ACCESS_LIST); if (rhs->_type == TRI_AQL_ACCESS_LIST) { // make a list of both @@ -750,7 +750,7 @@ static TRI_aql_field_access_t* MergeAndList (TRI_aql_context_t* const context, static TRI_aql_field_access_t* MergeAndRangeSingle (TRI_aql_context_t* const context, TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { - TRI_ASSERT_DEBUG(lhs->_type == TRI_AQL_ACCESS_RANGE_SINGLE); + TRI_ASSERT_MAINTAINER(lhs->_type == TRI_AQL_ACCESS_RANGE_SINGLE); if (rhs->_type == TRI_AQL_ACCESS_RANGE_SINGLE) { TRI_json_t* lhsValue; @@ -1095,7 +1095,7 @@ static TRI_aql_field_access_t* MergeAndRangeDouble (TRI_aql_context_t* const con TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { - TRI_ASSERT_DEBUG(lhs->_type == TRI_AQL_ACCESS_RANGE_DOUBLE); + TRI_ASSERT_MAINTAINER(lhs->_type == TRI_AQL_ACCESS_RANGE_DOUBLE); if (rhs->_type == TRI_AQL_ACCESS_RANGE_DOUBLE) { int compareResult; @@ -1163,7 +1163,7 @@ static TRI_aql_field_access_t* MergeAndRangeDouble (TRI_aql_context_t* const con static TRI_aql_field_access_t* MergeAndReference (TRI_aql_context_t* const context, TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { - TRI_ASSERT_DEBUG(lhs->_type == TRI_AQL_ACCESS_REFERENCE); + TRI_ASSERT_MAINTAINER(lhs->_type == TRI_AQL_ACCESS_REFERENCE); if (rhs->_type == TRI_AQL_ACCESS_REFERENCE) { TRI_aql_node_type_e lhsType = lhs->_value._reference._operator; @@ -1269,7 +1269,7 @@ static TRI_aql_field_access_t* MergeOrImpossible (TRI_aql_context_t* const conte TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { // impossible merged with anything just returns the other side - TRI_ASSERT_DEBUG(lhs->_type == TRI_AQL_ACCESS_IMPOSSIBLE); + TRI_ASSERT_MAINTAINER(lhs->_type == TRI_AQL_ACCESS_IMPOSSIBLE); TRI_FreeAccessAql(lhs); return rhs; @@ -1285,7 +1285,7 @@ static TRI_aql_field_access_t* MergeOrAll (TRI_aql_context_t* const context, TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { // all merged with anything just returns all - TRI_ASSERT_DEBUG(lhs->_type == TRI_AQL_ACCESS_ALL); + TRI_ASSERT_MAINTAINER(lhs->_type == TRI_AQL_ACCESS_ALL); TRI_FreeAccessAql(rhs); return lhs; @@ -1301,7 +1301,7 @@ static TRI_aql_field_access_t* MergeOrAll (TRI_aql_context_t* const context, static TRI_aql_field_access_t* MergeOrExact (TRI_aql_context_t* const context, TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { - TRI_ASSERT_DEBUG(lhs->_type == TRI_AQL_ACCESS_EXACT); + TRI_ASSERT_MAINTAINER(lhs->_type == TRI_AQL_ACCESS_EXACT); if (rhs->_type == TRI_AQL_ACCESS_EXACT) { TRI_json_t* result; @@ -1448,7 +1448,7 @@ static TRI_aql_field_access_t* MergeOrExact (TRI_aql_context_t* const context, static TRI_aql_field_access_t* MergeOrList (TRI_aql_context_t* const context, TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { - TRI_ASSERT_DEBUG(lhs->_type == TRI_AQL_ACCESS_LIST); + TRI_ASSERT_MAINTAINER(lhs->_type == TRI_AQL_ACCESS_LIST); if (rhs->_type == TRI_AQL_ACCESS_LIST) { // make a list of both @@ -1494,7 +1494,7 @@ static TRI_aql_field_access_t* MergeOrList (TRI_aql_context_t* const context, static TRI_aql_field_access_t* MergeOrRangeSingle (TRI_aql_context_t* const context, TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { - TRI_ASSERT_DEBUG(lhs->_type == TRI_AQL_ACCESS_RANGE_SINGLE); + TRI_ASSERT_MAINTAINER(lhs->_type == TRI_AQL_ACCESS_RANGE_SINGLE); if (rhs->_type == TRI_AQL_ACCESS_RANGE_SINGLE) { TRI_aql_range_e lhsType; @@ -1594,7 +1594,7 @@ static TRI_aql_field_access_t* MergeOrRangeSingle (TRI_aql_context_t* const cont static TRI_aql_field_access_t* MergeOrRangeDouble (TRI_aql_context_t* const context, TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { - TRI_ASSERT_DEBUG(lhs->_type == TRI_AQL_ACCESS_RANGE_DOUBLE); + TRI_ASSERT_MAINTAINER(lhs->_type == TRI_AQL_ACCESS_RANGE_DOUBLE); if (rhs->_type == TRI_AQL_ACCESS_RANGE_DOUBLE) { int compareResult; @@ -1665,7 +1665,7 @@ static TRI_aql_field_access_t* MergeOrRangeDouble (TRI_aql_context_t* const cont static TRI_aql_field_access_t* MergeOrReference (TRI_aql_context_t* const context, TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { - TRI_ASSERT_DEBUG(lhs->_type == TRI_AQL_ACCESS_REFERENCE); + TRI_ASSERT_MAINTAINER(lhs->_type == TRI_AQL_ACCESS_REFERENCE); if (rhs->_type == TRI_AQL_ACCESS_REFERENCE) { TRI_aql_node_type_e lhsType = lhs->_value._reference._operator; @@ -1734,11 +1734,11 @@ static TRI_aql_field_access_t* MergeOrReference (TRI_aql_context_t* const contex static TRI_aql_field_access_t* MergeAttributeAccessAnd (TRI_aql_context_t* const context, TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { - TRI_ASSERT_DEBUG(context != NULL); - TRI_ASSERT_DEBUG(lhs != NULL); - TRI_ASSERT_DEBUG(rhs != NULL); - TRI_ASSERT_DEBUG(lhs->_fullName != NULL); - TRI_ASSERT_DEBUG(rhs->_fullName != NULL); + TRI_ASSERT_MAINTAINER(context != NULL); + TRI_ASSERT_MAINTAINER(lhs != NULL); + TRI_ASSERT_MAINTAINER(rhs != NULL); + TRI_ASSERT_MAINTAINER(lhs->_fullName != NULL); + TRI_ASSERT_MAINTAINER(rhs->_fullName != NULL); if (lhs->_type > rhs->_type) { // swap operands so they are always sorted @@ -1747,7 +1747,7 @@ static TRI_aql_field_access_t* MergeAttributeAccessAnd (TRI_aql_context_t* const rhs = tmp; } - TRI_ASSERT_DEBUG(lhs->_type <= rhs->_type); + TRI_ASSERT_MAINTAINER(lhs->_type <= rhs->_type); switch (lhs->_type) { case TRI_AQL_ACCESS_IMPOSSIBLE: @@ -1777,11 +1777,11 @@ static TRI_aql_field_access_t* MergeAttributeAccessAnd (TRI_aql_context_t* const static TRI_aql_field_access_t* MergeAttributeAccessOr (TRI_aql_context_t* const context, TRI_aql_field_access_t* lhs, TRI_aql_field_access_t* rhs) { - TRI_ASSERT_DEBUG(context != NULL); - TRI_ASSERT_DEBUG(lhs != NULL); - TRI_ASSERT_DEBUG(rhs != NULL); - TRI_ASSERT_DEBUG(lhs->_fullName != NULL); - TRI_ASSERT_DEBUG(rhs->_fullName != NULL); + TRI_ASSERT_MAINTAINER(context != NULL); + TRI_ASSERT_MAINTAINER(lhs != NULL); + TRI_ASSERT_MAINTAINER(rhs != NULL); + TRI_ASSERT_MAINTAINER(lhs->_fullName != NULL); + TRI_ASSERT_MAINTAINER(rhs->_fullName != NULL); if (lhs->_type > rhs->_type) { // swap operands so they are always sorted @@ -1790,7 +1790,7 @@ static TRI_aql_field_access_t* MergeAttributeAccessOr (TRI_aql_context_t* const rhs = tmp; } - TRI_ASSERT_DEBUG(lhs->_type <= rhs->_type); + TRI_ASSERT_MAINTAINER(lhs->_type <= rhs->_type); switch (lhs->_type) { case TRI_AQL_ACCESS_IMPOSSIBLE: @@ -1829,7 +1829,7 @@ static TRI_aql_field_access_t* MergeAttributeAccessOr (TRI_aql_context_t* const static TRI_vector_pointer_t* CreateEmptyVector (TRI_aql_context_t* const context) { TRI_vector_pointer_t* result; - TRI_ASSERT_DEBUG(context != NULL); + TRI_ASSERT_MAINTAINER(context != NULL); result = (TRI_vector_pointer_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_vector_pointer_t), false); @@ -1852,7 +1852,7 @@ static TRI_vector_pointer_t* Vectorize (TRI_aql_context_t* const context, TRI_aql_field_access_t* fieldAccess) { TRI_vector_pointer_t* vector; - TRI_ASSERT_DEBUG(context != NULL); + TRI_ASSERT_MAINTAINER(context != NULL); if (fieldAccess == NULL) { return NULL; @@ -1887,8 +1887,8 @@ static TRI_vector_pointer_t* MakeAllVector (TRI_aql_context_t* const context, // turn all field access values into an all items access TRI_aql_field_access_t* fieldAccess = (TRI_aql_field_access_t*) TRI_AtVectorPointer(fieldAccesses, i); - TRI_ASSERT_DEBUG(fieldAccess != NULL); - TRI_ASSERT_DEBUG(fieldAccess->_fullName != NULL); + TRI_ASSERT_MAINTAINER(fieldAccess != NULL); + TRI_ASSERT_MAINTAINER(fieldAccess->_fullName != NULL); // modify the element in place FreeAccessMembers(fieldAccess); @@ -1910,8 +1910,8 @@ static void MergeVector (TRI_aql_context_t* const context, const TRI_vector_pointer_t* const source) { size_t i, n; - TRI_ASSERT_DEBUG(result != NULL); - TRI_ASSERT_DEBUG(source != NULL); + TRI_ASSERT_MAINTAINER(result != NULL); + TRI_ASSERT_MAINTAINER(source != NULL); n = source->_length; for (i = 0; i < n; ++i) { @@ -1919,8 +1919,8 @@ static void MergeVector (TRI_aql_context_t* const context, size_t j, len; bool found = false; - TRI_ASSERT_DEBUG(fieldAccess != NULL); - TRI_ASSERT_DEBUG(fieldAccess->_fullName != NULL); + TRI_ASSERT_MAINTAINER(fieldAccess != NULL); + TRI_ASSERT_MAINTAINER(fieldAccess->_fullName != NULL); // check if element is in result vector already len = result->_length; @@ -1963,16 +1963,16 @@ static void InsertVector (TRI_aql_context_t* const context, const TRI_vector_pointer_t* const source) { size_t i, n; - TRI_ASSERT_DEBUG(result != NULL); - TRI_ASSERT_DEBUG(source != NULL); + TRI_ASSERT_MAINTAINER(result != NULL); + TRI_ASSERT_MAINTAINER(source != NULL); n = source->_length; for (i = 0; i < n; ++i) { TRI_aql_field_access_t* fieldAccess = (TRI_aql_field_access_t*) TRI_AtVectorPointer(source, i); TRI_aql_field_access_t* copy; - TRI_ASSERT_DEBUG(fieldAccess != NULL); - TRI_ASSERT_DEBUG(fieldAccess->_fullName != NULL); + TRI_ASSERT_MAINTAINER(fieldAccess != NULL); + TRI_ASSERT_MAINTAINER(fieldAccess->_fullName != NULL); copy = TRI_CloneAccessAql(context, fieldAccess); @@ -1998,8 +1998,8 @@ static TRI_vector_pointer_t* MergeVectors (TRI_aql_context_t* const context, TRI_vector_pointer_t* result; TRI_vector_pointer_t* orElements; - TRI_ASSERT_DEBUG(context != NULL); - TRI_ASSERT_DEBUG(mergeType == TRI_AQL_NODE_OPERATOR_BINARY_AND || mergeType == TRI_AQL_NODE_OPERATOR_BINARY_OR); + TRI_ASSERT_MAINTAINER(context != NULL); + TRI_ASSERT_MAINTAINER(mergeType == TRI_AQL_NODE_OPERATOR_BINARY_AND || mergeType == TRI_AQL_NODE_OPERATOR_BINARY_OR); // first check if we can get away without copying/merging the vectors if (inheritedRestrictions == NULL) { @@ -2084,7 +2084,7 @@ static TRI_vector_pointer_t* MergeVectors (TRI_aql_context_t* const context, or_element_t* orElement; fieldAccess = (TRI_aql_field_access_t*) TRI_AtVectorPointer(result, i); - TRI_ASSERT_DEBUG(fieldAccess != NULL); + TRI_ASSERT_MAINTAINER(fieldAccess != NULL); if (fieldAccess->_type == TRI_AQL_ACCESS_ALL) { continue; @@ -2103,7 +2103,7 @@ static TRI_vector_pointer_t* MergeVectors (TRI_aql_context_t* const context, or_element_t* orElement; orElement = (or_element_t*) TRI_AtVectorPointer(orElements, i); - TRI_ASSERT_DEBUG(orElement != NULL); + TRI_ASSERT_MAINTAINER(orElement != NULL); // free members TRI_FreeString(TRI_UNKNOWN_MEM_ZONE, orElement->_name); @@ -2141,10 +2141,10 @@ static TRI_aql_field_access_t* CreateAccessForNode (TRI_aql_context_t* const con TRI_aql_field_access_t* fieldAccess; TRI_json_t* value; - TRI_ASSERT_DEBUG(context != NULL); - TRI_ASSERT_DEBUG(field != NULL); - TRI_ASSERT_DEBUG(field->_name._buffer != NULL); - TRI_ASSERT_DEBUG(node != NULL); + TRI_ASSERT_MAINTAINER(context != NULL); + TRI_ASSERT_MAINTAINER(field != NULL); + TRI_ASSERT_MAINTAINER(field->_name._buffer != NULL); + TRI_ASSERT_MAINTAINER(node != NULL); fieldAccess = (TRI_aql_field_access_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_field_access_t), false); if (fieldAccess == NULL) { @@ -2227,7 +2227,7 @@ static TRI_aql_field_access_t* CreateAccessForNode (TRI_aql_context_t* const con else if (operator == TRI_AQL_NODE_OPERATOR_BINARY_IN) { TRI_json_t* list; - TRI_ASSERT_DEBUG(value->_type == TRI_JSON_LIST); + TRI_ASSERT_MAINTAINER(value->_type == TRI_JSON_LIST); // create a list access fieldAccess->_type = TRI_AQL_ACCESS_LIST; @@ -2266,8 +2266,8 @@ static TRI_aql_field_access_t* GetAttributeAccess (TRI_aql_context_t* const cont const TRI_aql_node_t* const node) { TRI_aql_field_access_t* fieldAccess; - TRI_ASSERT_DEBUG(context != NULL); - TRI_ASSERT_DEBUG(node != NULL); + TRI_ASSERT_MAINTAINER(context != NULL); + TRI_ASSERT_MAINTAINER(node != NULL); if (field == NULL || ! field->_name._buffer) { // this is ok if the node type is not supported @@ -2291,8 +2291,8 @@ static TRI_aql_field_access_t* GetAttributeAccess (TRI_aql_context_t* const cont static TRI_aql_attribute_name_t* GetAttributeName (TRI_aql_context_t* const context, const TRI_aql_node_t* const node) { - TRI_ASSERT_DEBUG(context != NULL); - TRI_ASSERT_DEBUG(node != NULL); + TRI_ASSERT_MAINTAINER(context != NULL); + TRI_ASSERT_MAINTAINER(node != NULL); if (node->_type == TRI_AQL_NODE_ATTRIBUTE_ACCESS) { TRI_aql_attribute_name_t* field = GetAttributeName(context, TRI_AQL_NODE_MEMBER(node, 0)); @@ -2362,13 +2362,13 @@ static TRI_vector_pointer_t* ProcessNode (TRI_aql_context_t* const context, TRI_aql_node_t* node, bool* changed, const TRI_vector_pointer_t* const inheritedRestrictions) { - TRI_ASSERT_DEBUG(context != NULL); - TRI_ASSERT_DEBUG(node != NULL); + TRI_ASSERT_MAINTAINER(context != NULL); + TRI_ASSERT_MAINTAINER(node != NULL); if (node->_type == TRI_AQL_NODE_OPERATOR_UNARY_NOT) { TRI_aql_node_t* lhs = TRI_AQL_NODE_MEMBER(node, 0); - TRI_ASSERT_DEBUG(lhs != NULL); + TRI_ASSERT_MAINTAINER(lhs != NULL); // can ignore inherited restrictions here return MakeAllVector(context, ProcessNode(context, lhs, changed, NULL)); @@ -2380,8 +2380,8 @@ static TRI_vector_pointer_t* ProcessNode (TRI_aql_context_t* const context, TRI_aql_node_t* rhs = TRI_AQL_NODE_MEMBER(node, 1); TRI_vector_pointer_t* result; - TRI_ASSERT_DEBUG(lhs != NULL); - TRI_ASSERT_DEBUG(rhs != NULL); + TRI_ASSERT_MAINTAINER(lhs != NULL); + TRI_ASSERT_MAINTAINER(rhs != NULL); // recurse into next level result = MergeVectors(context, @@ -2449,7 +2449,7 @@ static TRI_vector_pointer_t* ProcessNode (TRI_aql_context_t* const context, node2 = lhs; operator = TRI_ReverseOperatorRelationalAql(node->_type); - TRI_ASSERT_DEBUG(operator != TRI_AQL_NODE_NOP); + TRI_ASSERT_MAINTAINER(operator != TRI_AQL_NODE_NOP); if (lhs->_type == TRI_AQL_NODE_REFERENCE || lhs->_type == TRI_AQL_NODE_ATTRIBUTE_ACCESS || lhs->_type == TRI_AQL_NODE_FCALL) { // expression of type reference|attribute access|fcall operator reference|attribute access|fcall @@ -2575,7 +2575,7 @@ bool TRI_ContainsImpossibleAql (const TRI_vector_pointer_t* const fieldAccesses) for (i = 0; i < n; ++i) { TRI_aql_field_access_t* fieldAccess = (TRI_aql_field_access_t*) TRI_AtVectorPointer(fieldAccesses, i); - TRI_ASSERT_DEBUG(fieldAccess != NULL); + TRI_ASSERT_MAINTAINER(fieldAccess != NULL); if (fieldAccess->_type == TRI_AQL_ACCESS_IMPOSSIBLE) { // impossible range found @@ -2614,7 +2614,7 @@ TRI_vector_pointer_t* TRI_CloneAccessesAql (TRI_aql_context_t* const context, //////////////////////////////////////////////////////////////////////////////// void TRI_FreeAccessAql (TRI_aql_field_access_t* const fieldAccess) { - TRI_ASSERT_DEBUG(fieldAccess != NULL); + TRI_ASSERT_MAINTAINER(fieldAccess != NULL); FreeAccessMembers(fieldAccess); TRI_Free(TRI_UNKNOWN_MEM_ZONE, fieldAccess->_fullName); @@ -2629,8 +2629,8 @@ TRI_aql_field_access_t* TRI_CloneAccessAql (TRI_aql_context_t* const context, TRI_aql_field_access_t* const source) { TRI_aql_field_access_t* fieldAccess; - TRI_ASSERT_DEBUG(source != NULL); - TRI_ASSERT_DEBUG(source->_fullName != NULL); + TRI_ASSERT_MAINTAINER(source != NULL); + TRI_ASSERT_MAINTAINER(source->_fullName != NULL); fieldAccess = CreateFieldAccess(context, source->_type, source->_fullName); if (fieldAccess == NULL) { @@ -2771,9 +2771,9 @@ TRI_vector_pointer_t* TRI_AddAccessAql (TRI_aql_context_t* const context, size_t i, n; bool found; - TRI_ASSERT_DEBUG(context != NULL); - TRI_ASSERT_DEBUG(candidate != NULL); - TRI_ASSERT_DEBUG(candidate->_fullName != NULL); + TRI_ASSERT_MAINTAINER(context != NULL); + TRI_ASSERT_MAINTAINER(candidate != NULL); + TRI_ASSERT_MAINTAINER(candidate->_fullName != NULL); if (previous != NULL) { // use existing vector if already available @@ -2788,7 +2788,7 @@ TRI_vector_pointer_t* TRI_AddAccessAql (TRI_aql_context_t* const context, } } - TRI_ASSERT_DEBUG(accesses != NULL); + TRI_ASSERT_MAINTAINER(accesses != NULL); found = false; n = accesses->_length; @@ -2809,7 +2809,7 @@ TRI_vector_pointer_t* TRI_AddAccessAql (TRI_aql_context_t* const context, TRI_aql_field_access_t* copy; // free existing field access - TRI_ASSERT_DEBUG(existing != NULL); + TRI_ASSERT_MAINTAINER(existing != NULL); TRI_FreeAccessAql(existing); copy = TRI_CloneAccessAql(context, candidate); if (copy == NULL) { diff --git a/arangod/Ahuacatl/ahuacatl-context.c b/arangod/Ahuacatl/ahuacatl-context.c index 13040f042e..618b4dc9c7 100644 --- a/arangod/Ahuacatl/ahuacatl-context.c +++ b/arangod/Ahuacatl/ahuacatl-context.c @@ -167,8 +167,8 @@ TRI_aql_context_t* TRI_CreateContextAql (TRI_vocbase_t* vocbase, const char* const query) { TRI_aql_context_t* context; - TRI_ASSERT_DEBUG(vocbase != NULL); - TRI_ASSERT_DEBUG(query != NULL); + TRI_ASSERT_MAINTAINER(vocbase != NULL); + TRI_ASSERT_MAINTAINER(query != NULL); LOG_TRACE("creating context"); @@ -248,7 +248,7 @@ TRI_aql_context_t* TRI_CreateContextAql (TRI_vocbase_t* vocbase, //////////////////////////////////////////////////////////////////////////////// void TRI_FreeContextAql (TRI_aql_context_t* const context) { - TRI_ASSERT_DEBUG(context != NULL); + TRI_ASSERT_MAINTAINER(context != NULL); LOG_TRACE("freeing context"); @@ -388,8 +388,8 @@ bool TRI_SetupCollectionsContextAql (TRI_aql_context_t* const context) { bool TRI_RegisterNodeContextAql (TRI_aql_context_t* const context, void* const node) { - TRI_ASSERT_DEBUG(context != NULL); - TRI_ASSERT_DEBUG(node != NULL); + TRI_ASSERT_MAINTAINER(context != NULL); + TRI_ASSERT_MAINTAINER(node != NULL); TRI_PushBackVectorPointer(&context->_memory._nodes, node); @@ -436,8 +436,8 @@ void TRI_SetErrorContextAql (TRI_aql_context_t* const context, const int code, const char* const data) { - TRI_ASSERT_DEBUG(context != NULL); - TRI_ASSERT_DEBUG(code > 0); + TRI_ASSERT_MAINTAINER(context != NULL); + TRI_ASSERT_MAINTAINER(code > 0); if (context->_error._code == 0) { // do not overwrite previous error diff --git a/arangod/Ahuacatl/ahuacatl-functions.c b/arangod/Ahuacatl/ahuacatl-functions.c index 4054b8cc51..fd2c19bc13 100644 --- a/arangod/Ahuacatl/ahuacatl-functions.c +++ b/arangod/Ahuacatl/ahuacatl-functions.c @@ -28,6 +28,7 @@ #include "Ahuacatl/ahuacatl-functions.h" #include "BasicsC/associative.h" +#include "BasicsC/hashes.h" #include "BasicsC/logging.h" #include "BasicsC/tri-strings.h" diff --git a/arangod/Ahuacatl/ahuacatl-node.c b/arangod/Ahuacatl/ahuacatl-node.c index bdafcf0ab1..6ece426c18 100644 --- a/arangod/Ahuacatl/ahuacatl-node.c +++ b/arangod/Ahuacatl/ahuacatl-node.c @@ -202,7 +202,7 @@ bool TRI_IsListNodeAql (const TRI_aql_node_t* const node) { //////////////////////////////////////////////////////////////////////////////// bool TRI_IsConstantValueNodeAql (const TRI_aql_node_t* const node) { - TRI_ASSERT_DEBUG(node != NULL); + TRI_ASSERT_MAINTAINER(node != NULL); if (node->_type != TRI_AQL_NODE_VALUE && node->_type != TRI_AQL_NODE_LIST && @@ -246,7 +246,7 @@ bool TRI_IsConstantValueNodeAql (const TRI_aql_node_t* const node) { //////////////////////////////////////////////////////////////////////////////// bool TRI_IsNumericValueNodeAql (const TRI_aql_node_t* const node) { - TRI_ASSERT_DEBUG(node != NULL); + TRI_ASSERT_MAINTAINER(node != NULL); if (node->_type != TRI_AQL_NODE_VALUE) { return false; @@ -261,7 +261,7 @@ bool TRI_IsNumericValueNodeAql (const TRI_aql_node_t* const node) { //////////////////////////////////////////////////////////////////////////////// bool TRI_IsBooleanValueNodeAql (const TRI_aql_node_t* const node) { - TRI_ASSERT_DEBUG(node != NULL); + TRI_ASSERT_MAINTAINER(node != NULL); return (node->_type == TRI_AQL_NODE_VALUE && node->_value._type == TRI_AQL_TYPE_BOOL); } diff --git a/arangod/Utils/AhuacatlTransaction.h b/arangod/Utils/AhuacatlTransaction.h index 350c5b5575..e21fa6754b 100644 --- a/arangod/Utils/AhuacatlTransaction.h +++ b/arangod/Utils/AhuacatlTransaction.h @@ -75,11 +75,11 @@ namespace triagens { for (size_t i = 0; i < n; ++i) { TRI_aql_collection_t* collection = (TRI_aql_collection_t*) TRI_AtVectorPointer(collections, i); - TRI_transaction_cid_t cid = 0; + TRI_voc_cid_t cid = 0; TRI_vocbase_col_t const* col = resolver.getCollectionStruct(collection->_name); if (col != 0) { - cid = (TRI_transaction_cid_t) col->_cid; + cid = col->_cid; } int res = this->addCollection(cid, TRI_TRANSACTION_READ); diff --git a/arangod/Utils/SingleCollectionReadOnlyTransaction.h b/arangod/Utils/SingleCollectionReadOnlyTransaction.h index 954465ec7a..53f6683b9d 100644 --- a/arangod/Utils/SingleCollectionReadOnlyTransaction.h +++ b/arangod/Utils/SingleCollectionReadOnlyTransaction.h @@ -65,7 +65,7 @@ namespace triagens { SingleCollectionReadOnlyTransaction (struct TRI_vocbase_s* const vocbase, const triagens::arango::CollectionNameResolver& resolver, - const TRI_transaction_cid_t cid) : + const TRI_voc_cid_t cid) : SingleCollectionTransaction(vocbase, resolver, cid, TRI_TRANSACTION_READ) { } diff --git a/arangod/Utils/SingleCollectionTransaction.h b/arangod/Utils/SingleCollectionTransaction.h index dcd5cdb1e9..a0e8e821d8 100644 --- a/arangod/Utils/SingleCollectionTransaction.h +++ b/arangod/Utils/SingleCollectionTransaction.h @@ -30,16 +30,16 @@ #include "BasicsC/common.h" +#include "BasicsC/voc-errors.h" +#include "Basics/StringUtils.h" +#include "Logger/Logger.h" +#include "Utils/Transaction.h" + #include "VocBase/barrier.h" #include "VocBase/primary-collection.h" #include "VocBase/transaction.h" #include "VocBase/vocbase.h" -#include "BasicsC/voc-errors.h" - -#include "Basics/StringUtils.h" -#include "Logger/Logger.h" - -#include "Utils/Transaction.h" +#include "VocBase/voc-types.h" namespace triagens { namespace arango { @@ -71,7 +71,7 @@ namespace triagens { SingleCollectionTransaction (TRI_vocbase_t* const vocbase, const triagens::arango::CollectionNameResolver& resolver, - const TRI_transaction_cid_t cid, + const TRI_voc_cid_t cid, const TRI_transaction_type_e accessType) : Transaction(vocbase, resolver), _cid(cid), @@ -108,11 +108,11 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// inline TRI_transaction_collection_t* trxCollection () { - TRI_ASSERT_DEBUG(_cid > 0); + TRI_ASSERT_MAINTAINER(_cid > 0); TRI_transaction_collection_t* trxCollection = TRI_GetCollectionTransaction(this->_trx, this->_cid, _accessType); - TRI_ASSERT_DEBUG(trxCollection != 0); + TRI_ASSERT_MAINTAINER(trxCollection != 0); return trxCollection; } @@ -123,9 +123,9 @@ namespace triagens { inline TRI_primary_collection_t* primaryCollection () { TRI_transaction_collection_t* trxCollection = this->trxCollection(); - TRI_ASSERT_DEBUG(trxCollection != 0); - TRI_ASSERT_DEBUG(trxCollection->_collection != 0); - TRI_ASSERT_DEBUG(trxCollection->_collection->_collection != 0); + TRI_ASSERT_MAINTAINER(trxCollection != 0); + TRI_ASSERT_MAINTAINER(trxCollection->_collection != 0); + TRI_ASSERT_MAINTAINER(trxCollection->_collection->_collection != 0); return trxCollection->_collection->_collection; } @@ -210,7 +210,7 @@ namespace triagens { /// @brief collection id //////////////////////////////////////////////////////////////////////////////// - TRI_transaction_cid_t _cid; + TRI_voc_cid_t _cid; //////////////////////////////////////////////////////////////////////////////// /// @brief collection access type diff --git a/arangod/Utils/SingleCollectionWriteTransaction.h b/arangod/Utils/SingleCollectionWriteTransaction.h index f44b997ba9..631e24b6cd 100644 --- a/arangod/Utils/SingleCollectionWriteTransaction.h +++ b/arangod/Utils/SingleCollectionWriteTransaction.h @@ -34,6 +34,7 @@ #include "ShapedJson/shaped-json.h" #include "VocBase/transaction.h" #include "VocBase/vocbase.h" +#include "VocBase/voc-types.h" namespace triagens { namespace arango { @@ -70,7 +71,7 @@ namespace triagens { SingleCollectionWriteTransaction (TRI_vocbase_t* const vocbase, const triagens::arango::CollectionNameResolver& resolver, - const TRI_transaction_cid_t cid) : + const TRI_voc_cid_t cid) : SingleCollectionTransaction(vocbase, resolver, cid, TRI_TRANSACTION_WRITE), _numWrites(0) { diff --git a/arangod/Utils/Transaction.h b/arangod/Utils/Transaction.h index 20f7f199f2..9eb017dc19 100644 --- a/arangod/Utils/Transaction.h +++ b/arangod/Utils/Transaction.h @@ -96,7 +96,7 @@ namespace triagens { _vocbase(vocbase), _resolver(resolver) { - TRI_ASSERT_DEBUG(_vocbase != 0); + TRI_ASSERT_MAINTAINER(_vocbase != 0); this->setupTransaction(); } @@ -257,10 +257,10 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// TRI_primary_collection_t* primaryCollection (TRI_transaction_collection_t const* trxCollection) const { - TRI_ASSERT_DEBUG(_trx != 0); - TRI_ASSERT_DEBUG(getStatus() == TRI_TRANSACTION_RUNNING); - TRI_ASSERT_DEBUG(trxCollection->_collection != 0); - TRI_ASSERT_DEBUG(trxCollection->_collection->_collection != 0); + TRI_ASSERT_MAINTAINER(_trx != 0); + TRI_ASSERT_MAINTAINER(getStatus() == TRI_TRANSACTION_RUNNING); + TRI_ASSERT_MAINTAINER(trxCollection->_collection != 0); + TRI_ASSERT_MAINTAINER(trxCollection->_collection->_collection != 0); return trxCollection->_collection->_collection; } @@ -270,10 +270,10 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// TRI_shaper_t* shaper (TRI_transaction_collection_t const* trxCollection) const { - TRI_ASSERT_DEBUG(_trx != 0); - TRI_ASSERT_DEBUG(getStatus() == TRI_TRANSACTION_RUNNING); - TRI_ASSERT_DEBUG(trxCollection->_collection != 0); - TRI_ASSERT_DEBUG(trxCollection->_collection->_collection != 0); + TRI_ASSERT_MAINTAINER(_trx != 0); + TRI_ASSERT_MAINTAINER(getStatus() == TRI_TRANSACTION_RUNNING); + TRI_ASSERT_MAINTAINER(trxCollection->_collection != 0); + TRI_ASSERT_MAINTAINER(trxCollection->_collection->_collection != 0); return trxCollection->_collection->_collection->_shaper; } @@ -282,7 +282,7 @@ namespace triagens { /// @brief add a collection by id //////////////////////////////////////////////////////////////////////////////// - int addCollection (TRI_transaction_cid_t cid, + int addCollection (TRI_voc_cid_t cid, TRI_transaction_type_e type) { if (_trx == 0) { return registerError(TRI_ERROR_INTERNAL); @@ -802,13 +802,13 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// int registerError (int errorNum) { - TRI_ASSERT_DEBUG(errorNum != TRI_ERROR_NO_ERROR); + TRI_ASSERT_MAINTAINER(errorNum != TRI_ERROR_NO_ERROR); if (_setupState == TRI_ERROR_NO_ERROR) { _setupState = errorNum; } - TRI_ASSERT_DEBUG(_setupState != TRI_ERROR_NO_ERROR); + TRI_ASSERT_MAINTAINER(_setupState != TRI_ERROR_NO_ERROR); return errorNum; } @@ -818,7 +818,7 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// int addCollectionEmbedded (TRI_voc_cid_t cid, TRI_transaction_type_e type) { - TRI_ASSERT_DEBUG(_trx != 0); + TRI_ASSERT_MAINTAINER(_trx != 0); int res = TRI_AddCollectionTransaction(_trx, cid, type, _nestingLevel); @@ -834,7 +834,7 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// int addCollectionToplevel (TRI_voc_cid_t cid, TRI_transaction_type_e type) { - TRI_ASSERT_DEBUG(_trx != 0); + TRI_ASSERT_MAINTAINER(_trx != 0); int res; @@ -881,7 +881,7 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// int setupEmbedded () { - TRI_ASSERT_DEBUG(_nestingLevel == 0); + TRI_ASSERT_MAINTAINER(_nestingLevel == 0); _nestingLevel = ++_trx->_nestingLevel; @@ -900,7 +900,7 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// int setupToplevel () { - TRI_ASSERT_DEBUG(_nestingLevel == 0); + TRI_ASSERT_MAINTAINER(_nestingLevel == 0); // we are not embedded. now start our own transaction _trx = TRI_CreateTransaction(_vocbase->_transactionContext); @@ -918,7 +918,7 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// int freeTransaction () { - TRI_ASSERT_DEBUG(! isEmbeddedTransaction()); + TRI_ASSERT_MAINTAINER(! isEmbeddedTransaction()); if (_trx != 0) { this->unregisterTransaction(); diff --git a/arangod/V8Server/v8-vocbase.cpp b/arangod/V8Server/v8-vocbase.cpp index bd72922af9..4e3b549dd3 100644 --- a/arangod/V8Server/v8-vocbase.cpp +++ b/arangod/V8Server/v8-vocbase.cpp @@ -2766,7 +2766,7 @@ static v8::Handle JS_UpgradeVocbaseCol (v8::Arguments const& argv) { voc_did_t _did; // this is the tick for a create, but not an update TRI_voc_rid_t _rid; // this is the tick for an create and update - TRI_voc_eid_t _sid; + TRI_voc_tid_t _sid; TRI_shape_sid_t _shape; } @@ -2788,7 +2788,7 @@ static v8::Handle JS_UpgradeVocbaseCol (v8::Arguments const& argv) { voc_did_t _did; // this is the tick for a create, but not an update TRI_voc_rid_t _rid; // this is the tick for an create and update - TRI_voc_eid_t _sid; + TRI_voc_tid_t _sid; } doc_deletion_marker_t_deprecated; @@ -2962,7 +2962,7 @@ static v8::Handle JS_UpgradeVocbaseCol (v8::Arguments const& argv) { TRI_CopyString(keyBody, didBuffer, keySize); newMarker._rid = oldMarker->_rid; - newMarker._sid = oldMarker->_sid; + newMarker._tid = 0; newMarker._shape = oldMarker->_shape; newMarker._offsetKey = newMarkerSize; newMarker._offsetJson = newMarkerSize + keyBodySize; @@ -3022,7 +3022,7 @@ static v8::Handle JS_UpgradeVocbaseCol (v8::Arguments const& argv) { TRI_CopyString(keyBody + keySize + toSize, fromDidBuffer, fromSize); newMarker.base._rid = oldMarker->base._rid; - newMarker.base._sid = oldMarker->base._sid; + newMarker.base._tid = 0; newMarker.base._shape = oldMarker->base._shape; newMarker.base._offsetKey = newMarkerSize; newMarker.base._offsetJson = newMarkerSize + keyBodySize; @@ -3071,7 +3071,7 @@ static v8::Handle JS_UpgradeVocbaseCol (v8::Arguments const& argv) { TRI_CopyString(keyBody, didBuffer, keySize); newMarker._rid = oldMarker->_rid; - newMarker._sid = oldMarker->_sid; + newMarker._tid = 0; newMarker._offsetKey = newMarkerSize; newMarker.base._size = newMarkerSize + keyBodySize; diff --git a/arangod/VocBase/datafile.h b/arangod/VocBase/datafile.h index f48d2e0c5d..9687cbe013 100644 --- a/arangod/VocBase/datafile.h +++ b/arangod/VocBase/datafile.h @@ -166,15 +166,15 @@ typedef enum { TRI_DOC_MARKER_HEADER = 3000, TRI_DOC_MARKER_DOCUMENT = 3001, TRI_DOC_MARKER_DELETION = 3002, - TRI_DOC_MARKER_BEGIN_TRANSACTION = 3003, // currently unused - TRI_DOC_MARKER_COMMIT_TRANSACTION = 3004, // currently unused - TRI_DOC_MARKER_ABORT_TRANSACTION = 3005, // currently unused TRI_DOC_MARKER_EDGE = 3006, TRI_DOC_MARKER_KEY_DOCUMENT = 3007, // new marker with key values TRI_DOC_MARKER_KEY_EDGE = 3008, // new marker with key values TRI_DOC_MARKER_KEY_DELETION = 3009, // new marker with key values + TRI_DOC_MARKER_BEGIN_TRANSACTION = 3100, + TRI_DOC_MARKER_COMMIT_TRANSACTION = 3101, + TRI_DOC_MARKER_ABORT_TRANSACTION = 3102, TRI_MARKER_MAX // again, this is not a real // marker, but we use it for diff --git a/arangod/VocBase/document-collection.c b/arangod/VocBase/document-collection.c index c3b2ef4034..4f5d1e6fd7 100644 --- a/arangod/VocBase/document-collection.c +++ b/arangod/VocBase/document-collection.c @@ -99,9 +99,9 @@ static int InsertPrimaryIndex (TRI_document_collection_t* document, TRI_primary_collection_t* primary; TRI_doc_mptr_t* found; - TRI_ASSERT_DEBUG(document != NULL); - TRI_ASSERT_DEBUG(header != NULL); - TRI_ASSERT_DEBUG(header->_key != NULL); + TRI_ASSERT_MAINTAINER(document != NULL); + TRI_ASSERT_MAINTAINER(header != NULL); + TRI_ASSERT_MAINTAINER(header->_key != NULL); if (header->_validTo != 0) { // don't insert in case the document is deleted @@ -280,16 +280,17 @@ static void IncreaseDocumentCount (TRI_primary_collection_t* primary) { //////////////////////////////////////////////////////////////////////////////// static void DecreaseDocumentCount (TRI_primary_collection_t* primary) { - TRI_ASSERT_DEBUG(primary->_numberDocuments > 0); + TRI_ASSERT_MAINTAINER(primary->_numberDocuments > 0); primary->_numberDocuments--; } //////////////////////////////////////////////////////////////////////////////// -/// @brief creates a new document or edge marker in memory +/// @brief creates a new deletion marker in memory //////////////////////////////////////////////////////////////////////////////// -static int CreateDeletionMarker (TRI_doc_deletion_key_marker_t** result, +static int CreateDeletionMarker (TRI_voc_tid_t tid, + TRI_doc_deletion_key_marker_t** result, TRI_voc_size_t* totalSize, char* keyBody, TRI_voc_size_t keyBodySize) { @@ -305,7 +306,8 @@ static int CreateDeletionMarker (TRI_doc_deletion_key_marker_t** result, TRI_InitMarker(&marker->base, TRI_DOC_MARKER_KEY_DELETION, *totalSize, TRI_NewTickVocBase()); - marker->_sid = 0; + // note: the transaction id is 0 for standalone operations + marker->_tid = tid; marker->_offsetKey = sizeof(TRI_doc_deletion_key_marker_t); // copy the key into the marker @@ -321,7 +323,8 @@ static int CreateDeletionMarker (TRI_doc_deletion_key_marker_t** result, /// existing marker //////////////////////////////////////////////////////////////////////////////// -static int CloneDocumentMarker (TRI_df_marker_t const* original, +static int CloneDocumentMarker (TRI_voc_tid_t tid, + TRI_df_marker_t const* original, TRI_doc_document_key_marker_t** result, TRI_voc_size_t* totalSize, const TRI_df_marker_type_e markerType, @@ -344,14 +347,14 @@ static int CloneDocumentMarker (TRI_df_marker_t const* original, TRI_doc_document_key_marker_t const* o = (TRI_doc_document_key_marker_t const*) original; baseLength = o->_offsetJson; - TRI_ASSERT_DEBUG(baseLength > sizeof(TRI_doc_document_key_marker_t)); + TRI_ASSERT_MAINTAINER(baseLength > sizeof(TRI_doc_document_key_marker_t)); } else if (markerType == TRI_DOC_MARKER_KEY_EDGE) { // edge marker TRI_doc_edge_key_marker_t const* o = (TRI_doc_edge_key_marker_t const*) original; baseLength = o->base._offsetJson; - TRI_ASSERT_DEBUG(baseLength > sizeof(TRI_doc_edge_key_marker_t)); + TRI_ASSERT_MAINTAINER(baseLength > sizeof(TRI_doc_edge_key_marker_t)); } else { // invalid marker type @@ -373,6 +376,7 @@ static int CloneDocumentMarker (TRI_df_marker_t const* original, TRI_CloneMarker(&marker->base, original, baseLength, *totalSize, tick); marker->_rid = tick; + marker->_tid = tid; marker->_shape = shaped->_sid; // copy shaped json into the marker @@ -382,17 +386,17 @@ static int CloneDocumentMarker (TRI_df_marker_t const* original, #ifdef TRI_ENABLE_MAINTAINER_MODE - TRI_ASSERT_DEBUG(marker->_offsetKey == ((TRI_doc_document_key_marker_t const*) original)->_offsetKey); - TRI_ASSERT_DEBUG(marker->_offsetJson == ((TRI_doc_document_key_marker_t const*) original)->_offsetJson); + TRI_ASSERT_MAINTAINER(marker->_offsetKey == ((TRI_doc_document_key_marker_t const*) original)->_offsetKey); + TRI_ASSERT_MAINTAINER(marker->_offsetJson == ((TRI_doc_document_key_marker_t const*) original)->_offsetJson); if (markerType == TRI_DOC_MARKER_KEY_EDGE) { TRI_doc_edge_key_marker_t const* o = (TRI_doc_edge_key_marker_t const*) original; TRI_doc_edge_key_marker_t const* c = (TRI_doc_edge_key_marker_t const*) marker; - TRI_ASSERT_DEBUG(c->_toCid == o->_toCid); - TRI_ASSERT_DEBUG(c->_fromCid == o->_fromCid); - TRI_ASSERT_DEBUG(c->_offsetToKey == o->_offsetToKey); - TRI_ASSERT_DEBUG(c->_offsetFromKey == o->_offsetFromKey); + TRI_ASSERT_MAINTAINER(c->_toCid == o->_toCid); + TRI_ASSERT_MAINTAINER(c->_fromCid == o->_fromCid); + TRI_ASSERT_MAINTAINER(c->_offsetToKey == o->_offsetToKey); + TRI_ASSERT_MAINTAINER(c->_offsetFromKey == o->_offsetFromKey); } #endif @@ -405,7 +409,7 @@ static int CloneDocumentMarker (TRI_df_marker_t const* original, /// @brief creates a new document or edge marker in memory //////////////////////////////////////////////////////////////////////////////// -static int CreateDocumentMarker (TRI_primary_collection_t* primary, +static int CreateDocumentMarker (TRI_transaction_collection_t* trxCollection, TRI_doc_document_key_marker_t** result, TRI_voc_size_t* totalSize, char** keyBody, @@ -413,10 +417,12 @@ static int CreateDocumentMarker (TRI_primary_collection_t* primary, TRI_voc_key_t key, TRI_shaped_json_t const* shaped, void const* data) { + TRI_primary_collection_t* primary; TRI_doc_document_key_marker_t* marker; TRI_key_generator_t* keyGenerator; char* position; char keyBuffer[TRI_VOC_KEY_MAX_LENGTH + 1]; + TRI_voc_tid_t tid; TRI_voc_size_t keyBodySize; TRI_voc_tick_t tick; size_t markerSize; @@ -427,10 +433,12 @@ static int CreateDocumentMarker (TRI_primary_collection_t* primary, *result = NULL; tick = TRI_NewTickVocBase(); + tid = TRI_GetMarkerIdTransaction(trxCollection->_transaction); + primary = trxCollection->_collection->_collection; // generate the key keyGenerator = (TRI_key_generator_t*) primary->_keyGenerator; - TRI_ASSERT_DEBUG(keyGenerator != NULL); + TRI_ASSERT_MAINTAINER(keyGenerator != NULL); // create key using key generator res = keyGenerator->generate(keyGenerator, @@ -484,6 +492,7 @@ static int CreateDocumentMarker (TRI_primary_collection_t* primary, // set the marker type, size, revision id etc. TRI_InitMarker(&marker->base, markerType, *totalSize, tick); marker->_rid = tick; + marker->_tid = tid; marker->_shape = shaped->_sid; *keyBody = ((char*) marker) + markerSize; @@ -705,26 +714,6 @@ static int WriteElement (TRI_document_collection_t* document, return TRI_ERROR_NO_ERROR; } -//////////////////////////////////////////////////////////////////////////////// -/// @brief whether or not to write synchronised -//////////////////////////////////////////////////////////////////////////////// - -static bool RealSync (TRI_transaction_collection_t* trxCollection, - const bool syncRequested) { - if (syncRequested) { - // explicit request to sync - return true; - } - - if (trxCollection->_waitForSync) { - // collection has waitForSync property - return true; - } - - // default is false - return false; -} - //////////////////////////////////////////////////////////////////////////////// /// @} //////////////////////////////////////////////////////////////////////////////// @@ -742,37 +731,39 @@ static bool RealSync (TRI_transaction_collection_t* trxCollection, /// @{ //////////////////////////////////////////////////////////////////////////////// -static int WriteMarker (TRI_document_collection_t* document, - TRI_df_marker_t* marker, - const TRI_voc_size_t totalSize, - TRI_voc_fid_t* fid, - TRI_df_marker_t** result, - const bool forceSync) { - TRI_datafile_t* journal; +//////////////////////////////////////////////////////////////////////////////// +/// @brief writes an insert marker into the datafile +//////////////////////////////////////////////////////////////////////////////// + +static int WriteInsertMarker (TRI_document_collection_t* document, + TRI_doc_document_key_marker_t* marker, + TRI_doc_mptr_t* header, + TRI_voc_size_t totalSize, + bool waitForSync) { + TRI_df_marker_t* result; + TRI_voc_fid_t fid; int res; - // find and select a journal - journal = SelectJournal(document, totalSize, result); - - if (journal == NULL) { - return TRI_ERROR_ARANGO_NO_JOURNAL; - } + res = TRI_WriteMarkerDocumentCollection(document, &marker->base, totalSize, &fid, &result, waitForSync); - *fid = journal->_fid; - - TRI_ASSERT_DEBUG(*result != NULL); - - // now write marker and blob - res = WriteElement(document, journal, marker, totalSize, *result); - if (res == TRI_ERROR_NO_ERROR) { - if (forceSync) { - WaitSync(document, journal, ((char const*) *result) + totalSize); + // writing the element into the datafile has succeeded + TRI_doc_datafile_info_t* dfi; + + // update the header with the correct fid and the positions in the datafile + header->_fid = fid; + header->_data = ((char*) result); + header->_key = ((char*) result) + marker->_offsetKey; + + // update the datafile info + dfi = TRI_FindDatafileInfoPrimaryCollection(&document->base, fid); + + if (dfi != NULL) { + dfi->_numberAlive++; + dfi->_sizeAlive += LengthDataMasterPointer(header); } - } - else { - // writing the element into the datafile has failed - LOG_ERROR("cannot write marker into datafile: '%s'", TRI_last_error()); + + IncreaseDocumentCount(&document->base); } return res; @@ -790,14 +781,14 @@ static int InsertDocument (TRI_transaction_collection_t* trxCollection, TRI_doc_mptr_t* header, TRI_voc_size_t totalSize, bool forceSync, - TRI_doc_mptr_t* mptr) { + TRI_doc_mptr_t* mptr, + bool* freeMarker) { TRI_document_collection_t* document; - TRI_df_marker_t* result; - TRI_voc_fid_t fid; + bool written; int res; - bool writeSynced; - TRI_ASSERT_DEBUG(header != NULL); + TRI_ASSERT_MAINTAINER(*freeMarker == true); + TRI_ASSERT_MAINTAINER(header != NULL); document = (TRI_document_collection_t*) trxCollection->_collection->_collection; // ............................................................................. @@ -809,6 +800,7 @@ static int InsertDocument (TRI_transaction_collection_t* trxCollection, if (res != TRI_ERROR_NO_ERROR) { // insert has failed + document->_headers->release(document->_headers, header); return res; } @@ -818,43 +810,34 @@ static int InsertDocument (TRI_transaction_collection_t* trxCollection, if (res != TRI_ERROR_NO_ERROR) { // insertion into secondary indexes failed DeletePrimaryIndex(document, header, true); + document->_headers->release(document->_headers, header); return res; } - + - // ............................................................................. - // insert into datafile - // ............................................................................. - - writeSynced = RealSync(trxCollection, forceSync); - res = WriteMarker(document, &marker->base, totalSize, &fid, &result, writeSynced); + TRI_ASSERT_MAINTAINER(res == TRI_ERROR_NO_ERROR); + res = TRI_AddOperationCollectionTransaction(trxCollection, + (int) TRI_DOCUMENT_INSERT, + header, + NULL, + &marker->base, + totalSize, + forceSync, + &written); + if (! written) { + *freeMarker = false; + } + if (res == TRI_ERROR_NO_ERROR) { - // writing the element into the datafile has succeeded - TRI_doc_datafile_info_t* dfi; size_t i, n; - - TRI_IncreaseWritesCollectionTransaction(trxCollection, writeSynced); - - // update the header with the correct fid and the positions in the datafile - header->_fid = fid; - header->_data = ((char*) result); - header->_key = ((char*) result) + marker->_offsetKey; - - *mptr = *header; - - // update the datafile info - dfi = TRI_FindDatafileInfoPrimaryCollection(&document->base, fid); - - if (dfi != NULL) { - dfi->_numberAlive++; - dfi->_sizeAlive += LengthDataMasterPointer(mptr); - } - + // ............................................................................. // post process insert // ............................................................................. + + *mptr = *header; n = document->_allIndexes._length; @@ -868,13 +851,60 @@ static int InsertDocument (TRI_transaction_collection_t* trxCollection, } } } - - // something has failed.... now delete from the indexes again - - if (res != TRI_ERROR_NO_ERROR) { - // some error has occurred + else { + // something has failed.... now delete from the indexes again DeleteSecondaryIndexes(document, header, true); DeletePrimaryIndex(document, header, true); + + // something has failed... free the header + document->_headers->release(document->_headers, header); + } + + return res; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief writes a remove marker into the datafile +//////////////////////////////////////////////////////////////////////////////// + +static int WriteRemoveMarker (TRI_document_collection_t* document, + TRI_doc_deletion_key_marker_t* marker, + TRI_doc_mptr_t* header, + TRI_voc_size_t totalSize, + bool waitForSync) { + TRI_df_marker_t* result; + TRI_voc_fid_t fid; + int res; + + res = TRI_WriteMarkerDocumentCollection(document, &marker->base, totalSize, &fid, &result, waitForSync); + + if (res == TRI_ERROR_NO_ERROR) { + // writing the element into the datafile has succeeded + TRI_doc_datafile_info_t* dfi; + + // update the datafile info + dfi = TRI_FindDatafileInfoPrimaryCollection(&document->base, header->_fid); + + if (dfi != NULL) { + size_t length = LengthDataMasterPointer(header); + + dfi->_numberAlive--; + dfi->_sizeAlive -= length; + + dfi->_numberDead++; + dfi->_sizeDead += length; + } + + if (header->_fid != fid) { + // only need to look up datafile if it is not the same + dfi = TRI_FindDatafileInfoPrimaryCollection(&document->base, fid); + } + + if (dfi != NULL) { + dfi->_numberDeletion++; + } + + DecreaseDocumentCount(&document->base); } return res; @@ -891,14 +921,15 @@ static int RemoveDocument (TRI_transaction_collection_t* trxCollection, TRI_doc_update_policy_t const* policy, TRI_doc_deletion_key_marker_t* marker, const TRI_voc_size_t totalSize, - const bool forceSync) { + const bool forceSync, + bool* freeMarker) { TRI_primary_collection_t* primary; TRI_document_collection_t* document; TRI_doc_mptr_t* header; - TRI_df_marker_t* result; - TRI_voc_fid_t fid; + bool written; int res; - bool writeSynced; + + TRI_ASSERT_MAINTAINER(*freeMarker == true); primary = trxCollection->_collection->_collection; document = (TRI_document_collection_t*) primary; @@ -945,41 +976,24 @@ static int RemoveDocument (TRI_transaction_collection_t* trxCollection, } - TRI_ASSERT_DEBUG(res == TRI_ERROR_NO_ERROR); - + TRI_ASSERT_MAINTAINER(res == TRI_ERROR_NO_ERROR); + + res = TRI_AddOperationCollectionTransaction(trxCollection, + (int) TRI_DOCUMENT_REMOVE, + header, + header, + &marker->base, + totalSize, + forceSync, + &written); + + if (! written) { + *freeMarker = false; + } - // find and select a journal - writeSynced = RealSync(trxCollection, forceSync); - res = WriteMarker(document, &marker->base, totalSize, &fid, &result, writeSynced); - if (res == TRI_ERROR_NO_ERROR) { - TRI_doc_datafile_info_t* dfi; size_t i, n; - - TRI_IncreaseWritesCollectionTransaction(trxCollection, writeSynced); - - // update the datafile info - dfi = TRI_FindDatafileInfoPrimaryCollection(primary, header->_fid); - - if (dfi != NULL) { - size_t length = LengthDataMasterPointer(header); - - dfi->_numberAlive--; - dfi->_sizeAlive -= length; - - dfi->_numberDead++; - dfi->_sizeDead += length; - } - - if (header->_fid != fid) { - // only need to look up datafile if it is not the same - dfi = TRI_FindDatafileInfoPrimaryCollection(primary, fid); - } - - if (dfi != NULL) { - dfi->_numberDeletion++; - } - + // ............................................................................. // post process delete // ............................................................................. @@ -988,18 +1002,19 @@ static int RemoveDocument (TRI_transaction_collection_t* trxCollection, for (i = 0; i < n; ++i) { TRI_index_t* idx; - idx = document->_allIndexes._buffer[i]; + idx = document->_allIndexes._buffer[i]; - if (idx->postRemove != NULL) { - idx->postRemove(trxCollection, idx, header); - } + if (idx->postRemove != NULL) { + idx->postRemove(trxCollection, idx, header); + } + } + + if (written) { + // release the header pointer + document->_headers->release(document->_headers, header); } - - // release the header pointer - document->_headers->release(document->_headers, header); } - - if (res != TRI_ERROR_NO_ERROR) { + else { // deletion failed. roll back InsertSecondaryIndexes(document, header, true); InsertPrimaryIndex(document, header, true); @@ -1028,6 +1043,56 @@ static void UpdateHeader (TRI_voc_fid_t fid, newHeader->_validTo = oldHeader->_validTo; // TODO: fix for trx } +//////////////////////////////////////////////////////////////////////////////// +/// @brief writes an update marker into the datafile +//////////////////////////////////////////////////////////////////////////////// + +static int WriteUpdateMarker (TRI_document_collection_t* document, + TRI_doc_document_key_marker_t* marker, + TRI_doc_mptr_t* header, + const TRI_doc_mptr_t* oldHeader, + TRI_voc_size_t totalSize, + bool waitForSync) { + TRI_df_marker_t* result; + TRI_voc_fid_t fid; + int res; + + res = TRI_WriteMarkerDocumentCollection(document, &marker->base, totalSize, &fid, &result, waitForSync); + + if (res == TRI_ERROR_NO_ERROR) { + // writing the element into the datafile has succeeded + TRI_doc_datafile_info_t* dfi; + + // update the header with the correct fid and the positions in the datafile + header->_fid = fid; + header->_data = ((char*) result); + header->_key = ((char*) result) + marker->_offsetKey; + + // update the datafile info + dfi = TRI_FindDatafileInfoPrimaryCollection(&document->base, fid); + + if (dfi != NULL) { + dfi->_numberAlive++; + dfi->_sizeAlive += LengthDataMasterPointer(header); + } + + if (oldHeader->_fid != fid) { + dfi = TRI_FindDatafileInfoPrimaryCollection(&document->base, oldHeader->_fid); + } + + if (dfi != NULL) { + size_t length = LengthDataMasterPointer(oldHeader); + + dfi->_numberAlive--; + dfi->_sizeAlive -= length; + dfi->_numberDead++; + dfi->_sizeDead += length; + } + } + + return res; +} + //////////////////////////////////////////////////////////////////////////////// /// @brief updates an existing document splitted into marker and body to file //////////////////////////////////////////////////////////////////////////////// @@ -1037,15 +1102,15 @@ static int UpdateDocument (TRI_transaction_collection_t* trxCollection, TRI_doc_document_key_marker_t* marker, const TRI_voc_size_t totalSize, const bool forceSync, - TRI_doc_mptr_t* mptr) { + TRI_doc_mptr_t* mptr, + bool *freeMarker) { TRI_document_collection_t* document; TRI_doc_mptr_t* newHeader; TRI_doc_mptr_t oldData; - TRI_df_marker_t* result; - TRI_voc_fid_t fid; int res; - bool writeSynced; + bool written; + TRI_ASSERT_MAINTAINER(*freeMarker == true); document = (TRI_document_collection_t*) trxCollection->_collection->_collection; // save the old data, remember @@ -1095,49 +1160,24 @@ static int UpdateDocument (TRI_transaction_collection_t* trxCollection, } - // ............................................................................. - // write datafile - // ............................................................................. + TRI_ASSERT_MAINTAINER(res == TRI_ERROR_NO_ERROR); - writeSynced = RealSync(trxCollection, forceSync); - res = WriteMarker(document, &marker->base, totalSize, &fid, &result, writeSynced); + res = TRI_AddOperationCollectionTransaction(trxCollection, + (int) TRI_DOCUMENT_UPDATE, + newHeader, + &oldData, + &marker->base, + totalSize, + forceSync, + &written); + + if (! written) { + *freeMarker = false; + } if (res == TRI_ERROR_NO_ERROR) { - TRI_doc_datafile_info_t* dfi; - TRI_primary_collection_t* primary; size_t i, n; - - TRI_IncreaseWritesCollectionTransaction(trxCollection, writeSynced); - - // update the header with the correct fid and the positions in the datafile - newHeader->_fid = fid; - newHeader->_data = ((char*) result); - newHeader->_key = ((char*) result) + marker->_offsetKey; - primary = (TRI_primary_collection_t*) document; - - // update the datafile info - dfi = TRI_FindDatafileInfoPrimaryCollection(primary, oldData._fid); - - if (dfi != NULL) { - size_t length = LengthDataMasterPointer(&oldData); - - dfi->_numberAlive--; - dfi->_sizeAlive -= length; - dfi->_numberDead++; - dfi->_sizeDead += length; - } - - if (oldData._fid != fid) { - // only select new journal if it different from the old - dfi = TRI_FindDatafileInfoPrimaryCollection(primary, fid); - } - - if (dfi != NULL) { - dfi->_numberAlive++; - dfi->_sizeAlive += LengthDataMasterPointer(newHeader); - } - // ............................................................................. // post process update // ............................................................................. @@ -1148,7 +1188,7 @@ static int UpdateDocument (TRI_transaction_collection_t* trxCollection, TRI_index_t* idx; idx = document->_allIndexes._buffer[i]; - + if (idx->postUpdate != NULL) { idx->postUpdate(trxCollection, idx, newHeader, oldHeader, &oldData); } @@ -1418,66 +1458,58 @@ static int InsertShapedJson (TRI_transaction_collection_t* trxCollection, const bool forceSync) { TRI_primary_collection_t* primary; - TRI_document_collection_t* document; TRI_doc_document_key_marker_t* marker; TRI_doc_mptr_t* header; char* keyBody; TRI_voc_size_t totalSize; + bool freeMarker; int res; + freeMarker = true; primary = trxCollection->_collection->_collection; - TRI_ASSERT_DEBUG(primary != NULL); - TRI_ASSERT_DEBUG(shaped != NULL); + TRI_ASSERT_MAINTAINER(primary != NULL); + TRI_ASSERT_MAINTAINER(shaped != NULL); // first create a new marker in memory // this does not require any locks - res = CreateDocumentMarker(primary, &marker, &totalSize, &keyBody, markerType, key, shaped, data); + res = CreateDocumentMarker(trxCollection, &marker, &totalSize, &keyBody, markerType, key, shaped, data); if (res != TRI_ERROR_NO_ERROR) { return res; } - TRI_ASSERT_DEBUG(marker != NULL); - TRI_ASSERT_DEBUG(keyBody != NULL); - TRI_ASSERT_DEBUG(totalSize > 0); + TRI_ASSERT_MAINTAINER(marker != NULL); + TRI_ASSERT_MAINTAINER(keyBody != NULL); + TRI_ASSERT_MAINTAINER(totalSize > 0); - document = (TRI_document_collection_t*) primary; - if (lock) { // WRITE-LOCK START primary->beginWrite(primary); } header = NULL; - res = CreateHeader(document, marker, 0, &header); + res = CreateHeader((TRI_document_collection_t*) primary, marker, 0, &header); if (res == TRI_ERROR_NO_ERROR) { - res = InsertDocument(trxCollection, marker, header, totalSize, forceSync, mptr); + res = InsertDocument(trxCollection, marker, header, totalSize, forceSync, mptr, &freeMarker); } - if (res != TRI_ERROR_NO_ERROR) { - // something has failed... free the header - document->_headers->release(document->_headers, header); - } - else { - IncreaseDocumentCount(primary); - } - if (lock) { primary->endWrite(primary); // WRITE-LOCK END } - - TRI_Free(TRI_UNKNOWN_MEM_ZONE, marker); + + if (freeMarker) { + TRI_Free(TRI_UNKNOWN_MEM_ZONE, marker); + } #ifdef TRI_ENABLE_MAINTAINER_MODE if (res == TRI_ERROR_NO_ERROR) { - TRI_ASSERT_DEBUG(mptr->_key != NULL); - TRI_ASSERT_DEBUG(mptr->_data != NULL); - TRI_ASSERT_DEBUG(mptr->_rid > 0); - TRI_ASSERT_DEBUG(mptr->_fid > 0); + TRI_ASSERT_MAINTAINER(mptr->_key != NULL); + TRI_ASSERT_MAINTAINER(mptr->_data != NULL); + TRI_ASSERT_MAINTAINER(mptr->_rid > 0); } #endif @@ -1522,10 +1554,9 @@ static int ReadShapedJson (TRI_transaction_collection_t* trxCollection, } #ifdef TRI_ENABLE_MAINTAINER_MODE - TRI_ASSERT_DEBUG(mptr->_key != NULL); - TRI_ASSERT_DEBUG(mptr->_data != NULL); - TRI_ASSERT_DEBUG(mptr->_rid > 0); - TRI_ASSERT_DEBUG(mptr->_fid > 0); + TRI_ASSERT_MAINTAINER(mptr->_key != NULL); + TRI_ASSERT_MAINTAINER(mptr->_data != NULL); + TRI_ASSERT_MAINTAINER(mptr->_rid > 0); #endif return TRI_ERROR_NO_ERROR; @@ -1546,11 +1577,14 @@ static int UpdateShapedJson (TRI_transaction_collection_t* trxCollection, TRI_doc_document_key_marker_t* marker; TRI_doc_mptr_t* header; TRI_voc_size_t totalSize; + TRI_voc_tid_t tid; + bool freeMarker; int res; - + + freeMarker = true; primary = trxCollection->_collection->_collection; - TRI_ASSERT_DEBUG(mptr != NULL); + TRI_ASSERT_MAINTAINER(mptr != NULL); // initialise the result mptr->_key = NULL; @@ -1562,7 +1596,7 @@ static int UpdateShapedJson (TRI_transaction_collection_t* trxCollection, primary->beginWrite(primary); } - TRI_ASSERT_DEBUG(key != NULL); + TRI_ASSERT_MAINTAINER(key != NULL); // get the header pointer of the previous revision header = TRI_LookupByKeyAssociativePointer(&primary->_primaryIndex, key); @@ -1582,10 +1616,11 @@ static int UpdateShapedJson (TRI_transaction_collection_t* trxCollection, original = header->_data; - res = CloneDocumentMarker(original, &marker, &totalSize, original->_type, shaped); + tid = TRI_GetMarkerIdTransaction(trxCollection->_transaction); + res = CloneDocumentMarker(tid, original, &marker, &totalSize, original->_type, shaped); if (res == TRI_ERROR_NO_ERROR) { - res = UpdateDocument(trxCollection, header, marker, totalSize, forceSync, mptr); + res = UpdateDocument(trxCollection, header, marker, totalSize, forceSync, mptr, &freeMarker); } } @@ -1593,16 +1628,15 @@ static int UpdateShapedJson (TRI_transaction_collection_t* trxCollection, primary->endWrite(primary); } - if (marker != NULL) { + if (marker != NULL && freeMarker) { TRI_Free(TRI_UNKNOWN_MEM_ZONE, marker); } #ifdef TRI_ENABLE_MAINTAINER_MODE if (res == TRI_ERROR_NO_ERROR) { - TRI_ASSERT_DEBUG(mptr->_key != NULL); - TRI_ASSERT_DEBUG(mptr->_data != NULL); - TRI_ASSERT_DEBUG(mptr->_rid > 0); - TRI_ASSERT_DEBUG(mptr->_fid > 0); + TRI_ASSERT_MAINTAINER(mptr->_key != NULL); + TRI_ASSERT_MAINTAINER(mptr->_data != NULL); + TRI_ASSERT_MAINTAINER(mptr->_rid > 0); } #endif @@ -1621,35 +1655,37 @@ static int RemoveShapedJson (TRI_transaction_collection_t* trxCollection, TRI_primary_collection_t* primary; TRI_doc_deletion_key_marker_t* marker; TRI_voc_size_t totalSize; + TRI_voc_tid_t tid; + bool freeMarker; int res; - + + freeMarker = true; primary = trxCollection->_collection->_collection; - TRI_ASSERT_DEBUG(key != NULL); + TRI_ASSERT_MAINTAINER(key != NULL); marker = NULL; - res = CreateDeletionMarker(&marker, &totalSize, key, strlen(key)); + tid = TRI_GetMarkerIdTransaction(trxCollection->_transaction); + res = CreateDeletionMarker(tid, &marker, &totalSize, key, strlen(key)); if (res != TRI_ERROR_NO_ERROR) { return res; } - TRI_ASSERT_DEBUG(marker != NULL); + TRI_ASSERT_MAINTAINER(marker != NULL); if (lock) { primary->beginWrite(primary); } - res = RemoveDocument(trxCollection, policy, marker, totalSize, forceSync); - - if (res == TRI_ERROR_NO_ERROR) { - DecreaseDocumentCount(primary); - } + res = RemoveDocument(trxCollection, policy, marker, totalSize, forceSync, &freeMarker); if (lock) { primary->endWrite(primary); } - - TRI_Free(TRI_UNKNOWN_MEM_ZONE, marker); + + if (freeMarker) { + TRI_Free(TRI_UNKNOWN_MEM_ZONE, marker); + } return res; } @@ -1787,7 +1823,7 @@ static bool OpenIterator (TRI_df_marker_t const* marker, void* data, TRI_datafil return false; } - TRI_ASSERT_DEBUG(header != NULL); + TRI_ASSERT_MAINTAINER(header != NULL); // insert into primary index res = InsertPrimaryIndex(document, header, false); @@ -2305,7 +2341,7 @@ TRI_document_collection_t* TRI_CreateDocumentCollection (TRI_vocbase_t* vocbase, return NULL; } - TRI_ASSERT_DEBUG(keyGenerator != NULL); + TRI_ASSERT_MAINTAINER(keyGenerator != NULL); // first create the document collection @@ -2423,6 +2459,78 @@ void TRI_FreeDocumentCollection (TRI_document_collection_t* collection) { /// @{ //////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +/// @brief writes a marker into the datafile +//////////////////////////////////////////////////////////////////////////////// + +int TRI_WriteMarkerDocumentCollection (TRI_document_collection_t* document, + TRI_df_marker_t* marker, + const TRI_voc_size_t totalSize, + TRI_voc_fid_t* fid, + TRI_df_marker_t** result, + const bool forceSync) { + TRI_datafile_t* journal; + int res; + + // find and select a journal + journal = SelectJournal(document, totalSize, result); + + if (journal == NULL) { + return TRI_ERROR_ARANGO_NO_JOURNAL; + } + + if (fid != NULL) { + *fid = journal->_fid; + } + + TRI_ASSERT_MAINTAINER(*result != NULL); + + // now write marker and blob + res = WriteElement(document, journal, marker, totalSize, *result); + + if (res == TRI_ERROR_NO_ERROR) { + if (forceSync) { + WaitSync(document, journal, ((char const*) *result) + totalSize); + } + } + else { + // writing the element into the datafile has failed + LOG_ERROR("cannot write marker into datafile: '%s'", TRI_last_error()); + } + + return res; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief writes a document operation marker into the datafile +//////////////////////////////////////////////////////////////////////////////// + +int TRI_WriteOperationDocumentCollection (TRI_document_collection_t* document, + TRI_document_operation_e type, + TRI_doc_mptr_t* header, + TRI_doc_mptr_t* oldHeader, + TRI_df_marker_t* marker, + TRI_voc_size_t totalSize, + bool waitForSync) { + int res; + + if (type == TRI_DOCUMENT_INSERT) { + res = WriteInsertMarker(document, (TRI_doc_document_key_marker_t*) marker, header, totalSize, waitForSync); + } + else if (type == TRI_DOCUMENT_UPDATE) { + res = WriteUpdateMarker(document, (TRI_doc_document_key_marker_t*) marker, header, oldHeader, totalSize, waitForSync); + } + else if (type == TRI_DOCUMENT_REMOVE) { + res = WriteRemoveMarker(document, (TRI_doc_deletion_key_marker_t*) marker, oldHeader, totalSize, waitForSync); + } + else { + res = TRI_ERROR_INTERNAL; + LOG_ERROR("logic error in TRI_WriteOperationDocumentCollection"); + } + + return res; +} + //////////////////////////////////////////////////////////////////////////////// /// @brief creates a new journal //////////////////////////////////////////////////////////////////////////////// @@ -2510,7 +2618,7 @@ TRI_document_collection_t* TRI_OpenDocumentCollection (TRI_vocbase_t* vocbase, c return NULL; } - TRI_ASSERT_DEBUG(keyGenerator != NULL); + TRI_ASSERT_MAINTAINER(keyGenerator != NULL); document->base._keyGenerator = keyGenerator; diff --git a/arangod/VocBase/document-collection.h b/arangod/VocBase/document-collection.h index 966c30d237..e9fb18609a 100644 --- a/arangod/VocBase/document-collection.h +++ b/arangod/VocBase/document-collection.h @@ -31,8 +31,6 @@ #include "VocBase/primary-collection.h" -#include "BasicsC/associative-multi.h" - #include "VocBase/headers.h" #include "VocBase/index.h" @@ -42,6 +40,12 @@ extern "C" { #endif +// ----------------------------------------------------------------------------- +// --SECTION-- forward declarations +// ----------------------------------------------------------------------------- + +struct TRI_df_marker_s; + // ----------------------------------------------------------------------------- // --SECTION-- DOCUMENT COLLECTION // ----------------------------------------------------------------------------- @@ -172,6 +176,17 @@ extern "C" { /// @{ //////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +/// @brief enum for write operations +//////////////////////////////////////////////////////////////////////////////// + +typedef enum { + TRI_DOCUMENT_INSERT = 1, + TRI_DOCUMENT_UPDATE, + TRI_DOCUMENT_REMOVE +} +TRI_document_operation_e; + //////////////////////////////////////////////////////////////////////////////// /// @brief primary collection with global read-write lock /// @@ -257,6 +272,29 @@ void TRI_FreeDocumentCollection (TRI_document_collection_t*); /// @{ //////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +/// @brief writes a marker into the datafile +//////////////////////////////////////////////////////////////////////////////// + +int TRI_WriteMarkerDocumentCollection (TRI_document_collection_t*, + struct TRI_df_marker_s*, + const TRI_voc_size_t, + TRI_voc_fid_t*, + struct TRI_df_marker_s**, + const bool); + +//////////////////////////////////////////////////////////////////////////////// +/// @brief writes a document operation marker into the datafile +//////////////////////////////////////////////////////////////////////////////// + +int TRI_WriteOperationDocumentCollection (TRI_document_collection_t*, + TRI_document_operation_e, + TRI_doc_mptr_t*, + TRI_doc_mptr_t*, + TRI_df_marker_t*, + TRI_voc_size_t, + bool); + //////////////////////////////////////////////////////////////////////////////// /// @brief creates a new journal //////////////////////////////////////////////////////////////////////////////// diff --git a/arangod/VocBase/headers.c b/arangod/VocBase/headers.c index 53167ef45f..e6d103da7d 100644 --- a/arangod/VocBase/headers.c +++ b/arangod/VocBase/headers.c @@ -94,7 +94,7 @@ static size_t GetBlockSize (const size_t blockNumber) { //////////////////////////////////////////////////////////////////////////////// static void ClearSimpleHeaders (TRI_doc_mptr_t* header, size_t headerSize) { - TRI_ASSERT_DEBUG(header); + assert(header != NULL); memset(header, 0, headerSize); } @@ -114,7 +114,7 @@ static TRI_doc_mptr_t* RequestSimpleHeaders (TRI_headers_t* h) { size_t blockSize; blockSize = GetBlockSize(headers->_blocks._length); - TRI_ASSERT_DEBUG(blockSize > 0); + TRI_ASSERT_MAINTAINER(blockSize > 0); begin = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, blockSize * headers->_headerSize, true); @@ -133,13 +133,13 @@ static TRI_doc_mptr_t* RequestSimpleHeaders (TRI_headers_t* h) { header = ptr; } - TRI_ASSERT_DEBUG(headers != NULL); + TRI_ASSERT_MAINTAINER(headers != NULL); headers->_freelist = (TRI_doc_mptr_t*) header; TRI_PushBackVectorPointer(&headers->_blocks, begin); } - TRI_ASSERT_DEBUG(headers->_freelist != NULL); + assert(headers->_freelist != NULL); result = CONST_CAST(headers->_freelist); headers->_freelist = result->_data; diff --git a/arangod/VocBase/index.c b/arangod/VocBase/index.c index 26034207b8..75f8a820c7 100644 --- a/arangod/VocBase/index.c +++ b/arangod/VocBase/index.c @@ -69,7 +69,7 @@ void TRI_InitIndex (TRI_index_t* idx, struct TRI_primary_collection_s* primary, bool unique, bool needsFullCoverage) { - TRI_ASSERT_DEBUG(idx != NULL); + assert(idx != NULL); idx->_iid = TRI_NewTickVocBase(); idx->_type = type; diff --git a/arangod/VocBase/index.h b/arangod/VocBase/index.h index 4772248f45..97a77ec04e 100644 --- a/arangod/VocBase/index.h +++ b/arangod/VocBase/index.h @@ -41,6 +41,7 @@ #include "PriorityQueue/pqueueindex.h" #include "ShapedJson/shaped-json.h" #include "SkipLists/skiplistIndex.h" +#include "VocBase/voc-types.h" #ifdef __cplusplus extern "C" { @@ -54,6 +55,7 @@ struct TRI_collection_s; struct TRI_doc_mptr_s; struct TRI_shaped_json_s; struct TRI_document_collection_s; +struct TRI_transaction_collection_s; // ----------------------------------------------------------------------------- // --SECTION-- public types diff --git a/arangod/VocBase/marker.c b/arangod/VocBase/marker.c index dfbe1f9272..6cf212edd9 100644 --- a/arangod/VocBase/marker.c +++ b/arangod/VocBase/marker.c @@ -36,6 +36,45 @@ /// @{ //////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +/// @brief returns the name for a marker +//////////////////////////////////////////////////////////////////////////////// + +char* TRI_NameMarker (TRI_df_marker_t const* marker) { + switch (marker->_type) { + case TRI_DOC_MARKER_KEY_DOCUMENT: + return "document"; + case TRI_DOC_MARKER_KEY_EDGE: + return "edge"; + case TRI_DOC_MARKER_KEY_DELETION: + return "deletion"; + case TRI_DOC_MARKER_BEGIN_TRANSACTION: + return "begin transaction"; + case TRI_DOC_MARKER_COMMIT_TRANSACTION: + return "commit transaction"; + case TRI_DOC_MARKER_ABORT_TRANSACTION: + return "abort transaction"; + + case TRI_DF_MARKER_HEADER: + case TRI_COL_MARKER_HEADER: + return "header"; + case TRI_DF_MARKER_FOOTER: + return "footer"; + case TRI_DF_MARKER_ATTRIBUTE: + return "attribute"; + case TRI_DF_MARKER_SHAPE: + return "shape"; + + case TRI_DOC_MARKER_DOCUMENT: + case TRI_DOC_MARKER_EDGE: + case TRI_DOC_MARKER_DELETION: + return "deprecated"; + + default: + return "unused/unknown"; + } +} + //////////////////////////////////////////////////////////////////////////////// /// @brief clones a marker //////////////////////////////////////////////////////////////////////////////// @@ -45,11 +84,11 @@ void TRI_CloneMarker (TRI_df_marker_t* dst, TRI_voc_size_t copyLength, TRI_voc_size_t newSize, TRI_voc_tick_t tick) { - TRI_ASSERT_DEBUG(src != NULL); - TRI_ASSERT_DEBUG(dst != NULL); - TRI_ASSERT_DEBUG(copyLength > 0); - TRI_ASSERT_DEBUG(newSize > 0); - TRI_ASSERT_DEBUG(tick > 0); + TRI_ASSERT_MAINTAINER(src != NULL); + TRI_ASSERT_MAINTAINER(dst != NULL); + TRI_ASSERT_MAINTAINER(copyLength > 0); + TRI_ASSERT_MAINTAINER(newSize > 0); + TRI_ASSERT_MAINTAINER(tick > 0); memcpy(dst, src, copyLength); @@ -66,12 +105,13 @@ void TRI_InitMarker (TRI_df_marker_t* marker, TRI_df_marker_type_e type, TRI_voc_size_t size, TRI_voc_tick_t tick) { - TRI_ASSERT_DEBUG(marker != NULL); - TRI_ASSERT_DEBUG(type > TRI_MARKER_MIN && type < TRI_MARKER_MAX); - TRI_ASSERT_DEBUG(size > 0); - TRI_ASSERT_DEBUG(tick > 0); - // initialise the basic byytes + TRI_ASSERT_MAINTAINER(marker != NULL); + TRI_ASSERT_MAINTAINER(type > TRI_MARKER_MIN && type < TRI_MARKER_MAX); + TRI_ASSERT_MAINTAINER(size > 0); + TRI_ASSERT_MAINTAINER(tick > 0); + + // initialise the basic bytes memset(marker, 0, size); marker->_size = size; diff --git a/arangod/VocBase/marker.h b/arangod/VocBase/marker.h index 4b18857776..83a88e2ba8 100644 --- a/arangod/VocBase/marker.h +++ b/arangod/VocBase/marker.h @@ -30,7 +30,7 @@ #include "BasicsC/common.h" #include "VocBase/datafile.h" -#include "VocBase/vocbase.h" +#include "VocBase/voc-types.h" #ifdef __cplusplus extern "C" { @@ -45,6 +45,12 @@ extern "C" { /// @{ //////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +/// @brief returns the name for a marker +//////////////////////////////////////////////////////////////////////////////// + +char* TRI_NameMarker (TRI_df_marker_t const*); + //////////////////////////////////////////////////////////////////////////////// /// @brief clones a marker //////////////////////////////////////////////////////////////////////////////// diff --git a/arangod/VocBase/primary-collection.c b/arangod/VocBase/primary-collection.c index 26563faa66..5c1f8a3a24 100644 --- a/arangod/VocBase/primary-collection.c +++ b/arangod/VocBase/primary-collection.c @@ -198,7 +198,7 @@ static TRI_datafile_t* CreateJournal (TRI_primary_collection_t* primary, return NULL; } - TRI_ASSERT_DEBUG(fid == journal->_fid); + assert(fid == journal->_fid); // if a physical file, we can rename it from the temporary name to the correct name diff --git a/arangod/VocBase/primary-collection.h b/arangod/VocBase/primary-collection.h index 44f5ed0028..35b1ae156a 100644 --- a/arangod/VocBase/primary-collection.h +++ b/arangod/VocBase/primary-collection.h @@ -34,7 +34,9 @@ #include "ShapedJson/json-shaper.h" #include "VocBase/barrier.h" #include "VocBase/marker.h" +#include "VocBase/transaction.h" #include "VocBase/update-policy.h" +#include "VocBase/voc-types.h" #ifdef __cplusplus extern "C" { @@ -305,7 +307,7 @@ typedef struct TRI_doc_document_key_marker_s { TRI_df_marker_t base; TRI_voc_rid_t _rid; // this is the tick for a create and update - TRI_voc_eid_t _sid; + TRI_voc_tid_t _tid; TRI_shape_sid_t _shape; @@ -313,7 +315,7 @@ typedef struct TRI_doc_document_key_marker_s { uint16_t _offsetJson; #ifdef TRI_PADDING_32 - char _padding_df_marker[4]; + char _padding_df_marker[4]; #endif } TRI_doc_document_key_marker_t; @@ -325,14 +327,14 @@ TRI_doc_document_key_marker_t; typedef struct TRI_doc_edge_key_marker_s { TRI_doc_document_key_marker_t base; - TRI_voc_cid_t _toCid; - TRI_voc_cid_t _fromCid; + TRI_voc_cid_t _toCid; + TRI_voc_cid_t _fromCid; - uint16_t _offsetToKey; - uint16_t _offsetFromKey; + uint16_t _offsetToKey; + uint16_t _offsetFromKey; #ifdef TRI_PADDING_32 - char _padding_df_marker[4]; + char _padding_df_marker[4]; #endif } TRI_doc_edge_key_marker_t; @@ -344,46 +346,13 @@ TRI_doc_edge_key_marker_t; typedef struct TRI_doc_deletion_key_marker_s { TRI_df_marker_t base; - TRI_voc_rid_t _rid; // this is the tick for an create and update - TRI_voc_eid_t _sid; + TRI_voc_rid_t _rid; // this is the tick for the deletion + TRI_voc_tid_t _tid; - uint16_t _offsetKey; + uint16_t _offsetKey; } TRI_doc_deletion_key_marker_t; -//////////////////////////////////////////////////////////////////////////////// -/// @brief document datafile begin transaction marker -//////////////////////////////////////////////////////////////////////////////// - -typedef struct TRI_doc_begin_transaction_marker_s { - TRI_df_marker_t base; - - TRI_voc_tid_t _tid; -} -TRI_doc_begin_transaction_marker_t; - -//////////////////////////////////////////////////////////////////////////////// -/// @brief document datafile commit transaction marker -//////////////////////////////////////////////////////////////////////////////// - -typedef struct TRI_doc_commit_transaction_marker_s { - TRI_df_marker_t base; - - TRI_voc_tid_t _tid; -} -TRI_doc_commit_transaction_marker_t; - -//////////////////////////////////////////////////////////////////////////////// -/// @brief document datafile abort transaction marker -//////////////////////////////////////////////////////////////////////////////// - -typedef struct TRI_doc_abort_transaction_marker_s { - TRI_df_marker_t base; - - TRI_voc_tid_t _tid; -} -TRI_doc_abort_transaction_marker_t; - //////////////////////////////////////////////////////////////////////////////// /// @} //////////////////////////////////////////////////////////////////////////////// diff --git a/arangod/VocBase/shape-collection.c b/arangod/VocBase/shape-collection.c index 6a96a887b3..b2c70b60e5 100644 --- a/arangod/VocBase/shape-collection.c +++ b/arangod/VocBase/shape-collection.c @@ -101,7 +101,7 @@ static bool CreateJournal (TRI_shape_collection_t* collection) { LOG_TRACE("created a new shape journal '%s'", journal->getName(journal)); - TRI_ASSERT_DEBUG(fid == journal->_fid); + assert(fid == journal->_fid); if (journal->isPhysical(journal)) { char* jname; diff --git a/arangod/VocBase/transaction.c b/arangod/VocBase/transaction.c index 8d17784ceb..6f26b208cd 100644 --- a/arangod/VocBase/transaction.c +++ b/arangod/VocBase/transaction.c @@ -31,15 +31,16 @@ #include "BasicsC/tri-strings.h" #include "VocBase/primary-collection.h" +#include "VocBase/document-collection.h" #include "VocBase/vocbase.h" +#define LOG_TRX(trx, level, format, ...) \ + LOG_TRACE("trx #%llu.%d (%s): " format, (unsigned long long) trx->_id, (int) level, StatusTransaction(trx->_status), __VA_ARGS__) + // ----------------------------------------------------------------------------- // --SECTION-- TRANSACTION CONTEXT // ----------------------------------------------------------------------------- -#define LOG_TRX(trx, level, format, ...) \ - LOG_TRACE("trx #%llu.%d (%s): " format, (unsigned long long) trx->_id, (int) level, StatusTransaction(trx->_status), __VA_ARGS__) - // ----------------------------------------------------------------------------- // --SECTION-- private functions // ----------------------------------------------------------------------------- @@ -54,7 +55,7 @@ //////////////////////////////////////////////////////////////////////////////// static uint64_t HashKeyCid (TRI_associative_pointer_t* array, void const* key) { - TRI_transaction_cid_t const* k = key; + TRI_voc_cid_t const* k = key; return (uint64_t) *k; } @@ -74,7 +75,7 @@ static uint64_t HashElementCid (TRI_associative_pointer_t* array, void const* el //////////////////////////////////////////////////////////////////////////////// static bool EqualKeyCid (TRI_associative_pointer_t* array, void const* key, void const* element) { - TRI_transaction_cid_t const* k = key; + TRI_voc_cid_t const* k = key; TRI_transaction_collection_global_t const* e = element; return *k == e->_cid; @@ -84,7 +85,7 @@ static bool EqualKeyCid (TRI_associative_pointer_t* array, void const* key, void /// @brief create a global instance of a collection //////////////////////////////////////////////////////////////////////////////// -static TRI_transaction_collection_global_t* CreateGlobalInstance (TRI_transaction_cid_t cid) { +static TRI_transaction_collection_global_t* CreateGlobalInstance (TRI_voc_cid_t cid) { TRI_transaction_collection_global_t* globalInstance; globalInstance = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_transaction_collection_global_t), false); @@ -117,7 +118,7 @@ static void FreeGlobalInstance (TRI_transaction_collection_global_t* globalInsta //////////////////////////////////////////////////////////////////////////////// static TRI_transaction_collection_global_t* GetGlobalInstance (TRI_transaction_context_t* context, - TRI_transaction_cid_t cid, + TRI_voc_cid_t cid, const bool create) { TRI_transaction_collection_global_t* globalInstance; TRI_transaction_collection_global_t* found; @@ -154,10 +155,10 @@ static TRI_transaction_collection_global_t* GetGlobalInstance (TRI_transaction_c if (found != NULL) { // someone else inserted another global instance. so we'll return it FreeGlobalInstance(globalInstance); - return found; + globalInstance = found; } - // our own instance has been inserted + // return whatever we've got return globalInstance; } @@ -172,17 +173,22 @@ static int UpdateGlobalStats (const TRI_transaction_t const* trx, n = trx->_collections._length; for (i = 0; i < n; ++i) { - TRI_transaction_collection_t* collection; + TRI_transaction_collection_t* trxCollection; TRI_transaction_collection_global_t* globalInstance; - collection = (TRI_transaction_collection_t*) TRI_AtVectorPointer(&trx->_collections, i); + trxCollection = (TRI_transaction_collection_t*) TRI_AtVectorPointer(&trx->_collections, i); - globalInstance = collection->_globalInstance; - TRI_ASSERT_DEBUG(globalInstance != NULL); + globalInstance = trxCollection->_globalInstance; + assert(globalInstance != NULL); + + if (globalInstance == NULL) { + LOG_ERROR("internal error in UpdateGlobalStats"); + return TRI_ERROR_INTERNAL; + } TRI_WriteLockReadWriteLock(&globalInstance->_lock); - if (collection->_accessType == TRI_TRANSACTION_READ) { + if (trxCollection->_accessType == TRI_TRANSACTION_READ) { if (status == TRI_TRANSACTION_RUNNING) { globalInstance->_stats._lastStartedReader = trx->_id; } @@ -278,7 +284,7 @@ void TRI_FreeTransactionContext (TRI_transaction_context_t* const context) { //////////////////////////////////////////////////////////////////////////////// void TRI_RemoveCollectionTransactionContext (TRI_transaction_context_t* context, - const TRI_transaction_cid_t cid) { + const TRI_voc_cid_t cid) { TRI_transaction_collection_global_t* globalInstance; globalInstance = GetGlobalInstance(context, cid, false); @@ -298,7 +304,7 @@ void TRI_RemoveCollectionTransactionContext (TRI_transaction_context_t* context, //////////////////////////////////////////////////////////////////////////////// int TRI_StatsCollectionTransactionContext (TRI_transaction_context_t* context, - const TRI_transaction_cid_t cid, + const TRI_voc_cid_t cid, TRI_transaction_collection_stats_t* stats) { TRI_transaction_collection_global_t* globalInstance; @@ -323,6 +329,32 @@ int TRI_StatsCollectionTransactionContext (TRI_transaction_context_t* context, // --SECTION-- TRANSACTION // ----------------------------------------------------------------------------- +// ----------------------------------------------------------------------------- +// --SECTION-- private types +// ----------------------------------------------------------------------------- + +//////////////////////////////////////////////////////////////////////////////// +/// @addtogroup VocBase +/// @{ +//////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////// +/// @brief type containing a write operation for a transaction collection +//////////////////////////////////////////////////////////////////////////////// + +typedef struct transaction_operation_s { + int _type; + TRI_doc_mptr_t* _newHeader; + TRI_doc_mptr_t _oldHeader; + TRI_df_marker_t* _marker; + size_t _markerSize; +} +transaction_operation_t; + +//////////////////////////////////////////////////////////////////////////////// +/// @} +//////////////////////////////////////////////////////////////////////////////// + // ----------------------------------------------------------------------------- // --SECTION-- private functions // ----------------------------------------------------------------------------- @@ -356,28 +388,311 @@ static const char* StatusTransaction (const TRI_transaction_status_e status) { return "unknown"; } +//////////////////////////////////////////////////////////////////////////////// +/// @brief initialise operations for a collection +//////////////////////////////////////////////////////////////////////////////// + +static int InitCollectionOperations (TRI_transaction_collection_t* trxCollection) { + int res; + + trxCollection->_operations = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_vector_t), false); + + if (trxCollection->_operations == NULL) { + return TRI_ERROR_OUT_OF_MEMORY; + } + + res = TRI_InitVector2(trxCollection->_operations, TRI_UNKNOWN_MEM_ZONE, sizeof(transaction_operation_t), 4); + + return res; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief free all operations for a collection +//////////////////////////////////////////////////////////////////////////////// + +static void FreeCollectionOperations (TRI_transaction_collection_t* trxCollection) { + TRI_document_collection_t* document; + size_t i, n; + + document = (TRI_document_collection_t*) trxCollection->_collection->_collection; + + n = trxCollection->_operations->_length; + + for (i = 0; i < n; ++i) { + transaction_operation_t* trxOperation = TRI_AtVector(trxCollection->_operations, i); + TRI_document_operation_e type = (TRI_document_operation_e) trxOperation->_type; + + if (type == TRI_DOCUMENT_REMOVE) { + document->_headers->release(document->_headers, trxOperation->_newHeader); + } + + TRI_Free(TRI_UNKNOWN_MEM_ZONE, trxOperation->_marker); + } +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief add an operation for a collection +//////////////////////////////////////////////////////////////////////////////// + +static int AddCollectionOperation (TRI_transaction_collection_t* trxCollection, + int type, + TRI_doc_mptr_t* newHeader, + TRI_doc_mptr_t* oldHeader, + TRI_df_marker_t* marker, + size_t totalSize) { + transaction_operation_t trxOperation; + int res; + + + if (trxCollection->_operations == NULL) { + res = InitCollectionOperations(trxCollection); + + if (res != TRI_ERROR_NO_ERROR) { + return res; + } + } + + trxOperation._type = type; + trxOperation._newHeader = newHeader; + trxOperation._marker = marker; + trxOperation._markerSize = totalSize; + + if (oldHeader != NULL) { + trxOperation._oldHeader = *oldHeader; + } + else { + memset(&trxOperation._oldHeader, 0, sizeof(TRI_doc_mptr_t)); + } + + res = TRI_PushBackVector(trxCollection->_operations, &trxOperation); + + return res; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief write all operations for a collection, +/// wrapped inside begin...commit|abort markers +//////////////////////////////////////////////////////////////////////////////// + +static int WriteCollectionOperations (TRI_transaction_collection_t* trxCollection, + int numCollections) { + TRI_document_collection_t* document; + TRI_transaction_t* trx; + TRI_df_marker_t* result; + TRI_doc_begin_transaction_marker_t* beginMarker; + int res; + size_t i, n; + + document = (TRI_document_collection_t*) trxCollection->_collection->_collection; + trx = trxCollection->_transaction; + n = trxCollection->_operations->_length; + + assert(n > 0); + + // create the "start transaction" marker + res = TRI_CreateMarkerBeginTransaction(trx, &beginMarker, (uint16_t) numCollections); + + if (res != TRI_ERROR_NO_ERROR) { + return res; + } + + res = TRI_WriteMarkerDocumentCollection(document, + &beginMarker->base, + beginMarker->base._size, + NULL, + &result, + false); + + TRI_Free(TRI_UNKNOWN_MEM_ZONE, beginMarker); + + if (res != TRI_ERROR_NO_ERROR) { + return res; + } + + // write the individual operations + for (i = 0; i < n; ++i) { + transaction_operation_t* trxOperation; + bool waitForSync; + + trxOperation = TRI_AtVector(trxCollection->_operations, i); + waitForSync = (trxCollection->_waitForSync && (i == n - 1)); + + res = TRI_WriteOperationDocumentCollection(document, + (TRI_document_operation_e) trxOperation->_type, + trxOperation->_newHeader, + &trxOperation->_oldHeader, + trxOperation->_marker, + trxOperation->_markerSize, + waitForSync); + + if (res != TRI_ERROR_NO_ERROR) { + break; + } + } + + // written all markers + + if (res == TRI_ERROR_NO_ERROR) { + // no errors happened, now write commit marker + TRI_doc_commit_transaction_marker_t* commitMarker; + + // create the "commit transaction" marker + res = TRI_CreateMarkerCommitTransaction(trx, &commitMarker); + + if (res != TRI_ERROR_NO_ERROR) { + return res; + } + + res = TRI_WriteMarkerDocumentCollection(document, + &commitMarker->base, + commitMarker->base._size, + NULL, + &result, + false); + + TRI_Free(TRI_UNKNOWN_MEM_ZONE, commitMarker); + } + else { + // some error happened, now write abort marker + TRI_doc_abort_transaction_marker_t* abortMarker; + + // create the "commit transaction" marker + res = TRI_CreateMarkerAbortTransaction(trx, &abortMarker); + + if (res != TRI_ERROR_NO_ERROR) { + return res; + } + + res = TRI_WriteMarkerDocumentCollection(document, + &abortMarker->base, + abortMarker->base._size, + NULL, + &result, + false); + + TRI_Free(TRI_UNKNOWN_MEM_ZONE, abortMarker); + } + + return res; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief free all operations for a transaction +//////////////////////////////////////////////////////////////////////////////// + +static void FreeOperations (TRI_transaction_t* trx) { + if (trx->_hasOperations) { + size_t i, n; + + n = trx->_collections._length; + + for (i = 0; i < n; ++i) { + TRI_transaction_collection_t* trxCollection; + + trxCollection = TRI_AtVectorPointer(&trx->_collections, i); + + if (trxCollection->_operations == NULL) { + continue; + } + + FreeCollectionOperations(trxCollection); + + TRI_FreeVector(TRI_UNKNOWN_MEM_ZONE, trxCollection->_operations); + trxCollection->_operations = NULL; + } + + trx->_hasOperations = false; + } +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief count the number of write collections +//////////////////////////////////////////////////////////////////////////////// + +static int CountWriteCollections (TRI_transaction_t* const trx) { + int numCollections; + + numCollections = 0; + + if (trx->_hasOperations) { + size_t i, n; + + n = trx->_collections._length; + + for (i = 0; i < n; ++i) { + TRI_transaction_collection_t* trxCollection; + + trxCollection = TRI_AtVectorPointer(&trx->_collections, i); + + if (trxCollection->_operations != NULL) { + numCollections++; + } + } + } + + return numCollections; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief write all operations for a transaction +//////////////////////////////////////////////////////////////////////////////// + +static int WriteOperations (TRI_transaction_t* const trx) { + int res; + + res = TRI_ERROR_NO_ERROR; + + if (trx->_hasOperations) { + size_t i, n; + int numCollections; + + numCollections = CountWriteCollections(trx); + + n = trx->_collections._length; + + for (i = 0; i < n; ++i) { + TRI_transaction_collection_t* trxCollection; + + trxCollection = TRI_AtVectorPointer(&trx->_collections, i); + + if (trxCollection->_operations == NULL) { + // no markers available for collection + continue; + } + + res = WriteCollectionOperations(trxCollection, numCollections); + + if (res != TRI_ERROR_NO_ERROR) { + break; + } + } + } + + return res; +} + //////////////////////////////////////////////////////////////////////////////// /// @brief find a collection in the transaction's list of collections //////////////////////////////////////////////////////////////////////////////// static TRI_transaction_collection_t* FindCollection (const TRI_transaction_t* const trx, - const TRI_transaction_cid_t cid, + const TRI_voc_cid_t cid, size_t* position) { size_t i, n; n = trx->_collections._length; for (i = 0; i < n; ++i) { - TRI_transaction_collection_t* collection = TRI_AtVectorPointer(&trx->_collections, i); + TRI_transaction_collection_t* trxCollection = TRI_AtVectorPointer(&trx->_collections, i); - if (cid < collection->_cid) { + if (cid < trxCollection->_cid) { // collection not found break; } - if (cid == collection->_cid) { + if (cid == trxCollection->_cid) { // found - return collection; + return trxCollection; } // next @@ -396,7 +711,7 @@ static TRI_transaction_collection_t* FindCollection (const TRI_transaction_t* co //////////////////////////////////////////////////////////////////////////////// static TRI_transaction_collection_t* CreateCollection (TRI_transaction_t* trx, - const TRI_transaction_cid_t cid, + const TRI_voc_cid_t cid, const TRI_transaction_type_e accessType, const int nestingLevel) { TRI_transaction_collection_t* trxCollection; @@ -422,10 +737,9 @@ static TRI_transaction_collection_t* CreateCollection (TRI_transaction_t* trx, trxCollection->_nestingLevel = nestingLevel; trxCollection->_collection = NULL; trxCollection->_globalInstance = globalInstance; - trxCollection->_numWrites = 0; + trxCollection->_operations = NULL; trxCollection->_locked = false; trxCollection->_waitForSync = false; - trxCollection->_hadSyncedWrites = false; return trxCollection; } @@ -435,7 +749,8 @@ static TRI_transaction_collection_t* CreateCollection (TRI_transaction_t* trx, //////////////////////////////////////////////////////////////////////////////// static void FreeCollection (TRI_transaction_collection_t* trxCollection) { - TRI_ASSERT_DEBUG(trxCollection != NULL); + assert(trxCollection != NULL); + assert(trxCollection->_operations == NULL); TRI_Free(TRI_UNKNOWN_MEM_ZONE, trxCollection); } @@ -449,10 +764,10 @@ static int LockCollection (TRI_transaction_collection_t* trxCollection, const int nestingLevel) { TRI_primary_collection_t* primary; - TRI_ASSERT_DEBUG(trxCollection != NULL); - TRI_ASSERT_DEBUG(trxCollection->_collection != NULL); - TRI_ASSERT_DEBUG(trxCollection->_collection->_collection != NULL); - TRI_ASSERT_DEBUG(trxCollection->_locked == false); + assert(trxCollection != NULL); + assert(trxCollection->_collection != NULL); + assert(trxCollection->_collection->_collection != NULL); + assert(trxCollection->_locked == false); primary = trxCollection->_collection->_collection; @@ -479,10 +794,10 @@ static int UnlockCollection (TRI_transaction_collection_t* trxCollection, const int nestingLevel) { TRI_primary_collection_t* primary; - TRI_ASSERT_DEBUG(trxCollection != NULL); - TRI_ASSERT_DEBUG(trxCollection->_collection != NULL); - TRI_ASSERT_DEBUG(trxCollection->_collection->_collection != NULL); - TRI_ASSERT_DEBUG(trxCollection->_locked == true); + assert(trxCollection != NULL); + assert(trxCollection->_collection != NULL); + assert(trxCollection->_collection->_collection != NULL); + assert(trxCollection->_locked == true); primary = trxCollection->_collection->_collection; @@ -578,8 +893,8 @@ static int UseCollections (TRI_transaction_t* const trx, trxCollection->_waitForSync = trxCollection->_collection->_collection->base._info._waitForSync; } - TRI_ASSERT_DEBUG(trxCollection->_collection != NULL); - TRI_ASSERT_DEBUG(trxCollection->_collection->_collection != NULL); + assert(trxCollection->_collection != NULL); + assert(trxCollection->_collection->_collection != NULL); if (! trxCollection->_locked && ((trx->_hints & (TRI_transaction_hint_t) TRI_TRANSACTION_HINT_LOCK_ENTIRELY) != 0)) { @@ -639,14 +954,13 @@ static int ReleaseCollections (TRI_transaction_t* const trx, static int UpdateTransactionStatus (TRI_transaction_t* const trx, const TRI_transaction_status_e status) { - assert(trx->_status == TRI_TRANSACTION_CREATED || trx->_status == TRI_TRANSACTION_RUNNING); if (trx->_status == TRI_TRANSACTION_CREATED) { - TRI_ASSERT_DEBUG(status == TRI_TRANSACTION_RUNNING || status == TRI_TRANSACTION_FAILED); + assert(status == TRI_TRANSACTION_RUNNING || status == TRI_TRANSACTION_FAILED); } else if (trx->_status == TRI_TRANSACTION_RUNNING) { - TRI_ASSERT_DEBUG(status == TRI_TRANSACTION_COMMITTED || status == TRI_TRANSACTION_ABORTED); + assert(status == TRI_TRANSACTION_COMMITTED || status == TRI_TRANSACTION_ABORTED); } if (status == TRI_TRANSACTION_RUNNING || @@ -691,15 +1005,16 @@ TRI_transaction_t* TRI_CreateTransaction (TRI_transaction_context_t* const conte return NULL; } - trx->_context = context; + trx->_context = context; // note: the real transaction id will be acquired on transaction start - trx->_id = 0; + trx->_id = 0; - trx->_status = TRI_TRANSACTION_CREATED; - trx->_type = TRI_TRANSACTION_READ; - trx->_hints = 0; - trx->_nestingLevel = 0; + trx->_status = TRI_TRANSACTION_CREATED; + trx->_type = TRI_TRANSACTION_READ; + trx->_hints = 0; + trx->_nestingLevel = 0; + trx->_hasOperations = false; TRI_InitVectorPointer2(&trx->_collections, TRI_UNKNOWN_MEM_ZONE, 2); @@ -713,7 +1028,7 @@ TRI_transaction_t* TRI_CreateTransaction (TRI_transaction_context_t* const conte void TRI_FreeTransaction (TRI_transaction_t* const trx) { size_t i; - TRI_ASSERT_DEBUG(trx != NULL); + assert(trx != NULL); if (trx->_status == TRI_TRANSACTION_RUNNING) { TRI_AbortTransaction(trx, 0); @@ -722,9 +1037,9 @@ void TRI_FreeTransaction (TRI_transaction_t* const trx) { // free all collections i = trx->_collections._length; while (i-- > 0) { - TRI_transaction_collection_t* collection = TRI_AtVectorPointer(&trx->_collections, i); + TRI_transaction_collection_t* trxCollection = TRI_AtVectorPointer(&trx->_collections, i); - FreeCollection(collection); + FreeCollection(trxCollection); } TRI_DestroyVectorPointer(&trx->_collections); @@ -745,6 +1060,135 @@ void TRI_FreeTransaction (TRI_transaction_t* const trx) { /// @{ //////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +/// @brief return the collection from a transaction +//////////////////////////////////////////////////////////////////////////////// + +bool TRI_WasSynchronousCollectionTransaction (TRI_transaction_t const* trx, + const TRI_voc_cid_t cid) { + + TRI_transaction_collection_t* trxCollection; + + assert(trx->_status == TRI_TRANSACTION_RUNNING || + trx->_status == TRI_TRANSACTION_ABORTED || + trx->_status == TRI_TRANSACTION_COMMITTED); + + trxCollection = FindCollection(trx, cid, NULL); + + if (trxCollection == NULL || trxCollection->_collection == NULL) { + // not found or not opened. probably a mistake made by the caller + return false; + } + + return trxCollection->_waitForSync; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief return the collection from a transaction +//////////////////////////////////////////////////////////////////////////////// + +TRI_transaction_collection_t* TRI_GetCollectionTransaction (TRI_transaction_t const* trx, + const TRI_voc_cid_t cid, + const TRI_transaction_type_e accessType) { + + TRI_transaction_collection_t* trxCollection; + + assert(trx->_status == TRI_TRANSACTION_CREATED || + trx->_status == TRI_TRANSACTION_RUNNING); + + trxCollection = FindCollection(trx, cid, NULL); + + if (trxCollection == NULL || trxCollection->_collection == NULL) { + // not found or not opened. probably a mistake made by the caller + return NULL; + } + + // check if access type matches + if (accessType == TRI_TRANSACTION_WRITE && trxCollection->_accessType == TRI_TRANSACTION_READ) { + // type doesn't match. probably also a mistake by the caller + return NULL; + } + + return trxCollection; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief add a collection to a transaction +//////////////////////////////////////////////////////////////////////////////// + +int TRI_AddCollectionTransaction (TRI_transaction_t* const trx, + const TRI_voc_cid_t cid, + const TRI_transaction_type_e accessType, + const int nestingLevel) { + + TRI_transaction_collection_t* trxCollection; + size_t position; + + LOG_TRX(trx, nestingLevel, "adding collection %llu", (unsigned long long) cid); + + // upgrade transaction type if required + if (nestingLevel == 0) { + assert(trx->_status == TRI_TRANSACTION_CREATED); + + if (accessType == TRI_TRANSACTION_WRITE && + trx->_type == TRI_TRANSACTION_READ) { + // if one collection is written to, the whole transaction becomes a write-transaction + trx->_type = TRI_TRANSACTION_WRITE; + } + } + + // check if we already have got this collection in the _collections vector + trxCollection = FindCollection(trx, cid, &position); + + if (trxCollection != NULL) { + // collection is already contained in vector + + if (accessType == TRI_TRANSACTION_WRITE && trxCollection->_accessType != accessType) { + if (nestingLevel > 0) { + // trying to write access a collection that is only marked with read-access + return TRI_ERROR_TRANSACTION_UNREGISTERED_COLLECTION; + } + + assert(nestingLevel == 0); + + // upgrade collection type to write-access + trxCollection->_accessType = TRI_TRANSACTION_WRITE; + } + + if (nestingLevel < trxCollection->_nestingLevel) { + trxCollection->_nestingLevel = nestingLevel; + } + + // all correct + return TRI_ERROR_NO_ERROR; + } + + + // collection not found. + + if (nestingLevel > 0 && accessType == TRI_TRANSACTION_WRITE) { + // trying to write access a collection in an embedded transaction + return TRI_ERROR_TRANSACTION_UNREGISTERED_COLLECTION; + } + + // collection was not contained. now create and insert it + trxCollection = CreateCollection(trx, cid, accessType, nestingLevel); + + if (trxCollection == NULL) { + // out of memory + return TRI_ERROR_OUT_OF_MEMORY; + } + + // insert collection at the correct position + if (TRI_InsertVectorPointer(&trx->_collections, trxCollection, position) != TRI_ERROR_NO_ERROR) { + FreeCollection(trxCollection); + + return TRI_ERROR_OUT_OF_MEMORY; + } + + return TRI_ERROR_NO_ERROR; +} + //////////////////////////////////////////////////////////////////////////////// /// @brief request a lock for a collection //////////////////////////////////////////////////////////////////////////////// @@ -805,144 +1249,68 @@ bool TRI_IsLockedCollectionTransaction (TRI_transaction_collection_t* trxCollect } //////////////////////////////////////////////////////////////////////////////// -/// @brief increase the number of writes done for a collection +/// @brief add an operation for a transaction collection //////////////////////////////////////////////////////////////////////////////// -void TRI_IncreaseWritesCollectionTransaction (TRI_transaction_collection_t* trxCollection, - bool wasSynchronous) { - if (wasSynchronous) { - trxCollection->_hadSyncedWrites = true; +int TRI_AddOperationCollectionTransaction (TRI_transaction_collection_t* trxCollection, + int type, + TRI_doc_mptr_t* newHeader, + TRI_doc_mptr_t* oldHeader, + TRI_df_marker_t* marker, + size_t totalSize, + bool syncRequested, + bool* written) { + TRI_transaction_t* trx; + int res; + + trx = trxCollection->_transaction; + + if (trx->_hints & ((TRI_transaction_hint_t) TRI_TRANSACTION_HINT_SINGLE_OPERATION)) { + // just one operation in the transaction. we can write the marker directly + // TODO: error checking + res = TRI_WriteOperationDocumentCollection((TRI_document_collection_t*) trxCollection->_collection->_collection, + (TRI_document_operation_e) type, + newHeader, + oldHeader, + marker, + totalSize, + syncRequested || trxCollection->_waitForSync); + *written = true; } - trxCollection->_numWrites++; -} + else { + trx->_hasOperations = true; -//////////////////////////////////////////////////////////////////////////////// -/// @brief return the collection from a transaction -//////////////////////////////////////////////////////////////////////////////// - -bool TRI_WasSynchronousCollectionTransaction (TRI_transaction_t const* trx, - const TRI_transaction_cid_t cid) { + res = AddCollectionOperation(trxCollection, type, newHeader, oldHeader, marker, totalSize); - TRI_transaction_collection_t* collection; - - TRI_ASSERT_DEBUG(trx->_status == TRI_TRANSACTION_RUNNING || - trx->_status == TRI_TRANSACTION_ABORTED || - trx->_status == TRI_TRANSACTION_COMMITTED); - - collection = FindCollection(trx, cid, NULL); - - if (collection == NULL || collection->_collection == NULL) { - // not found or not opened. probably a mistake made by the caller - return false; + *written = false; } - - return collection->_hadSyncedWrites; -} - -//////////////////////////////////////////////////////////////////////////////// -/// @brief return the collection from a transaction -//////////////////////////////////////////////////////////////////////////////// - -TRI_transaction_collection_t* TRI_GetCollectionTransaction (TRI_transaction_t const* trx, - const TRI_transaction_cid_t cid, - const TRI_transaction_type_e accessType) { - - TRI_transaction_collection_t* collection; - - TRI_ASSERT_DEBUG(trx->_status == TRI_TRANSACTION_CREATED || - trx->_status == TRI_TRANSACTION_RUNNING); - - collection = FindCollection(trx, cid, NULL); - - if (collection == NULL || collection->_collection == NULL) { - // not found or not opened. probably a mistake made by the caller - return NULL; - } - - // check if access type matches - if (accessType == TRI_TRANSACTION_WRITE && collection->_accessType == TRI_TRANSACTION_READ) { - // type doesn't match. probably also a mistake by the caller - return NULL; - } - - return collection; -} - -//////////////////////////////////////////////////////////////////////////////// -/// @brief add a collection to a transaction -//////////////////////////////////////////////////////////////////////////////// - -int TRI_AddCollectionTransaction (TRI_transaction_t* const trx, - const TRI_transaction_cid_t cid, - const TRI_transaction_type_e accessType, - const int nestingLevel) { - - TRI_transaction_collection_t* collection; - size_t position; - LOG_TRX(trx, nestingLevel, "adding collection %llu", (unsigned long long) cid); - - // upgrade transaction type if required - if (nestingLevel == 0) { - TRI_ASSERT_DEBUG(trx->_status == TRI_TRANSACTION_CREATED); - - if (accessType == TRI_TRANSACTION_WRITE && - trx->_type == TRI_TRANSACTION_READ) { - // if one collection is written to, the whole transaction becomes a write-transaction - trx->_type = TRI_TRANSACTION_WRITE; - } + if (syncRequested) { + trxCollection->_waitForSync = true; } - // check if we already have got this collection in the _collections vector - collection = FindCollection(trx, cid, &position); + return res; +} - if (collection != NULL) { - // collection is already contained in vector - - if (accessType == TRI_TRANSACTION_WRITE && collection->_accessType != accessType) { - if (nestingLevel > 0) { - // trying to write access a collection that is only marked with read-access - return TRI_ERROR_TRANSACTION_UNREGISTERED_COLLECTION; - } +//////////////////////////////////////////////////////////////////////////////// +/// @brief get a transaction's id +//////////////////////////////////////////////////////////////////////////////// - TRI_ASSERT_DEBUG(nestingLevel == 0); +TRI_voc_tid_t TRI_GetIdTransaction (const TRI_transaction_t* trx) { + return trx->_id; +} - // upgrade collection type to write-access - collection->_accessType = TRI_TRANSACTION_WRITE; - } +//////////////////////////////////////////////////////////////////////////////// +/// @brief get a transaction's id for writing into a marker +/// this will return 0 if the operation is standalone +//////////////////////////////////////////////////////////////////////////////// - if (nestingLevel < collection->_nestingLevel) { - collection->_nestingLevel = nestingLevel; - } - - // all correct - return TRI_ERROR_NO_ERROR; +TRI_voc_tid_t TRI_GetMarkerIdTransaction (const TRI_transaction_t* trx) { + if (trx->_hints & ((TRI_transaction_hint_t) TRI_TRANSACTION_HINT_SINGLE_OPERATION)) { + return 0; } - - // collection not found. - - if (nestingLevel > 0 && accessType == TRI_TRANSACTION_WRITE) { - // trying to write access a collection in an embedded transaction - return TRI_ERROR_TRANSACTION_UNREGISTERED_COLLECTION; - } - - // collection was not contained. now create and insert it - collection = CreateCollection(trx, cid, accessType, nestingLevel); - - if (collection == NULL) { - // out of memory - return TRI_ERROR_OUT_OF_MEMORY; - } - - // insert collection at the correct position - if (TRI_InsertVectorPointer(&trx->_collections, collection, position) != TRI_ERROR_NO_ERROR) { - FreeCollection(collection); - - return TRI_ERROR_OUT_OF_MEMORY; - } - - return TRI_ERROR_NO_ERROR; + return TRI_GetIdTransaction(trx); } //////////////////////////////////////////////////////////////////////////////// @@ -957,7 +1325,7 @@ int TRI_BeginTransaction (TRI_transaction_t* const trx, LOG_TRX(trx, nestingLevel, "%s transaction", "beginning"); if (nestingLevel == 0) { - TRI_ASSERT_DEBUG(trx->_status == TRI_TRANSACTION_CREATED); + assert(trx->_status == TRI_TRANSACTION_CREATED); // get a new id trx->_id = TRI_NewTickVocBase(); @@ -974,7 +1342,7 @@ int TRI_BeginTransaction (TRI_transaction_t* const trx, trx->_hints = hints; } else { - TRI_ASSERT_DEBUG(trx->_status == TRI_TRANSACTION_RUNNING); + assert(trx->_status == TRI_TRANSACTION_RUNNING); } res = UseCollections(trx, nestingLevel); @@ -1008,10 +1376,19 @@ int TRI_CommitTransaction (TRI_transaction_t* const trx, LOG_TRX(trx, nestingLevel, "%s transaction", "committing"); - TRI_ASSERT_DEBUG(trx->_status == TRI_TRANSACTION_RUNNING); + assert(trx->_status == TRI_TRANSACTION_RUNNING); if (nestingLevel == 0) { - res = UpdateTransactionStatus(trx, TRI_TRANSACTION_COMMITTED); + res = WriteOperations(trx); + FreeOperations(trx); + + if (res != TRI_ERROR_NO_ERROR) { + // writing markers has failed + res = UpdateTransactionStatus(trx, TRI_TRANSACTION_ABORTED); + } + else { + res = UpdateTransactionStatus(trx, TRI_TRANSACTION_COMMITTED); + } } else { res = TRI_ERROR_NO_ERROR; @@ -1032,9 +1409,11 @@ int TRI_AbortTransaction (TRI_transaction_t* const trx, LOG_TRX(trx, nestingLevel, "%s transaction", "aborting"); - TRI_ASSERT_DEBUG(trx->_status == TRI_TRANSACTION_RUNNING); + assert(trx->_status == TRI_TRANSACTION_RUNNING); if (nestingLevel == 0) { + FreeOperations(trx); + res = UpdateTransactionStatus(trx, TRI_TRANSACTION_ABORTED); } else { @@ -1050,6 +1429,98 @@ int TRI_AbortTransaction (TRI_transaction_t* const trx, /// @} //////////////////////////////////////////////////////////////////////////////// +// ----------------------------------------------------------------------------- +// --SECTION-- TRANSACTION MARKERS +// ----------------------------------------------------------------------------- + +// ----------------------------------------------------------------------------- +// --SECTION-- public functions +// ----------------------------------------------------------------------------- + +//////////////////////////////////////////////////////////////////////////////// +/// @addtogroup VocBase +/// @{ +//////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////// +/// @brief create a "begin" marker +//////////////////////////////////////////////////////////////////////////////// + +int TRI_CreateMarkerBeginTransaction (TRI_transaction_t* trx, + TRI_doc_begin_transaction_marker_t** result, + uint16_t numCollections) { + TRI_doc_begin_transaction_marker_t* marker; + TRI_voc_tick_t tick; + + *result = NULL; + marker = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_doc_begin_transaction_marker_t), false); + + if (marker == NULL) { + return TRI_ERROR_OUT_OF_MEMORY; + } + + tick = TRI_NewTickVocBase(); + TRI_InitMarker(&marker->base, TRI_DOC_MARKER_BEGIN_TRANSACTION, sizeof(TRI_doc_begin_transaction_marker_t), tick); + + marker->_numCollections = numCollections; + + *result = marker; + + return TRI_ERROR_NO_ERROR; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief create a "commit" marker +//////////////////////////////////////////////////////////////////////////////// + +int TRI_CreateMarkerCommitTransaction (TRI_transaction_t* trx, + TRI_doc_commit_transaction_marker_t** result) { + TRI_doc_commit_transaction_marker_t* marker; + TRI_voc_tick_t tick; + + *result = NULL; + marker = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_doc_commit_transaction_marker_t), false); + + if (marker == NULL) { + return TRI_ERROR_OUT_OF_MEMORY; + } + + tick = TRI_NewTickVocBase(); + TRI_InitMarker(&marker->base, TRI_DOC_MARKER_COMMIT_TRANSACTION, sizeof(TRI_doc_commit_transaction_marker_t), tick); + + *result = marker; + + return TRI_ERROR_NO_ERROR; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @brief create an "abort" marker +//////////////////////////////////////////////////////////////////////////////// + +int TRI_CreateMarkerAbortTransaction (TRI_transaction_t* trx, + TRI_doc_abort_transaction_marker_t** result) { + TRI_doc_abort_transaction_marker_t* marker; + TRI_voc_tick_t tick; + + *result = NULL; + marker = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_doc_commit_transaction_marker_t), false); + + if (marker == NULL) { + return TRI_ERROR_OUT_OF_MEMORY; + } + + tick = TRI_NewTickVocBase(); + TRI_InitMarker(&marker->base, TRI_DOC_MARKER_ABORT_TRANSACTION, sizeof(TRI_doc_abort_transaction_marker_t), tick); + + *result = marker; + + return TRI_ERROR_NO_ERROR; +} + +//////////////////////////////////////////////////////////////////////////////// +/// @} +//////////////////////////////////////////////////////////////////////////////// + // Local Variables: // mode: outline-minor // outline-regexp: "/// @brief\\|/// {@inheritDoc}\\|/// @addtogroup\\|/// @page\\|// --SECTION--\\|/// @\\}" diff --git a/arangod/VocBase/transaction.h b/arangod/VocBase/transaction.h index 3311bfb7a1..35aad5c30c 100644 --- a/arangod/VocBase/transaction.h +++ b/arangod/VocBase/transaction.h @@ -35,6 +35,9 @@ #include "BasicsC/locks.h" #include "BasicsC/vector.h" +#include "VocBase/datafile.h" +#include "VocBase/voc-types.h" + #ifdef __cplusplus extern "C" { #endif @@ -43,6 +46,10 @@ extern "C" { // --SECTION-- forward declarations // ----------------------------------------------------------------------------- +struct TRI_doc_abort_transaction_marker_s; +struct TRI_doc_begin_transaction_marker_s; +struct TRI_doc_commit_transaction_marker_s; +struct TRI_doc_mptr_s; struct TRI_vocbase_s; struct TRI_vocbase_col_s; @@ -59,18 +66,6 @@ struct TRI_vocbase_col_s; /// @{ //////////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////////// -/// @brief transaction id -//////////////////////////////////////////////////////////////////////////////// - -typedef uint64_t TRI_transaction_id_t; - -//////////////////////////////////////////////////////////////////////////////// -/// @brief collection id -//////////////////////////////////////////////////////////////////////////////// - -typedef uint64_t TRI_transaction_cid_t; - //////////////////////////////////////////////////////////////////////////////// /// @brief transaction type //////////////////////////////////////////////////////////////////////////////// @@ -146,12 +141,12 @@ TRI_transaction_context_t; //////////////////////////////////////////////////////////////////////////////// typedef struct TRI_transaction_collection_stats_s { - TRI_transaction_id_t _lastStartedReader; - TRI_transaction_id_t _lastFinishedReader; + TRI_voc_tid_t _lastStartedReader; + TRI_voc_tid_t _lastFinishedReader; - TRI_transaction_id_t _lastStartedWriter; - TRI_transaction_id_t _lastAbortedWriter; - TRI_transaction_id_t _lastFinishedWriter; + TRI_voc_tid_t _lastStartedWriter; + TRI_voc_tid_t _lastAbortedWriter; + TRI_voc_tid_t _lastFinishedWriter; } TRI_transaction_collection_stats_t; @@ -160,7 +155,7 @@ TRI_transaction_collection_stats_t; //////////////////////////////////////////////////////////////////////////////// typedef struct TRI_transaction_collection_global_s { - TRI_transaction_cid_t _cid; + TRI_voc_cid_t _cid; TRI_read_write_lock_t _lock; TRI_transaction_collection_stats_t _stats; @@ -211,14 +206,14 @@ void TRI_FreeTransactionContext (TRI_transaction_context_t* const); //////////////////////////////////////////////////////////////////////////////// void TRI_RemoveCollectionTransactionContext (TRI_transaction_context_t*, - const TRI_transaction_cid_t); + const TRI_voc_cid_t); //////////////////////////////////////////////////////////////////////////////// /// @brief populates a struct with transaction statistics for a collections //////////////////////////////////////////////////////////////////////////////// int TRI_StatsCollectionTransactionContext (TRI_transaction_context_t*, - const TRI_transaction_cid_t, + const TRI_voc_cid_t, TRI_transaction_collection_stats_t*); //////////////////////////////////////////////////////////////////////////////// @@ -263,12 +258,13 @@ TRI_transaction_hint_e; typedef struct TRI_transaction_s { TRI_transaction_context_t* _context; // global context object - TRI_transaction_id_t _id; + TRI_voc_tid_t _id; TRI_transaction_type_e _type; // access type (read|write) TRI_transaction_status_e _status; // current status TRI_vector_pointer_t _collections; // list of participating collections TRI_transaction_hint_t _hints; // hints; - int _nestingLevel; + int _nestingLevel; + bool _hasOperations; } TRI_transaction_t; @@ -278,15 +274,14 @@ TRI_transaction_t; typedef struct TRI_transaction_collection_s { TRI_transaction_t* _transaction; // the transaction - TRI_transaction_cid_t _cid; // collection id + TRI_voc_cid_t _cid; // collection id TRI_transaction_type_e _accessType; // access type (read|write) int _nestingLevel; // the transaction level that added this collection struct TRI_vocbase_col_s* _collection; // vocbase collection pointer TRI_transaction_collection_global_t* _globalInstance; // pointer to the global instance - uint64_t _numWrites; // number of writes + TRI_vector_t* _operations; // buffered CRUD operations bool _locked; // collection lock flag bool _waitForSync; // whether or not the collection has waitForSync - bool _hadSyncedWrites; // whether or not synced writes happened } TRI_transaction_collection_t; @@ -340,14 +335,14 @@ void TRI_IncreaseWritesCollectionTransaction (TRI_transaction_collection_t*, //////////////////////////////////////////////////////////////////////////////// bool TRI_WasSynchronousCollectionTransaction (TRI_transaction_t const*, - const TRI_transaction_cid_t); + const TRI_voc_cid_t); //////////////////////////////////////////////////////////////////////////////// /// @brief return the collection from a transaction //////////////////////////////////////////////////////////////////////////////// TRI_transaction_collection_t* TRI_GetCollectionTransaction (TRI_transaction_t const*, - const TRI_transaction_cid_t, + const TRI_voc_cid_t, const TRI_transaction_type_e); //////////////////////////////////////////////////////////////////////////////// @@ -355,7 +350,7 @@ TRI_transaction_collection_t* TRI_GetCollectionTransaction (TRI_transaction_t co //////////////////////////////////////////////////////////////////////////////// int TRI_AddCollectionTransaction (TRI_transaction_t* const, - const TRI_transaction_cid_t, + const TRI_voc_cid_t, const TRI_transaction_type_e, const int); @@ -383,6 +378,32 @@ bool TRI_IsLockedCollectionTransaction (TRI_transaction_collection_t*, const TRI_transaction_type_e, const int); +//////////////////////////////////////////////////////////////////////////////// +/// @brief add a marker to a transaction collection +//////////////////////////////////////////////////////////////////////////////// + +int TRI_AddOperationCollectionTransaction (TRI_transaction_collection_t*, + int, + struct TRI_doc_mptr_s*, + struct TRI_doc_mptr_s*, + TRI_df_marker_t*, + size_t, + bool, + bool*); + +//////////////////////////////////////////////////////////////////////////////// +/// @brief get a transaction's id +//////////////////////////////////////////////////////////////////////////////// + +TRI_voc_tid_t TRI_GetIdTransaction (const TRI_transaction_t*); + +//////////////////////////////////////////////////////////////////////////////// +/// @brief get a transaction's id for writing into a marker +/// this will return 0 if the operation is standalone +//////////////////////////////////////////////////////////////////////////////// + +TRI_voc_tid_t TRI_GetMarkerIdTransaction (const TRI_transaction_t*); + //////////////////////////////////////////////////////////////////////////////// /// @brief begin a transaction //////////////////////////////////////////////////////////////////////////////// @@ -409,6 +430,92 @@ int TRI_AbortTransaction (TRI_transaction_t* const, /// @} //////////////////////////////////////////////////////////////////////////////// +// ----------------------------------------------------------------------------- +// --SECTION-- TRANSACTION MARKERS +// ----------------------------------------------------------------------------- + +// ----------------------------------------------------------------------------- +// --SECTION-- public types +// ----------------------------------------------------------------------------- + +//////////////////////////////////////////////////////////////////////////////// +/// @addtogroup VocBase +/// @{ +//////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////// +/// @brief begin transaction marker +//////////////////////////////////////////////////////////////////////////////// + +typedef struct TRI_doc_begin_transaction_marker_s { + TRI_df_marker_t base; + + TRI_voc_tid_t _tid; + uint16_t _numCollections; +} +TRI_doc_begin_transaction_marker_t; + +//////////////////////////////////////////////////////////////////////////////// +/// @brief commit transaction marker +//////////////////////////////////////////////////////////////////////////////// + +typedef struct TRI_doc_commit_transaction_marker_s { + TRI_df_marker_t base; + + TRI_voc_tid_t _tid; +} +TRI_doc_commit_transaction_marker_t; + +//////////////////////////////////////////////////////////////////////////////// +/// @brief abort transaction marker +//////////////////////////////////////////////////////////////////////////////// + +typedef struct TRI_doc_abort_transaction_marker_s { + TRI_df_marker_t base; + + TRI_voc_tid_t _tid; +} +TRI_doc_abort_transaction_marker_t; + +//////////////////////////////////////////////////////////////////////////////// +/// @} +//////////////////////////////////////////////////////////////////////////////// + +// ----------------------------------------------------------------------------- +// --SECTION-- public functions +// ----------------------------------------------------------------------------- + +//////////////////////////////////////////////////////////////////////////////// +/// @addtogroup VocBase +/// @{ +//////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////// +/// @brief create a "begin" marker +//////////////////////////////////////////////////////////////////////////////// + +int TRI_CreateMarkerBeginTransaction (TRI_transaction_t*, + struct TRI_doc_begin_transaction_marker_s**, + uint16_t); + +//////////////////////////////////////////////////////////////////////////////// +/// @brief create a "commit" marker +//////////////////////////////////////////////////////////////////////////////// + +int TRI_CreateMarkerCommitTransaction (TRI_transaction_t*, + struct TRI_doc_commit_transaction_marker_s**); + +//////////////////////////////////////////////////////////////////////////////// +/// @brief create an "abort" marker +//////////////////////////////////////////////////////////////////////////////// + +int TRI_CreateMarkerAbortTransaction (TRI_transaction_t*, + struct TRI_doc_abort_transaction_marker_s**); + +//////////////////////////////////////////////////////////////////////////////// +/// @} +//////////////////////////////////////////////////////////////////////////////// + #ifdef __cplusplus } #endif diff --git a/arangod/VocBase/voc-types.h b/arangod/VocBase/voc-types.h new file mode 100644 index 0000000000..1555d77d40 --- /dev/null +++ b/arangod/VocBase/voc-types.h @@ -0,0 +1,123 @@ +//////////////////////////////////////////////////////////////////////////////// +/// @brief vocbase types +/// +/// @file +/// +/// DISCLAIMER +/// +/// Copyright 2004-2013 triAGENS GmbH, Cologne, Germany +/// +/// Licensed under the Apache License, Version 2.0 (the "License"); +/// you may not use this file except in compliance with the License. +/// You may obtain a copy of the License at +/// +/// http://www.apache.org/licenses/LICENSE-2.0 +/// +/// Unless required by applicable law or agreed to in writing, software +/// distributed under the License is distributed on an "AS IS" BASIS, +/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +/// See the License for the specific language governing permissions and +/// limitations under the License. +/// +/// Copyright holder is triAGENS GmbH, Cologne, Germany +/// +/// @author Dr. Frank Celler +/// @author Copyright 2011-2013, triAGENS GmbH, Cologne, Germany +//////////////////////////////////////////////////////////////////////////////// + +#ifndef TRIAGENS_VOC_BASE_VOC_TYPES_H +#define TRIAGENS_VOC_BASE_VOC_TYPES_H 1 + +#include "BasicsC/common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// ----------------------------------------------------------------------------- +// --SECTION-- public types +// ----------------------------------------------------------------------------- + +//////////////////////////////////////////////////////////////////////////////// +/// @addtogroup VocBase +/// @{ +//////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////// +/// @brief tick type (48bit) +//////////////////////////////////////////////////////////////////////////////// + +typedef uint64_t TRI_voc_tick_t; + +//////////////////////////////////////////////////////////////////////////////// +/// @brief collection identifier type +//////////////////////////////////////////////////////////////////////////////// + +typedef uint64_t TRI_voc_cid_t; + +//////////////////////////////////////////////////////////////////////////////// +/// @brief datafile identifier type +//////////////////////////////////////////////////////////////////////////////// + +typedef uint64_t TRI_voc_fid_t; + +//////////////////////////////////////////////////////////////////////////////// +/// @brief document key identifier type +//////////////////////////////////////////////////////////////////////////////// + +typedef char* TRI_voc_key_t; + +//////////////////////////////////////////////////////////////////////////////// +/// @brief revision identifier type +//////////////////////////////////////////////////////////////////////////////// + +typedef uint64_t TRI_voc_rid_t; + +//////////////////////////////////////////////////////////////////////////////// +/// @brief transaction identifier type +//////////////////////////////////////////////////////////////////////////////// + +typedef uint64_t TRI_voc_tid_t; + +//////////////////////////////////////////////////////////////////////////////// +/// @brief size type +//////////////////////////////////////////////////////////////////////////////// + +typedef uint32_t TRI_voc_size_t; + +//////////////////////////////////////////////////////////////////////////////// +/// @brief signed size type +//////////////////////////////////////////////////////////////////////////////// + +typedef int32_t TRI_voc_ssize_t; + +//////////////////////////////////////////////////////////////////////////////// +/// @brief crc type +//////////////////////////////////////////////////////////////////////////////// + +typedef uint32_t TRI_voc_crc_t; + +//////////////////////////////////////////////////////////////////////////////// +/// @brief collection storage type +//////////////////////////////////////////////////////////////////////////////// + +typedef uint32_t TRI_col_type_t; + +//////////////////////////////////////////////////////////////////////////////// +/// @} +//////////////////////////////////////////////////////////////////////////////// + +#ifdef __cplusplus +} +#endif + +// ----------------------------------------------------------------------------- +// --SECTION-- END-OF-FILE +// ----------------------------------------------------------------------------- + +#endif + +// Local Variables: +// mode: outline-minor +// outline-regexp: "/// @brief\\|/// {@inheritDoc}\\|/// @addtogroup\\|/// @page\\|// --SECTION--\\|/// @\\}" +// End: diff --git a/arangod/VocBase/vocbase.h b/arangod/VocBase/vocbase.h index b9280fb425..33ebd5f884 100644 --- a/arangod/VocBase/vocbase.h +++ b/arangod/VocBase/vocbase.h @@ -35,7 +35,7 @@ #include "BasicsC/threads.h" #include "BasicsC/vector.h" #include "BasicsC/voc-errors.h" -#include "VocBase/transaction.h" +#include "VocBase/voc-types.h" #ifdef __cplusplus extern "C" { @@ -48,6 +48,7 @@ extern "C" { struct TRI_primary_collection_s; struct TRI_col_info_s; struct TRI_shadow_store_s; +struct TRI_transaction_context_s; // ----------------------------------------------------------------------------- // --SECTION-- public macros @@ -281,84 +282,6 @@ extern size_t PageSize; /// @{ //////////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////////// -/// @brief tick type (48bit) -//////////////////////////////////////////////////////////////////////////////// - -typedef uint64_t TRI_voc_tick_t; - -//////////////////////////////////////////////////////////////////////////////// -/// @brief collection identifier type -//////////////////////////////////////////////////////////////////////////////// - -typedef uint64_t TRI_voc_cid_t; - -//////////////////////////////////////////////////////////////////////////////// -/// @brief datafile identifier type -//////////////////////////////////////////////////////////////////////////////// - -typedef uint64_t TRI_voc_fid_t; - -//////////////////////////////////////////////////////////////////////////////// -/// @brief document key identifier type -//////////////////////////////////////////////////////////////////////////////// - -typedef char* TRI_voc_key_t; - -//////////////////////////////////////////////////////////////////////////////// -/// @brief revision identifier type -//////////////////////////////////////////////////////////////////////////////// - -typedef uint64_t TRI_voc_rid_t; - -//////////////////////////////////////////////////////////////////////////////// -/// @brief step identifier type -//////////////////////////////////////////////////////////////////////////////// - -typedef uint64_t TRI_voc_eid_t; - -//////////////////////////////////////////////////////////////////////////////// -/// @brief transaction identifier type -//////////////////////////////////////////////////////////////////////////////// - -typedef uint64_t TRI_voc_tid_t; - -//////////////////////////////////////////////////////////////////////////////// -/// @brief size type -//////////////////////////////////////////////////////////////////////////////// - -typedef uint32_t TRI_voc_size_t; - -//////////////////////////////////////////////////////////////////////////////// -/// @brief signed size type -//////////////////////////////////////////////////////////////////////////////// - -typedef int32_t TRI_voc_ssize_t; - -//////////////////////////////////////////////////////////////////////////////// -/// @brief boolean flag type -//////////////////////////////////////////////////////////////////////////////// - -typedef uint32_t TRI_voc_flag_t; - -//////////////////////////////////////////////////////////////////////////////// -/// @brief milli-seconds -//////////////////////////////////////////////////////////////////////////////// - -typedef uint32_t TRI_voc_ms_t; - -//////////////////////////////////////////////////////////////////////////////// -/// @brief crc type -//////////////////////////////////////////////////////////////////////////////// - -typedef uint32_t TRI_voc_crc_t; - -//////////////////////////////////////////////////////////////////////////////// -/// @brief collection storage type -//////////////////////////////////////////////////////////////////////////////// - -typedef uint32_t TRI_col_type_t; - //////////////////////////////////////////////////////////////////////////////// /// @brief database /// @@ -387,7 +310,7 @@ typedef struct TRI_vocbase_s { TRI_associative_pointer_t _authInfo; TRI_read_write_lock_t _authInfoLock; - TRI_transaction_context_t* _transactionContext; + struct TRI_transaction_context_s* _transactionContext; // state of the database // 0 = inactive diff --git a/lib/BasicsC/common.h b/lib/BasicsC/common.h index 2e579fd67d..82df37f3d4 100644 --- a/lib/BasicsC/common.h +++ b/lib/BasicsC/common.h @@ -180,23 +180,24 @@ static inline void* CONST_CAST (void const* ptr) { //////////////////////////////////////////////////////////////////////////////// /// @brief a wrapper for assert() /// -/// This wrapper maps TRI_ASSERT_DEBUG() to (void) 0 for non-maintainers. It -/// maps TRI_ASSERT_DEBUG() to assert() when TRI_ENABLE_MAINTAINER_MODE is set. +/// This wrapper maps TRI_ASSERT_MAINTAINER() to (void) 0 for non-maintainers. +/// It maps TRI_ASSERT_MAINTAINER() to assert() when TRI_ENABLE_MAINTAINER_MODE +/// is set. //////////////////////////////////////////////////////////////////////////////// #ifdef TRI_ENABLE_MAINTAINER_MODE -#define TRI_ASSERT_DEBUG(what) assert(what) +#define TRI_ASSERT_MAINTAINER(what) assert(what) #else #ifdef __cplusplus -#define TRI_ASSERT_DEBUG(what) (static_cast (0)) +#define TRI_ASSERT_MAINTAINER(what) (static_cast (0)) #else -#define TRI_ASSERT_DEBUG(what) ((void) (0)) +#define TRI_ASSERT_MAINTAINER(what) ((void) (0)) #endif diff --git a/lib/BasicsC/zip.c b/lib/BasicsC/zip.c index 1ae5c7d593..ae15b4a0a0 100644 --- a/lib/BasicsC/zip.c +++ b/lib/BasicsC/zip.c @@ -154,7 +154,7 @@ static int ExtractCurrentFile (unzFile uf, } } else { - TRI_ASSERT_DEBUG(result == 0); + assert(result == 0); break; } } diff --git a/lib/ShapedJson/shaped-json.c b/lib/ShapedJson/shaped-json.c index bd8b123886..8bdc9e35bb 100644 --- a/lib/ShapedJson/shaped-json.c +++ b/lib/ShapedJson/shaped-json.c @@ -782,8 +782,8 @@ static bool FillShapeValueArray (TRI_shaper_t* shaper, TRI_shape_value_t* dst, T char* ptr; // sanity checks - TRI_ASSERT_DEBUG(json->_type == TRI_JSON_ARRAY); - TRI_ASSERT_DEBUG(json->_value._objects._length % 2 == 0); + assert(json->_type == TRI_JSON_ARRAY); + assert(json->_value._objects._length % 2 == 0); // number of attributes n = json->_value._objects._length / 2; @@ -807,8 +807,8 @@ static bool FillShapeValueArray (TRI_shaper_t* shaper, TRI_shape_value_t* dst, T key = TRI_AtVector(&json->_value._objects, 2 * i); val = TRI_AtVector(&json->_value._objects, 2 * i + 1); - TRI_ASSERT_DEBUG(key != NULL); - TRI_ASSERT_DEBUG(val != NULL); + assert(key != NULL); + assert(val != NULL); if (key->_value._string.data == NULL || key->_value._string.length == 1 ||