Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/arangod/Aql/AstNode.cpp

532 lines
15 KiB
C++
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
/// @brief Aql, AST node
///
/// @file
///
/// DISCLAIMER
///
/// Copyright 2014 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 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 ArangoDB GmbH, Cologne, Germany
///
/// @author Jan Steemann
/// @author Copyright 2014, ArangoDB GmbH, Cologne, Germany
/// @author Copyright 2012-2013, triAGENS GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
#include "Aql/AstNode.h"
#include "Aql/Function.h"
#include "Aql/Scopes.h"
#include "Basics/StringBuffer.h"
using namespace triagens::aql;
// -----------------------------------------------------------------------------
// --SECTION-- constructors / destructors
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief create the node
////////////////////////////////////////////////////////////////////////////////
AstNode::AstNode (AstNodeType type)
: type(type) {
TRI_InitVectorPointer(&members, TRI_UNKNOWN_MEM_ZONE);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief destroy the node
////////////////////////////////////////////////////////////////////////////////
AstNode::~AstNode () {
TRI_DestroyVectorPointer(&members);
}
// -----------------------------------------------------------------------------
// --SECTION-- public functions
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief return a JSON representation of the node value
/// the caller is responsible for freeing the JSON later
////////////////////////////////////////////////////////////////////////////////
TRI_json_t* AstNode::toJsonValue (TRI_memory_zone_t* zone) const {
if (type == NODE_TYPE_VALUE) {
// dump value of "value" node
switch (value.type) {
case VALUE_TYPE_NULL:
return TRI_CreateNullJson(zone);
case VALUE_TYPE_BOOL:
return TRI_CreateBooleanJson(zone, value.value._bool);
case VALUE_TYPE_INT:
return TRI_CreateNumberJson(zone, static_cast<double>(value.value._int));
case VALUE_TYPE_DOUBLE:
return TRI_CreateNumberJson(zone, value.value._int);
case VALUE_TYPE_STRING:
return TRI_CreateStringCopyJson(zone, value.value._string);
default: {
}
}
}
else if (type == NODE_TYPE_LIST) {
size_t const n = numMembers();
TRI_json_t* list = TRI_CreateList2Json(zone, n);
if (list == nullptr) {
return nullptr;
}
for (size_t i = 0; i < n; ++i) {
auto member = getMember(i);
if (member != nullptr) {
TRI_json_t* j = member->toJsonValue(zone);
if (j != nullptr) {
TRI_PushBack3ListJson(zone, list, j);
}
}
}
return list;
}
else if (type == NODE_TYPE_ARRAY) {
size_t const n = numMembers();
TRI_json_t* list = TRI_CreateArray2Json(zone, n);
for (size_t i = 0; i < n; ++i) {
auto member = getMember(i);
if (member != nullptr) {
TRI_json_t* j = member->toJsonValue(zone);
if (j != nullptr) {
TRI_Insert3ArrayJson(zone, list, member->getStringValue(), j);
}
}
}
}
return nullptr;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief return a JSON representation of the node
/// the caller is responsible for freeing the JSON later
////////////////////////////////////////////////////////////////////////////////
TRI_json_t* AstNode::toJson (TRI_memory_zone_t* zone) const {
TRI_json_t* node = TRI_CreateArrayJson(zone);
if (node == nullptr) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_OUT_OF_MEMORY);
}
// dump node type
TRI_Insert3ArrayJson(zone, node, "type", TRI_CreateStringCopyJson(zone, typeString().c_str()));
if (type == NODE_TYPE_COLLECTION ||
type == NODE_TYPE_PARAMETER ||
type == NODE_TYPE_ATTRIBUTE_ACCESS ||
type == NODE_TYPE_FCALL_USER) {
// dump "name" of node
TRI_Insert3ArrayJson(zone, node, "name", TRI_CreateStringCopyJson(zone, getStringValue()));
}
if (type == NODE_TYPE_FCALL) {
auto func = static_cast<Function*>(getData());
TRI_Insert3ArrayJson(zone, node, "name", TRI_CreateStringCopyJson(zone, func->name.c_str()));
}
if (type == NODE_TYPE_VALUE) {
// dump value of "value" node
switch (value.type) {
case VALUE_TYPE_NULL:
TRI_Insert3ArrayJson(zone, node, "value", TRI_CreateStringCopyJson(zone, "null"));
break;
case VALUE_TYPE_BOOL:
TRI_Insert3ArrayJson(zone, node, "value", TRI_CreateBooleanJson(zone, value.value._bool));
break;
case VALUE_TYPE_INT:
TRI_Insert3ArrayJson(zone, node, "value", TRI_CreateNumberJson(zone, static_cast<double>(value.value._int)));
break;
case VALUE_TYPE_DOUBLE:
TRI_Insert3ArrayJson(zone, node, "value", TRI_CreateNumberJson(zone, value.value._double));
break;
case VALUE_TYPE_STRING:
TRI_Insert3ArrayJson(zone, node, "value", TRI_CreateStringCopyJson(zone, value.value._string));
break;
default: {
}
}
}
if (type == NODE_TYPE_VARIABLE ||
type == NODE_TYPE_REFERENCE) {
auto variable = static_cast<Variable*>(getData());
TRI_Insert3ArrayJson(zone, node, "name", TRI_CreateStringCopyJson(zone, variable->name.c_str()));
TRI_Insert3ArrayJson(zone, node, "id", TRI_CreateNumberJson(zone, static_cast<double>(variable->id)));
}
// dump sub-nodes
size_t const n = members._length;
if (n > 0) {
TRI_json_t* subNodes = TRI_CreateListJson(zone);
if (subNodes == nullptr) {
TRI_FreeJson(zone, node);
THROW_ARANGO_EXCEPTION(TRI_ERROR_OUT_OF_MEMORY);
}
try {
for (size_t i = 0; i < n; ++i) {
auto member = getMember(i);
if (member != nullptr && member->type != NODE_TYPE_NOP) {
member->toJson(subNodes, zone);
}
}
}
catch (...) {
TRI_FreeJson(zone, subNodes);
TRI_FreeJson(zone, node);
THROW_ARANGO_EXCEPTION(TRI_ERROR_OUT_OF_MEMORY);
}
TRI_Insert3ArrayJson(zone, node, "subNodes", subNodes);
}
return node;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief adds a JSON representation of the node to the JSON list specified
/// in the first argument
////////////////////////////////////////////////////////////////////////////////
void AstNode::toJson (TRI_json_t* json,
TRI_memory_zone_t* zone) const {
TRI_ASSERT(TRI_IsListJson(json));
TRI_json_t* node = toJson(zone);
if (node == nullptr) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_OUT_OF_MEMORY);
}
TRI_PushBack3ListJson(zone, json, node);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief whether or not a node has a constant value
////////////////////////////////////////////////////////////////////////////////
bool AstNode::isConstant () const {
if (type == NODE_TYPE_VALUE) {
return true;
}
if (type == NODE_TYPE_LIST) {
size_t const n = numMembers();
for (size_t i = 0; i < n; ++i) {
auto member = getMember(i);
if (member != nullptr) {
if (! member->isConstant()) {
return false;
}
}
}
return true;
}
if (type == NODE_TYPE_ARRAY) {
size_t const n = numMembers();
for (size_t i = 0; i < n; ++i) {
auto member = getMember(i);
if (member != nullptr) {
auto value = member->getMember(0);
if (value == nullptr) {
continue;
}
if (! value->isConstant()) {
return false;
}
}
}
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief return the type name of a node
////////////////////////////////////////////////////////////////////////////////
std::string AstNode::typeString () const {
switch (type) {
case NODE_TYPE_ROOT:
return "root";
case NODE_TYPE_FOR:
return "for";
case NODE_TYPE_LET:
return "let";
case NODE_TYPE_FILTER:
return "filter";
case NODE_TYPE_RETURN:
return "return";
case NODE_TYPE_REMOVE:
return "remove";
case NODE_TYPE_INSERT:
return "insert";
case NODE_TYPE_UPDATE:
return "update";
case NODE_TYPE_REPLACE:
return "replace";
case NODE_TYPE_COLLECT:
return "collect";
case NODE_TYPE_SORT:
return "sort";
case NODE_TYPE_SORT_ELEMENT:
return "sort element";
case NODE_TYPE_LIMIT:
return "limit";
case NODE_TYPE_VARIABLE:
return "variable";
case NODE_TYPE_ASSIGN:
return "assign";
case NODE_TYPE_OPERATOR_UNARY_PLUS:
return "unary plus";
case NODE_TYPE_OPERATOR_UNARY_MINUS:
return "unary minus";
case NODE_TYPE_OPERATOR_UNARY_NOT:
return "unary not";
case NODE_TYPE_OPERATOR_BINARY_AND:
return "logical and";
case NODE_TYPE_OPERATOR_BINARY_OR:
return "logical or";
case NODE_TYPE_OPERATOR_BINARY_PLUS:
return "plus";
case NODE_TYPE_OPERATOR_BINARY_MINUS:
return "minus";
case NODE_TYPE_OPERATOR_BINARY_TIMES:
return "times";
case NODE_TYPE_OPERATOR_BINARY_DIV:
return "division";
case NODE_TYPE_OPERATOR_BINARY_MOD:
return "modulus";
case NODE_TYPE_OPERATOR_BINARY_EQ:
return "compare ==";
case NODE_TYPE_OPERATOR_BINARY_NE:
return "compare !=";
case NODE_TYPE_OPERATOR_BINARY_LT:
return "compare <";
case NODE_TYPE_OPERATOR_BINARY_LE:
return "compare <=";
case NODE_TYPE_OPERATOR_BINARY_GT:
return "compare >";
case NODE_TYPE_OPERATOR_BINARY_GE:
return "compare >=";
case NODE_TYPE_OPERATOR_BINARY_IN:
return "compare in";
case NODE_TYPE_OPERATOR_TERNARY:
return "ternary";
case NODE_TYPE_SUBQUERY:
return "subquery";
case NODE_TYPE_ATTRIBUTE_ACCESS:
return "attribute access";
case NODE_TYPE_BOUND_ATTRIBUTE_ACCESS:
return "bound attribute access";
case NODE_TYPE_INDEXED_ACCESS:
return "indexed access";
case NODE_TYPE_EXPAND:
return "expand";
case NODE_TYPE_ITERATOR:
return "iterator";
case NODE_TYPE_VALUE:
return "value";
case NODE_TYPE_LIST:
return "list";
case NODE_TYPE_ARRAY:
return "array";
case NODE_TYPE_ARRAY_ELEMENT:
return "array element";
case NODE_TYPE_COLLECTION:
return "collection";
case NODE_TYPE_REFERENCE:
return "reference";
case NODE_TYPE_ATTRIBUTE:
return "attribute";
case NODE_TYPE_PARAMETER:
return "parameter";
case NODE_TYPE_FCALL:
return "function call";
case NODE_TYPE_FCALL_USER:
return "user function call";
case NODE_TYPE_RANGE:
return "range";
case NODE_TYPE_NOP:
return "no-op";
default: {
}
}
TRI_ASSERT(false);
return "";
}
////////////////////////////////////////////////////////////////////////////////
/// @brief append a JavaScript representation of the node into a string buffer
////////////////////////////////////////////////////////////////////////////////
void AstNode::append (triagens::basics::StringBuffer* buffer) const {
if (type == NODE_TYPE_VALUE) {
appendValue(buffer);
return;
}
if (type == NODE_TYPE_LIST) {
buffer->appendText("[ ");
size_t const n = numMembers();
for (size_t i = 0; i < n; ++i) {
if (i > 0) {
buffer->appendText(", ");
}
AstNode* member = getMember(i);
if (member != nullptr) {
member->append(buffer);
}
}
buffer->appendText(" ]");
return;
}
if (type == NODE_TYPE_ARRAY) {
buffer->appendText("{ ");
size_t const n = numMembers();
for (size_t i = 0; i < n; ++i) {
if (i > 0) {
buffer->appendText(", ");
}
AstNode* member = getMember(i);
if (member != nullptr) {
TRI_ASSERT(member->type == NODE_TYPE_ARRAY_ELEMENT);
TRI_ASSERT(member->numMembers() == 1);
buffer->appendChar('"');
buffer->appendJsonEncoded(member->getStringValue());
buffer->appendText("\" : ");
member->getMember(0)->append(buffer);
}
}
buffer->appendText(" }");
return;
}
if (type == NODE_TYPE_OPERATOR_BINARY_AND ||
type == NODE_TYPE_OPERATOR_BINARY_OR ||
type == NODE_TYPE_OPERATOR_BINARY_PLUS ||
type == NODE_TYPE_OPERATOR_BINARY_MINUS ||
type == NODE_TYPE_OPERATOR_BINARY_TIMES ||
type == NODE_TYPE_OPERATOR_BINARY_DIV ||
type == NODE_TYPE_OPERATOR_BINARY_MOD ||
type == NODE_TYPE_OPERATOR_BINARY_EQ ||
type == NODE_TYPE_OPERATOR_BINARY_NE ||
type == NODE_TYPE_OPERATOR_BINARY_LT ||
type == NODE_TYPE_OPERATOR_BINARY_LE ||
type == NODE_TYPE_OPERATOR_BINARY_GT ||
type == NODE_TYPE_OPERATOR_BINARY_GE ||
type == NODE_TYPE_OPERATOR_BINARY_IN) {
size_t const n = numMembers();
TRI_ASSERT(n == 2);
getMember(0)->append(buffer);
buffer->appendText(", ");
getMember(1)->append(buffer);
}
}
// -----------------------------------------------------------------------------
// --SECTION-- private methods
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief stringify the value of a node into a string buffer
////////////////////////////////////////////////////////////////////////////////
void AstNode::appendValue (triagens::basics::StringBuffer* buffer) const {
TRI_ASSERT(type == NODE_TYPE_VALUE);
switch (value.type) {
case VALUE_TYPE_BOOL: {
if (value.value._bool) {
buffer->appendText("true", 4);
}
else {
buffer->appendText("false", 5);
}
break;
}
case VALUE_TYPE_INT: {
buffer->appendInteger(value.value._int);
break;
}
case VALUE_TYPE_DOUBLE: {
buffer->appendDecimal(value.value._double);
break;
}
case VALUE_TYPE_STRING: {
buffer->appendChar('"');
buffer->appendJsonEncoded(value.value._string);
buffer->appendChar('"');
break;
}
case VALUE_TYPE_NULL:
default: {
buffer->appendText("null", 4);
break;
}
}
}
// -----------------------------------------------------------------------------
// --SECTION-- END-OF-FILE
// -----------------------------------------------------------------------------
// Local Variables:
// mode: outline-minor
// outline-regexp: "/// @brief\\|/// {@inheritDoc}\\|/// @page\\|// --SECTION--\\|/// @\\}"
// End:
Reference in New Issue View Git Blame Copy Permalink