Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/arangod/SkipListsEx/skiplistExIndex.c

1538 lines
59 KiB
C
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
/// @brief skiplistEx index
///
/// @file
///
/// DISCLAIMER
///
/// Copyright by triAGENS GmbH - All rights reserved.
///
/// The Programs (which include both the software and documentation)
/// contain proprietary information of triAGENS GmbH; they are
/// provided under a license agreement containing restrictions on use and
/// disclosure and are also protected by copyright, patent and other
/// intellectual and industrial property laws. Reverse engineering,
/// disassembly or decompilation of the Programs, except to the extent
/// required to obtain interoperability with other independently created
/// software or as specified by law, is prohibited.
///
/// The Programs are not intended for use in any nuclear, aviation, mass
/// transit, medical, or other inherently dangerous applications. It shall
/// be the licensee's responsibility to take all appropriate fail-safe,
/// backup, redundancy, and other measures to ensure the safe use of such
/// applications if the Programs are used for such purposes, and triAGENS
/// GmbH disclaims liability for any damages caused by such use of
/// the Programs.
///
/// This software is the confidential and proprietary information of
/// triAGENS GmbH. You shall not disclose such confidential and
/// proprietary information and shall use it only in accordance with the
/// terms of the license agreement you entered into with triAGENS GmbH.
///
/// Copyright holder is triAGENS GmbH, Cologne, Germany
///
/// @author Dr. O
/// @author Copyright 2011, triagens GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
#include "skiplistExIndex.h"
#include "VocBase/index-garbage-collector.h"
#ifdef TRI_SKIPLIST_EX
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Common private methods
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// .............................................................................
// forward declaration - some helper methods
// .............................................................................
static bool skiplistExIndex_findHelperIntervalValid (SkiplistExIndex*, TRI_skiplistEx_iterator_interval_t*);
static bool multiSkiplistExIndex_findHelperIntervalValid (SkiplistExIndex*, TRI_skiplistEx_iterator_interval_t*);
// .............................................................................
// forward declaration of static functions which are used by the query engine
// .............................................................................
static int SkiplistExIndex_queryMethodCall (void*, TRI_index_operator_t*, TRI_index_challenge_t*, void*);
static TRI_index_iterator_t* SkiplistExIndex_resultMethodCall (void*, TRI_index_operator_t*, void*, bool (*filter) (TRI_index_iterator_t*));
static int SkiplistExIndex_freeMethodCall (void*, void*);
////////////////////////////////////////////////////////////////////////////////
/// @brief Attempts to determine if there is a next document within an interval - without advancing the iterator.
////////////////////////////////////////////////////////////////////////////////
static bool SkiplistExHasNextIterationCallback(TRI_skiplistEx_iterator_t* iterator) {
TRI_skiplistEx_iterator_interval_t* interval;
void* leftNode;
// .............................................................................
// Some simple checks.
// .............................................................................
if (iterator == NULL) {
return false;
}
if (iterator->_intervals._length == 0) {
return false;
}
// .............................................................................
// if we have more intervals than the one we are currently working on then of course we have a next doc
// .............................................................................
if (iterator->_intervals._length - 1 > iterator->_currentInterval) {
return true;
}
// .............................................................................
// Obtain the current interval -- in case we ever use more than one interval
// .............................................................................
interval = (TRI_skiplistEx_iterator_interval_t*) ( TRI_AtVector(&(iterator->_intervals), iterator->_currentInterval) );
// .............................................................................
// Obtain the left end point we are currently at
// .............................................................................
if (iterator->_cursor == NULL) {
leftNode = interval->_leftEndPoint;
}
else {
leftNode = iterator->_cursor;
}
// .............................................................................
// If the left == right end point AND there are no more intervals then we have
// no next.
// .............................................................................
if (leftNode == interval->_rightEndPoint) {
return false;
}
// ...........................................................................
// interval of the type (a,b) -- but nothing between a and b
// such intervals are optimised out so will not be here
// ...........................................................................
if (iterator->_index->_unique) {
leftNode = TRI_NextNodeSkipListEx(iterator->_index->_skiplistEx.uniqueSkiplistEx, leftNode, iterator->_thisTransID);
}
else {
leftNode = TRI_NextNodeSkipListExMulti(iterator->_index->_skiplistEx.nonUniqueSkiplistEx, leftNode, iterator->_thisTransID);
}
// ...........................................................................
// Check various possibilities
// ...........................................................................
if (leftNode == NULL) {
return false;
}
if (leftNode == interval->_rightEndPoint) {
return false;
}
return true;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief Attempts to determine if there is a previous document within an interval - without advancing the iterator.
////////////////////////////////////////////////////////////////////////////////
static bool SkiplistExHasPrevIterationCallback(TRI_skiplistEx_iterator_t* iterator) {
TRI_skiplistEx_iterator_interval_t* interval;
void* rightNode;
// .............................................................................
// Some simple checks.
// .............................................................................
if (iterator == NULL) {
return false;
}
if (iterator->_intervals._length == 0) {
return false;
}
// .............................................................................
// this check is as follows if we have more intervals than the one
// we are currently working on -- then of course we have a prev doc
// .............................................................................
if (iterator->_currentInterval > 0 ) {
return true;
}
// .............................................................................
// Obtain the current interval -- in case we ever use more than one interval
// .............................................................................
interval = (TRI_skiplistEx_iterator_interval_t*) ( TRI_AtVector(&(iterator->_intervals), iterator->_currentInterval) );
// .............................................................................
// Obtain the left end point we are currently at
// .............................................................................
if (iterator->_cursor == NULL) {
rightNode = interval->_rightEndPoint;
}
else {
rightNode = iterator->_cursor;
}
// .............................................................................
// If the left == right end point AND there are no more intervals then we have
// no next.
// .............................................................................
if (rightNode == interval->_leftEndPoint) {
return false;
}
// ...........................................................................
// interval of the type (a,b) -- but nothing between a and b
// such intervals are optimised out so will not be here
// ...........................................................................
if (iterator->_index->_unique) {
rightNode = TRI_PrevNodeSkipListEx(iterator->_index->_skiplistEx.uniqueSkiplistEx, rightNode, iterator->_thisTransID);
}
else {
rightNode = TRI_PrevNodeSkipListExMulti(iterator->_index->_skiplistEx.nonUniqueSkiplistEx, rightNode, iterator->_thisTransID);
}
// ...........................................................................
// Check various possibilities
// ...........................................................................
if (rightNode == NULL) {
return false;
}
if (rightNode == interval->_leftEndPoint) {
return false;
}
return true;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief Jumps forwards or backwards by jumpSize and returns the document
////////////////////////////////////////////////////////////////////////////////
static void* SkiplistExIteration(TRI_skiplistEx_iterator_t* iterator, int64_t jumpSize) {
TRI_skiplistEx_iterator_interval_t* interval;
TRI_skiplistEx_node_t* currentNode;
int64_t j;
// .............................................................................
// Some simple checks.
// .............................................................................
if (iterator == NULL) {
return NULL;
}
if (iterator->_intervals._length == 0) {
return NULL;
}
currentNode = (TRI_skiplistEx_node_t*) (iterator->_cursor);
if (jumpSize == 0) {
if (currentNode == NULL) {
return NULL;
}
else {
return &(currentNode->_element);
}
}
// .............................................................................
// If the current cursor is NULL and jumpSize < 0, then start at the endpoint of
// the right most interval.
// .............................................................................
if (currentNode == NULL && jumpSize < 0) {
interval = (TRI_skiplistEx_iterator_interval_t*) ( TRI_AtVector(&(iterator->_intervals), iterator->_intervals._length - 1) );
if (iterator->_index->_unique) {
iterator->_cursor = TRI_PrevNodeSkipListEx(iterator->_index->_skiplistEx.uniqueSkiplistEx, interval->_rightEndPoint, iterator->_thisTransID);
}
else {
iterator->_cursor = TRI_PrevNodeSkipListExMulti(iterator->_index->_skiplistEx.nonUniqueSkiplistEx, interval->_rightEndPoint, iterator->_thisTransID);
}
currentNode = (TRI_skiplistEx_node_t*) (iterator->_cursor);
if (currentNode == NULL) {
return NULL;
}
if (currentNode == interval->_leftEndPoint) {
return NULL;
}
return &(currentNode->_element);
}
// .............................................................................
// If the current cursor is NULL and jumpSize > 0, then start at the left point of
// the left most interval.
// .............................................................................
if (currentNode == NULL && jumpSize > 0) {
interval = (TRI_skiplistEx_iterator_interval_t*) ( TRI_AtVector(&(iterator->_intervals), 0) );
if (iterator->_index->_unique) {
iterator->_cursor = TRI_NextNodeSkipListEx(iterator->_index->_skiplistEx.uniqueSkiplistEx, interval->_leftEndPoint, iterator->_thisTransID);
}
else {
iterator->_cursor = TRI_NextNodeSkipListExMulti(iterator->_index->_skiplistEx.nonUniqueSkiplistEx, interval->_leftEndPoint, iterator->_thisTransID);
}
currentNode = (TRI_skiplistEx_node_t*) (iterator->_cursor);
if (currentNode == NULL) {
return NULL;
}
if (currentNode == interval->_rightEndPoint) {
if (iterator->_index->_unique) {
iterator->_cursor = TRI_NextNodeSkipListEx(iterator->_index->_skiplistEx.uniqueSkiplistEx, interval->_leftEndPoint, iterator->_thisTransID);
}
else {
iterator->_cursor = TRI_NextNodeSkipListExMulti(iterator->_index->_skiplistEx.nonUniqueSkiplistEx, interval->_leftEndPoint, iterator->_thisTransID);
}
currentNode = (TRI_skiplistEx_node_t*) (iterator->_cursor);
return NULL;
}
return &(currentNode->_element);
}
// .............................................................................
// Obtain the current interval we are at.
// .............................................................................
interval = (TRI_skiplistEx_iterator_interval_t*) ( TRI_AtVector(&(iterator->_intervals), iterator->_currentInterval) );
// .............................................................................
// use the current cursor and move jumpSize back.
// .............................................................................
if (jumpSize < 0) {
jumpSize = -jumpSize;
for (j = 0; j < jumpSize; ++j) {
if (iterator->_cursor == interval->_leftEndPoint) {
if (iterator->_currentInterval == 0) {
return NULL;
}
--iterator->_currentInterval;
interval = (TRI_skiplistEx_iterator_interval_t*) ( TRI_AtVector(&(iterator->_intervals), iterator->_currentInterval) );
iterator->_cursor = interval->_rightEndPoint;
}
if (iterator->_index->_unique) {
iterator->_cursor = TRI_PrevNodeSkipListEx(iterator->_index->_skiplistEx.uniqueSkiplistEx, iterator->_cursor, iterator->_thisTransID);
}
else {
iterator->_cursor = TRI_PrevNodeSkipListExMulti(iterator->_index->_skiplistEx.nonUniqueSkiplistEx, iterator->_cursor, iterator->_thisTransID);
}
}
if (iterator->_cursor == interval->_leftEndPoint) {
if (iterator->_currentInterval == 0) {
return NULL;
}
--iterator->_currentInterval;
interval = (TRI_skiplistEx_iterator_interval_t*) ( TRI_AtVector(&(iterator->_intervals), iterator->_currentInterval) );
iterator->_cursor = interval->_rightEndPoint;
if (iterator->_index->_unique) {
iterator->_cursor = TRI_PrevNodeSkipListEx(iterator->_index->_skiplistEx.uniqueSkiplistEx, iterator->_cursor, iterator->_thisTransID);
}
else {
iterator->_cursor = TRI_PrevNodeSkipListExMulti(iterator->_index->_skiplistEx.nonUniqueSkiplistEx, iterator->_cursor, iterator->_thisTransID);
}
}
}
// .............................................................................
// use the current cursor and move jumpSize forward.
// .............................................................................
if (jumpSize > 0) {
for (j = 0; j < jumpSize; ++j) {
if (iterator->_cursor == interval->_rightEndPoint) {
if (iterator->_currentInterval == (iterator->_intervals._length - 1)) {
return NULL;
}
++iterator->_currentInterval;
interval = (TRI_skiplistEx_iterator_interval_t*) ( TRI_AtVector(&(iterator->_intervals), iterator->_currentInterval) );
iterator->_cursor = interval->_leftEndPoint;
}
if (iterator->_index->_unique) {
iterator->_cursor = TRI_NextNodeSkipListEx(iterator->_index->_skiplistEx.uniqueSkiplistEx, iterator->_cursor, iterator->_thisTransID);
}
else {
iterator->_cursor = TRI_NextNodeSkipListExMulti(iterator->_index->_skiplistEx.nonUniqueSkiplistEx, iterator->_cursor, iterator->_thisTransID);
}
}
if (iterator->_cursor == interval->_rightEndPoint) {
if (iterator->_currentInterval == (iterator->_intervals._length - 1)) {
return NULL;
}
++iterator->_currentInterval;
interval = (TRI_skiplistEx_iterator_interval_t*) ( TRI_AtVector(&(iterator->_intervals), iterator->_currentInterval) );
iterator->_cursor = interval->_leftEndPoint;
if (iterator->_index->_unique) {
iterator->_cursor = TRI_NextNodeSkipListEx(iterator->_index->_skiplistEx.uniqueSkiplistEx, iterator->_cursor, iterator->_thisTransID);
}
else {
iterator->_cursor = TRI_NextNodeSkipListExMulti(iterator->_index->_skiplistEx.nonUniqueSkiplistEx, iterator->_cursor, iterator->_thisTransID);
}
}
}
currentNode = (TRI_skiplistEx_node_t*) (iterator->_cursor);
if (currentNode == NULL) {
return NULL;
}
return &(currentNode->_element);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief default callback for jumping forward by 1
////////////////////////////////////////////////////////////////////////////////
static void* SkiplistExNextIterationCallback(TRI_skiplistEx_iterator_t* iterator) {
return SkiplistExIteration(iterator,1);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief default callback for jumping forward by jumpSize docs
////////////////////////////////////////////////////////////////////////////////
static void* SkiplistExNextsIterationCallback(TRI_skiplistEx_iterator_t* iterator, int64_t jumpSize) {
return SkiplistExIteration(iterator,jumpSize);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief default callback for jumping backwards by 1
////////////////////////////////////////////////////////////////////////////////
static void* SkiplistExPrevIterationCallback(TRI_skiplistEx_iterator_t* iterator) {
return SkiplistExIteration(iterator,-1);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief default callback for jumping backwards by jumpSize docs
////////////////////////////////////////////////////////////////////////////////
static void* SkiplistExPrevsIterationCallback(TRI_skiplistEx_iterator_t* iterator, int64_t jumpSize) {
return SkiplistExIteration(iterator,-jumpSize);
}
// -----------------------------------------------------------------------------
// --SECTION-- skiplistIndex common public methods
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @addtogroup skiplistIndex
/// @{
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/// @brief Assigns a static function call to a function pointer used by Query Engine
////////////////////////////////////////////////////////////////////////////////
int SkiplistExIndex_assignMethod(void* methodHandle, TRI_index_method_assignment_type_e methodType) {
switch (methodType) {
case TRI_INDEX_METHOD_ASSIGNMENT_FREE : {
TRI_index_query_free_method_call_t* call = (TRI_index_query_free_method_call_t*)(methodHandle);
*call = SkiplistExIndex_freeMethodCall;
break;
}
case TRI_INDEX_METHOD_ASSIGNMENT_QUERY : {
TRI_index_query_method_call_t* call = (TRI_index_query_method_call_t*)(methodHandle);
*call = SkiplistExIndex_queryMethodCall;
break;
}
case TRI_INDEX_METHOD_ASSIGNMENT_RESULT : {
TRI_index_query_result_method_call_t* call = (TRI_index_query_result_method_call_t*)(methodHandle);
*call = SkiplistExIndex_resultMethodCall;
break;
}
default : {
assert(false);
}
}
return TRI_ERROR_NO_ERROR;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief Free a skiplist iterator
////////////////////////////////////////////////////////////////////////////////
void TRI_FreeSkiplistExIterator (TRI_skiplistEx_iterator_t* const iterator) {
assert(iterator);
TRI_DestroyVector(&iterator->_intervals);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, iterator);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief destroys a skip list index , but does not free the pointer
////////////////////////////////////////////////////////////////////////////////
void SkiplistExIndex_destroy(SkiplistExIndex* slIndex) {
if (slIndex == NULL) {
return;
}
if (slIndex->_unique) {
TRI_FreeSkipListEx(slIndex->_skiplistEx.uniqueSkiplistEx);
slIndex->_skiplistEx.uniqueSkiplistEx = NULL;
}
else {
TRI_FreeSkipListExMulti(slIndex->_skiplistEx.nonUniqueSkiplistEx);
slIndex->_skiplistEx.nonUniqueSkiplistEx = NULL;
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief destroys a skip list index and frees the pointer
////////////////////////////////////////////////////////////////////////////////
void SkiplistExIndex_free(SkiplistExIndex* slIndex) {
if (slIndex == NULL) {
return;
}
SkiplistExIndex_destroy(slIndex);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, slIndex);
}
////////////////////////////////////////////////////////////////////////////////
/// @}
////////////////////////////////////////////////////////////////////////////////
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Unique Skiplists
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Private Methods Unique Skiplists
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Public Methods Unique Skiplists
//------------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief creates a new unique entry skiplist
////////////////////////////////////////////////////////////////////////////////
SkiplistExIndex* SkiplistExIndex_new(TRI_transaction_context_t* transactionContext) {
SkiplistExIndex* skiplistExIndex;
int result;
uint64_t lastKnownTransID = 0;
skiplistExIndex = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(SkiplistExIndex), true);
if (skiplistExIndex == NULL) {
return NULL;
}
skiplistExIndex->_unique = true;
skiplistExIndex->_skiplistEx.uniqueSkiplistEx = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_skiplistEx_t), true);
if (skiplistExIndex->_skiplistEx.uniqueSkiplistEx == NULL) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, skiplistExIndex);
return NULL;
}
skiplistExIndex->_transactionContext = transactionContext;
// TODO ORESTE: determine the last know transaction id from the transaction context
result = TRI_InitSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx,
sizeof(SkiplistExIndexElement),
NULL,NULL,TRI_SKIPLIST_EX_PROB_HALF, 40,
lastKnownTransID);
if (result != TRI_ERROR_NO_ERROR) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, skiplistExIndex->_skiplistEx.uniqueSkiplistEx);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, skiplistExIndex);
return NULL;
}
return skiplistExIndex;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief adds (inserts) a data element into a unique skip list
////////////////////////////////////////////////////////////////////////////////
int SkiplistExIndex_add(SkiplistExIndex* skiplistExIndex, SkiplistExIndexElement* element, uint64_t thisTransID) {
int result;
result = TRI_InsertKeySkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx, element, element, false, thisTransID);
return result;
}
//////////////////////////////////////////////////////////////////////////////////
/// @brief Locates one or more ranges within the unique skiplist and returns iterator
//////////////////////////////////////////////////////////////////////////////////
// ...............................................................................
// Tests whether the LeftEndPoint is < than RightEndPoint (-1)
// Tests whether the LeftEndPoint is == to RightEndPoint (0) [empty]
// Tests whether the LeftEndPoint is > than RightEndPoint (1) [undefined]
// ...............................................................................
/*
static void debugElement(SkiplistIndex* skiplistIndex, TRI_skiplist_node_t* node) {
size_t numFields;
SkiplistIndexElement* element = (SkiplistIndexElement*)(&(node->_element));
TRI_shaper_t* shaper;
size_t j;
if (node == NULL) {
printf("%s:%u:node null\n",__FILE__,__LINE__);
return;
}
if (node == TRI_StartNodeSkipList(skiplistIndex->skiplist.uniqueSkiplist)) {
printf("%s:%u:start node\n",__FILE__,__LINE__);
}
if (node == TRI_EndNodeSkipList(skiplistIndex->skiplist.uniqueSkiplist)) {
printf("%s:%u:end node\n",__FILE__,__LINE__);
}
if (element == NULL) {
printf("%s:%u:element null\n",__FILE__,__LINE__);
return;
}
numFields = element->numFields;
shaper = ((TRI_primary_collection_t*)(element->collection))->_shaper;
for (j = 0; j < numFields; j++) {
printf("%s:%u:!!!:%f:%lu\n",__FILE__,__LINE__,
*((double*)((j + element->fields)->_data.data)),
(long unsigned int)(element->data) );
}
return;
}
*/
static bool skiplistExIndex_findHelperIntervalIntersectionValid(SkiplistExIndex* skiplistExIndex,
TRI_skiplistEx_iterator_interval_t* lInterval,
TRI_skiplistEx_iterator_interval_t* rInterval,
TRI_skiplistEx_iterator_interval_t* interval) {
int compareResult;
TRI_skiplistEx_node_t* lNode;
TRI_skiplistEx_node_t* rNode;
lNode = (TRI_skiplistEx_node_t*)(lInterval->_leftEndPoint);
rNode = (TRI_skiplistEx_node_t*)(rInterval->_leftEndPoint);
if (lNode == TRI_EndNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx) || lNode == NULL ||
rNode == TRI_EndNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx) || rNode == NULL) {
return false;
}
if (lNode == TRI_StartNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx)) {
compareResult = -1;
}
else if (rNode == TRI_StartNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx)) {
compareResult = 1;
}
else {
compareResult = skiplistExIndex->_skiplistEx.uniqueSkiplistEx->compareKeyElement(
skiplistExIndex->_skiplistEx.uniqueSkiplistEx,
&(lNode->_element), &(rNode->_element), 0);
}
if (compareResult < 1) {
interval->_leftEndPoint = rNode;
}
else {
interval->_leftEndPoint = lNode;
}
lNode = (TRI_skiplistEx_node_t*)(lInterval->_rightEndPoint);
rNode = (TRI_skiplistEx_node_t*)(rInterval->_rightEndPoint);
if (lNode == TRI_EndNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx)) {
compareResult = 1;
}
else if (rNode == TRI_EndNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx)) {
compareResult = -1;
}
else {
compareResult = skiplistExIndex->_skiplistEx.uniqueSkiplistEx->compareKeyElement(
skiplistExIndex->_skiplistEx.uniqueSkiplistEx,
&(lNode->_element), &(rNode->_element), 0);
}
if (compareResult < 1) {
interval->_rightEndPoint = lNode;
}
else {
interval->_rightEndPoint = rNode;
}
return skiplistExIndex_findHelperIntervalValid(skiplistExIndex, interval);
}
static bool skiplistExIndex_findHelperIntervalValid(SkiplistExIndex* skiplistExIndex, TRI_skiplistEx_iterator_interval_t* interval) {
int compareResult;
TRI_skiplistEx_node_t* lNode;
TRI_skiplistEx_node_t* rNode;
if ((interval->_leftEndPoint == NULL) || (interval->_rightEndPoint == NULL)) {
return false;
}
if (interval->_leftEndPoint == interval->_rightEndPoint) {
return false;
}
if ( (interval->_leftEndPoint == TRI_StartNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx)) ||
(interval->_rightEndPoint == TRI_EndNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx))) {
return true;
}
lNode = (TRI_skiplistEx_node_t*)(interval->_leftEndPoint);
rNode = (TRI_skiplistEx_node_t*)(interval->_rightEndPoint);
compareResult = skiplistExIndex->_skiplistEx.uniqueSkiplistEx->compareKeyElement(
skiplistExIndex->_skiplistEx.uniqueSkiplistEx,
&(lNode->_element), &(rNode->_element), 0);
return (compareResult == -1);
}
static void SkiplistExIndex_findHelper(SkiplistExIndex* skiplistExIndex,
TRI_vector_t* shapeList,
TRI_index_operator_t* indexOperator,
TRI_vector_t* resultIntervalList,
uint64_t thisTransID) {
SkiplistExIndexElement values;
TRI_vector_t leftResult;
TRI_vector_t rightResult;
TRI_relation_index_operator_t* relationOperator;
TRI_logical_index_operator_t* logicalOperator;
TRI_skiplistEx_iterator_interval_t interval;
TRI_skiplistEx_iterator_interval_t* tempLeftInterval;
TRI_skiplistEx_iterator_interval_t* tempRightInterval;
size_t j;
size_t i;
TRI_InitVector(&(leftResult), TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_skiplistEx_iterator_interval_t));
TRI_InitVector(&(rightResult), TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_skiplistEx_iterator_interval_t));
relationOperator = (TRI_relation_index_operator_t*)(indexOperator);
logicalOperator = (TRI_logical_index_operator_t*)(indexOperator);
switch (indexOperator->_type) {
case TRI_EQ_INDEX_OPERATOR:
case TRI_LE_INDEX_OPERATOR:
case TRI_LT_INDEX_OPERATOR:
case TRI_GE_INDEX_OPERATOR:
case TRI_GT_INDEX_OPERATOR:
values.fields = relationOperator->_fields;
values.numFields = relationOperator->_numFields;
values.collection = relationOperator->_collection;
values.data = 0; // we do not have a document pointer
default: {
// must not access relationOperator->xxx if the operator is not a relational one
// otherwise we'll get invalid reads and the prog might crash
}
}
switch (indexOperator->_type) {
/*
case TRI_SL_OR_OPERATOR: {
SkiplistIndex_findHelper(skiplistIndex,shapeList,logicalOperator->_left,&leftResult);
SkiplistIndex_findHelper(skiplistIndex,shapeList,logicalOperator->_right,&leftResult);
i = 0;
while (i < leftResult._length - 1) {
tempLeftInterval = (TRI_skiplist_iterator_interval_t*) (TRI_AtVector(&leftResult, i));
tempRightInterval = (TRI_skiplist_iterator_interval_t*) (TRI_AtVector(&leftResult, i + 1));
// if intervals intersect, optimise and start again
}
assert(0);
}
*/
case TRI_AND_INDEX_OPERATOR: {
SkiplistExIndex_findHelper(skiplistExIndex,shapeList,logicalOperator->_left,&leftResult, thisTransID);
SkiplistExIndex_findHelper(skiplistExIndex,shapeList,logicalOperator->_right,&rightResult, thisTransID);
for (i = 0; i < leftResult._length; ++i) {
for (j = 0; j < rightResult._length; ++j) {
tempLeftInterval = (TRI_skiplistEx_iterator_interval_t*) (TRI_AtVector(&leftResult, i));
tempRightInterval = (TRI_skiplistEx_iterator_interval_t*) (TRI_AtVector(&rightResult, j));
if (!skiplistExIndex_findHelperIntervalIntersectionValid(skiplistExIndex, tempLeftInterval,
tempRightInterval, &interval)) {
continue;
}
TRI_PushBackVector(resultIntervalList,&interval);
}
}
TRI_DestroyVector(&leftResult);
TRI_DestroyVector(&rightResult);
return;
}
case TRI_EQ_INDEX_OPERATOR: {
// ............................................................................
// The index is constructed from n fields and the client has sent us n values
// ............................................................................
if (relationOperator->_numFields == shapeList->_length) {
interval._leftEndPoint = TRI_LookupByKeySkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx, &values, thisTransID);
if (interval._leftEndPoint != NULL) {
interval._rightEndPoint = TRI_NextNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx, interval._leftEndPoint, thisTransID);
interval._leftEndPoint = TRI_PrevNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx, interval._leftEndPoint, thisTransID);
}
}
// ............................................................................
// The index is constructed from n fields and the client has sent us m values
// where m < n
// ............................................................................
else {
interval._leftEndPoint = TRI_LeftLookupByKeySkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx, &values, thisTransID);
interval._rightEndPoint = TRI_RightLookupByKeySkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx, &values, thisTransID);
}
if (skiplistExIndex_findHelperIntervalValid(skiplistExIndex, &interval)) {
TRI_PushBackVector(resultIntervalList,&interval);
}
return;
}
case TRI_LE_INDEX_OPERATOR: {
interval._leftEndPoint = TRI_StartNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx);
interval._rightEndPoint = TRI_RightLookupByKeySkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx, &values, thisTransID);
if (skiplistExIndex_findHelperIntervalValid(skiplistExIndex, &interval)) {
TRI_PushBackVector(resultIntervalList,&interval);
}
return;
}
case TRI_LT_INDEX_OPERATOR: {
interval._leftEndPoint = TRI_StartNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx);
interval._rightEndPoint = TRI_LeftLookupByKeySkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx, &values, thisTransID);
if (interval._rightEndPoint != TRI_EndNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx)) {
interval._rightEndPoint = TRI_NextNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx, interval._rightEndPoint, thisTransID);
}
if (skiplistExIndex_findHelperIntervalValid(skiplistExIndex, &interval)) {
TRI_PushBackVector(resultIntervalList, &interval);
}
return;
}
case TRI_GE_INDEX_OPERATOR: {
interval._leftEndPoint = TRI_LeftLookupByKeySkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx, &values, thisTransID);
interval._rightEndPoint = TRI_EndNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx);
if (skiplistExIndex_findHelperIntervalValid(skiplistExIndex, &interval)) {
TRI_PushBackVector(resultIntervalList,&interval);
}
return;
}
case TRI_GT_INDEX_OPERATOR: {
interval._leftEndPoint = TRI_RightLookupByKeySkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx, &values, thisTransID);
interval._rightEndPoint = TRI_EndNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx);
if (interval._leftEndPoint != TRI_StartNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx)) {
interval._leftEndPoint = TRI_PrevNodeSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx, interval._leftEndPoint, thisTransID);
}
if (skiplistExIndex_findHelperIntervalValid(skiplistExIndex, &interval)) {
TRI_PushBackVector(resultIntervalList,&interval);
}
return;
}
default: {
assert(0);
}
} // end of switch statement
}
TRI_skiplistEx_iterator_t* SkiplistExIndex_find(SkiplistExIndex* skiplistExIndex, TRI_vector_t* shapeList, TRI_index_operator_t* indexOperator, uint64_t thisTransID) {
TRI_skiplistEx_iterator_t* results;
results = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_skiplistEx_iterator_t), true);
if (results == NULL) {
return NULL; // calling procedure needs to care when the iterator is null
}
results->_index = skiplistExIndex;
TRI_InitVector(&(results->_intervals), TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_skiplistEx_iterator_interval_t));
results->_currentInterval = 0;
results->_cursor = NULL;
results->_thisTransID = thisTransID;
results->_hasNext = SkiplistExHasNextIterationCallback;
results->_next = SkiplistExNextIterationCallback;
results->_nexts = SkiplistExNextsIterationCallback;
results->_hasPrev = SkiplistExHasPrevIterationCallback;
results->_prev = SkiplistExPrevIterationCallback;
results->_prevs = SkiplistExPrevsIterationCallback;
SkiplistExIndex_findHelper(skiplistExIndex, shapeList, indexOperator, &(results->_intervals), thisTransID);
return results;
}
//////////////////////////////////////////////////////////////////////////////////
/// @brief alias for addIndex
//////////////////////////////////////////////////////////////////////////////////
int SkiplistExIndex_insert(SkiplistExIndex* skiplistExIndex, SkiplistExIndexElement* element, uint64_t thisTransID) {
return SkiplistExIndex_add(skiplistExIndex,element, thisTransID);
}
//////////////////////////////////////////////////////////////////////////////////
/// @brief removes an entry from the skip list
//////////////////////////////////////////////////////////////////////////////////
static int CollectSkiplistExGarbage(TRI_index_gc_t* indexGCData) {
int result = TRI_ERROR_NO_ERROR;
SkiplistExIndex* skiplistIndex;
TRI_skiplistEx_node_t* passNode;
TRI_skiplistEx_t* skiplist;
if (indexGCData == NULL) {
abort(); // remove after debugging
return TRI_ERROR_INTERNAL;
}
skiplistIndex = (SkiplistExIndex*)(indexGCData->_index);
if (skiplistIndex == NULL) {
abort(); // remove after debugging
return TRI_ERROR_INTERNAL;
}
skiplist = (skiplistIndex->_skiplistEx).uniqueSkiplistEx;
passNode = (TRI_skiplistEx_node_t*)(indexGCData->_data);
if (passNode == NULL) {
abort(); // remove after debugging
return TRI_ERROR_INTERNAL;
}
switch (indexGCData->_lastPass) {
case 1: { // the first call from the garbage collector
result = TRI_RemoveElementSkipListEx (skiplist, NULL, NULL, 2, passNode->_delTransID, &passNode);
break;
}
case 2: {
result = TRI_RemoveElementSkipListEx (skiplist, NULL, NULL, 3, passNode->_delTransID, &passNode);
break;
}
case 254: { // just before the node is excised from the skiplist
result = TRI_ERROR_NO_ERROR;
break;
}
case 255: { // just AFTER the node is excised from the skiplist
result = TRI_ERROR_NO_ERROR;
break;
}
default : {
abort();
}
} // end of switch statement
return result;
}
int SkiplistExIndex_remove(SkiplistExIndex* skiplistExIndex, SkiplistExIndexElement* element, uint64_t thisTransID) {
int result;
TRI_skiplistEx_node_t* passNode;
TRI_index_gc_t indexGCData;
// ............................................................................
// This has been called from the database so it has a pass level of 1
// ............................................................................
result = TRI_RemoveElementSkipListEx(skiplistExIndex->_skiplistEx.uniqueSkiplistEx, element,
NULL, 1, thisTransID, &passNode);
if (result == TRI_ERROR_NO_ERROR) {
// ..........................................................................
// add to garbage collection
// ..........................................................................
indexGCData._index = (void*)(skiplistExIndex);
indexGCData._passes = 2;
indexGCData._lastPass = 0; // will be assigned correctly by the GC
indexGCData._transID = 0; // will be assigned correctly by the GC
indexGCData._data = passNode; // the address of the node in the linked list which will eventually be excised
indexGCData._collectGarbage = CollectSkiplistExGarbage;
// ...........................................................................
// Adds an item to the rubbish collection linked list.
// This can fail if the GC is busy and the CAS statements in the GC fail.
// It is up to the calling procedure to determine what to do with this failure,
// generally a retry will suffice.
// ...........................................................................
result = TRI_AddToIndexGC(&indexGCData);
}
return result;
}
//////////////////////////////////////////////////////////////////////////////////
/// @brief updates a skiplist entry
//////////////////////////////////////////////////////////////////////////////////
bool SkiplistExIndex_update(SkiplistExIndex* skiplistExIndex, const SkiplistExIndexElement* beforeElement, const SkiplistExIndexElement* afterElement, uint64_t thisTransID) {
// updates an entry in the skip list, first removes beforeElement,
// then adds the afterElement -- should never be called here
// call SkiplistIndex_remove first and then SkiplistIndex_add
assert(false);
return false; // shuts the VC++ up
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Multi-skiplist non-unique skiplist indexes
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Private methods
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Public Methods Non-Unique Muilti Skiplists
//------------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief creates a new non-uniqe (allows duplicates) multi skiplist
////////////////////////////////////////////////////////////////////////////////
SkiplistExIndex* MultiSkiplistExIndex_new(TRI_transaction_context_t* transactionContext) {
SkiplistExIndex* skiplistExIndex;
int result;
uint64_t lastKnownTransID = 0;
skiplistExIndex = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(SkiplistExIndex), true);
if (skiplistExIndex == NULL) {
return NULL;
}
skiplistExIndex->_unique = false;
skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_skiplistEx_multi_t), true);
if (skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx == NULL) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, skiplistExIndex);
return NULL;
}
skiplistExIndex->_transactionContext = transactionContext;
// TODO ORESTE: determine the last know transaction id from the transaction context
result = TRI_InitSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx,
sizeof(SkiplistExIndexElement),
NULL, NULL, NULL,TRI_SKIPLIST_EX_PROB_HALF, 40,
lastKnownTransID);
if (result != TRI_ERROR_NO_ERROR) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, skiplistExIndex);
return NULL;
}
return skiplistExIndex;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief adds (inserts) a data element into a multi skiplist
////////////////////////////////////////////////////////////////////////////////
int MultiSkiplistExIndex_add(SkiplistExIndex* skiplistExIndex, SkiplistExIndexElement* element, uint64_t thisTransID) {
int result;
result = TRI_InsertElementSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx, element, false, thisTransID);
return result;
}
//////////////////////////////////////////////////////////////////////////////////
/// @brief Locates one or more ranges within the unique skiplist and returns iterator
//////////////////////////////////////////////////////////////////////////////////
static bool multiSkiplistExIndex_findHelperIntervalIntersectionValid(SkiplistExIndex* skiplistExIndex,
TRI_skiplistEx_iterator_interval_t* lInterval,
TRI_skiplistEx_iterator_interval_t* rInterval,
TRI_skiplistEx_iterator_interval_t* interval) {
int compareResult;
TRI_skiplistEx_node_t* lNode;
TRI_skiplistEx_node_t* rNode;
lNode = (TRI_skiplistEx_node_t*)(lInterval->_leftEndPoint);
rNode = (TRI_skiplistEx_node_t*)(rInterval->_leftEndPoint);
if (lNode == TRI_EndNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx) || lNode == NULL ||
rNode == TRI_EndNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx) || rNode == NULL) {
return false;
}
if (lNode == TRI_StartNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx)) {
compareResult = -1;
}
else if (rNode == TRI_StartNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx)) {
compareResult = 1;
}
else {
compareResult = skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx->compareKeyElement(
skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx,
&(lNode->_element), &(rNode->_element), 0);
}
if (compareResult < 1) {
interval->_leftEndPoint = rNode;
}
else {
interval->_leftEndPoint = lNode;
}
lNode = (TRI_skiplistEx_node_t*)(lInterval->_rightEndPoint);
rNode = (TRI_skiplistEx_node_t*)(rInterval->_rightEndPoint);
if (lNode == TRI_EndNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx)) {
compareResult = 1;
}
else if (rNode == TRI_EndNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx)) {
compareResult = -1;
}
else {
compareResult = skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx->compareKeyElement(
skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx,
&(lNode->_element), &(rNode->_element), 0);
}
if (compareResult < 1) {
interval->_rightEndPoint = lNode;
}
else {
interval->_rightEndPoint = rNode;
}
return multiSkiplistExIndex_findHelperIntervalValid(skiplistExIndex, interval);
}
static bool multiSkiplistExIndex_findHelperIntervalValid(SkiplistExIndex* skiplistExIndex, TRI_skiplistEx_iterator_interval_t* interval) {
int compareResult;
TRI_skiplistEx_node_t* lNode;
TRI_skiplistEx_node_t* rNode;
if ((interval->_leftEndPoint == NULL) || (interval->_rightEndPoint == NULL)) {
return 0;
}
if (interval->_leftEndPoint == interval->_rightEndPoint) {
return 0;
}
if ( (interval->_leftEndPoint == TRI_StartNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx)) ||
(interval->_rightEndPoint == TRI_EndNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx))) {
return -1;
}
lNode = (TRI_skiplistEx_node_t*)(interval->_leftEndPoint);
rNode = (TRI_skiplistEx_node_t*)(interval->_rightEndPoint);
compareResult = skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx->compareKeyElement(
skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx,
&(lNode->_element), &(rNode->_element), 0);
return (compareResult == -1);
}
static void MultiSkiplistExIndex_findHelper(SkiplistExIndex* skiplistExIndex,
TRI_vector_t* shapeList,
TRI_index_operator_t* indexOperator,
TRI_vector_t* resultIntervalList,
uint64_t thisTransID) {
SkiplistExIndexElement values;
TRI_vector_t leftResult;
TRI_vector_t rightResult;
TRI_relation_index_operator_t* relationOperator;
TRI_logical_index_operator_t* logicalOperator;
TRI_skiplistEx_iterator_interval_t interval;
TRI_skiplistEx_iterator_interval_t* tempLeftInterval;
TRI_skiplistEx_iterator_interval_t* tempRightInterval;
size_t j;
size_t i;
TRI_InitVector(&(leftResult), TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_skiplistEx_iterator_interval_t));
TRI_InitVector(&(rightResult), TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_skiplistEx_iterator_interval_t));
logicalOperator = (TRI_logical_index_operator_t*)(indexOperator);
relationOperator = (TRI_relation_index_operator_t*)(indexOperator);
switch (indexOperator->_type) {
case TRI_EQ_INDEX_OPERATOR:
case TRI_LE_INDEX_OPERATOR:
case TRI_LT_INDEX_OPERATOR:
case TRI_GE_INDEX_OPERATOR:
case TRI_GT_INDEX_OPERATOR:
values.fields = relationOperator->_fields;
values.numFields = relationOperator->_numFields;
values.collection = relationOperator->_collection;
values.data = 0; // no document pointer available
default: {
// must not access relationOperator->xxx if the operator is not a relational one
// otherwise we'll get invalid reads and the prog might crash
}
}
switch (indexOperator->_type) {
/*
case TRI_SL_OR_OPERATOR: {
todo
}
*/
case TRI_AND_INDEX_OPERATOR: {
MultiSkiplistExIndex_findHelper(skiplistExIndex,shapeList,logicalOperator->_left,&leftResult, thisTransID);
MultiSkiplistExIndex_findHelper(skiplistExIndex,shapeList,logicalOperator->_right,&rightResult, thisTransID);
for (i = 0; i < leftResult._length; ++i) {
for (j = 0; j < rightResult._length; ++j) {
tempLeftInterval = (TRI_skiplistEx_iterator_interval_t*) (TRI_AtVector(&leftResult, i));
tempRightInterval = (TRI_skiplistEx_iterator_interval_t*) (TRI_AtVector(&rightResult, j));
if (!multiSkiplistExIndex_findHelperIntervalIntersectionValid(skiplistExIndex,tempLeftInterval,
tempRightInterval, &interval)) {
continue;
}
TRI_PushBackVector(resultIntervalList,&interval);
}
}
TRI_DestroyVector(&leftResult);
TRI_DestroyVector(&rightResult);
return;
}
case TRI_EQ_INDEX_OPERATOR: {
interval._leftEndPoint = TRI_LeftLookupByKeySkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx, &values, thisTransID);
interval._rightEndPoint = TRI_RightLookupByKeySkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx, &values, thisTransID);
if (multiSkiplistExIndex_findHelperIntervalValid(skiplistExIndex, &interval)) {
TRI_PushBackVector(resultIntervalList, &interval);
}
return;
}
case TRI_LE_INDEX_OPERATOR: {
interval._leftEndPoint = TRI_StartNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx);
interval._rightEndPoint = TRI_RightLookupByKeySkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx, &values, thisTransID);
if (multiSkiplistExIndex_findHelperIntervalValid(skiplistExIndex, &interval)) {
TRI_PushBackVector(resultIntervalList, &interval);
}
return;
}
case TRI_LT_INDEX_OPERATOR: {
interval._leftEndPoint = TRI_StartNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx);
interval._rightEndPoint = TRI_LeftLookupByKeySkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx, &values, thisTransID);
if (interval._rightEndPoint != TRI_EndNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx)) {
interval._rightEndPoint = TRI_NextNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx, interval._rightEndPoint, thisTransID);
}
if (multiSkiplistExIndex_findHelperIntervalValid(skiplistExIndex, &interval)) {
TRI_PushBackVector(resultIntervalList,&interval);
}
return;
}
case TRI_GE_INDEX_OPERATOR: {
interval._leftEndPoint = TRI_LeftLookupByKeySkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx, &values, thisTransID);
interval._rightEndPoint = TRI_EndNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx);
if (multiSkiplistExIndex_findHelperIntervalValid(skiplistExIndex, &interval)) {
TRI_PushBackVector(resultIntervalList,&interval);
}
return;
}
case TRI_GT_INDEX_OPERATOR: {
interval._leftEndPoint = TRI_RightLookupByKeySkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx, &values, thisTransID);
interval._rightEndPoint = TRI_EndNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx);
if (interval._leftEndPoint != TRI_StartNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx)) {
interval._leftEndPoint = TRI_PrevNodeSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx, interval._leftEndPoint, thisTransID);
}
if (multiSkiplistExIndex_findHelperIntervalValid(skiplistExIndex, &interval)) {
TRI_PushBackVector(resultIntervalList, &interval);
}
return;
}
default: {
assert(0);
}
} // end of switch statement
}
TRI_skiplistEx_iterator_t* MultiSkiplistExIndex_find(SkiplistExIndex* skiplistExIndex, TRI_vector_t* shapeList, TRI_index_operator_t* indexOperator, uint64_t thisTransID) {
TRI_skiplistEx_iterator_t* results;
results = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_skiplistEx_iterator_t), false);
if (results == NULL) {
return NULL;
}
results->_index = skiplistExIndex;
TRI_InitVector(&(results->_intervals), TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_skiplistEx_iterator_interval_t));
results->_currentInterval = 0;
results->_cursor = NULL;
results->_thisTransID = thisTransID;
results->_hasNext = SkiplistExHasNextIterationCallback;
results->_next = SkiplistExNextIterationCallback;
results->_nexts = SkiplistExNextsIterationCallback;
results->_hasPrev = SkiplistExHasPrevIterationCallback;
results->_prev = SkiplistExPrevIterationCallback;
results->_prevs = SkiplistExPrevsIterationCallback;
MultiSkiplistExIndex_findHelper(skiplistExIndex, shapeList, indexOperator, &(results->_intervals), thisTransID);
return results;
}
//////////////////////////////////////////////////////////////////////////////////
/// @brief alias for addIndex
//////////////////////////////////////////////////////////////////////////////////
int MultiSkiplistExIndex_insert(SkiplistExIndex* skiplistExIndex, SkiplistExIndexElement* element, uint64_t thisTransID) {
return MultiSkiplistExIndex_add(skiplistExIndex, element, thisTransID);
}
//////////////////////////////////////////////////////////////////////////////////
/// @brief removes an entry from the skiplist
//////////////////////////////////////////////////////////////////////////////////
static int CollectSkiplistExMultiGarbage(TRI_index_gc_t* indexGCData) {
int result = TRI_ERROR_NO_ERROR;
return result;
}
int MultiSkiplistExIndex_remove(SkiplistExIndex* skiplistExIndex, SkiplistExIndexElement* element, uint64_t thisTransID) {
int result;
TRI_skiplistEx_node_t* passNode;
TRI_index_gc_t indexGCData;
// ............................................................................
// This has been called from the database so it has a pass level of 1
// ............................................................................
result = TRI_RemoveElementSkipListExMulti(skiplistExIndex->_skiplistEx.nonUniqueSkiplistEx,
element, NULL, 1, thisTransID, &passNode);
if (result == TRI_ERROR_NO_ERROR) {
// ..........................................................................
// add to garbage collection
// ..........................................................................
indexGCData._index = (void*)(skiplistExIndex);
indexGCData._passes = 2;
indexGCData._lastPass = 0; // will be assigned correctly by the GC
indexGCData._transID = 0; // will be assigned correctly by the GC
indexGCData._data = passNode; // the address of the node in the linked list which will eventually be excised
indexGCData._collectGarbage = CollectSkiplistExMultiGarbage;
result = TRI_AddToIndexGC(&indexGCData); // adds an item to the rubbish collection linked list
}
return result;
}
//////////////////////////////////////////////////////////////////////////////////
/// @brief updates and entry in a multi skiplist
//////////////////////////////////////////////////////////////////////////////////
bool MultiSkiplistExIndex_update(SkiplistExIndex* skiplistExIndex, SkiplistExIndexElement* beforeElement, SkiplistExIndexElement* afterElement, uint64_t thisTransID) {
assert(false); // should never be called directly
return false; // shuts the VC++ up
}
////////////////////////////////////////////////////////////////////////////////////////
// Implementation of forward declared query engine callback functions
////////////////////////////////////////////////////////////////////////////////////////
static int SkiplistExIndex_queryMethodCall(void* theIndex, TRI_index_operator_t* indexOperator,
TRI_index_challenge_t* challenge, void* data) {
SkiplistExIndex* slIndex = (SkiplistExIndex*)(theIndex);
if (slIndex == NULL || indexOperator == NULL) {
return TRI_ERROR_INTERNAL;
}
assert(false);
return TRI_ERROR_NO_ERROR;
}
static TRI_index_iterator_t* SkiplistExIndex_resultMethodCall(void* theIndex, TRI_index_operator_t* indexOperator,
void* data, bool (*filter) (TRI_index_iterator_t*)) {
SkiplistExIndex* slIndex = (SkiplistExIndex*)(theIndex);
if (slIndex == NULL || indexOperator == NULL) {
return NULL;
}
assert(false);
return NULL;
}
static int SkiplistExIndex_freeMethodCall(void* theIndex, void* data) {
SkiplistExIndex* slIndex = (SkiplistExIndex*)(theIndex);
if (slIndex == NULL) {
return TRI_ERROR_INTERNAL;
}
assert(false);
return TRI_ERROR_NO_ERROR;
}
////////////////////////////////////////////////////////////////////////////////
/// @}
////////////////////////////////////////////////////////////////////////////////
#endif
// Local Variables:
// mode: outline-minor
// outline-regexp: "^\\(/// @brief\\|/// {@inheritDoc}\\|/// @addtogroup\\|// --SECTION--\\|/// @\\}\\)"
// End:
Reference in New Issue View Git Blame Copy Permalink