TRI_json_t* TRI_UniquifyListJson (const TRI_json_t* const list) {
TRI_json_t* last = NULL;
TRI_json_t* result;
size_t i, n;
assert(list);
assert(list->_type == TRI_JSON_LIST);
// create result list
result = TRI_CreateListJson(TRI_UNKNOWN_MEM_ZONE);
if (!result) {
return NULL;
}
n = list->_value._objects._length;
for (i = 0; i < n; ++i) {
TRI_json_t* p = TRI_AtVector(&list->_value._objects, i);
// don't push value if it is the same as the last value
if (!last || TRI_CompareValuesJson(p, last) > 0) {
TRI_PushBackListJson(TRI_UNKNOWN_MEM_ZONE, result, p);
// remember last element
last = p;
}
}
return result;
}
TRI_json_t* TRI_BetweenListJson (const TRI_json_t* const list,
const TRI_json_t* const lower,
const bool includeLower,
const TRI_json_t* const upper,
const bool includeUpper) {
TRI_json_t* result;
size_t i, n;
TRI_ASSERT(list);
TRI_ASSERT(list->_type == TRI_JSON_LIST);
TRI_ASSERT(lower || upper);
// create result list
result = TRI_CreateListJson(TRI_UNKNOWN_MEM_ZONE);
if (result == NULL) {
return NULL;
}
n = list->_value._objects._length;
for (i = 0; i < n; ++i) {
TRI_json_t* p = TRI_AtVector(&list->_value._objects, i);
if (lower) {
// lower bound is set
int compareResult = TRI_CompareValuesJson(lower, p);
if (compareResult > 0 || (compareResult == 0 && ! includeLower)) {
// element is bigger than lower bound
continue;
}
}
if (upper) {
// upper bound is set
int compareResult = TRI_CompareValuesJson(p, upper);
if (compareResult > 0 || (compareResult == 0 && ! includeUpper)) {
// element is smaller than upper bound
continue;
}
}
// element is between lower and upper bound
TRI_PushBackListJson(TRI_UNKNOWN_MEM_ZONE, result, p);
}
return result;
}
static TRI_json_t* JsonGeo2Index (TRI_index_t const* idx) {
TRI_json_t* json;
TRI_json_t* fields;
TRI_shape_path_t const* path;
char const* latitude;
char const* longitude;
TRI_geo_index_t const* geo = (TRI_geo_index_t const*) idx;
TRI_document_collection_t* document = idx->_collection;
// convert latitude to string
path = document->getShaper()->lookupAttributePathByPid(document->getShaper(), geo->_latitude); // ONLY IN INDEX, PROTECTED by RUNTIME
if (path == 0) {
return nullptr;
}
latitude = TRI_NAME_SHAPE_PATH(path);
// convert longitude to string
path = document->getShaper()->lookupAttributePathByPid(document->getShaper(), geo->_longitude); // ONLY IN INDEX, PROTECTED by RUNTIME
if (path == 0) {
return nullptr;
}
longitude = TRI_NAME_SHAPE_PATH(path);
// create json
json = TRI_JsonIndex(TRI_CORE_MEM_ZONE, idx);
if (json == nullptr) {
return nullptr;
}
// "constraint" and "unique" are identical for geo indexes.
// we return "constraint" just for downwards-compatibility
TRI_Insert3ArrayJson(TRI_CORE_MEM_ZONE, json, "constraint", TRI_CreateBooleanJson(TRI_CORE_MEM_ZONE, idx->_unique));
TRI_Insert3ArrayJson(TRI_CORE_MEM_ZONE, json, "ignoreNull", TRI_CreateBooleanJson(TRI_CORE_MEM_ZONE, geo->base._ignoreNull));
fields = TRI_CreateListJson(TRI_CORE_MEM_ZONE);
TRI_PushBack3ListJson(TRI_CORE_MEM_ZONE, fields, TRI_CreateStringCopyJson(TRI_CORE_MEM_ZONE, latitude));
TRI_PushBack3ListJson(TRI_CORE_MEM_ZONE, fields, TRI_CreateStringCopyJson(TRI_CORE_MEM_ZONE, longitude));
TRI_Insert3ArrayJson(TRI_CORE_MEM_ZONE, json, "fields", fields);
return json;
}
static TRI_aql_explain_t* CreateExplain (void) {
TRI_aql_explain_t* explain;
explain = (TRI_aql_explain_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_explain_t), false);
if (explain == NULL) {
return NULL;
}
explain->_count = 0;
explain->_level = 0;
explain->_result = TRI_CreateListJson(TRI_UNKNOWN_MEM_ZONE);
if (explain->_result == NULL) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, explain);
return NULL;
}
return explain;
}
static TRI_json_t* GetMergedKeyList (const TRI_json_t* const lhs,
const TRI_json_t* const rhs) {
TRI_json_t* keys;
TRI_json_t* unique;
size_t i, n;
assert(lhs->_type == TRI_JSON_ARRAY);
assert(rhs->_type == TRI_JSON_ARRAY);
keys = TRI_CreateListJson(TRI_UNKNOWN_MEM_ZONE);
if (keys == NULL) {
return NULL;
}
n = lhs->_value._objects._length;
for (i = 0 ; i < n; i += 2) {
TRI_json_t* key = TRI_AtVector(&lhs->_value._objects, i);
assert(key->_type == TRI_JSON_STRING);
TRI_PushBackListJson(TRI_UNKNOWN_MEM_ZONE, keys, key);
}
n = rhs->_value._objects._length;
for (i = 0 ; i < n; i += 2) {
TRI_json_t* key = TRI_AtVector(&rhs->_value._objects, i);
assert(key->_type == TRI_JSON_STRING);
TRI_PushBackListJson(TRI_UNKNOWN_MEM_ZONE, keys, key);
}
// sort the key list in place
TRI_SortListJson(keys);
// list is now sorted
unique = TRI_UniquifyListJson(keys);
TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, keys);
return unique; // might be NULL
}
static TRI_json_t* JsonHashIndex (TRI_index_t* idx,
TRI_primary_collection_t const* primary) {
TRI_json_t* json;
TRI_json_t* fields;
TRI_hash_index_t* hashIndex;
char const** fieldList;
size_t j;
// .............................................................................
// Recast as a hash index
// .............................................................................
hashIndex = (TRI_hash_index_t*) idx;
// .............................................................................
// Allocate sufficent memory for the field list
// .............................................................................
fieldList = TRI_FieldListByPathList(primary->_shaper, &hashIndex->_paths);
if (fieldList == NULL) {
return NULL;
}
// ..........................................................................
// create json object and fill it
// ..........................................................................
json = TRI_JsonIndex(TRI_CORE_MEM_ZONE, idx);
fields = TRI_CreateListJson(TRI_CORE_MEM_ZONE);
for (j = 0; j < hashIndex->_paths._length; ++j) {
TRI_PushBack3ListJson(TRI_CORE_MEM_ZONE, fields, TRI_CreateStringCopyJson(TRI_CORE_MEM_ZONE, fieldList[j]));
}
TRI_Insert3ArrayJson(TRI_CORE_MEM_ZONE, json, "fields", fields);
TRI_Free(TRI_CORE_MEM_ZONE, fieldList);
return json;
}
TRI_json_t* TRI_IntersectListsJson (const TRI_json_t* const list1,
const TRI_json_t* const list2,
const bool unique) {
TRI_json_t* last = NULL;
TRI_json_t* result;
size_t i1, i2;
size_t n1, n2;
assert(list1);
assert(list1->_type == TRI_JSON_LIST);
assert(list2);
assert(list2->_type == TRI_JSON_LIST);
// create result list
result = TRI_CreateListJson(TRI_UNKNOWN_MEM_ZONE);
if (!result) {
return NULL;
}
n1 = list1->_value._objects._length;
n2 = list2->_value._objects._length;
// special case for empty lists
if (n1 == 0 || n2 == 0) {
return result;
}
// reset positions
i1 = 0;
i2 = 0;
// iterate over lists
while (i1 < n1 && i2 < n2) {
// pointers to elements in both lists
TRI_json_t* p1 = TRI_AtVector(&list1->_value._objects, i1);
TRI_json_t* p2 = TRI_AtVector(&list2->_value._objects, i2);
int compareResult = TRI_CompareValuesJson(p1, p2);
if (compareResult < 0) {
// left element is smaller
++i1;
}
else if (compareResult > 0) {
// right element is smaller
++i2;
}
else {
// both elements are equal
if (!unique || !last || TRI_CompareValuesJson(p1, last) > 0) {
TRI_PushBackListJson(TRI_UNKNOWN_MEM_ZONE, result, p1);
last = p1;
if (!unique) {
TRI_PushBackListJson(TRI_UNKNOWN_MEM_ZONE, result, p2);
}
}
++i1;
++i2;
}
}
return result;
}
TRI_json_t* TRI_UnionizeListsJson (const TRI_json_t* const list1,
const TRI_json_t* const list2,
const bool unique) {
TRI_json_t* last = NULL;
TRI_json_t* result;
size_t i1, i2;
size_t n1, n2;
assert(list1);
assert(list1->_type == TRI_JSON_LIST);
assert(list2);
assert(list2->_type == TRI_JSON_LIST);
n1 = list1->_value._objects._length;
n2 = list2->_value._objects._length;
// special cases for empty lists
if (n1 == 0 && !unique) {
return TRI_CopyJson(TRI_UNKNOWN_MEM_ZONE, (TRI_json_t*) list2);
}
if (n2 == 0 && !unique) {
return TRI_CopyJson(TRI_UNKNOWN_MEM_ZONE, (TRI_json_t*) list1);
}
// create result list
result = TRI_CreateListJson(TRI_UNKNOWN_MEM_ZONE);
if (!result) {
return NULL;
}
// reset positions
i1 = 0;
i2 = 0;
// iterate over lists
while (true) {
// pointers to elements in both lists
TRI_json_t* p1;
TRI_json_t* p2;
if (i1 < n1 && i2 < n2) {
int compareResult;
// both lists not yet exhausted
p1 = TRI_AtVector(&list1->_value._objects, i1);
p2 = TRI_AtVector(&list2->_value._objects, i2);
compareResult = TRI_CompareValuesJson(p1, p2);
if (compareResult < 0) {
// left element is smaller
if (!unique || !last || TRI_CompareValuesJson(p1, last) > 0) {
TRI_PushBackListJson(TRI_UNKNOWN_MEM_ZONE, result, p1);
last = p1;
}
++i1;
}
else if (compareResult > 0) {
// right element is smaller
if (!unique || !last || TRI_CompareValuesJson(p2, last) > 0) {
TRI_PushBackListJson(TRI_UNKNOWN_MEM_ZONE, result, p2);
last = p2;
}
++i2;
}
else {
// both elements are equal
if (!unique || !last || TRI_CompareValuesJson(p1, last) > 0) {
TRI_PushBackListJson(TRI_UNKNOWN_MEM_ZONE, result, p1);
last = p1;
if (!unique) {
TRI_PushBackListJson(TRI_UNKNOWN_MEM_ZONE, result, p2);
}
}
++i1;
++i2;
}
}
else if (i1 < n1 && i2 >= n2) {
// only right list is exhausted
p1 = TRI_AtVector(&list1->_value._objects, i1);
if (!unique || !last || TRI_CompareValuesJson(p1, last) > 0) {
TRI_PushBackListJson(TRI_UNKNOWN_MEM_ZONE, result, p1);
last = p1;
}
++i1;
}
else if (i1 >= n1 && i2 < n2) {
// only left list is exhausted
p2 = TRI_AtVector(&list2->_value._objects, i2);
if (!unique || !last || TRI_CompareValuesJson(p2, last) > 0) {
TRI_PushBackListJson(TRI_UNKNOWN_MEM_ZONE, result, p2);
last = p2;
}
++i2;
}
else {
// both lists exhausted, stop!
break;
}
}
return result;
}
TRI_json_t* TRI_NodeJsonAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const node) {
switch (node->_type) {
case TRI_AQL_NODE_VALUE: {
switch (node->_value._type) {
case TRI_AQL_TYPE_FAIL:
case TRI_AQL_TYPE_NULL:
return TRI_CreateNullJson(TRI_UNKNOWN_MEM_ZONE);
case TRI_AQL_TYPE_BOOL:
return TRI_CreateBooleanJson(TRI_UNKNOWN_MEM_ZONE, node->_value._value._bool);
case TRI_AQL_TYPE_INT:
return TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, (double) node->_value._value._int);
case TRI_AQL_TYPE_DOUBLE:
return TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, node->_value._value._double);
case TRI_AQL_TYPE_STRING:
return TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, node->_value._value._string);
}
}
case TRI_AQL_NODE_LIST: {
TRI_json_t* result = TRI_CreateListJson(TRI_UNKNOWN_MEM_ZONE);
if (result) {
size_t i, n;
n = node->_members._length;
for (i = 0; i < n; ++i) {
TRI_json_t* subValue = TRI_NodeJsonAql(context, TRI_AQL_NODE_MEMBER(node, i));
if (subValue) {
TRI_PushBack3ListJson(TRI_UNKNOWN_MEM_ZONE, result, subValue);
}
}
}
return result;
}
case TRI_AQL_NODE_ARRAY: {
TRI_json_t* result = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE);
if (result) {
size_t i, n;
n = node->_members._length;
for (i = 0; i < n; ++i) {
TRI_aql_node_t* element = TRI_AQL_NODE_MEMBER(node, i);
TRI_json_t* subValue = TRI_NodeJsonAql(context, TRI_AQL_NODE_MEMBER(element, 0));
if (subValue) {
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE,
result,
TRI_AQL_NODE_STRING(element),
subValue);
}
}
}
return result;
}
default: {
return NULL;
}
}
}
