New convert query

aql/convertQuery2.go

+/*
+This program has been developed by students from the bachelor Computer Science at Utrecht University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+*/
+
+package aql
+
+import (
+	"errors"
+	"fmt"
+
+	"git.science.uu.nl/graphpolaris/query-conversion/entity"
+)
+
+// Version 1.13
+
+/*
+ConvertQuery converts an IncomingQueryJSON object into AQL
+	JSONQuery: *entity.IncomingQueryJSON, the query to be converted to AQL
+	Returns: *string, the AQL query and a possible error
+*/
+func (s *Service) ConvertQuery(JSONQuery *entity.IncomingQueryJSON) (*string, error) {
+	// Check to make sure all indexes exist
+	// The largest possible id for an entity
+	largestEntityID := len(JSONQuery.Entities) - 1
+	// The largest possible id for a relation
+	largestRelationID := len(JSONQuery.Relations) - 1
+
+	// Make sure no entity should be returned that is outside the range of that list
+	for _, e := range JSONQuery.Return.Entities {
+		// If this entity references an entity that is outside the range
+		if e > largestEntityID || e < 0 {
+			return nil, errors.New("non-existing entity referenced in return")
+		}
+	}
+
+	// Make sure that no relation mentions a non-existing entity
+	for _, r := range JSONQuery.Relations {
+		if r.FromID > largestEntityID && r.FromType == "entity" || r.ToID > largestEntityID && r.ToType == "entity" {
+			return nil, errors.New("non-exisiting entity referenced in relation")
+		}
+	}
+
+	// Make sure no non-existing relation is tried to be returned
+	for _, r := range JSONQuery.Return.Relations {
+		if r > largestRelationID || r < 0 {
+			return nil, errors.New("non-existing relation referenced in return")
+		}
+	}
+	// Don't run search if we are getting empty queries from unit tests
+	var tree []entity.Tree
+	if len(JSONQuery.Entities) != 0 && len(JSONQuery.Relations) != 0 {
+		tree = search(JSONQuery, 0)
+	}
+	result := createQuery(JSONQuery, tree)
+	return result, nil
+}
+
+/*
+createQuery generates a query based on the json file provided
+	JSONQuery: *entity.IncomingQueryJSON, this is a parsedJSON struct holding all the data needed to form a query,
+	Return: *string, a string containing the corresponding AQL query and an error
+*/
+func createQuery(JSONQuery *entity.IncomingQueryJSON, tree []entity.Tree) *string {
+	currentTree := tree[0]
+	output := createLetFor("result", fmt.Sprintf("e_%v", currentTree.Self.In.ID), currentTree.Self.In.Name)
+	for constraint := range currentTree.Self.In.Constraints {
+		output += createFilter(currentTree.Self.In.Constraints[constraint], fmt.Sprintf("e_%v", currentTree.Self.In.ID))
+	}
+	var subNames []string
+	for i := range currentTree.Children {
+		subQuery, subName := createQueryRecurse(JSONQuery, tree, currentTree.Children[i])
+		output += subQuery
+		subNames = append(subNames, subName)
+	}
+	output += createZeroFilter(append(subNames, fmt.Sprintf("e_%v", currentTree.Self.In.ID)))
+	output += createReturn(fmt.Sprintf("e_%v", currentTree.Self.In.ID), "", subNames)
+	output += "let nodes = union_distinct(flatten(result[**].nodes),[])\nlet edges = union_distinct(flatten(result[**].rel),[])\nreturn {\"vertices\":nodes,\"edges\":edges}"
+	return &output
+}
+
+func createQueryRecurse(JSONQuery *entity.IncomingQueryJSON, tree []entity.Tree, currentindex int) (string, string) {
+	currentTree := tree[currentindex]
+	newNode, oldNode := getTreeNewAndOldNode(currentTree, tree)
+	output := createLetFor(fmt.Sprintf("e%v", newNode.ID), fmt.Sprintf("e_%v", newNode.ID), newNode.Name)
+	output += fmt.Sprintf("FOR r%v IN %v", currentTree.Self.Rel.ID, currentTree.Self.Rel.Name)
+	for constraint := range newNode.Constraints {
+		output += createFilter(newNode.Constraints[constraint], fmt.Sprintf("e_%v", newNode.ID))
+	}
+	for constraint := range currentTree.Self.Rel.QueryConstraintStruct {
+		output += createFilter(currentTree.Self.Rel.QueryConstraintStruct[constraint], fmt.Sprintf("r%v", currentTree.Self.Rel.ID))
+	}
+	if currentTree.Self.Rel.FromID == newNode.ID {
+		output += fmt.Sprintf("FILTER r%v._from == e_%v._id AND r%v._to == e_%v._id", currentTree.Self.Rel.ID, newNode.ID, currentTree.Self.Rel.ID, oldNode.ID)
+	} else {
+		output += fmt.Sprintf("FILTER r%v._from == e_%v._id AND r%v._to == e_%v._id", currentTree.Self.Rel.ID, oldNode.ID, currentTree.Self.Rel.ID, newNode.ID)
+	}
+	var subNames []string
+	for i := range currentTree.Children {
+		subQuery, subName := createQueryRecurse(JSONQuery, tree, currentTree.Children[i])
+		output += subQuery
+		subNames = append(subNames, subName)
+	}
+	output += createZeroFilter(append(subNames, fmt.Sprintf("e_%v", newNode.ID), fmt.Sprintf("r%v", currentTree.Self.Rel.ID)))
+	output += createReturn(fmt.Sprintf("e_%v", newNode.ID), fmt.Sprintf("r%v", currentTree.Self.Rel.ID), subNames)
+	return output, fmt.Sprintf("e%v", newNode.ID)
+}
+
+func getTreeNewAndOldNode(currentTree entity.Tree, tree []entity.Tree) (entity.QueryEntityStruct, entity.QueryEntityStruct) {
+	if currentTree.Self.In.ID == tree[currentTree.Parent].Self.In.ID || currentTree.Self.In.ID == tree[currentTree.Parent].Self.Out.ID {
+		return currentTree.Self.Out, currentTree.Self.In
+	} else {
+		return currentTree.Self.In, currentTree.Self.Out
+	}
+}
+
+func createLetFor(variableName string, forName string, enumerableName string) string {
+	return "LET " + variableName + " = (\n\tFOR " + forName + " IN " + enumerableName + "\n"
+}
+
+func createFilter(constraint entity.QueryConstraintStruct, filtered string) string {
+	return "\tFILTER + " + filtered + constraint.Attribute + " " + wordsToLogicalSign(constraint) + " " + constraint.Value + " \n"
+}
+
+func createZeroFilter(subNames []string) string {
+	output := "FILTER"
+	for i := range subNames {
+		output += fmt.Sprintf(" length(%v) != 0", subNames[i])
+		if i < len(subNames)-1 {
+			output += " AND"
+		}
+	}
+	return output
+}
+
+func createReturn(nodeName string, relName string, subNames []string) string {
+	output := "RETURN {\"nodes\":union_distinct("
+	for i := range subNames {
+		output += fmt.Sprintf("flatten(%v[**].nodes), ", subNames[i])
+	}
+	output += "[" + nodeName + "]"
+	if len(subNames) == 0 {
+		output += ", []"
+	}
+	output += "), \"rel\": union_distinct("
+	for i := range subNames {
+		output += fmt.Sprintf("flatten(%v[**].rel), ", subNames[i])
+	}
+	output += "[" + relName + "]"
+	if len(subNames) == 0 {
+		output += ", []"
+	}
+	output += ")}\n)\n"
+	return output
+}
+
+func wordsToLogicalSign(element entity.QueryConstraintStruct) string {
+	var match string
+	switch element.DataType {
+	case "string":
+		switch element.MatchType {
+		case "NEQ":
+			match = "!="
+		case "contains":
+			match = "LIKE"
+		case "excludes":
+			match = "NOT LIKE"
+		default: //EQ
+			match = "=="
+		}
+	case "int":
+		switch element.MatchType {
+		case "NEQ":
+			match = "!="
+		case "GT":
+			match = ">"
+		case "LT":
+			match = "<"
+		case "GET":
+			match = ">="
+		case "LET":
+			match = "<="
+		default: //EQ
+			match = "=="
+		}
+	default: /*bool*/
+		switch element.MatchType {
+		case "NEQ":
+			match = "!="
+		default: //EQ
+			match = "=="
+		}
+	}
+	return match
+}