static void LogIndexString (const char* const what,
TRI_index_t const* idx,
char const* collectionName) {
TRI_string_buffer_t* buffer = TRI_CreateStringBuffer(TRI_UNKNOWN_MEM_ZONE);
size_t i;
if (buffer == NULL) {
return;
}
for (i = 0; i < idx->_fields._length; i++) {
if (i > 0) {
TRI_AppendStringStringBuffer(buffer, ", ");
}
TRI_AppendStringStringBuffer(buffer, idx->_fields._buffer[i]);
}
LOG_TRACE("%s %s index (%s) for '%s'",
what,
TRI_TypeNameIndex(idx->_type),
buffer->_buffer,
collectionName);
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buffer);
}
bool TRI_ValueStringAql (TRI_string_buffer_t* const buffer,
const TRI_aql_value_t* const value,
const TRI_aql_value_type_e type) {
switch (type) {
case TRI_AQL_TYPE_FAIL:
return (TRI_AppendStringStringBuffer(buffer, "fail") == TRI_ERROR_NO_ERROR);
case TRI_AQL_TYPE_NULL:
return (TRI_AppendStringStringBuffer(buffer, "null") == TRI_ERROR_NO_ERROR);
case TRI_AQL_TYPE_BOOL:
return (TRI_AppendStringStringBuffer(buffer, value->_value._bool ? "true" : "false") == TRI_ERROR_NO_ERROR);
case TRI_AQL_TYPE_INT:
return (TRI_AppendInt64StringBuffer(buffer, value->_value._int) == TRI_ERROR_NO_ERROR);
case TRI_AQL_TYPE_DOUBLE:
return (TRI_AppendDoubleStringBuffer(buffer, value->_value._double) == TRI_ERROR_NO_ERROR);
case TRI_AQL_TYPE_STRING: {
if (TRI_AppendCharStringBuffer(buffer, '"') != TRI_ERROR_NO_ERROR) {
return false;
}
if (TRI_AppendStringStringBuffer(buffer, value->_value._string) != TRI_ERROR_NO_ERROR) {
return false;
}
return (TRI_AppendCharStringBuffer(buffer, '"') == TRI_ERROR_NO_ERROR);
}
}
return false;
}
void TRI_ConvertOrderQueryJavascript (TRI_query_javascript_converter_t* converter,
const TRI_query_node_t* const node,
TRI_associative_pointer_t* bindParameters) {
TRI_query_node_t* lhs;
TRI_query_node_t* rhs;
TRI_query_node_t* current;
if (!node) {
return;
}
current = (TRI_query_node_t*) node;
// iterate over all sort dimensions
while (current) {
// set the initial lhs and rhs values
assert(current->_lhs);
assert(current->_rhs);
lhs = current->_lhs;
TRI_AppendStringStringBuffer(converter->_buffer, "lhs=");
converter->_prefix = "l";
TRI_ConvertQueryJavascript(converter, lhs, bindParameters);
TRI_AppendStringStringBuffer(converter->_buffer, ";rhs=");
converter->_prefix = "r";
TRI_ConvertQueryJavascript(converter, lhs, bindParameters);
rhs = current->_rhs;
if (rhs->_value._boolValue) {
// sort ascending
TRI_AppendStringStringBuffer(
converter->_buffer,
";if(lhs<rhs)return -1;if(lhs>rhs)return 1;"
);
}
else {
// sort descending
TRI_AppendStringStringBuffer(
converter->_buffer,
";if(lhs<rhs)return 1;if(lhs>rhs)return -1;"
);
}
// next sort dimension
current = current->_next;
}
// finally return 0 if all values are the same
TRI_AppendStringStringBuffer(converter->_buffer, "return 0;");
}
bool TRI_ValueJavascriptAql (TRI_string_buffer_t* const buffer,
const TRI_aql_value_t* const value,
const TRI_aql_value_type_e type) {
switch (type) {
case TRI_AQL_TYPE_FAIL:
return (TRI_AppendStringStringBuffer(buffer, "fail") == TRI_ERROR_NO_ERROR);
case TRI_AQL_TYPE_NULL:
return (TRI_AppendStringStringBuffer(buffer, "null") == TRI_ERROR_NO_ERROR);
case TRI_AQL_TYPE_BOOL:
return (TRI_AppendStringStringBuffer(buffer, value->_value._bool ? "true" : "false") == TRI_ERROR_NO_ERROR);
case TRI_AQL_TYPE_INT:
return (TRI_AppendInt64StringBuffer(buffer, value->_value._int) == TRI_ERROR_NO_ERROR);
case TRI_AQL_TYPE_DOUBLE:
return (TRI_AppendDoubleStringBuffer(buffer, value->_value._double) == TRI_ERROR_NO_ERROR);
case TRI_AQL_TYPE_STRING: {
char* escapedString;
size_t outLength;
if (TRI_AppendCharStringBuffer(buffer, '"') != TRI_ERROR_NO_ERROR) {
return false;
}
escapedString = TRI_EscapeUtf8StringZ(TRI_UNKNOWN_MEM_ZONE,
value->_value._string,
strlen(value->_value._string),
false,
&outLength);
if (escapedString == NULL) {
return false;
}
if (TRI_AppendStringStringBuffer(buffer, escapedString) != TRI_ERROR_NO_ERROR) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, escapedString);
return false;
}
TRI_Free(TRI_UNKNOWN_MEM_ZONE, escapedString);
return (TRI_AppendCharStringBuffer(buffer, '"') == TRI_ERROR_NO_ERROR);
}
}
return false;
}
static TRI_string_buffer_t* FcallCode (const char* const name,
const TRI_aql_node_t* const args) {
TRI_string_buffer_t* buffer = TRI_CreateStringBuffer(TRI_UNKNOWN_MEM_ZONE);
size_t i;
size_t n;
if (!buffer) {
return NULL;
}
if (TRI_AppendStringStringBuffer(buffer, "(function(){return AHUACATL_FCALL(") != TRI_ERROR_NO_ERROR) {
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buffer);
return NULL;
}
if (TRI_AppendStringStringBuffer(buffer, name) != TRI_ERROR_NO_ERROR) {
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buffer);
return NULL;
}
if (TRI_AppendStringStringBuffer(buffer, ",[") != TRI_ERROR_NO_ERROR) {
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buffer);
return NULL;
}
n = args->_members._length;
for (i = 0; i < n; ++i) {
TRI_aql_node_t* arg = (TRI_aql_node_t*) args->_members._buffer[i];
if (i > 0) {
if (TRI_AppendCharStringBuffer(buffer, ',') != TRI_ERROR_NO_ERROR) {
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buffer);
return NULL;
}
}
if (!TRI_NodeJavascriptAql(buffer, arg)) {
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buffer);
return NULL;
}
}
if (TRI_AppendStringStringBuffer(buffer, "]);})") != TRI_ERROR_NO_ERROR) {
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buffer);
return NULL;
}
return buffer;
}
static TRI_string_buffer_t* RelationCode (const char* const name,
const TRI_aql_node_t* const lhs,
const TRI_aql_node_t* const rhs) {
TRI_string_buffer_t* buffer = TRI_CreateStringBuffer(TRI_UNKNOWN_MEM_ZONE);
if (!lhs || !rhs) {
return NULL;
}
if (TRI_AppendStringStringBuffer(buffer, "(function(){return AHUACATL_RELATIONAL_") != TRI_ERROR_NO_ERROR) {
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buffer);
return NULL;
}
if (TRI_AppendStringStringBuffer(buffer, name) != TRI_ERROR_NO_ERROR) {
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buffer);
return NULL;
}
if (TRI_AppendStringStringBuffer(buffer, "(") != TRI_ERROR_NO_ERROR) {
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buffer);
return NULL;
}
if (!TRI_NodeJavascriptAql(buffer, lhs)) {
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buffer);
return NULL;
}
if (TRI_AppendCharStringBuffer(buffer, ',') != TRI_ERROR_NO_ERROR) {
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buffer);
return NULL;
}
if (!TRI_NodeJavascriptAql(buffer, rhs)) {
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buffer);
return NULL;
}
if (TRI_AppendStringStringBuffer(buffer, ");})") != TRI_ERROR_NO_ERROR) {
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buffer);
return NULL;
}
return buffer;
}
char* TRI_GetFunctionCodeQueryJavascript (const TRI_query_node_t* const node,
TRI_associative_pointer_t* bindParameters) {
TRI_query_javascript_converter_t* js;
char* function = NULL;
assert(node);
js = TRI_InitQueryJavascript();
if (js) {
TRI_AppendStringStringBuffer(js->_buffer, "(function($) { return ");
TRI_ConvertQueryJavascript(js, node, bindParameters);
TRI_AppendStringStringBuffer(js->_buffer, " })");
function = TRI_DuplicateString(js->_buffer->_buffer);
TRI_FreeQueryJavascript(js);
}
return function;
}
static TRI_json_t* NodeType (const TRI_aql_node_t* const node) {
TRI_json_t* result;
TRI_string_buffer_t buffer;
assert(node);
TRI_InitStringBuffer(&buffer, TRI_UNKNOWN_MEM_ZONE);
TRI_AppendStringStringBuffer(&buffer, TRI_NodeGroupAql(node, true));
result = TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, buffer._buffer);
TRI_DestroyStringBuffer(&buffer);
return result;
}
static bool AppendListValues (TRI_string_buffer_t* const buffer,
const TRI_aql_node_t* const node,
convert_f func) {
size_t i, n;
n = node->_members._length;
for (i = 0; i < n; ++i) {
if (i > 0) {
if (TRI_AppendStringStringBuffer(buffer, ", ") != TRI_ERROR_NO_ERROR) {
return false;
}
}
if (! func(buffer, TRI_AQL_NODE_MEMBER(node, i))) {
return false;
}
}
return true;
}
void TRI_ConvertQueryJavascript (TRI_query_javascript_converter_t* converter,
const TRI_query_node_t* const node,
TRI_associative_pointer_t* bindParameters) {
TRI_query_node_t* lhs;
TRI_query_node_t* rhs;
TRI_bind_parameter_t* parameter;
char* escapedString;
size_t outLength;
assert(converter);
assert(bindParameters);
if (!node) {
return;
}
lhs = node->_lhs;
rhs = node->_rhs;
switch (node->_type) {
case TRI_QueryNodeValueUndefined:
TRI_AppendStringStringBuffer(converter->_buffer, "undefined");
return;
case TRI_QueryNodeValueNull:
TRI_AppendStringStringBuffer(converter->_buffer, "null");
return;
case TRI_QueryNodeValueBool:
TRI_AppendStringStringBuffer(converter->_buffer,
node->_value._boolValue ? "true" : "false");
return;
case TRI_QueryNodeValueString:
TRI_AppendCharStringBuffer(converter->_buffer, '"');
escapedString = TRI_EscapeUtf8String(
node->_value._stringValue,
strlen(node->_value._stringValue),
false,
&outLength
);
if (escapedString) {
TRI_AppendStringStringBuffer(converter->_buffer, escapedString);
TRI_Free(escapedString);
}
TRI_AppendCharStringBuffer(converter->_buffer, '"');
return;
case TRI_QueryNodeValueNumberInt:
TRI_AppendInt64StringBuffer(converter->_buffer, node->_value._intValue);
return;
case TRI_QueryNodeValueNumberDouble:
TRI_AppendDoubleStringBuffer(converter->_buffer, node->_value._doubleValue);
return;
case TRI_QueryNodeValueNumberDoubleString:
TRI_AppendStringStringBuffer(converter->_buffer, node->_value._stringValue);
return;
case TRI_QueryNodeValueArray:
TRI_AppendCharStringBuffer(converter->_buffer, '[');
TRI_WalkListQueryJavascript(converter, rhs, bindParameters, ',', 0);
TRI_AppendCharStringBuffer(converter->_buffer, ']');
return;
case TRI_QueryNodeValueDocument:
TRI_AppendCharStringBuffer(converter->_buffer, '{');
TRI_WalkListQueryJavascript(converter, rhs, bindParameters, ',', 0);
TRI_AppendCharStringBuffer(converter->_buffer, '}');
return;
case TRI_QueryNodeValueParameterNamed:
parameter = (TRI_bind_parameter_t*)
TRI_LookupByKeyAssociativePointer(bindParameters,
node->_value._stringValue);
assert(parameter);
TRI_StringifyJson(converter->_buffer, parameter->_data);
return;
case TRI_QueryNodeValueIdentifier:
TRI_AppendStringStringBuffer(converter->_buffer,
node->_value._stringValue);
return;
case TRI_QueryNodeValueNamedValue:
TRI_ConvertQueryJavascript(converter, lhs, bindParameters);
TRI_AppendCharStringBuffer(converter->_buffer, ':');
TRI_ConvertQueryJavascript(converter, rhs, bindParameters);
return;
case TRI_QueryNodeReferenceCollectionAlias:
if (!converter->_prefix) {
TRI_AppendStringStringBuffer(converter->_buffer, "$['");
TRI_AppendStringStringBuffer(converter->_buffer,
node->_value._stringValue);
TRI_AppendStringStringBuffer(converter->_buffer, "']");
}
else {
TRI_AppendStringStringBuffer(converter->_buffer, "$['");
TRI_AppendStringStringBuffer(converter->_buffer,
converter->_prefix);
TRI_AppendStringStringBuffer(converter->_buffer, "'].");
TRI_AppendStringStringBuffer(converter->_buffer,
node->_value._stringValue);
}
return;
case TRI_QueryNodeUnaryOperatorPlus:
case TRI_QueryNodeUnaryOperatorMinus:
case TRI_QueryNodeUnaryOperatorNot:
TRI_AppendStringStringBuffer(
converter->_buffer,
TRI_QueryNodeGetUnaryOperatorString(node->_type)
);
TRI_ConvertQueryJavascript(converter, lhs, bindParameters);
return;
case TRI_QueryNodeBinaryOperatorAnd:
case TRI_QueryNodeBinaryOperatorOr:
case TRI_QueryNodeBinaryOperatorIdentical:
case TRI_QueryNodeBinaryOperatorUnidentical:
case TRI_QueryNodeBinaryOperatorEqual:
case TRI_QueryNodeBinaryOperatorUnequal:
case TRI_QueryNodeBinaryOperatorLess:
case TRI_QueryNodeBinaryOperatorGreater:
case TRI_QueryNodeBinaryOperatorLessEqual:
case TRI_QueryNodeBinaryOperatorGreaterEqual:
case TRI_QueryNodeBinaryOperatorAdd:
case TRI_QueryNodeBinaryOperatorSubtract:
case TRI_QueryNodeBinaryOperatorMultiply:
case TRI_QueryNodeBinaryOperatorDivide:
case TRI_QueryNodeBinaryOperatorModulus:
case TRI_QueryNodeBinaryOperatorIn:
TRI_AppendCharStringBuffer(converter->_buffer, '(');
TRI_ConvertQueryJavascript(converter, lhs, bindParameters);
TRI_AppendStringStringBuffer(
converter->_buffer,
TRI_QueryNodeGetBinaryOperatorString(node->_type)
);
TRI_ConvertQueryJavascript(converter, rhs, bindParameters);
TRI_AppendCharStringBuffer(converter->_buffer, ')');
return;
case TRI_QueryNodeContainerMemberAccess:
TRI_ConvertQueryJavascript(converter, lhs, bindParameters);
TRI_WalkListQueryJavascript(converter, rhs, bindParameters, '.', 1);
return;
case TRI_QueryNodeContainerTernarySwitch:
TRI_ConvertQueryJavascript(converter, lhs, bindParameters);
TRI_AppendCharStringBuffer(converter->_buffer, ':');
TRI_ConvertQueryJavascript(converter, rhs, bindParameters);
return;
case TRI_QueryNodeControlFunctionCall:
TRI_ConvertQueryJavascript(converter, lhs, bindParameters);
TRI_AppendCharStringBuffer(converter->_buffer, '(');
TRI_WalkListQueryJavascript(converter, rhs, bindParameters, ',', 0);
TRI_AppendCharStringBuffer(converter->_buffer, ')');
return;
case TRI_QueryNodeControlTernary:
TRI_AppendCharStringBuffer(converter->_buffer, '(');
TRI_ConvertQueryJavascript(converter, lhs, bindParameters);
TRI_AppendCharStringBuffer(converter->_buffer, '?');
TRI_ConvertQueryJavascript(converter, rhs, bindParameters);
TRI_AppendCharStringBuffer(converter->_buffer, ')');
return;
default:
return;
}
}
static int StringifyJson (TRI_memory_zone_t* zone,
TRI_string_buffer_t* buffer,
TRI_json_t const* object,
bool braces) {
size_t n;
size_t i;
size_t outLength;
char* ptr;
int res;
switch (object->_type) {
case TRI_JSON_UNUSED:
break;
case TRI_JSON_NULL:
res = TRI_AppendStringStringBuffer(buffer, "null");
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
break;
case TRI_JSON_BOOLEAN:
if (object->_value._boolean) {
res = TRI_AppendStringStringBuffer(buffer, "true");
}
else {
res = TRI_AppendStringStringBuffer(buffer, "false");
}
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
break;
case TRI_JSON_NUMBER:
res = TRI_AppendDoubleStringBuffer(buffer, object->_value._number);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
break;
case TRI_JSON_STRING:
res = TRI_AppendStringStringBuffer(buffer, "\"");
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
ptr = TRI_EscapeUtf8StringZ(zone,
object->_value._string.data,
object->_value._string.length - 1,
false,
&outLength);
if (ptr == NULL) {
return TRI_ERROR_OUT_OF_MEMORY;
}
res = TRI_AppendString2StringBuffer(buffer, ptr, outLength);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
TRI_Free(zone, ptr);
res = TRI_AppendStringStringBuffer(buffer, "\"");
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
break;
case TRI_JSON_ARRAY:
if (braces) {
res = TRI_AppendStringStringBuffer(buffer, "{");
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
}
n = object->_value._objects._length;
for (i = 0; i < n; i += 2) {
if (0 < i) {
res = TRI_AppendStringStringBuffer(buffer, ",");
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
}
res = StringifyJson(zone, buffer, TRI_AtVector(&object->_value._objects, i), true);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
res = TRI_AppendCharStringBuffer(buffer, ':');
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
res = StringifyJson(zone, buffer, TRI_AtVector(&object->_value._objects, i + 1), true);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
}
if (braces) {
res = TRI_AppendStringStringBuffer(buffer, "}");
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
}
break;
case TRI_JSON_LIST:
if (braces) {
res = TRI_AppendStringStringBuffer(buffer, "[");
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
}
n = object->_value._objects._length;
for (i = 0; i < n; ++i) {
if (0 < i) {
res = TRI_AppendStringStringBuffer(buffer, ",");
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
}
res = StringifyJson(zone, buffer, TRI_AtVector(&object->_value._objects, i), true);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
}
if (braces) {
res = TRI_AppendStringStringBuffer(buffer, "]");
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
}
break;
}
return TRI_ERROR_NO_ERROR;
}
bool TRI_NodeStringAql (TRI_string_buffer_t* const buffer,
const TRI_aql_node_t* const node) {
switch (node->_type) {
case TRI_AQL_NODE_VALUE: {
return TRI_ValueStringAql(buffer, &node->_value, node->_value._type);
}
case TRI_AQL_NODE_ARRAY_ELEMENT: {
if (! TRI_ValueStringAql(buffer, &node->_value, TRI_AQL_TYPE_STRING)) {
return false;
}
if (TRI_AppendStringStringBuffer(buffer, " : ") != TRI_ERROR_NO_ERROR) {
return false;
}
return TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0));
}
case TRI_AQL_NODE_LIST: {
if (TRI_AppendStringStringBuffer(buffer, "[ ") != TRI_ERROR_NO_ERROR) {
return false;
}
if (! AppendListValues(buffer, node, &TRI_NodeStringAql)) {
return false;
}
return (TRI_AppendStringStringBuffer(buffer, " ]") == TRI_ERROR_NO_ERROR);
}
case TRI_AQL_NODE_ARRAY: {
if (TRI_AppendStringStringBuffer(buffer, "{ ") != TRI_ERROR_NO_ERROR) {
return false;
}
if (! AppendListValues(buffer, node, &TRI_NodeStringAql)) {
return false;
}
return (TRI_AppendStringStringBuffer(buffer, " }") == TRI_ERROR_NO_ERROR);
}
case TRI_AQL_NODE_OPERATOR_UNARY_PLUS:
case TRI_AQL_NODE_OPERATOR_UNARY_MINUS:
case TRI_AQL_NODE_OPERATOR_UNARY_NOT: {
if (TRI_AppendStringStringBuffer(buffer, GetStringOperator(node->_type)) != TRI_ERROR_NO_ERROR) {
return false;
}
return TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0));
}
case TRI_AQL_NODE_OPERATOR_BINARY_AND:
case TRI_AQL_NODE_OPERATOR_BINARY_OR:
case TRI_AQL_NODE_OPERATOR_BINARY_PLUS:
case TRI_AQL_NODE_OPERATOR_BINARY_MINUS:
case TRI_AQL_NODE_OPERATOR_BINARY_TIMES:
case TRI_AQL_NODE_OPERATOR_BINARY_DIV:
case TRI_AQL_NODE_OPERATOR_BINARY_MOD:
case TRI_AQL_NODE_OPERATOR_BINARY_EQ:
case TRI_AQL_NODE_OPERATOR_BINARY_NE:
case TRI_AQL_NODE_OPERATOR_BINARY_LT:
case TRI_AQL_NODE_OPERATOR_BINARY_LE:
case TRI_AQL_NODE_OPERATOR_BINARY_GT:
case TRI_AQL_NODE_OPERATOR_BINARY_GE:
case TRI_AQL_NODE_OPERATOR_BINARY_IN: {
if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0))) {
return false;
}
if (TRI_AppendStringStringBuffer(buffer, GetStringOperator(node->_type)) != TRI_ERROR_NO_ERROR) {
return false;
}
return TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 1));
}
case TRI_AQL_NODE_OPERATOR_TERNARY: {
if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0))) {
return false;
}
if (TRI_AppendStringStringBuffer(buffer, " ? ") != TRI_ERROR_NO_ERROR) {
return false;
}
if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 1))) {
return false;
}
if (TRI_AppendStringStringBuffer(buffer, " : ") != TRI_ERROR_NO_ERROR) {
return false;
}
return TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 2));
}
case TRI_AQL_NODE_ATTRIBUTE_ACCESS: {
if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0))) {
return false;
}
if (TRI_AppendStringStringBuffer(buffer, ".") != TRI_ERROR_NO_ERROR) {
return false;
}
return TRI_AppendStringStringBuffer(buffer, TRI_AQL_NODE_STRING(node)) == TRI_ERROR_NO_ERROR;
}
case TRI_AQL_NODE_INDEXED: {
if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0))) {
return false;
}
if (TRI_AppendStringStringBuffer(buffer, "[") != TRI_ERROR_NO_ERROR) {
return false;
}
if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 1))) {
return false;
}
return TRI_AppendStringStringBuffer(buffer, "]") == TRI_ERROR_NO_ERROR;
}
case TRI_AQL_NODE_FCALL: {
TRI_aql_function_t* function = (TRI_aql_function_t*) TRI_AQL_NODE_DATA(node);
if (TRI_AppendStringStringBuffer(buffer, function->_externalName) != TRI_ERROR_NO_ERROR) {
return false;
}
if (TRI_AppendStringStringBuffer(buffer, "(") != TRI_ERROR_NO_ERROR) {
return false;
}
if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0))) {
return false;
}
return TRI_AppendStringStringBuffer(buffer, ")") == TRI_ERROR_NO_ERROR;
}
case TRI_AQL_NODE_EXPAND: {
return TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 3));
}
case TRI_AQL_NODE_REFERENCE: {
return TRI_AppendStringStringBuffer(buffer, TRI_AQL_NODE_STRING(node)) == TRI_ERROR_NO_ERROR;
}
case TRI_AQL_NODE_COLLECTION: {
TRI_aql_node_t* nameNode = TRI_AQL_NODE_MEMBER(node, 0);
char* name = TRI_AQL_NODE_STRING(nameNode);
return TRI_AppendStringStringBuffer(buffer, name) == TRI_ERROR_NO_ERROR;
}
case TRI_AQL_NODE_SORT: {
return TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0));
}
case TRI_AQL_NODE_SORT_ELEMENT: {
if (! TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 0))) {
return false;
}
return TRI_AppendStringStringBuffer(buffer, (TRI_AQL_NODE_BOOL(node) ? " ASC" : " DESC")) == TRI_ERROR_NO_ERROR;
}
case TRI_AQL_NODE_ASSIGN: {
TRI_aql_node_t* nameNode = TRI_AQL_NODE_MEMBER(node, 0);
char* name = TRI_AQL_NODE_STRING(nameNode);
if (TRI_AppendStringStringBuffer(buffer, name) != TRI_ERROR_NO_ERROR) {
return false;
}
if (TRI_AppendStringStringBuffer(buffer, " = ") != TRI_ERROR_NO_ERROR) {
return false;
}
return TRI_NodeStringAql(buffer, TRI_AQL_NODE_MEMBER(node, 1));
}
default: {
// nadata
}
}
return true;
}
TRI_json_t* TRI_GetJsonCollectionHintAql (TRI_aql_collection_hint_t* const hint) {
TRI_json_t* result;
if (hint == NULL) {
return NULL;
}
result = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE);
if (result == NULL) {
return NULL;
}
if (hint->_index == NULL) {
// full table scan
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE,
result,
"accessType",
TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, "all"));
}
else {
// index usage
TRI_index_t* idx = hint->_index->_idx;
TRI_json_t* indexDescription;
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE,
result,
"accessType",
TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, "index"));
indexDescription = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE);
if (indexDescription != NULL) {
TRI_string_buffer_t* buffer;
char* idString = GetIndexIdString(hint);
// index id
if (idString != NULL) {
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE,
indexDescription,
"id",
TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, idString));
TRI_FreeString(TRI_UNKNOWN_MEM_ZONE, idString);
}
// index type
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE,
indexDescription,
"type",
TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, idx->typeName(idx)));
// index attributes
buffer = TRI_CreateStringBuffer(TRI_UNKNOWN_MEM_ZONE);
if (buffer != NULL) {
size_t i;
for (i = 0; i < idx->_fields._length; i++) {
if (i > 0) {
TRI_AppendStringStringBuffer(buffer, ", ");
}
TRI_AppendStringStringBuffer(buffer, idx->_fields._buffer[i]);
}
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE,
indexDescription,
"attributes",
TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, buffer->_buffer));
TRI_FreeStringBuffer(TRI_UNKNOWN_MEM_ZONE, buffer);
}
}
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE,
result,
"index",
indexDescription);
}
if (hint->_limit._status == TRI_AQL_LIMIT_USE) {
TRI_Insert3ArrayJson(TRI_UNKNOWN_MEM_ZONE,
result,
"limit",
TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, (double) hint->_limit._offset + (double) hint->_limit._limit));
}
return result;
}
int TRI_AppendDoubleStringBuffer (TRI_string_buffer_t * self, double attr) {
int res;
// IEEE754 NaN values have an interesting property that we can exploit...
// if the architecture does not use IEEE754 values then this shouldn't do
// any harm either
if (attr != attr) {
return TRI_AppendStringStringBuffer(self, "NaN");
}
if (attr == HUGE_VAL) {
return TRI_AppendStringStringBuffer(self, "inf");
}
if (attr == -HUGE_VAL) {
return TRI_AppendStringStringBuffer(self, "-inf");
}
res = Reserve(self, 1);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
if (attr < 0.0) {
AppendChar(self, '-');
attr = -attr;
}
else if (attr == 0.0) {
AppendChar(self, '0');
return TRI_ERROR_NO_ERROR;
}
if (((double)((uint32_t) attr)) == attr) {
return TRI_AppendUInt32StringBuffer(self, (uint32_t) attr);
}
else if (attr < (double) 429496U) {
uint32_t smll;
smll = (uint32_t)(attr * 10000.0);
if (((double) smll) == attr * 10000.0) {
uint32_t ep;
TRI_AppendUInt32StringBuffer(self, smll / 10000);
ep = smll % 10000;
if (ep != 0) {
size_t pos;
char a1;
char a2;
char a3;
char a4;
pos = 0;
res = Reserve(self, 6);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
AppendChar(self, '.');
if ((ep / 1000L) % 10 != 0) pos = 1;
a1 = (char) ((ep / 1000L) % 10 + '0');
if ((ep / 100L) % 10 != 0) pos = 2;
a2 = (char) ((ep / 100L) % 10 + '0');
if ((ep / 10L) % 10 != 0) pos = 3;
a3 = (char) ((ep / 10L) % 10 + '0');
if (ep % 10 != 0) pos = 4;
a4 = (char) (ep % 10 + '0');
AppendChar(self, a1);
if (pos > 1) { AppendChar(self, a2); }
if (pos > 2) { AppendChar(self, a3); }
if (pos > 3) { AppendChar(self, a4); }
}
return TRI_ERROR_NO_ERROR;
}
}
// we do not habe a small integral number nor small decimal number with only a few decimal digits
// there at most 16 significant digits, first find out if we have an integer value
if (10000000000000000.0 < attr) {
size_t n;
n = 0;
while (10000000000000000.0 < attr) {
attr /= 10.0;
++n;
}
res = TRI_AppendUInt64StringBuffer(self, (uint64_t) attr);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
res = Reserve(self, n);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
for (; 0 < n; --n) {
AppendChar(self, '0');
}
return TRI_ERROR_NO_ERROR;
}
// very small, i. e. less than 1
else if (attr < 1.0) {
size_t n;
n = 0;
while (attr < 1.0) {
attr *= 10.0;
++n;
// should not happen, so it must be almost 0
if (n > 400) {
return TRI_AppendUInt32StringBuffer(self, 0);
}
}
res = Reserve(self, n + 2);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
AppendChar(self, '0');
AppendChar(self, '.');
for (--n; 0 < n; --n) {
AppendChar(self, '0');
}
attr = 10000000000000000.0 * attr;
return TRI_AppendUInt64StringBuffer(self, (uint64_t) attr);
}
// somewhere in between
else {
uint64_t m;
double d;
size_t n;
m = (uint64_t) attr;
d = attr - m;
n = 0;
TRI_AppendUInt64StringBuffer(self, m);
while (d < 1.0) {
d *= 10.0;
++n;
// should not happen, so it must be almost 0
if (n > 400) {
return TRI_ERROR_NO_ERROR;
}
}
res = Reserve(self, n + 1);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
AppendChar(self, '.');
for (--n; 0 < n; --n) {
AppendChar(self, '0');
}
d = 10000000000000000.0 * d;
return TRI_AppendUInt64StringBuffer(self, (uint64_t) d);
}
}
