diff --git a/aql/convertQueryBenchmark_test.go b/aql/convertQueryBenchmark_test.go
index f6c7fec73405949fc3ed44ae34a5938bfc3893c1..3445a181dd8cdd8c12d0860c940a403c551e134b 100644
--- a/aql/convertQueryBenchmark_test.go
+++ b/aql/convertQueryBenchmark_test.go
@@ -5,182 +5,182 @@ This program has been developed by students from the bachelor Computer Science a
package aql
-import (
- "encoding/json"
- "testing"
-
- "git.science.uu.nl/graphpolaris/query-conversion/entity"
-)
-
-/*
-Benchmarks converting an empty query
- t: *testing.T, makes go recognise this as a test
-*/
-func BenchmarkConvertEmptyQuery(b *testing.B) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- query := []byte(`{
- "return": {
- "entities": [],
- "relations": []
- },
- "entities": [],
- "relations": [],
- "limit": 5000
- }`)
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- service.ConvertQuery(&JSONQuery)
- }
-}
-
-/*
-Benchmarks converting a one attribute query
- t: *testing.T, makes go recognise this as a test
-*/
-func BenchmarkConvertOneAttributeQuery(b *testing.B) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- query := []byte(`{
- "return": {
- "entities": [
- 0
- ],
- "relations": []
- },
- "entities": [
- {
- "type": "airports",
- "constraints": [
- {
- "attribute": "state",
- "value": "HI",
- "dataType": "string",
- "matchType": "exact"
- }
- ]
- }
- ],
- "relations": [],
- "limit": 5000
- }`)
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- service.ConvertQuery(&JSONQuery)
- }
-}
-
-/*
-Benchmarks converting a two relation query
- t: *testing.T, makes go recognise this as a test
-*/
-func BenchmarkConvertTwoRelationQuery(b *testing.B) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- query := []byte(`{
- "return": {
- "entities": [
- 0,
- 1,
- 2
- ],
- "relations": [
- 0,
- 1
- ]
- },
- "entities": [
- {
- "type": "airports",
- "constraints": [
- {
- "attribute": "city",
- "value": "New York",
- "dataType": "string",
- "matchType": "exact"
- }
- ]
- },
- {
- "type": "airports",
- "constraints": [
- {
- "attribute": "city",
- "value": "San Francisco",
- "dataType": "string",
- "matchType": "exact"
- }
- ]
- },
- {
- "type": "airports",
- "constraints": [
- {
- "attribute": "state",
- "value": "HI",
- "dataType": "string",
- "matchType": "exact"
- }
- ]
- }
- ],
- "relations": [
- {
- "type": "flights",
- "depth": {
- "min": 1,
- "max": 3
- },
- "entityFrom": 2,
- "entityTo": 1,
- "constraints": [
- {
- "attribute": "Day",
- "value": "15",
- "dataType": "int",
- "matchType": "EQ"
- }
- ]
- },
- {
- "type": "flights",
- "depth": {
- "min": 1,
- "max": 1
- },
- "entityFrom": 0,
- "entityTo": -1,
- "constraints": []
- }
- ],
- "limit": 5000
- }`)
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- service.ConvertQuery(&JSONQuery)
- }
-}
+// import (
+// "encoding/json"
+// "testing"
+
+// "git.science.uu.nl/graphpolaris/query-conversion/entity"
+// )
+
+// /*
+// Benchmarks converting an empty query
+// t: *testing.T, makes go recognise this as a test
+// */
+// func BenchmarkConvertEmptyQuery(b *testing.B) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// query := []byte(`{
+// "return": {
+// "entities": [],
+// "relations": []
+// },
+// "entities": [],
+// "relations": [],
+// "limit": 5000
+// }`)
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// b.ResetTimer()
+
+// for i := 0; i < b.N; i++ {
+// service.ConvertQuery(&JSONQuery)
+// }
+// }
+
+// /*
+// Benchmarks converting a one attribute query
+// t: *testing.T, makes go recognise this as a test
+// */
+// func BenchmarkConvertOneAttributeQuery(b *testing.B) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// query := []byte(`{
+// "return": {
+// "entities": [
+// 0
+// ],
+// "relations": []
+// },
+// "entities": [
+// {
+// "type": "airports",
+// "constraints": [
+// {
+// "attribute": "state",
+// "value": "HI",
+// "dataType": "string",
+// "matchType": "exact"
+// }
+// ]
+// }
+// ],
+// "relations": [],
+// "limit": 5000
+// }`)
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// b.ResetTimer()
+
+// for i := 0; i < b.N; i++ {
+// service.ConvertQuery(&JSONQuery)
+// }
+// }
+
+// /*
+// Benchmarks converting a two relation query
+// t: *testing.T, makes go recognise this as a test
+// */
+// func BenchmarkConvertTwoRelationQuery(b *testing.B) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// query := []byte(`{
+// "return": {
+// "entities": [
+// 0,
+// 1,
+// 2
+// ],
+// "relations": [
+// 0,
+// 1
+// ]
+// },
+// "entities": [
+// {
+// "type": "airports",
+// "constraints": [
+// {
+// "attribute": "city",
+// "value": "New York",
+// "dataType": "string",
+// "matchType": "exact"
+// }
+// ]
+// },
+// {
+// "type": "airports",
+// "constraints": [
+// {
+// "attribute": "city",
+// "value": "San Francisco",
+// "dataType": "string",
+// "matchType": "exact"
+// }
+// ]
+// },
+// {
+// "type": "airports",
+// "constraints": [
+// {
+// "attribute": "state",
+// "value": "HI",
+// "dataType": "string",
+// "matchType": "exact"
+// }
+// ]
+// }
+// ],
+// "relations": [
+// {
+// "type": "flights",
+// "depth": {
+// "min": 1,
+// "max": 3
+// },
+// "entityFrom": 2,
+// "entityTo": 1,
+// "constraints": [
+// {
+// "attribute": "Day",
+// "value": "15",
+// "dataType": "int",
+// "matchType": "EQ"
+// }
+// ]
+// },
+// {
+// "type": "flights",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "entityFrom": 0,
+// "entityTo": -1,
+// "constraints": []
+// }
+// ],
+// "limit": 5000
+// }`)
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// b.ResetTimer()
+
+// for i := 0; i < b.N; i++ {
+// service.ConvertQuery(&JSONQuery)
+// }
+// }
diff --git a/aql/convertQuery_test.go b/aql/convertQuery_test.go
index 08943f4e5f53759ca93a5df78c4539920fc1ba77..e8517d54ec3a8f98c51a1b096d3226e70c9dad60 100644
--- a/aql/convertQuery_test.go
+++ b/aql/convertQuery_test.go
@@ -5,729 +5,729 @@ This program has been developed by students from the bachelor Computer Science a
package aql
-import (
- "encoding/json"
- "errors"
- "regexp"
- "strings"
- "testing"
-
- "git.science.uu.nl/graphpolaris/query-conversion/entity"
- "github.com/stretchr/testify/assert"
-)
-
-/*
-Tests an empty query
- t: *testing.T, makes go recognise this as a test
-*/
-func TestEmptyQueryConversion(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(emptyQuery, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &EmptyQueryResult)
-}
-
-/*
-Tests two entities (two types) without a filter
-Query description: Give me all parties connected to their respective parliament members
- t: *testing.T, makes go recognise this as a test
-*/
-func TestTwoEntitiesNoFilter(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(TwoEntitiesNoFilter, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &TwoEntitiesNoFilterResult)
-}
-
-/*
-Tests two entities (two types) with one entity filter
-Query description: Give me all parties, with less than 10 seats, connected to their respective parliament members
- t: *testing.T, makes go recognise this as a test
-*/
-func TestTwoEntitiesOneEntityFilter(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(TwoEntitiesOneEntityFilter, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &TwoEntitiesOneEntityFilterResult)
-}
-
-/*
-Tests two entities (two types) with two entity filters
-Query description: Give me all parties, with less than 10 seats, connected to their respective parliament members, who are more than 45 years old
- t: *testing.T, makes go recognise this as a test
-*/
-func TestTwoEntitiesTwoEntityFilters(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(TwoEntitiesTwoEntityFilters, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &TwoEntitiesTwoEntityFiltersResult)
-}
-
-/*
-Tests three entities (three types) without a filter
-Query description: Give me all parties, connected to their respective parliament members, who are then connected to the resolutions they submitted
- t: *testing.T, makes go recognise this as a test
-*/
-func TestThreeEntitiesNoFilter(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(ThreeEntitiesNoFilter, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &ThreeEntitiesNoFilterResult)
-}
-
-/*
-Tests three entities (three types) with one entity filter
-Query description: Give me all parties, connected to their respective parliament members, whose name has "Geert" in it (this results in only "Geert Wilders"), who are/is then connected to the resolutions they submitted
- t: *testing.T, makes go recognise this as a test
-*/
-func TestThreeEntitiesOneEntityFilter(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(ThreeEntitiesOneEntityFilter, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &ThreeEntitiesOneEntityFilterResult)
-}
-
-/*
-Tests three entities (three types) with two entity filters
-Query description: Give me all parties, connected to their respective parliament members, whose name has "Geert" in it (this results in only "Geert Wilders"), who are/is then connected to the resolutions they submitted, but only those submitted in May
- t: *testing.T, makes go recognise this as a test
-*/
-func TestThreeEntitiesTwoEntityFilters(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(ThreeEntitiesTwoEntityFilters, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &ThreeEntitiesTwoEntityFiltersResult)
-}
-
-/*
-Tests five entities (three types) with four entity filters
-Query description: Give me all parties, which have less than 10 seats, connected to their respective parliament members, whose name has "A" in it, who are/is then connected to the resolutions they submitted, but only those submitted in May, which are then also connected to all other persons who were part of that submission, who are part of the "VVD"
-Translator's note: This returns a member of the PvdA who submitted a motion alongside a member of the VVD
-t: *testing.T, makes go recognise this as a test
-*/
-func TestFiveEntitiesFourEntityFilters(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(FiveEntitiesFourEntityFilters, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &FiveEntitiesFourEntityFiltersResult)
-}
-
-/*
-Tests five entities (four types) with three entity filters and one junction
-Query description: Give me all parties, with less than 10 seats, connected to their respective parliament members, who are then connected to the resolutions they submitted, but only those submitted in May, and connected to the comissions they're in, which are then connected to all of their members, but only those with "Geert" in their name (resulting in only "Geert Wilders")
- t: *testing.T, makes go recognise this as a test
-*/
-func TestSingleJunctionFiveEntitiesThreeEntityFilters(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(SingleJunctionFiveEntitiesThreeEntityFilters, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &SingleJunctionFiveEntitiesThreeEntityFiltersResult)
-}
-
-/*
-Tests nine entities (four types) with three entity filters and two junctions
-Query description: Give me all parties, with less than 10 seats, connected to their respective parliament members, who are then connected to the resolutions they submitted, but only those submitted in May, and connected to the comissions they're in, which are then connected to all of their members, but only those with "Geert" in their name (resulting in only "Geert Wilders"), who is then connected to their submited resolutions and their party, which is connected to all of its members
- t: *testing.T, makes go recognise this as a test
-*/
-func TestDoubleJunctionNineEntitiesThreeEntityFilters(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(DoubleJunctionNineEntitiesThreeEntityFilters, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &DoubleJunctionNineEntitiesThreeEntityFiltersResult)
-}
-
-/*
-Tests two entities (one type) with one entity filter and one relation filter
-Query description: Give me all airports, in the state "HI", connected to any other airport by flight, but only the flights on "day" 15
- t: *testing.T, makes go recognise this as a test
-*/
-func TestTwoEntitiesOneEntityFilterOneRelationFilter(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(TwoEntitiesOneEntityFilterOneRelationFilter, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &TwoEntitiesOneEntityFilterOneRelationFilterResult)
-}
-
-//TODO
-//FIX THESE TESTS, THEY'RE NOT THAT INTERESTING BUT SHOULD BE FIXED ANYWAY
-
-/*
-Tests a query with no relation field
- t: *testing.T, makes go recognise this as a test
-*/
-func TestNoRelationsField(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(NoRelationsField, &JSONQuery)
-
- _, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is an error
- assert.Equal(t, errors.New("JSONQuery invalid"), err)
-}
-
-/*
-Tests a query with a single group by as an endpoint
- t: *testing.T, makes go recognise this as a test
-*/
-func TestSingleEndPointGroupBy(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(SingleEndPointGroupBy, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &SingleEndPointGroupByResult)
-}
-
-/*
-Tests a query with a single group by which is connected to a relation
- t: *testing.T, makes go recognise this as a test
-*/
-func TestSingleGroupBy(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(SingleGroupBy, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &SingleGroupByResult)
-}
-
-/*
-Tests a query with a group by with multiple inputs which is an endpoint
- t: *testing.T, makes go recognise this as a test
-*/
-func TestMultipleInputGroupByEndpoint(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(MultipleInputGroupByEndpoint, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &MultipleInputGroupByEndpointResult)
-}
-
-/*
-Tests a query with a group by with multiple inputs which is connected to a relation
- t: *testing.T, makes go recognise this as a test
-*/
-func TestMultipleInputGroupBy(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(MultipleInputGroupBy, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &MultipleInputGroupByResult)
-}
-
-/*
-Tests a query with a group by with a group by as top pill
- t: *testing.T, makes go recognise this as a test
-*/
-func TestTopGroupBy(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(TopGroupBy, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &TopGroupByResult)
-}
-
-/*
-Tests a large query with multiple groupbys nested and multiple chained filters and chained subqueries
- t: *testing.T, makes go recognise this as a test
-*/
-func TestWayTooLargeQuery(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(WayTooLargeQuery, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &WayTooLargeQueryResult)
-}
-
-/*
-Tests an entity with a lower than -1 in a relation
- t: *testing.T, makes go recognise this as a test
-*/
-func TestIncorrectRelationFrom(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(IncorrectRelationFrom, &JSONQuery)
-
- _, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is an error
- assert.Equal(t, errors.New("JSONQuery invalid"), err)
-}
-
-func CheckResults(t *testing.T, convertedResult *string, correctConvertedResult *string) {
- inTree := false
- convertedResultSplit := strings.Split(*convertedResult, "\n")
- correctConvertedResultSplit := strings.Split(*correctConvertedResult, "\n")
- for x := range convertedResultSplit {
- convertedLine := convertedResultSplit[x]
- correctLine := correctConvertedResultSplit[x]
- regExCleaner := regexp.MustCompile(`\s+`)
- convertedCleanedLine := strings.TrimSpace(regExCleaner.ReplaceAllString(convertedLine, " "))
- correctCleanedLine := strings.TrimSpace(regExCleaner.ReplaceAllString(correctLine, " "))
- if len(correctCleanedLine) > 8 && correctCleanedLine[:8] == "LET tree" {
- inTree = true
- }
- if inTree && len(correctCleanedLine) > 6 && correctCleanedLine[:5] == "LET g" && correctCleanedLine[:6] != "LET gb" {
- inTree = false
- }
- if inTree && len(correctCleanedLine) > 6 && correctCleanedLine[:6] == "RETURN" {
- assert.Equal(t, convertedCleanedLine[:8], correctCleanedLine[:8])
- assert.Equal(t, convertedCleanedLine[len(convertedCleanedLine)-1:], correctCleanedLine[len(correctCleanedLine)-1:])
- convertedReturn := strings.Split(strings.ReplaceAll(convertedCleanedLine[8:][:len(convertedCleanedLine)-9], ", \"", "< \""), "< ")
- correctReturn := strings.Split(strings.ReplaceAll(correctCleanedLine[8:][:len(correctCleanedLine)-9], ", \"", "< \""), "< ")
- for _, element := range convertedReturn {
- assert.Contains(t, correctReturn, element)
- }
- for _, element := range correctReturn {
- assert.Contains(t, convertedReturn, element)
- }
- } else if inTree && len(correctCleanedLine) > 27 && (correctCleanedLine[:27] == "LET nodes = union_distinct(" || correctCleanedLine[:27] == "LET edges = union_distinct(") {
- assert.Equal(t, convertedCleanedLine[:27], correctCleanedLine[:27])
- assert.Equal(t, convertedCleanedLine[len(convertedCleanedLine)-3:], correctCleanedLine[len(correctCleanedLine)-3:])
- convertedReturn := strings.Split(convertedCleanedLine[27:][:len(convertedCleanedLine)-30], ", ")
- correctReturn := strings.Split(correctCleanedLine[27:][:len(correctCleanedLine)-30], ", ")
- for _, element := range convertedReturn {
- assert.Contains(t, correctReturn, element)
- }
- } else {
- assert.Equal(t, convertedCleanedLine, correctCleanedLine)
- }
- }
-}
-
-/*
-Tests two separated chains consisting of 1 relation each
- t: *testing.T, makes go recognise this as a test
-*/
-func TestSeparatedChainSingleRelationPerChain(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(SeparatedChainSingleRelationPerChain, &JSONQuery)
-
- _, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is an error
- assert.Equal(t, errors.New("JSONQuery invalid"), err)
-}
-
-/*
-Tests two separated chains consisting of 1 relation each
- t: *testing.T, makes go recognise this as a test
-*/
-func TestSeparatedChainDoubleRelationPerChain(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(SeparatedChainDoubleRelationPerChain, &JSONQuery)
-
- _, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is an error
- assert.Equal(t, errors.New("JSONQuery invalid"), err)
-}
-
-/*
-Tests two separated chains
- t: *testing.T, makes go recognise this as a test
-*/
-func TestSeperatedChainWithGroupBys(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(SeperatedChainWithGroupBys, &JSONQuery)
-
- _, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is an error
- assert.Equal(t, errors.New("JSONQuery invalid"), err)
-}
-
-/*
-Tests a group by which has different nodes on its group and by
- t: *testing.T, makes go recognise this as a test
-*/
-func TestDifferentNodesOnGroupBy(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(DifferentNodesOnGroupBy, &JSONQuery)
-
- _, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is an error
- assert.Equal(t, errors.New("JSONQuery invalid"), err)
-}
-
-/*
-Tests a group by which has a modifier which aql doesn't recognise
- t: *testing.T, makes go recognise this as a test
-*/
-func TestIncorrectGroupByModifier(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(IncorrectGroupByModifier, &JSONQuery)
-
- _, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is an error
- assert.Equal(t, errors.New("JSONQuery invalid"), err)
-}
-
-/*
-Tests a query with nested group bys
- t: *testing.T, makes go recognise this as a test
-*/
-func TestAllStreamers(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(AllStreamers, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &AllStreamersResult)
-}
-
-/*
-Tests the string match types
- t: *testing.T, makes go recognise this as a test
-*/
-func TestStringMatchTypes(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(StringMatchTypes, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &StringMatchTypesResult)
-}
-
-/*
-Tests a query where a top pill is the to, and is connected to a from group by
- t: *testing.T, makes go recognise this as a test
-*/
-func TestTopEntityToFromGroupBy(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(TopEntityToFromGroupBy, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &TopEntityToFromGroupByResult)
-}
-
-/*
-Tests in not equals filter
- t: *testing.T, makes go recognise this as a test
-*/
-func TestIntNotEquals(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(IntNotEquals, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &IntNotEqualsResult)
-}
-
-/*
-Tests bool equals filter
- t: *testing.T, makes go recognise this as a test
-*/
-func TestBoolEqual(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(BoolEqual, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &BoolEqualResult)
-}
-
-/*
-Tests bool not equals filter
- t: *testing.T, makes go recognise this as a test
-*/
-func TestBoolNotEqual(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(BoolNotEqual, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &BoolNotEqualResult)
-}
-
-/*
-Tests a different nested group by which will have to propagate to get group by type
- t: *testing.T, makes go recognise this as a test
-*/
-func TestGroupNestedGroupBys2(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(NestedGroupBys2, &JSONQuery)
-
- convertedResult, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- // Assert that the result and the expected result are the same
- CheckResults(t, convertedResult, &NestedGroupBys2Result)
-}
+// import (
+// "encoding/json"
+// "errors"
+// "regexp"
+// "strings"
+// "testing"
+
+// "git.science.uu.nl/graphpolaris/query-conversion/entity"
+// "github.com/stretchr/testify/assert"
+// )
+
+// /*
+// Tests an empty query
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestEmptyQueryConversion(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(emptyQuery, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &EmptyQueryResult)
+// }
+
+// /*
+// Tests two entities (two types) without a filter
+// Query description: Give me all parties connected to their respective parliament members
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestTwoEntitiesNoFilter(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(TwoEntitiesNoFilter, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &TwoEntitiesNoFilterResult)
+// }
+
+// /*
+// Tests two entities (two types) with one entity filter
+// Query description: Give me all parties, with less than 10 seats, connected to their respective parliament members
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestTwoEntitiesOneEntityFilter(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(TwoEntitiesOneEntityFilter, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &TwoEntitiesOneEntityFilterResult)
+// }
+
+// /*
+// Tests two entities (two types) with two entity filters
+// Query description: Give me all parties, with less than 10 seats, connected to their respective parliament members, who are more than 45 years old
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestTwoEntitiesTwoEntityFilters(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(TwoEntitiesTwoEntityFilters, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &TwoEntitiesTwoEntityFiltersResult)
+// }
+
+// /*
+// Tests three entities (three types) without a filter
+// Query description: Give me all parties, connected to their respective parliament members, who are then connected to the resolutions they submitted
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestThreeEntitiesNoFilter(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(ThreeEntitiesNoFilter, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &ThreeEntitiesNoFilterResult)
+// }
+
+// /*
+// Tests three entities (three types) with one entity filter
+// Query description: Give me all parties, connected to their respective parliament members, whose name has "Geert" in it (this results in only "Geert Wilders"), who are/is then connected to the resolutions they submitted
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestThreeEntitiesOneEntityFilter(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(ThreeEntitiesOneEntityFilter, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &ThreeEntitiesOneEntityFilterResult)
+// }
+
+// /*
+// Tests three entities (three types) with two entity filters
+// Query description: Give me all parties, connected to their respective parliament members, whose name has "Geert" in it (this results in only "Geert Wilders"), who are/is then connected to the resolutions they submitted, but only those submitted in May
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestThreeEntitiesTwoEntityFilters(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(ThreeEntitiesTwoEntityFilters, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &ThreeEntitiesTwoEntityFiltersResult)
+// }
+
+// /*
+// Tests five entities (three types) with four entity filters
+// Query description: Give me all parties, which have less than 10 seats, connected to their respective parliament members, whose name has "A" in it, who are/is then connected to the resolutions they submitted, but only those submitted in May, which are then also connected to all other persons who were part of that submission, who are part of the "VVD"
+// Translator's note: This returns a member of the PvdA who submitted a motion alongside a member of the VVD
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestFiveEntitiesFourEntityFilters(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(FiveEntitiesFourEntityFilters, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &FiveEntitiesFourEntityFiltersResult)
+// }
+
+// /*
+// Tests five entities (four types) with three entity filters and one junction
+// Query description: Give me all parties, with less than 10 seats, connected to their respective parliament members, who are then connected to the resolutions they submitted, but only those submitted in May, and connected to the comissions they're in, which are then connected to all of their members, but only those with "Geert" in their name (resulting in only "Geert Wilders")
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestSingleJunctionFiveEntitiesThreeEntityFilters(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(SingleJunctionFiveEntitiesThreeEntityFilters, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &SingleJunctionFiveEntitiesThreeEntityFiltersResult)
+// }
+
+// /*
+// Tests nine entities (four types) with three entity filters and two junctions
+// Query description: Give me all parties, with less than 10 seats, connected to their respective parliament members, who are then connected to the resolutions they submitted, but only those submitted in May, and connected to the comissions they're in, which are then connected to all of their members, but only those with "Geert" in their name (resulting in only "Geert Wilders"), who is then connected to their submited resolutions and their party, which is connected to all of its members
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestDoubleJunctionNineEntitiesThreeEntityFilters(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(DoubleJunctionNineEntitiesThreeEntityFilters, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &DoubleJunctionNineEntitiesThreeEntityFiltersResult)
+// }
+
+// /*
+// Tests two entities (one type) with one entity filter and one relation filter
+// Query description: Give me all airports, in the state "HI", connected to any other airport by flight, but only the flights on "day" 15
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestTwoEntitiesOneEntityFilterOneRelationFilter(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(TwoEntitiesOneEntityFilterOneRelationFilter, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &TwoEntitiesOneEntityFilterOneRelationFilterResult)
+// }
+
+// //TODO
+// //FIX THESE TESTS, THEY'RE NOT THAT INTERESTING BUT SHOULD BE FIXED ANYWAY
+
+// /*
+// Tests a query with no relation field
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestNoRelationsField(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(NoRelationsField, &JSONQuery)
+
+// _, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is an error
+// assert.Equal(t, errors.New("JSONQuery invalid"), err)
+// }
+
+// /*
+// Tests a query with a single group by as an endpoint
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestSingleEndPointGroupBy(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(SingleEndPointGroupBy, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &SingleEndPointGroupByResult)
+// }
+
+// /*
+// Tests a query with a single group by which is connected to a relation
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestSingleGroupBy(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(SingleGroupBy, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &SingleGroupByResult)
+// }
+
+// /*
+// Tests a query with a group by with multiple inputs which is an endpoint
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestMultipleInputGroupByEndpoint(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(MultipleInputGroupByEndpoint, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &MultipleInputGroupByEndpointResult)
+// }
+
+// /*
+// Tests a query with a group by with multiple inputs which is connected to a relation
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestMultipleInputGroupBy(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(MultipleInputGroupBy, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &MultipleInputGroupByResult)
+// }
+
+// /*
+// Tests a query with a group by with a group by as top pill
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestTopGroupBy(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(TopGroupBy, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &TopGroupByResult)
+// }
+
+// /*
+// Tests a large query with multiple groupbys nested and multiple chained filters and chained subqueries
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestWayTooLargeQuery(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(WayTooLargeQuery, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &WayTooLargeQueryResult)
+// }
+
+// /*
+// Tests an entity with a lower than -1 in a relation
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestIncorrectRelationFrom(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(IncorrectRelationFrom, &JSONQuery)
+
+// _, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is an error
+// assert.Equal(t, errors.New("JSONQuery invalid"), err)
+// }
+
+// func CheckResults(t *testing.T, convertedResult *string, correctConvertedResult *string) {
+// inTree := false
+// convertedResultSplit := strings.Split(*convertedResult, "\n")
+// correctConvertedResultSplit := strings.Split(*correctConvertedResult, "\n")
+// for x := range convertedResultSplit {
+// convertedLine := convertedResultSplit[x]
+// correctLine := correctConvertedResultSplit[x]
+// regExCleaner := regexp.MustCompile(`\s+`)
+// convertedCleanedLine := strings.TrimSpace(regExCleaner.ReplaceAllString(convertedLine, " "))
+// correctCleanedLine := strings.TrimSpace(regExCleaner.ReplaceAllString(correctLine, " "))
+// if len(correctCleanedLine) > 8 && correctCleanedLine[:8] == "LET tree" {
+// inTree = true
+// }
+// if inTree && len(correctCleanedLine) > 6 && correctCleanedLine[:5] == "LET g" && correctCleanedLine[:6] != "LET gb" {
+// inTree = false
+// }
+// if inTree && len(correctCleanedLine) > 6 && correctCleanedLine[:6] == "RETURN" {
+// assert.Equal(t, convertedCleanedLine[:8], correctCleanedLine[:8])
+// assert.Equal(t, convertedCleanedLine[len(convertedCleanedLine)-1:], correctCleanedLine[len(correctCleanedLine)-1:])
+// convertedReturn := strings.Split(strings.ReplaceAll(convertedCleanedLine[8:][:len(convertedCleanedLine)-9], ", \"", "< \""), "< ")
+// correctReturn := strings.Split(strings.ReplaceAll(correctCleanedLine[8:][:len(correctCleanedLine)-9], ", \"", "< \""), "< ")
+// for _, element := range convertedReturn {
+// assert.Contains(t, correctReturn, element)
+// }
+// for _, element := range correctReturn {
+// assert.Contains(t, convertedReturn, element)
+// }
+// } else if inTree && len(correctCleanedLine) > 27 && (correctCleanedLine[:27] == "LET nodes = union_distinct(" || correctCleanedLine[:27] == "LET edges = union_distinct(") {
+// assert.Equal(t, convertedCleanedLine[:27], correctCleanedLine[:27])
+// assert.Equal(t, convertedCleanedLine[len(convertedCleanedLine)-3:], correctCleanedLine[len(correctCleanedLine)-3:])
+// convertedReturn := strings.Split(convertedCleanedLine[27:][:len(convertedCleanedLine)-30], ", ")
+// correctReturn := strings.Split(correctCleanedLine[27:][:len(correctCleanedLine)-30], ", ")
+// for _, element := range convertedReturn {
+// assert.Contains(t, correctReturn, element)
+// }
+// } else {
+// assert.Equal(t, convertedCleanedLine, correctCleanedLine)
+// }
+// }
+// }
+
+// /*
+// Tests two separated chains consisting of 1 relation each
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestSeparatedChainSingleRelationPerChain(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(SeparatedChainSingleRelationPerChain, &JSONQuery)
+
+// _, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is an error
+// assert.Equal(t, errors.New("JSONQuery invalid"), err)
+// }
+
+// /*
+// Tests two separated chains consisting of 1 relation each
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestSeparatedChainDoubleRelationPerChain(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(SeparatedChainDoubleRelationPerChain, &JSONQuery)
+
+// _, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is an error
+// assert.Equal(t, errors.New("JSONQuery invalid"), err)
+// }
+
+// /*
+// Tests two separated chains
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestSeperatedChainWithGroupBys(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(SeperatedChainWithGroupBys, &JSONQuery)
+
+// _, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is an error
+// assert.Equal(t, errors.New("JSONQuery invalid"), err)
+// }
+
+// /*
+// Tests a group by which has different nodes on its group and by
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestDifferentNodesOnGroupBy(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(DifferentNodesOnGroupBy, &JSONQuery)
+
+// _, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is an error
+// assert.Equal(t, errors.New("JSONQuery invalid"), err)
+// }
+
+// /*
+// Tests a group by which has a modifier which aql doesn't recognise
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestIncorrectGroupByModifier(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(IncorrectGroupByModifier, &JSONQuery)
+
+// _, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is an error
+// assert.Equal(t, errors.New("JSONQuery invalid"), err)
+// }
+
+// /*
+// Tests a query with nested group bys
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestAllStreamers(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(AllStreamers, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &AllStreamersResult)
+// }
+
+// /*
+// Tests the string match types
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestStringMatchTypes(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(StringMatchTypes, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &StringMatchTypesResult)
+// }
+
+// /*
+// Tests a query where a top pill is the to, and is connected to a from group by
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestTopEntityToFromGroupBy(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(TopEntityToFromGroupBy, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &TopEntityToFromGroupByResult)
+// }
+
+// /*
+// Tests in not equals filter
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestIntNotEquals(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(IntNotEquals, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &IntNotEqualsResult)
+// }
+
+// /*
+// Tests bool equals filter
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestBoolEqual(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(BoolEqual, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &BoolEqualResult)
+// }
+
+// /*
+// Tests bool not equals filter
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestBoolNotEqual(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(BoolNotEqual, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &BoolNotEqualResult)
+// }
+
+// /*
+// Tests a different nested group by which will have to propagate to get group by type
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestGroupNestedGroupBys2(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(NestedGroupBys2, &JSONQuery)
+
+// convertedResult, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// // Assert that the result and the expected result are the same
+// CheckResults(t, convertedResult, &NestedGroupBys2Result)
+// }
diff --git a/aql/queryConverter.go b/aql/queryConverter.go
index 9052af18e7e95386a401dee71c1bb70dbc16848f..2110842cff575f70233f6ff0f1468f7c7ec706bb 100644
--- a/aql/queryConverter.go
+++ b/aql/queryConverter.go
@@ -5,16 +5,11 @@ This program has been developed by students from the bachelor Computer Science a
package aql
-import (
- "git.science.uu.nl/graphpolaris/query-conversion"
- "git.science.uu.nl/graphpolaris/query-conversion/entity"
-)
-
// Service implements the QueryConverter interface (in the query service)
type Service struct {
}
// NewService creates a new AQL conversion service
-func NewService() query.Converter[entity.IncomingQueryJSON] {
- return &Service{}
-}
+// func NewService() query.Converter {
+// return &Service{}
+// }
diff --git a/cypher/convertQueryBenchmark_test.go b/cypher/convertQueryBenchmark_test.go
index 6367492a829aa2d42c867b52ce7b8297414c0b86..f2a6eef2453f0f0638ec73e86b2ed5549b7f7839 100644
--- a/cypher/convertQueryBenchmark_test.go
+++ b/cypher/convertQueryBenchmark_test.go
@@ -5,170 +5,170 @@
package cypher
-import (
- "encoding/json"
- "testing"
-
- "git.science.uu.nl/graphpolaris/query-conversion/entity"
-)
-
-func BenchmarkConvertEmptyQuery(b *testing.B) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- query := []byte(`{
- "return": {
- "entities": [],
- "relations": []
- },
- "entities": [],
- "relations": [],
- "limit": 5000
- }`)
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- service.ConvertQuery(&JSONQuery)
- }
-}
-
-func BenchmarkConvertOneAttributeQuery(b *testing.B) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- query := []byte(`{
- "return": {
- "entities": [
- 0
- ],
- "relations": []
- },
- "entities": [
- {
- "type": "airports",
- "constraints": [
- {
- "attribute": "state",
- "value": "HI",
- "dataType": "string",
- "matchType": "exact"
- }
- ]
- }
- ],
- "relations": [],
- "limit": 5000
- }`)
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- service.ConvertQuery(&JSONQuery)
- }
-}
-
-func BenchmarkConvertTwoRelationQuery(b *testing.B) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- query := []byte(`{
- "return": {
- "entities": [
- 0,
- 1,
- 2
- ],
- "relations": [
- 0,
- 1
- ]
- },
- "entities": [
- {
- "type": "airports",
- "constraints": [
- {
- "attribute": "city",
- "value": "New York",
- "dataType": "string",
- "matchType": "exact"
- }
- ]
- },
- {
- "type": "airports",
- "constraints": [
- {
- "attribute": "city",
- "value": "San Francisco",
- "dataType": "string",
- "matchType": "exact"
- }
- ]
- },
- {
- "type": "airports",
- "constraints": [
- {
- "attribute": "state",
- "value": "HI",
- "dataType": "string",
- "matchType": "exact"
- }
- ]
- }
- ],
- "relations": [
- {
- "type": "flights",
- "depth": {
- "min": 1,
- "max": 3
- },
- "entityFrom": 2,
- "entityTo": 1,
- "constraints": [
- {
- "attribute": "Day",
- "value": "15",
- "dataType": "int",
- "matchType": "EQ"
- }
- ]
- },
- {
- "type": "flights",
- "depth": {
- "min": 1,
- "max": 1
- },
- "entityFrom": 0,
- "entityTo": -1,
- "constraints": []
- }
- ],
- "limit": 5000
- }`)
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- service.ConvertQuery(&JSONQuery)
- }
-}
+// import (
+// "encoding/json"
+// "testing"
+
+// "git.science.uu.nl/graphpolaris/query-conversion/entity"
+// )
+
+// func BenchmarkConvertEmptyQuery(b *testing.B) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// query := []byte(`{
+// "return": {
+// "entities": [],
+// "relations": []
+// },
+// "entities": [],
+// "relations": [],
+// "limit": 5000
+// }`)
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// b.ResetTimer()
+
+// for i := 0; i < b.N; i++ {
+// service.ConvertQuery(&JSONQuery)
+// }
+// }
+
+// func BenchmarkConvertOneAttributeQuery(b *testing.B) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// query := []byte(`{
+// "return": {
+// "entities": [
+// 0
+// ],
+// "relations": []
+// },
+// "entities": [
+// {
+// "type": "airports",
+// "constraints": [
+// {
+// "attribute": "state",
+// "value": "HI",
+// "dataType": "string",
+// "matchType": "exact"
+// }
+// ]
+// }
+// ],
+// "relations": [],
+// "limit": 5000
+// }`)
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// b.ResetTimer()
+
+// for i := 0; i < b.N; i++ {
+// service.ConvertQuery(&JSONQuery)
+// }
+// }
+
+// func BenchmarkConvertTwoRelationQuery(b *testing.B) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// query := []byte(`{
+// "return": {
+// "entities": [
+// 0,
+// 1,
+// 2
+// ],
+// "relations": [
+// 0,
+// 1
+// ]
+// },
+// "entities": [
+// {
+// "type": "airports",
+// "constraints": [
+// {
+// "attribute": "city",
+// "value": "New York",
+// "dataType": "string",
+// "matchType": "exact"
+// }
+// ]
+// },
+// {
+// "type": "airports",
+// "constraints": [
+// {
+// "attribute": "city",
+// "value": "San Francisco",
+// "dataType": "string",
+// "matchType": "exact"
+// }
+// ]
+// },
+// {
+// "type": "airports",
+// "constraints": [
+// {
+// "attribute": "state",
+// "value": "HI",
+// "dataType": "string",
+// "matchType": "exact"
+// }
+// ]
+// }
+// ],
+// "relations": [
+// {
+// "type": "flights",
+// "depth": {
+// "min": 1,
+// "max": 3
+// },
+// "entityFrom": 2,
+// "entityTo": 1,
+// "constraints": [
+// {
+// "attribute": "Day",
+// "value": "15",
+// "dataType": "int",
+// "matchType": "EQ"
+// }
+// ]
+// },
+// {
+// "type": "flights",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "entityFrom": 0,
+// "entityTo": -1,
+// "constraints": []
+// }
+// ],
+// "limit": 5000
+// }`)
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// b.ResetTimer()
+
+// for i := 0; i < b.N; i++ {
+// service.ConvertQuery(&JSONQuery)
+// }
+// }
diff --git a/cypher/convertQuery_test.go b/cypher/convertQuery_test.go
index 824fda3381d2bacdf99c1a010a0e15d296d06d5b..1a30ac1ebedf7e24d0893c95ed7bee06d9ee0444 100644
--- a/cypher/convertQuery_test.go
+++ b/cypher/convertQuery_test.go
@@ -5,1561 +5,1555 @@
package cypher
-import (
- "encoding/json"
- "errors"
- "fmt"
- "strings"
- "testing"
-
- "git.science.uu.nl/graphpolaris/query-conversion/entity"
- "github.com/stretchr/testify/assert"
-)
-
-// All these tests test the entire flow
-
-func fixCypherSpaces(cypher *string) string {
- trimmedCypher := strings.Replace(*cypher, "\n", " ", -1)
- trimmedCypher = strings.Replace(trimmedCypher, " ", " ", -1)
- trimmedCypher = strings.Replace(trimmedCypher, "\t", "", -1)
- return trimmedCypher
-}
-
-func TestGroupBy(t *testing.T) {
- query := []byte(`{
- "databaseName": "Movies3",
- "return": {
- "entities": [
- 0,
- 1,
- 2
- ],
- "relations": [
- 0,
- 1
- ],
- "groupBys": [
- 0
- ]
- },
- "entities": [
- {
- "id": 0,
- "name": "Person",
- "constraints": [
- {
- "attribute": "name",
- "value": "Raymond Campbell",
- "dataType": "string",
- "matchType": "NEQ",
- "inID": -1,
- "inType": ""
- }
- ]
- },
- {
- "id": 1,
- "name": "Movie",
- "constraints": []
- },
- {
- "id": 2,
- "name": "Genre",
- "constraints": []
- }
- ],
- "relations": [
- {
- "id": 0,
- "name": "DIRECTED",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 0,
- "toType": "entity",
- "toID": 1,
- "constraints": []
- },
- {
- "id": 1,
- "name": "IN_GENRE",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "groupBy",
- "fromID": 0,
- "toType": "entity",
- "toID": 2,
- "constraints": []
- }
- ],
- "groupBys": [
- {
- "id": 0,
- "groupType": "entity",
- "groupID": [0],
- "groupAttribute": "bornIn",
- "byType": "entity",
- "byID": [1],
- "byAttribute": "imdbId",
- "appliedModifier": "AVG",
- "relationID": 0,
- "constraints": []
- }
- ],
- "machineLearning": [],
- "limit": 5000
- }`)
-
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- s := NewService()
- cypher, _, err := s.ConvertQuery(&JSONQuery)
- if err != nil {
- fmt.Println(err)
- }
-
- answer := `MATCH p0 = (e0:Person)-[:DIRECTED*1..1]-(e1:Movie)
- WHERE e0.name <> "Raymond Campbell"
- UNWIND relationships(p0) as r0
- WITH *
- WITH e1.imdbId AS e1_imdbId, AVG(e0.bornIn) AS AVG_bornIn
- MATCH p1 = (eg1:Movie)-[:IN_GENRE*1..1]-(e2:Genre)
- WHERE eg1.imdbId IN e1_imdbId UNWIND relationships(p1) as r1
- WITH *
- UNWIND [r1,eg1,e2] AS x
- RETURN DISTINCT x
- LIMIT 5000;nodelink`
-
- trimmedCypher := fixCypherSpaces(cypher)
- trimmedAnswer := fixCypherSpaces(&answer)
-
- fmt.Println(*cypher)
- assert.Equal(t, trimmedAnswer, trimmedCypher)
-
-}
-func TestSmallChain(t *testing.T) {
- query := []byte(`{
- "databaseName": "TweedeKamer",
- "return": {
- "entities": [
- 0,
- 1,
- 2
- ],
- "relations": [
- 0,
- 1
- ]
- },
- "entities": [
- {
- "name": "parliament",
- "ID": 0,
- "constraints": [
- {
- "attribute": "name",
- "value": "Geert",
- "dataType": "string",
- "matchType": "contains",
- "inID": -1,
- "inType": ""
- }
- ]
- },
- {
- "name": "parties",
- "ID": 1,
- "constraints": []
- },
- {
- "name": "resolutions",
- "ID": 2,
- "constraints": []
- }
- ],
- "relations": [
- {
- "ID": 0,
- "name": "member_of",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 0,
- "toType": "entity",
- "toID": 1,
- "constraints": []
- },
- {
- "ID": 1,
- "name": "submits",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 0,
- "toType": "entity",
- "toID": 2,
- "constraints": []
- }
- ],
- "groupBys": [],
- "machineLearning": [],
- "limit": 5000
- }
- `)
-
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- s := NewService()
- cypher, _, err := s.ConvertQuery(&JSONQuery)
- if err != nil {
- fmt.Println(err)
- }
-
- answer := `MATCH p0 = (e0:parliament)-[:member_of*1..1]-(e1:parties)
- WHERE e0.name CONTAINS "%Geert%"
- UNWIND relationships(p0) as r0
- WITH *
- MATCH p1 = (e0:parliament)-[:submits*1..1]-(e2:resolutions)
- WHERE e0.name CONTAINS "%Geert%"
- UNWIND relationships(p1) as r1
- WITH *
- UNWIND [r1,e0,e2,r0,e0,e1] AS x
- RETURN DISTINCT x
- LIMIT 5000;nodelink`
-
- trimmedCypher := fixCypherSpaces(cypher)
- trimmedAnswer := fixCypherSpaces(&answer)
-
- assert.Equal(t, trimmedAnswer, trimmedCypher)
-
-}
-
-// This one does not really have dependencies, the order doesnt matter, maybe sort on numbers between equal dependencies?
-func TestLargeQueryChain(t *testing.T) {
- query := []byte(`{
- "databaseName": "TweedeKamer",
- "return": {
- "entities": [
- 0,
- 1,
- 2,
- 3,
- 4
- ],
- "relations": [
- 0,
- 1,
- 2,
- 3
- ]
- },
- "entities": [
- {
- "name": "parliament",
- "ID": 0,
- "constraints": [
- {
- "attribute": "name",
- "value": "A",
- "dataType": "string",
- "matchType": "contains",
- "inID": -1,
- "inType": ""
- }
- ]
- },
- {
- "name": "parties",
- "ID": 1,
- "constraints": [
- {
- "attribute": "seats",
- "value": "10",
- "dataType": "int",
- "matchType": "LT",
- "inID": -1,
- "inType": ""
- }
- ]
- },
- {
- "name": "resolutions",
- "ID": 2,
- "constraints": [
- {
- "attribute": "date",
- "value": "mei",
- "dataType": "string",
- "matchType": "contains",
- "inID": -1,
- "inType": ""
- }
- ]
- },
- {
- "name": "parliament",
- "ID": 3,
- "constraints": []
- },
- {
- "name": "parties",
- "ID": 4,
- "constraints": [
- {
- "attribute": "name",
- "value": "Volkspartij voor Vrijheid en Democratie",
- "dataType": "string",
- "matchType": "==",
- "inID": -1,
- "inType": ""
- }
- ]
- }
- ],
- "relations": [
- {
- "ID": 0,
- "name": "member_of",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 0,
- "toType": "entity",
- "toID": 1,
- "constraints": []
- },
- {
- "ID": 1,
- "name": "submits",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 1,
- "toType": "entity",
- "toID": 2,
- "constraints": []
- },
- {
- "ID": 2,
- "name": "submits",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 2,
- "toType": "entity",
- "toID": 3,
- "constraints": []
- },
- {
- "ID": 3,
- "name": "member_of",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 3,
- "toType": "entity",
- "toID": 4,
- "constraints": []
- }
- ],
- "groupBys": [],
- "machineLearning": [],
- "limit": 5000
- }
-
- `)
-
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- s := NewService()
- cypher, _, err := s.ConvertQuery(&JSONQuery)
- if err != nil {
- fmt.Println(err)
- }
-
- answer := `MATCH p0 = (e0:parliament)-[:member_of*1..1]-(e1:parties)
- WHERE e0.name CONTAINS "%A%"
- AND e1.seats < 10
- UNWIND relationships(p0) as r0
- WITH *
- MATCH p1 = (e1:parties)-[:submits*1..1]-(e2:resolutions)
- WHERE e1.seats < 10
- AND e2.date CONTAINS "%mei%"
- UNWIND relationships(p1) as r1
- WITH *
- MATCH p2 = (e2:resolutions)-[:submits*1..1]-(e3:parliament)
- WHERE e2.date CONTAINS "%mei%"
- UNWIND relationships(p2) as r2
- WITH *
- MATCH p3 = (e3:parliament)-[:member_of*1..1]-(e4:parties)
- WHERE e4.name = "Volkspartij voor Vrijheid en Democratie"
- UNWIND relationships(p3) as r3
- WITH *
- UNWIND [r3,e3,e4,r2,e2,e3,r1,e1,e2,r0,e0,e1] AS x
- RETURN DISTINCT x
- LIMIT 5000;nodelink`
-
-
- trimmedCypher := fixCypherSpaces(cypher)
- trimmedAnswer := fixCypherSpaces(&answer)
-
- assert.Equal(t, trimmedAnswer, trimmedCypher)
-
-}
-
-func TestInStatement(t *testing.T) {
- query := []byte(`{
- "databaseName": "Movies3",
- "entities": [
- {
- "id": 0,
- "name": "Person",
- "constraints": []
- },
- {
- "id": 1,
- "name": "Movie",
- "constraints": []
- },
- {
- "id": 2,
- "name": "Person",
- "constraints": [
- {
- "attribute": "bornIn",
- "value": "",
- "dataType": "string",
- "matchType": "",
- "inID": 0,
- "inType": "groupBy"
- }
- ]
- }
- ],
- "relations": [
- {
- "id": 0,
- "name": "ACTED_IN",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 0,
- "toType": "entity",
- "toID": 1,
- "constraints": []
- }
- ],
- "groupBys": [
- {
- "id": 0,
- "groupType": "entity",
- "groupID": [1],
- "groupAttribute": "imdbRating",
- "byType": "entity",
- "byID": [0],
- "byAttribute": "bornIn",
- "appliedModifier": "AVG",
- "relationID": 0,
- "constraints": [
- {
- "attribute": "imdbRating",
- "value": "7.5",
- "dataType": "int",
- "matchType": "GT",
- "inID": -1,
- "inType": ""
- }
- ]
- }
- ],
- "machineLearning": [],
- "limit": 5000
- }
- `)
-
- answer := `MATCH p0 = (e0:Person)-[:ACTED_IN*1..1]-(e1:Movie)
- UNWIND relationships(p0) as r0
- WITH *
- WITH e0.bornIn AS e0_bornIn, AVG(e1.imdbRating) AS AVG_imdbRating
- WHERE AVG_imdbRating > 7.5
- MATCH (e2:Person)
- WHERE e2.bornIn IN e0_bornIn
- WITH *
- UNWIND [e2] AS x
- RETURN DISTINCT x
- LIMIT 5000;nodelink`
-
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- s := NewService()
- cypher, _, err := s.ConvertQuery(&JSONQuery)
- if err != nil {
- fmt.Println(err)
- }
-
-
- trimmedCypher := fixCypherSpaces(cypher)
- trimmedAnswer := fixCypherSpaces(&answer)
- assert.Equal(t, trimmedAnswer, trimmedCypher)
-
-}
-func TestMultipleByStatementDisconnected(t *testing.T) {
- query := []byte(`{
- "databaseName": "Movies3",
- "entities": [
- {
- "id": 0,
- "name": "Person",
- "constraints": []
- },
- {
- "id": 1,
- "name": "Movie",
- "constraints": []
- },
- {
- "id": 2,
- "name": "Person",
- "constraints": []
- },
- {
- "id": 3,
- "name": "Movie",
- "constraints": []
- }
- ],
- "relations": [
- {
- "id": 0,
- "name": "ACTED_IN",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 0,
- "toType": "entity",
- "toID": 1,
- "constraints": []
- },
- {
- "id": 2,
- "name": "ACTED_IN",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 2,
- "toType": "entity",
- "toID": 3,
- "constraints": []
- }
- ],
- "groupBys": [
- {
- "id": 0,
- "groupType": "entity",
- "groupID": [1,3],
- "groupAttribute": "imdbRating",
- "byType": "entity",
- "byID": [0,2],
- "byAttribute": "bornIn",
- "appliedModifier": "AVG",
- "relationID": 0,
- "constraints": [
- {
- "attribute": "imdbRating",
- "value": "7.5",
- "dataType": "int",
- "matchType": "GT",
- "inID": -1,
- "inType": ""
- }
- ]
- }
- ],
- "machineLearning": [],
- "limit": 5000
- }
- `)
-
- answer := `MATCH p0 = (e0:Person)-[:ACTED_IN*1..1]-(e1:Movie)
- UNWIND relationships(p0) as r0
- WITH *
- MATCH p1 = (e2:Person)-[:ACTED_IN*1..1]-(e3:Movie)
- UNWIND relationships(p1) as r2
- WITH *
- UNWIND [e0,e2] AS e02L
- UNWIND [e1,e3] AS e13L
- WITH e02L.bornIn AS e02L_bornIn, AVG(e13L.imdbRating) AS AVG_imdbRating
- WHERE AVG_imdbRating > 7.5
- RETURN e02L_bornIn, AVG_imdbRating
- LIMIT 5000;table`
-
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- s := NewService()
- cypher, _, err := s.ConvertQuery(&JSONQuery)
- if err != nil {
- fmt.Println(err)
- }
-
-
- trimmedCypher := fixCypherSpaces(cypher)
- trimmedAnswer := fixCypherSpaces(&answer)
- assert.Equal(t, trimmedAnswer, trimmedCypher)
-
-}
-func TestDoubleInStatement(t *testing.T) {
- query := []byte(`{
- "databaseName": "Movies3",
- "entities": [
- {
- "id": 0,
- "name": "Person",
- "constraints": []
- },
- {
- "id": 1,
- "name": "Movie",
- "constraints": []
- },
- {
- "id": 2,
- "name": "Person",
- "constraints": [
- {
- "attribute": "bornIn",
- "value": "",
- "dataType": "string",
- "matchType": "",
- "inID": 0,
- "inType": "groupBy"
- }
- ]
- },
- {
- "id": 3,
- "name": "Person",
- "constraints": [
- {
- "attribute": "bornIn",
- "value": "",
- "dataType": "string",
- "matchType": "",
- "inID": 0,
- "inType": "groupBy"
- }
- ]
- }
- ],
- "relations": [
- {
- "id": 0,
- "name": "ACTED_IN",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 0,
- "toType": "entity",
- "toID": 1,
- "constraints": []
- }
- ],
- "groupBys": [
- {
- "id": 0,
- "groupType": "entity",
- "groupID": [1],
- "groupAttribute": "imdbRating",
- "byType": "entity",
- "byID": [0],
- "byAttribute": "bornIn",
- "appliedModifier": "AVG",
- "relationID": 0,
- "constraints": [
- {
- "attribute": "imdbRating",
- "value": "7.5",
- "dataType": "int",
- "matchType": "GT",
- "inID": -1,
- "inType": ""
- }
- ]
- }
- ],
- "machineLearning": [],
- "limit": 5000
- }
- `)
-
- answer := `MATCH p0 = (e0:Person)-[:ACTED_IN*1..1]-(e1:Movie)
- UNWIND relationships(p0) as r0
- WITH *
- WITH e0.bornIn AS e0_bornIn, AVG(e1.imdbRating) AS AVG_imdbRating
- WHERE AVG_imdbRating > 7.5
- MATCH (e2:Person)
- WHERE e2.bornIn IN e0_bornIn
- WITH *
- MATCH (e3:Person)
- WHERE e3.bornIn IN e0_bornIn
- WITH *
- UNWIND [e3] AS x
- RETURN DISTINCT x
- LIMIT 5000;nodelink`
-
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- s := NewService()
- cypher, _, err := s.ConvertQuery(&JSONQuery)
- if err != nil {
- fmt.Println(err)
- }
-
-
- trimmedCypher := fixCypherSpaces(cypher)
- trimmedAnswer := fixCypherSpaces(&answer)
- assert.Equal(t, trimmedAnswer, trimmedCypher)
-
-}
-func TestEndOnGroupBy(t *testing.T) {
- query := []byte(`{
- "return": {
- "entities": [
- 11,
- 12
- ],
- "relations": [
- 10
- ],
- "groupBys": [
- 1
- ]
- },
- "entities": [
- {
- "name": "Person",
- "ID": 11,
- "constraints": []
- },
- {
- "name": "Movie",
- "ID": 12,
- "constraints": []
- }
- ],
- "relations": [
- {
- "ID": 10,
- "name": "DIRECTED",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 11,
- "toType": "entity",
- "toID": 12,
- "constraints": []
- }
- ],
- "groupBys": [
- {
- "id": 0,
- "groupType": "entity",
- "groupID": [11],
- "groupAttribute": "imdbRating",
- "byType": "entity",
- "byID": [12],
- "byAttribute": "bornIn",
- "appliedModifier": "AVG",
- "relationID": 10,
- "constraints": []
- }
- ],
- "machineLearning": [],
- "limit": 5000,
- "databaseName": "Movies3"
- }
- `)
-
- answer := `MATCH p0 = (e11:Person)-[:DIRECTED*1..1]-(e12:Movie)
- UNWIND relationships(p0) as r10
- WITH *
- WITH e12.bornIn AS e12_bornIn, AVG(e11.imdbRating) AS AVG_imdbRating
- RETURN e12_bornIn, AVG_imdbRating
- LIMIT 5000;table`
-
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- s := NewService()
- cypher, _, err := s.ConvertQuery(&JSONQuery)
- if err != nil {
- fmt.Println(err)
- }
-
-
- trimmedCypher := fixCypherSpaces(cypher)
- trimmedAnswer := fixCypherSpaces(&answer)
- assert.Equal(t, trimmedAnswer, trimmedCypher)
-}
-func TestSimpleQuery(t *testing.T) {
- query := []byte(`{
- "return": {
- "entities": [
- 11,
- 12
- ],
- "relations": [
- 10
- ],
- "groupBys": []
- },
- "entities": [
- {
- "name": "Person",
- "ID": 11,
- "constraints": []
- },
- {
- "name": "Movie",
- "ID": 12,
- "constraints": []
- }
- ],
- "relations": [
- {
- "ID": 10,
- "name": "DIRECTED",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 11,
- "toType": "entity",
- "toID": 12,
- "constraints": []
- }
- ],
- "groupBys": [],
- "machineLearning": [],
- "limit": 5000,
- "databaseName": "Movies3"
- }
- `)
-
- answer := `MATCH p0 = (e11:Person)-[:DIRECTED*1..1]-(e12:Movie)
- UNWIND relationships(p0) as r10
- WITH *
- UNWIND [r10,e11,e12] AS x
- RETURN DISTINCT x
- LIMIT 5000;nodelink`
-
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- s := NewService()
- cypher, _, err := s.ConvertQuery(&JSONQuery)
- if err != nil {
- fmt.Println(err)
- }
-
-
- trimmedCypher := fixCypherSpaces(cypher)
- trimmedAnswer := fixCypherSpaces(&answer)
- assert.Equal(t, trimmedAnswer, trimmedCypher)
-}
-func TestNoRelation(t *testing.T) {
- query := []byte(`{
- "return": {
- "entities": [
- 11,
- 12
- ],
- "relations": [
- 10
- ],
- "groupBys": []
- },
- "entities": [
- {
- "name": "Person",
- "ID": 11,
- "constraints": []
- },
- {
- "name": "Movie",
- "ID": 12,
- "constraints": []
- }
- ],
- "relations": [],
- "groupBys": [],
- "machineLearning": [],
- "limit": 5000,
- "databaseName": "Movies3"
- }
- `)
-
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
- fmt.Println(JSONQuery)
- fmt.Println(" ")
-
- s := NewService()
- _, _, err := s.ConvertQuery(&JSONQuery)
- if err != nil {
- assert.Equal(t, err.Error(), "Invalid query")
- } else {
- // It should error, thus it must not reach this
- t.Fail()
- }
-}
-
-func TestNoEntities(t *testing.T) {
- query := []byte(`{
- "return": {
- "entities": [
- 11,
- 12
- ],
- "relations": [
- 10
- ],
- "groupBys": []
- },
- "entities": [],
- "relations": [
- {
- "ID": 10,
- "name": "DIRECTED",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 11,
- "toType": "entity",
- "toID": 12,
- "constraints": []
- }
- ],
- "groupBys": [],
- "machineLearning": [],
- "limit": 5000,
- "databaseName": "Movies3"
- }
- `)
-
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
- fmt.Println(JSONQuery)
- fmt.Println(" ")
-
- s := NewService()
- _, _, err := s.ConvertQuery(&JSONQuery)
- if err != nil {
- assert.Equal(t, err.Error(), "Invalid query")
- } else {
- // It should error, thus it must not reach this
- t.Fail()
- }
-}
-func TestTwoRelationsCycle(t *testing.T) {
- query := []byte(`{
- "return": {
- "entities": [
- 11,
- 12
- ],
- "relations": [
- 10
- ],
- "groupBys": []
- },
- "entities": [
- {
- "name": "Person",
- "ID": 11,
- "constraints": []
- },
- {
- "name": "Movie",
- "ID": 12,
- "constraints": []
- }
- ],
- "relations": [
- {
- "ID": 10,
- "name": "DIRECTED",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 11,
- "toType": "entity",
- "toID": 12,
- "constraints": []
- },
- {
- "ID": 11,
- "name": "ACTED_IN",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 12,
- "toType": "entity",
- "toID": 11,
- "constraints": []
- }
- ],
- "groupBys": [],
- "machineLearning": [],
- "limit": 5000,
- "databaseName": "Movies3"
- }
- `)
-
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
- fmt.Println(JSONQuery)
- fmt.Println(" ")
-
- s := NewService()
- cypher, _, err := s.ConvertQuery(&JSONQuery)
- if err != nil {
- fmt.Println(err)
- t.Fail()
- return
- }
-
- if cypher == nil {
- t.Fail()
- return
- }
-
- answer1 := `MATCH p0 = (e11:Person)-[:DIRECTED*1..1]-(e12:Movie)
- UNWIND relationships(p0) as r10
- WITH *
- MATCH p1 = (e12:Movie)-[:ACTED_IN*1..1]-(e11:Person)
- UNWIND relationships(p1) as r11
- WITH *
- UNWIND [r11,e12,e11,r10,e11,e12] AS x
- RETURN DISTINCT x
- LIMIT 5000;nodelink`
-
- answer2 := `MATCH p1 = (e12:Movie)-[:ACTED_IN*1..1]-(e11:Person)
- UNWIND relationships(p1) as r11
- WITH *
- MATCH p0 = (e11:Person)-[:DIRECTED*1..1]-(e12:Movie)
- UNWIND relationships(p0) as r10
- WITH *
- UNWIND [r10,e11,e12,r11,e12,e11] AS x
- RETURN DISTINCT x
- LIMIT 5000;nodelink`
-
- trimmedCypher := fixCypherSpaces(cypher)
- trimmedAnswer1 := fixCypherSpaces(&answer1)
- trimmedAnswer2 := fixCypherSpaces(&answer2)
-
- fmt.Println(*cypher)
- // Both answers are correct
- if !(trimmedAnswer1 == trimmedCypher || trimmedAnswer2 == trimmedCypher) {
- t.Fail()
- }
-}
-
-func TestCyclePlusDependency(t *testing.T) {
- query := []byte(`{
- "return": {
- "entities": [
- 11,
- 12
- ],
- "relations": [
- 10
- ],
- "groupBys": []
- },
- "entities": [
- {
- "name": "Person",
- "ID": 11,
- "constraints": []
- },
- {
- "name": "Movie",
- "ID": 12,
- "constraints": []
- },
- {
- "name": "Person",
- "ID": 13,
- "constraints": []
- }
- ],
- "relations": [
- {
- "ID": 10,
- "name": "DIRECTED",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 11,
- "toType": "entity",
- "toID": 12,
- "constraints": []
- },
- {
- "ID": 11,
- "name": "ACTED_IN",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 12,
- "toType": "entity",
- "toID": 11,
- "constraints": []
- },
- {
- "ID": 12,
- "name": "ACTED_IN",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 13,
- "toType": "entity",
- "toID": 12,
- "constraints": []
- }
- ],
- "groupBys": [],
- "machineLearning": [],
- "limit": 5000,
- "databaseName": "Movies3"
- }
- `)
-
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
- fmt.Println(JSONQuery)
- fmt.Println(" ")
-
- s := NewService()
- cypher, _, err := s.ConvertQuery(&JSONQuery)
- if err != nil {
- fmt.Println(err)
- t.Fail()
- return
- }
-
- if cypher == nil {
- t.Fail()
- return
- }
-
- answer := `MATCH p2 = (e13:Person)-[:ACTED_IN*1..1]-(e12:Movie)
- UNWIND relationships(p2) as r12
- WITH *
- MATCH p1 = (e12:Movie)-[:ACTED_IN*1..1]-(e11:Person)
- UNWIND relationships(p1) as r11
- WITH *
- MATCH p0 = (e11:Person)-[:DIRECTED*1..1]-(e12:Movie)
- UNWIND relationships(p0) as r10
- WITH *
- UNWIND [r10,e11,e12,r11,e12,e11,r12,e13,e12] AS x
- RETURN DISTINCT x
- LIMIT 5000;nodelink`
-
- trimmedCypher := fixCypherSpaces(cypher)
- trimmedAnswer := fixCypherSpaces(&answer)
-
- fmt.Println(*cypher)
- assert.Equal(t, trimmedAnswer, trimmedCypher)
-}
-func TestTripleCycle(t *testing.T) {
- query := []byte(`{
- "return": {
- "entities": [
- 11,
- 12
- ],
- "relations": [
- 10
- ],
- "groupBys": []
- },
- "entities": [
- {
- "name": "Person",
- "ID": 11,
- "constraints": []
- },
- {
- "name": "Movie",
- "ID": 12,
- "constraints": []
- },
- {
- "name": "Person",
- "ID": 13,
- "constraints": []
- }
- ],
- "relations": [
- {
- "ID": 10,
- "name": "DIRECTED",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 11,
- "toType": "entity",
- "toID": 12,
- "constraints": []
- },
- {
- "ID": 11,
- "name": "ACTED_IN",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 12,
- "toType": "entity",
- "toID": 13,
- "constraints": []
- },
- {
- "ID": 12,
- "name": "ACTED_IN",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 13,
- "toType": "entity",
- "toID": 11,
- "constraints": []
- }
- ],
- "groupBys": [],
- "machineLearning": [],
- "limit": 5000,
- "databaseName": "Movies3"
- }
- `)
-
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- s := NewService()
- cypher, _, err := s.ConvertQuery(&JSONQuery)
- if err != nil {
- fmt.Println(err)
- assert.Equal(t, err, errors.New("Cyclic query detected"))
- return
- }
-
- if cypher == nil {
- t.Fail()
- return
- }
- t.Fail()
-}
-
-func TestMultipleByStatementConnected(t *testing.T) {
- query := []byte(`{
- "databaseName": "Movies3",
- "entities": [
- {
- "id": 0,
- "name": "Person",
- "constraints": []
- },
- {
- "id": 1,
- "name": "Movie",
- "constraints": []
- },
- {
- "id": 2,
- "name": "Person",
- "constraints": []
- }
- ],
- "relations": [
- {
- "id": 0,
- "name": "ACTED_IN",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 0,
- "toType": "entity",
- "toID": 1,
- "constraints": []
- },
- {
- "id": 2,
- "name": "ACTED_IN",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 2,
- "toType": "entity",
- "toID": 1,
- "constraints": []
- }
- ],
- "groupBys": [
- {
- "id": 0,
- "groupType": "entity",
- "groupID": [1],
- "groupAttribute": "imdbRating",
- "byType": "entity",
- "byID": [0,2],
- "byAttribute": "bornIn",
- "appliedModifier": "AVG",
- "relationID": 0,
- "constraints": [
- {
- "attribute": "imdbRating",
- "value": "7.5",
- "dataType": "int",
- "matchType": "GT",
- "inID": -1,
- "inType": ""
- }
- ]
- }
- ],
- "machineLearning": [],
- "limit": 5000
- }
- `)
-
- answer := `MATCH p0 = (e0:Person)-[:ACTED_IN*1..1]-(e1:Movie)
- UNWIND relationships(p0) as r0
- WITH *
- MATCH p1 = (e2:Person)-[:ACTED_IN*1..1]-(e1:Movie)
- UNWIND relationships(p1) as r2
- WITH *
- UNWIND [e0,e2] AS e02L
- WITH e02L.bornIn AS e02L_bornIn, AVG(e1.imdbRating) AS AVG_imdbRating
- WHERE AVG_imdbRating > 7.5
- RETURN e02L_bornIn, AVG_imdbRating
- LIMIT 5000;table`
-
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- s := NewService()
- cypher, _, err := s.ConvertQuery(&JSONQuery)
- if err != nil {
- fmt.Println(err)
- }
- println(cypher)
-
- trimmedCypher := fixCypherSpaces(cypher)
- trimmedAnswer := fixCypherSpaces(&answer)
-
- fmt.Println(*cypher)
- assert.Equal(t, trimmedAnswer, trimmedCypher)
-
-}
-
-func TestRelationOnGroupBy(t *testing.T) {
- query := []byte(`{
- "databaseName": "Movies3",
- "entities": [
- {
- "id": 0,
- "name": "Person",
- "constraints": []
- },
- {
- "id": 1,
- "name": "Movie",
- "constraints": []
- },
- {
- "id": 2,
- "name": "Person",
- "constraints": []
- },
- {
- "id": 3,
- "name": "Movie",
- "constraints": []
- }
- ],
- "relations": [
- {
- "id": 0,
- "name": "ACTED_IN",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 0,
- "toType": "entity",
- "toID": 1,
- "constraints": []
- },
- {
- "id": 1,
- "name": "ACTED_IN",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "entity",
- "fromID": 2,
- "toType": "entity",
- "toID": 1,
- "constraints": []
- },
- {
- "id": 2,
- "name": "ACTED_IN",
- "depth": {
- "min": 1,
- "max": 1
- },
- "fromType": "groupBy",
- "fromID": 0,
- "toType": "entity",
- "toID": 3,
- "constraints": []
- }
- ],
- "groupBys": [
- {
- "id": 0,
- "groupType": "entity",
- "groupID": [1],
- "groupAttribute": "imdbRating",
- "byType": "entity",
- "byID": [0,2],
- "byAttribute": "bornIn",
- "appliedModifier": "AVG",
- "relationID": 0,
- "constraints": [
- {
- "attribute": "imdbRating",
- "value": "7.5",
- "dataType": "int",
- "matchType": "GT",
- "inID": -1,
- "inType": ""
- }
- ]
- }
- ],
- "machineLearning": [],
- "limit": 5000
- }
- `)
-
- answer1 := `MATCH p0 = (e0:Person)-[:ACTED_IN*1..1]-(e1:Movie)
- UNWIND relationships(p0) as r0
- WITH *
- MATCH p1 = (e2:Person)-[:ACTED_IN*1..1]-(e1:Movie)
- UNWIND relationships(p1) as r1
- WITH *
- UNWIND [e0,e2] AS e02L
- WITH e02L.bornIn AS e02L_bornIn, AVG(e1.imdbRating) AS AVG_imdbRating
- WHERE AVG_imdbRating > 7.5
- MATCH p2 = (eg02L:Person)-[:ACTED_IN*1..1]-(e3:Movie)
- WHERE eg02L.bornIn IN e02L_bornIn
- UNWIND relationships(p2) as r2
- WITH *
- UNWIND [r2,eg02L,e3] AS x
- RETURN DISTINCT x
- LIMIT 5000;nodelink`
-
- answer2 := `MATCH p1 = (e2:Person)-[:ACTED_IN*1..1]-(e1:Movie)
- UNWIND relationships(p1) as r1
- WITH *
- MATCH p0 = (e0:Person)-[:ACTED_IN*1..1]-(e1:Movie)
- UNWIND relationships(p0) as r0
- WITH *
- UNWIND [e0,e2] AS e02L
- WITH e02L.bornIn AS e02L_bornIn, AVG(e1.imdbRating) AS AVG_imdbRating
- WHERE AVG_imdbRating > 7.5
- MATCH p2 = (eg02L:Person)-[:ACTED_IN*1..1]-(e3:Movie)
- WHERE eg02L.bornIn IN e02L_bornIn
- UNWIND relationships(p2) as r2
- WITH *
- UNWIND [r2,eg02L,e3] AS x
- RETURN DISTINCT x
- LIMIT 5000;nodelink`
-
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(query, &JSONQuery)
-
- s := NewService()
- cypher, _, err := s.ConvertQuery(&JSONQuery)
- if err != nil {
- fmt.Println(err)
- }
-
- trimmedCypher := fixCypherSpaces(cypher)
- trimmedAnswer1 := fixCypherSpaces(&answer1)
- trimmedAnswer2 := fixCypherSpaces(&answer2)
-
- if !(trimmedCypher == trimmedAnswer1 || trimmedCypher == trimmedAnswer2) {
- t.Fail()
- }
-}
+// import (
+// "encoding/json"
+// "errors"
+// "fmt"
+// "strings"
+// "testing"
+
+// "git.science.uu.nl/graphpolaris/query-conversion/entity"
+// "github.com/stretchr/testify/assert"
+// )
+
+// // All these tests test the entire flow
+
+// func fixCypherSpaces(cypher *string) string {
+// trimmedCypher := strings.Replace(*cypher, "\n", " ", -1)
+// trimmedCypher = strings.Replace(trimmedCypher, " ", " ", -1)
+// trimmedCypher = strings.Replace(trimmedCypher, "\t", "", -1)
+// return trimmedCypher
+// }
+
+// func TestGroupBy(t *testing.T) {
+// query := []byte(`{
+// "databaseName": "Movies3",
+// "return": {
+// "entities": [
+// 0,
+// 1,
+// 2
+// ],
+// "relations": [
+// 0,
+// 1
+// ],
+// "groupBys": [
+// 0
+// ]
+// },
+// "entities": [
+// {
+// "id": 0,
+// "name": "Person",
+// "constraints": [
+// {
+// "attribute": "name",
+// "value": "Raymond Campbell",
+// "dataType": "string",
+// "matchType": "NEQ",
+// "inID": -1,
+// "inType": ""
+// }
+// ]
+// },
+// {
+// "id": 1,
+// "name": "Movie",
+// "constraints": []
+// },
+// {
+// "id": 2,
+// "name": "Genre",
+// "constraints": []
+// }
+// ],
+// "relations": [
+// {
+// "id": 0,
+// "name": "DIRECTED",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 0,
+// "toType": "entity",
+// "toID": 1,
+// "constraints": []
+// },
+// {
+// "id": 1,
+// "name": "IN_GENRE",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "groupBy",
+// "fromID": 0,
+// "toType": "entity",
+// "toID": 2,
+// "constraints": []
+// }
+// ],
+// "groupBys": [
+// {
+// "id": 0,
+// "groupType": "entity",
+// "groupID": [0],
+// "groupAttribute": "bornIn",
+// "byType": "entity",
+// "byID": [1],
+// "byAttribute": "imdbId",
+// "appliedModifier": "AVG",
+// "relationID": 0,
+// "constraints": []
+// }
+// ],
+// "machineLearning": [],
+// "limit": 5000
+// }`)
+
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// s := NewService()
+// cypher, _, err := s.ConvertQuery(&JSONQuery)
+// if err != nil {
+// fmt.Println(err)
+// }
+
+// answer := `MATCH p0 = (e0:Person)-[:DIRECTED*1..1]-(e1:Movie)
+// WHERE e0.name <> "Raymond Campbell"
+// UNWIND relationships(p0) as r0
+// WITH *
+// WITH e1.imdbId AS e1_imdbId, AVG(e0.bornIn) AS AVG_bornIn
+// MATCH p1 = (eg1:Movie)-[:IN_GENRE*1..1]-(e2:Genre)
+// WHERE eg1.imdbId IN e1_imdbId UNWIND relationships(p1) as r1
+// WITH *
+// UNWIND [r1,eg1,e2] AS x
+// RETURN DISTINCT x
+// LIMIT 5000;nodelink`
+
+// trimmedCypher := fixCypherSpaces(cypher)
+// trimmedAnswer := fixCypherSpaces(&answer)
+
+// fmt.Println(*cypher)
+// assert.Equal(t, trimmedAnswer, trimmedCypher)
+
+// }
+// func TestSmallChain(t *testing.T) {
+// query := []byte(`{
+// "databaseName": "TweedeKamer",
+// "return": {
+// "entities": [
+// 0,
+// 1,
+// 2
+// ],
+// "relations": [
+// 0,
+// 1
+// ]
+// },
+// "entities": [
+// {
+// "name": "parliament",
+// "ID": 0,
+// "constraints": [
+// {
+// "attribute": "name",
+// "value": "Geert",
+// "dataType": "string",
+// "matchType": "contains",
+// "inID": -1,
+// "inType": ""
+// }
+// ]
+// },
+// {
+// "name": "parties",
+// "ID": 1,
+// "constraints": []
+// },
+// {
+// "name": "resolutions",
+// "ID": 2,
+// "constraints": []
+// }
+// ],
+// "relations": [
+// {
+// "ID": 0,
+// "name": "member_of",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 0,
+// "toType": "entity",
+// "toID": 1,
+// "constraints": []
+// },
+// {
+// "ID": 1,
+// "name": "submits",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 0,
+// "toType": "entity",
+// "toID": 2,
+// "constraints": []
+// }
+// ],
+// "groupBys": [],
+// "machineLearning": [],
+// "limit": 5000
+// }
+// `)
+
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// s := NewService()
+// cypher, _, err := s.ConvertQuery(&JSONQuery)
+// if err != nil {
+// fmt.Println(err)
+// }
+
+// answer := `MATCH p0 = (e0:parliament)-[:member_of*1..1]-(e1:parties)
+// WHERE e0.name CONTAINS "%Geert%"
+// UNWIND relationships(p0) as r0
+// WITH *
+// MATCH p1 = (e0:parliament)-[:submits*1..1]-(e2:resolutions)
+// WHERE e0.name CONTAINS "%Geert%"
+// UNWIND relationships(p1) as r1
+// WITH *
+// UNWIND [r1,e0,e2,r0,e0,e1] AS x
+// RETURN DISTINCT x
+// LIMIT 5000;nodelink`
+
+// trimmedCypher := fixCypherSpaces(cypher)
+// trimmedAnswer := fixCypherSpaces(&answer)
+
+// assert.Equal(t, trimmedAnswer, trimmedCypher)
+
+// }
+
+// // This one does not really have dependencies, the order doesnt matter, maybe sort on numbers between equal dependencies?
+// func TestLargeQueryChain(t *testing.T) {
+// query := []byte(`{
+// "databaseName": "TweedeKamer",
+// "return": {
+// "entities": [
+// 0,
+// 1,
+// 2,
+// 3,
+// 4
+// ],
+// "relations": [
+// 0,
+// 1,
+// 2,
+// 3
+// ]
+// },
+// "entities": [
+// {
+// "name": "parliament",
+// "ID": 0,
+// "constraints": [
+// {
+// "attribute": "name",
+// "value": "A",
+// "dataType": "string",
+// "matchType": "contains",
+// "inID": -1,
+// "inType": ""
+// }
+// ]
+// },
+// {
+// "name": "parties",
+// "ID": 1,
+// "constraints": [
+// {
+// "attribute": "seats",
+// "value": "10",
+// "dataType": "int",
+// "matchType": "LT",
+// "inID": -1,
+// "inType": ""
+// }
+// ]
+// },
+// {
+// "name": "resolutions",
+// "ID": 2,
+// "constraints": [
+// {
+// "attribute": "date",
+// "value": "mei",
+// "dataType": "string",
+// "matchType": "contains",
+// "inID": -1,
+// "inType": ""
+// }
+// ]
+// },
+// {
+// "name": "parliament",
+// "ID": 3,
+// "constraints": []
+// },
+// {
+// "name": "parties",
+// "ID": 4,
+// "constraints": [
+// {
+// "attribute": "name",
+// "value": "Volkspartij voor Vrijheid en Democratie",
+// "dataType": "string",
+// "matchType": "==",
+// "inID": -1,
+// "inType": ""
+// }
+// ]
+// }
+// ],
+// "relations": [
+// {
+// "ID": 0,
+// "name": "member_of",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 0,
+// "toType": "entity",
+// "toID": 1,
+// "constraints": []
+// },
+// {
+// "ID": 1,
+// "name": "submits",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 1,
+// "toType": "entity",
+// "toID": 2,
+// "constraints": []
+// },
+// {
+// "ID": 2,
+// "name": "submits",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 2,
+// "toType": "entity",
+// "toID": 3,
+// "constraints": []
+// },
+// {
+// "ID": 3,
+// "name": "member_of",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 3,
+// "toType": "entity",
+// "toID": 4,
+// "constraints": []
+// }
+// ],
+// "groupBys": [],
+// "machineLearning": [],
+// "limit": 5000
+// }
+
+// `)
+
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// s := NewService()
+// cypher, _, err := s.ConvertQuery(&JSONQuery)
+// if err != nil {
+// fmt.Println(err)
+// }
+
+// answer := `MATCH p0 = (e0:parliament)-[:member_of*1..1]-(e1:parties)
+// WHERE e0.name CONTAINS "%A%"
+// AND e1.seats < 10
+// UNWIND relationships(p0) as r0
+// WITH *
+// MATCH p1 = (e1:parties)-[:submits*1..1]-(e2:resolutions)
+// WHERE e1.seats < 10
+// AND e2.date CONTAINS "%mei%"
+// UNWIND relationships(p1) as r1
+// WITH *
+// MATCH p2 = (e2:resolutions)-[:submits*1..1]-(e3:parliament)
+// WHERE e2.date CONTAINS "%mei%"
+// UNWIND relationships(p2) as r2
+// WITH *
+// MATCH p3 = (e3:parliament)-[:member_of*1..1]-(e4:parties)
+// WHERE e4.name = "Volkspartij voor Vrijheid en Democratie"
+// UNWIND relationships(p3) as r3
+// WITH *
+// UNWIND [r3,e3,e4,r2,e2,e3,r1,e1,e2,r0,e0,e1] AS x
+// RETURN DISTINCT x
+// LIMIT 5000;nodelink`
+
+// trimmedCypher := fixCypherSpaces(cypher)
+// trimmedAnswer := fixCypherSpaces(&answer)
+
+// assert.Equal(t, trimmedAnswer, trimmedCypher)
+
+// }
+
+// func TestInStatement(t *testing.T) {
+// query := []byte(`{
+// "databaseName": "Movies3",
+// "entities": [
+// {
+// "id": 0,
+// "name": "Person",
+// "constraints": []
+// },
+// {
+// "id": 1,
+// "name": "Movie",
+// "constraints": []
+// },
+// {
+// "id": 2,
+// "name": "Person",
+// "constraints": [
+// {
+// "attribute": "bornIn",
+// "value": "",
+// "dataType": "string",
+// "matchType": "",
+// "inID": 0,
+// "inType": "groupBy"
+// }
+// ]
+// }
+// ],
+// "relations": [
+// {
+// "id": 0,
+// "name": "ACTED_IN",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 0,
+// "toType": "entity",
+// "toID": 1,
+// "constraints": []
+// }
+// ],
+// "groupBys": [
+// {
+// "id": 0,
+// "groupType": "entity",
+// "groupID": [1],
+// "groupAttribute": "imdbRating",
+// "byType": "entity",
+// "byID": [0],
+// "byAttribute": "bornIn",
+// "appliedModifier": "AVG",
+// "relationID": 0,
+// "constraints": [
+// {
+// "attribute": "imdbRating",
+// "value": "7.5",
+// "dataType": "int",
+// "matchType": "GT",
+// "inID": -1,
+// "inType": ""
+// }
+// ]
+// }
+// ],
+// "machineLearning": [],
+// "limit": 5000
+// }
+// `)
+
+// answer := `MATCH p0 = (e0:Person)-[:ACTED_IN*1..1]-(e1:Movie)
+// UNWIND relationships(p0) as r0
+// WITH *
+// WITH e0.bornIn AS e0_bornIn, AVG(e1.imdbRating) AS AVG_imdbRating
+// WHERE AVG_imdbRating > 7.5
+// MATCH (e2:Person)
+// WHERE e2.bornIn IN e0_bornIn
+// WITH *
+// UNWIND [e2] AS x
+// RETURN DISTINCT x
+// LIMIT 5000;nodelink`
+
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// s := NewService()
+// cypher, _, err := s.ConvertQuery(&JSONQuery)
+// if err != nil {
+// fmt.Println(err)
+// }
+
+// trimmedCypher := fixCypherSpaces(cypher)
+// trimmedAnswer := fixCypherSpaces(&answer)
+// assert.Equal(t, trimmedAnswer, trimmedCypher)
+
+// }
+// func TestMultipleByStatementDisconnected(t *testing.T) {
+// query := []byte(`{
+// "databaseName": "Movies3",
+// "entities": [
+// {
+// "id": 0,
+// "name": "Person",
+// "constraints": []
+// },
+// {
+// "id": 1,
+// "name": "Movie",
+// "constraints": []
+// },
+// {
+// "id": 2,
+// "name": "Person",
+// "constraints": []
+// },
+// {
+// "id": 3,
+// "name": "Movie",
+// "constraints": []
+// }
+// ],
+// "relations": [
+// {
+// "id": 0,
+// "name": "ACTED_IN",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 0,
+// "toType": "entity",
+// "toID": 1,
+// "constraints": []
+// },
+// {
+// "id": 2,
+// "name": "ACTED_IN",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 2,
+// "toType": "entity",
+// "toID": 3,
+// "constraints": []
+// }
+// ],
+// "groupBys": [
+// {
+// "id": 0,
+// "groupType": "entity",
+// "groupID": [1,3],
+// "groupAttribute": "imdbRating",
+// "byType": "entity",
+// "byID": [0,2],
+// "byAttribute": "bornIn",
+// "appliedModifier": "AVG",
+// "relationID": 0,
+// "constraints": [
+// {
+// "attribute": "imdbRating",
+// "value": "7.5",
+// "dataType": "int",
+// "matchType": "GT",
+// "inID": -1,
+// "inType": ""
+// }
+// ]
+// }
+// ],
+// "machineLearning": [],
+// "limit": 5000
+// }
+// `)
+
+// answer := `MATCH p0 = (e0:Person)-[:ACTED_IN*1..1]-(e1:Movie)
+// UNWIND relationships(p0) as r0
+// WITH *
+// MATCH p1 = (e2:Person)-[:ACTED_IN*1..1]-(e3:Movie)
+// UNWIND relationships(p1) as r2
+// WITH *
+// UNWIND [e0,e2] AS e02L
+// UNWIND [e1,e3] AS e13L
+// WITH e02L.bornIn AS e02L_bornIn, AVG(e13L.imdbRating) AS AVG_imdbRating
+// WHERE AVG_imdbRating > 7.5
+// RETURN e02L_bornIn, AVG_imdbRating
+// LIMIT 5000;table`
+
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// s := NewService()
+// cypher, _, err := s.ConvertQuery(&JSONQuery)
+// if err != nil {
+// fmt.Println(err)
+// }
+
+// trimmedCypher := fixCypherSpaces(cypher)
+// trimmedAnswer := fixCypherSpaces(&answer)
+// assert.Equal(t, trimmedAnswer, trimmedCypher)
+
+// }
+// func TestDoubleInStatement(t *testing.T) {
+// query := []byte(`{
+// "databaseName": "Movies3",
+// "entities": [
+// {
+// "id": 0,
+// "name": "Person",
+// "constraints": []
+// },
+// {
+// "id": 1,
+// "name": "Movie",
+// "constraints": []
+// },
+// {
+// "id": 2,
+// "name": "Person",
+// "constraints": [
+// {
+// "attribute": "bornIn",
+// "value": "",
+// "dataType": "string",
+// "matchType": "",
+// "inID": 0,
+// "inType": "groupBy"
+// }
+// ]
+// },
+// {
+// "id": 3,
+// "name": "Person",
+// "constraints": [
+// {
+// "attribute": "bornIn",
+// "value": "",
+// "dataType": "string",
+// "matchType": "",
+// "inID": 0,
+// "inType": "groupBy"
+// }
+// ]
+// }
+// ],
+// "relations": [
+// {
+// "id": 0,
+// "name": "ACTED_IN",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 0,
+// "toType": "entity",
+// "toID": 1,
+// "constraints": []
+// }
+// ],
+// "groupBys": [
+// {
+// "id": 0,
+// "groupType": "entity",
+// "groupID": [1],
+// "groupAttribute": "imdbRating",
+// "byType": "entity",
+// "byID": [0],
+// "byAttribute": "bornIn",
+// "appliedModifier": "AVG",
+// "relationID": 0,
+// "constraints": [
+// {
+// "attribute": "imdbRating",
+// "value": "7.5",
+// "dataType": "int",
+// "matchType": "GT",
+// "inID": -1,
+// "inType": ""
+// }
+// ]
+// }
+// ],
+// "machineLearning": [],
+// "limit": 5000
+// }
+// `)
+
+// answer := `MATCH p0 = (e0:Person)-[:ACTED_IN*1..1]-(e1:Movie)
+// UNWIND relationships(p0) as r0
+// WITH *
+// WITH e0.bornIn AS e0_bornIn, AVG(e1.imdbRating) AS AVG_imdbRating
+// WHERE AVG_imdbRating > 7.5
+// MATCH (e2:Person)
+// WHERE e2.bornIn IN e0_bornIn
+// WITH *
+// MATCH (e3:Person)
+// WHERE e3.bornIn IN e0_bornIn
+// WITH *
+// UNWIND [e3] AS x
+// RETURN DISTINCT x
+// LIMIT 5000;nodelink`
+
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// s := NewService()
+// cypher, _, err := s.ConvertQuery(&JSONQuery)
+// if err != nil {
+// fmt.Println(err)
+// }
+
+// trimmedCypher := fixCypherSpaces(cypher)
+// trimmedAnswer := fixCypherSpaces(&answer)
+// assert.Equal(t, trimmedAnswer, trimmedCypher)
+
+// }
+// func TestEndOnGroupBy(t *testing.T) {
+// query := []byte(`{
+// "return": {
+// "entities": [
+// 11,
+// 12
+// ],
+// "relations": [
+// 10
+// ],
+// "groupBys": [
+// 1
+// ]
+// },
+// "entities": [
+// {
+// "name": "Person",
+// "ID": 11,
+// "constraints": []
+// },
+// {
+// "name": "Movie",
+// "ID": 12,
+// "constraints": []
+// }
+// ],
+// "relations": [
+// {
+// "ID": 10,
+// "name": "DIRECTED",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 11,
+// "toType": "entity",
+// "toID": 12,
+// "constraints": []
+// }
+// ],
+// "groupBys": [
+// {
+// "id": 0,
+// "groupType": "entity",
+// "groupID": [11],
+// "groupAttribute": "imdbRating",
+// "byType": "entity",
+// "byID": [12],
+// "byAttribute": "bornIn",
+// "appliedModifier": "AVG",
+// "relationID": 10,
+// "constraints": []
+// }
+// ],
+// "machineLearning": [],
+// "limit": 5000,
+// "databaseName": "Movies3"
+// }
+// `)
+
+// answer := `MATCH p0 = (e11:Person)-[:DIRECTED*1..1]-(e12:Movie)
+// UNWIND relationships(p0) as r10
+// WITH *
+// WITH e12.bornIn AS e12_bornIn, AVG(e11.imdbRating) AS AVG_imdbRating
+// RETURN e12_bornIn, AVG_imdbRating
+// LIMIT 5000;table`
+
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// s := NewService()
+// cypher, _, err := s.ConvertQuery(&JSONQuery)
+// if err != nil {
+// fmt.Println(err)
+// }
+
+// trimmedCypher := fixCypherSpaces(cypher)
+// trimmedAnswer := fixCypherSpaces(&answer)
+// assert.Equal(t, trimmedAnswer, trimmedCypher)
+// }
+// func TestSimpleQuery(t *testing.T) {
+// query := []byte(`{
+// "return": {
+// "entities": [
+// 11,
+// 12
+// ],
+// "relations": [
+// 10
+// ],
+// "groupBys": []
+// },
+// "entities": [
+// {
+// "name": "Person",
+// "ID": 11,
+// "constraints": []
+// },
+// {
+// "name": "Movie",
+// "ID": 12,
+// "constraints": []
+// }
+// ],
+// "relations": [
+// {
+// "ID": 10,
+// "name": "DIRECTED",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 11,
+// "toType": "entity",
+// "toID": 12,
+// "constraints": []
+// }
+// ],
+// "groupBys": [],
+// "machineLearning": [],
+// "limit": 5000,
+// "databaseName": "Movies3"
+// }
+// `)
+
+// answer := `MATCH p0 = (e11:Person)-[:DIRECTED*1..1]-(e12:Movie)
+// UNWIND relationships(p0) as r10
+// WITH *
+// UNWIND [r10,e11,e12] AS x
+// RETURN DISTINCT x
+// LIMIT 5000;nodelink`
+
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// s := NewService()
+// cypher, _, err := s.ConvertQuery(&JSONQuery)
+// if err != nil {
+// fmt.Println(err)
+// }
+
+// trimmedCypher := fixCypherSpaces(cypher)
+// trimmedAnswer := fixCypherSpaces(&answer)
+// assert.Equal(t, trimmedAnswer, trimmedCypher)
+// }
+// func TestNoRelation(t *testing.T) {
+// query := []byte(`{
+// "return": {
+// "entities": [
+// 11,
+// 12
+// ],
+// "relations": [
+// 10
+// ],
+// "groupBys": []
+// },
+// "entities": [
+// {
+// "name": "Person",
+// "ID": 11,
+// "constraints": []
+// },
+// {
+// "name": "Movie",
+// "ID": 12,
+// "constraints": []
+// }
+// ],
+// "relations": [],
+// "groupBys": [],
+// "machineLearning": [],
+// "limit": 5000,
+// "databaseName": "Movies3"
+// }
+// `)
+
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+// fmt.Println(JSONQuery)
+// fmt.Println(" ")
+
+// s := NewService()
+// _, _, err := s.ConvertQuery(&JSONQuery)
+// if err != nil {
+// assert.Equal(t, err.Error(), "Invalid query")
+// } else {
+// // It should error, thus it must not reach this
+// t.Fail()
+// }
+// }
+
+// func TestNoEntities(t *testing.T) {
+// query := []byte(`{
+// "return": {
+// "entities": [
+// 11,
+// 12
+// ],
+// "relations": [
+// 10
+// ],
+// "groupBys": []
+// },
+// "entities": [],
+// "relations": [
+// {
+// "ID": 10,
+// "name": "DIRECTED",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 11,
+// "toType": "entity",
+// "toID": 12,
+// "constraints": []
+// }
+// ],
+// "groupBys": [],
+// "machineLearning": [],
+// "limit": 5000,
+// "databaseName": "Movies3"
+// }
+// `)
+
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+// fmt.Println(JSONQuery)
+// fmt.Println(" ")
+
+// s := NewService()
+// _, _, err := s.ConvertQuery(&JSONQuery)
+// if err != nil {
+// assert.Equal(t, err.Error(), "Invalid query")
+// } else {
+// // It should error, thus it must not reach this
+// t.Fail()
+// }
+// }
+// func TestTwoRelationsCycle(t *testing.T) {
+// query := []byte(`{
+// "return": {
+// "entities": [
+// 11,
+// 12
+// ],
+// "relations": [
+// 10
+// ],
+// "groupBys": []
+// },
+// "entities": [
+// {
+// "name": "Person",
+// "ID": 11,
+// "constraints": []
+// },
+// {
+// "name": "Movie",
+// "ID": 12,
+// "constraints": []
+// }
+// ],
+// "relations": [
+// {
+// "ID": 10,
+// "name": "DIRECTED",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 11,
+// "toType": "entity",
+// "toID": 12,
+// "constraints": []
+// },
+// {
+// "ID": 11,
+// "name": "ACTED_IN",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 12,
+// "toType": "entity",
+// "toID": 11,
+// "constraints": []
+// }
+// ],
+// "groupBys": [],
+// "machineLearning": [],
+// "limit": 5000,
+// "databaseName": "Movies3"
+// }
+// `)
+
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+// fmt.Println(JSONQuery)
+// fmt.Println(" ")
+
+// s := NewService()
+// cypher, _, err := s.ConvertQuery(&JSONQuery)
+// if err != nil {
+// fmt.Println(err)
+// t.Fail()
+// return
+// }
+
+// if cypher == nil {
+// t.Fail()
+// return
+// }
+
+// answer1 := `MATCH p0 = (e11:Person)-[:DIRECTED*1..1]-(e12:Movie)
+// UNWIND relationships(p0) as r10
+// WITH *
+// MATCH p1 = (e12:Movie)-[:ACTED_IN*1..1]-(e11:Person)
+// UNWIND relationships(p1) as r11
+// WITH *
+// UNWIND [r11,e12,e11,r10,e11,e12] AS x
+// RETURN DISTINCT x
+// LIMIT 5000;nodelink`
+
+// answer2 := `MATCH p1 = (e12:Movie)-[:ACTED_IN*1..1]-(e11:Person)
+// UNWIND relationships(p1) as r11
+// WITH *
+// MATCH p0 = (e11:Person)-[:DIRECTED*1..1]-(e12:Movie)
+// UNWIND relationships(p0) as r10
+// WITH *
+// UNWIND [r10,e11,e12,r11,e12,e11] AS x
+// RETURN DISTINCT x
+// LIMIT 5000;nodelink`
+
+// trimmedCypher := fixCypherSpaces(cypher)
+// trimmedAnswer1 := fixCypherSpaces(&answer1)
+// trimmedAnswer2 := fixCypherSpaces(&answer2)
+
+// fmt.Println(*cypher)
+// // Both answers are correct
+// if !(trimmedAnswer1 == trimmedCypher || trimmedAnswer2 == trimmedCypher) {
+// t.Fail()
+// }
+// }
+
+// func TestCyclePlusDependency(t *testing.T) {
+// query := []byte(`{
+// "return": {
+// "entities": [
+// 11,
+// 12
+// ],
+// "relations": [
+// 10
+// ],
+// "groupBys": []
+// },
+// "entities": [
+// {
+// "name": "Person",
+// "ID": 11,
+// "constraints": []
+// },
+// {
+// "name": "Movie",
+// "ID": 12,
+// "constraints": []
+// },
+// {
+// "name": "Person",
+// "ID": 13,
+// "constraints": []
+// }
+// ],
+// "relations": [
+// {
+// "ID": 10,
+// "name": "DIRECTED",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 11,
+// "toType": "entity",
+// "toID": 12,
+// "constraints": []
+// },
+// {
+// "ID": 11,
+// "name": "ACTED_IN",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 12,
+// "toType": "entity",
+// "toID": 11,
+// "constraints": []
+// },
+// {
+// "ID": 12,
+// "name": "ACTED_IN",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 13,
+// "toType": "entity",
+// "toID": 12,
+// "constraints": []
+// }
+// ],
+// "groupBys": [],
+// "machineLearning": [],
+// "limit": 5000,
+// "databaseName": "Movies3"
+// }
+// `)
+
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+// fmt.Println(JSONQuery)
+// fmt.Println(" ")
+
+// s := NewService()
+// cypher, _, err := s.ConvertQuery(&JSONQuery)
+// if err != nil {
+// fmt.Println(err)
+// t.Fail()
+// return
+// }
+
+// if cypher == nil {
+// t.Fail()
+// return
+// }
+
+// answer := `MATCH p2 = (e13:Person)-[:ACTED_IN*1..1]-(e12:Movie)
+// UNWIND relationships(p2) as r12
+// WITH *
+// MATCH p1 = (e12:Movie)-[:ACTED_IN*1..1]-(e11:Person)
+// UNWIND relationships(p1) as r11
+// WITH *
+// MATCH p0 = (e11:Person)-[:DIRECTED*1..1]-(e12:Movie)
+// UNWIND relationships(p0) as r10
+// WITH *
+// UNWIND [r10,e11,e12,r11,e12,e11,r12,e13,e12] AS x
+// RETURN DISTINCT x
+// LIMIT 5000;nodelink`
+
+// trimmedCypher := fixCypherSpaces(cypher)
+// trimmedAnswer := fixCypherSpaces(&answer)
+
+// fmt.Println(*cypher)
+// assert.Equal(t, trimmedAnswer, trimmedCypher)
+// }
+// func TestTripleCycle(t *testing.T) {
+// query := []byte(`{
+// "return": {
+// "entities": [
+// 11,
+// 12
+// ],
+// "relations": [
+// 10
+// ],
+// "groupBys": []
+// },
+// "entities": [
+// {
+// "name": "Person",
+// "ID": 11,
+// "constraints": []
+// },
+// {
+// "name": "Movie",
+// "ID": 12,
+// "constraints": []
+// },
+// {
+// "name": "Person",
+// "ID": 13,
+// "constraints": []
+// }
+// ],
+// "relations": [
+// {
+// "ID": 10,
+// "name": "DIRECTED",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 11,
+// "toType": "entity",
+// "toID": 12,
+// "constraints": []
+// },
+// {
+// "ID": 11,
+// "name": "ACTED_IN",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 12,
+// "toType": "entity",
+// "toID": 13,
+// "constraints": []
+// },
+// {
+// "ID": 12,
+// "name": "ACTED_IN",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 13,
+// "toType": "entity",
+// "toID": 11,
+// "constraints": []
+// }
+// ],
+// "groupBys": [],
+// "machineLearning": [],
+// "limit": 5000,
+// "databaseName": "Movies3"
+// }
+// `)
+
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// s := NewService()
+// cypher, _, err := s.ConvertQuery(&JSONQuery)
+// if err != nil {
+// fmt.Println(err)
+// assert.Equal(t, err, errors.New("Cyclic query detected"))
+// return
+// }
+
+// if cypher == nil {
+// t.Fail()
+// return
+// }
+// t.Fail()
+// }
+
+// func TestMultipleByStatementConnected(t *testing.T) {
+// query := []byte(`{
+// "databaseName": "Movies3",
+// "entities": [
+// {
+// "id": 0,
+// "name": "Person",
+// "constraints": []
+// },
+// {
+// "id": 1,
+// "name": "Movie",
+// "constraints": []
+// },
+// {
+// "id": 2,
+// "name": "Person",
+// "constraints": []
+// }
+// ],
+// "relations": [
+// {
+// "id": 0,
+// "name": "ACTED_IN",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 0,
+// "toType": "entity",
+// "toID": 1,
+// "constraints": []
+// },
+// {
+// "id": 2,
+// "name": "ACTED_IN",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 2,
+// "toType": "entity",
+// "toID": 1,
+// "constraints": []
+// }
+// ],
+// "groupBys": [
+// {
+// "id": 0,
+// "groupType": "entity",
+// "groupID": [1],
+// "groupAttribute": "imdbRating",
+// "byType": "entity",
+// "byID": [0,2],
+// "byAttribute": "bornIn",
+// "appliedModifier": "AVG",
+// "relationID": 0,
+// "constraints": [
+// {
+// "attribute": "imdbRating",
+// "value": "7.5",
+// "dataType": "int",
+// "matchType": "GT",
+// "inID": -1,
+// "inType": ""
+// }
+// ]
+// }
+// ],
+// "machineLearning": [],
+// "limit": 5000
+// }
+// `)
+
+// answer := `MATCH p0 = (e0:Person)-[:ACTED_IN*1..1]-(e1:Movie)
+// UNWIND relationships(p0) as r0
+// WITH *
+// MATCH p1 = (e2:Person)-[:ACTED_IN*1..1]-(e1:Movie)
+// UNWIND relationships(p1) as r2
+// WITH *
+// UNWIND [e0,e2] AS e02L
+// WITH e02L.bornIn AS e02L_bornIn, AVG(e1.imdbRating) AS AVG_imdbRating
+// WHERE AVG_imdbRating > 7.5
+// RETURN e02L_bornIn, AVG_imdbRating
+// LIMIT 5000;table`
+
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// s := NewService()
+// cypher, _, err := s.ConvertQuery(&JSONQuery)
+// if err != nil {
+// fmt.Println(err)
+// }
+// println(cypher)
+
+// trimmedCypher := fixCypherSpaces(cypher)
+// trimmedAnswer := fixCypherSpaces(&answer)
+
+// fmt.Println(*cypher)
+// assert.Equal(t, trimmedAnswer, trimmedCypher)
+
+// }
+
+// func TestRelationOnGroupBy(t *testing.T) {
+// query := []byte(`{
+// "databaseName": "Movies3",
+// "entities": [
+// {
+// "id": 0,
+// "name": "Person",
+// "constraints": []
+// },
+// {
+// "id": 1,
+// "name": "Movie",
+// "constraints": []
+// },
+// {
+// "id": 2,
+// "name": "Person",
+// "constraints": []
+// },
+// {
+// "id": 3,
+// "name": "Movie",
+// "constraints": []
+// }
+// ],
+// "relations": [
+// {
+// "id": 0,
+// "name": "ACTED_IN",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 0,
+// "toType": "entity",
+// "toID": 1,
+// "constraints": []
+// },
+// {
+// "id": 1,
+// "name": "ACTED_IN",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "entity",
+// "fromID": 2,
+// "toType": "entity",
+// "toID": 1,
+// "constraints": []
+// },
+// {
+// "id": 2,
+// "name": "ACTED_IN",
+// "depth": {
+// "min": 1,
+// "max": 1
+// },
+// "fromType": "groupBy",
+// "fromID": 0,
+// "toType": "entity",
+// "toID": 3,
+// "constraints": []
+// }
+// ],
+// "groupBys": [
+// {
+// "id": 0,
+// "groupType": "entity",
+// "groupID": [1],
+// "groupAttribute": "imdbRating",
+// "byType": "entity",
+// "byID": [0,2],
+// "byAttribute": "bornIn",
+// "appliedModifier": "AVG",
+// "relationID": 0,
+// "constraints": [
+// {
+// "attribute": "imdbRating",
+// "value": "7.5",
+// "dataType": "int",
+// "matchType": "GT",
+// "inID": -1,
+// "inType": ""
+// }
+// ]
+// }
+// ],
+// "machineLearning": [],
+// "limit": 5000
+// }
+// `)
+
+// answer1 := `MATCH p0 = (e0:Person)-[:ACTED_IN*1..1]-(e1:Movie)
+// UNWIND relationships(p0) as r0
+// WITH *
+// MATCH p1 = (e2:Person)-[:ACTED_IN*1..1]-(e1:Movie)
+// UNWIND relationships(p1) as r1
+// WITH *
+// UNWIND [e0,e2] AS e02L
+// WITH e02L.bornIn AS e02L_bornIn, AVG(e1.imdbRating) AS AVG_imdbRating
+// WHERE AVG_imdbRating > 7.5
+// MATCH p2 = (eg02L:Person)-[:ACTED_IN*1..1]-(e3:Movie)
+// WHERE eg02L.bornIn IN e02L_bornIn
+// UNWIND relationships(p2) as r2
+// WITH *
+// UNWIND [r2,eg02L,e3] AS x
+// RETURN DISTINCT x
+// LIMIT 5000;nodelink`
+
+// answer2 := `MATCH p1 = (e2:Person)-[:ACTED_IN*1..1]-(e1:Movie)
+// UNWIND relationships(p1) as r1
+// WITH *
+// MATCH p0 = (e0:Person)-[:ACTED_IN*1..1]-(e1:Movie)
+// UNWIND relationships(p0) as r0
+// WITH *
+// UNWIND [e0,e2] AS e02L
+// WITH e02L.bornIn AS e02L_bornIn, AVG(e1.imdbRating) AS AVG_imdbRating
+// WHERE AVG_imdbRating > 7.5
+// MATCH p2 = (eg02L:Person)-[:ACTED_IN*1..1]-(e3:Movie)
+// WHERE eg02L.bornIn IN e02L_bornIn
+// UNWIND relationships(p2) as r2
+// WITH *
+// UNWIND [r2,eg02L,e3] AS x
+// RETURN DISTINCT x
+// LIMIT 5000;nodelink`
+
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(query, &JSONQuery)
+
+// s := NewService()
+// cypher, _, err := s.ConvertQuery(&JSONQuery)
+// if err != nil {
+// fmt.Println(err)
+// }
+
+// trimmedCypher := fixCypherSpaces(cypher)
+// trimmedAnswer1 := fixCypherSpaces(&answer1)
+// trimmedAnswer2 := fixCypherSpaces(&answer2)
+
+// if !(trimmedCypher == trimmedAnswer1 || trimmedCypher == trimmedAnswer2) {
+// t.Fail()
+// }
+// }
diff --git a/cypher/queryConverter.go b/cypher/queryConverter.go
index b9fb0be4579ca99f5b46df0def58de0601c57d9d..3f85be862903cd55a915f9eaa1a4d6bf98e687d8 100644
--- a/cypher/queryConverter.go
+++ b/cypher/queryConverter.go
@@ -5,11 +5,6 @@ This program has been developed by students from the bachelor Computer Science a
package cypher
-import (
- "git.science.uu.nl/graphpolaris/query-conversion"
- "git.science.uu.nl/graphpolaris/query-conversion/entity"
-)
-
/*
Service implements the QueryConverter interface (in the query service)
*/
@@ -20,6 +15,6 @@ type Service struct {
NewService creates a new Cypher conversion service
Return: *Service, the new service
*/
-func NewService() query.Converter[entity.IncomingQueryJSON] {
- return &Service{}
-}
+// func NewService() query.Converter {
+// return &Service{}
+// }
diff --git a/cypherv2/queryConverter.go b/cypherv2/queryConverter.go
index 69d9a0fcbf1049d6da106add81c9d8e88b262621..708177a6ca72e86eff801dea74cf608db664eee7 100644
--- a/cypherv2/queryConverter.go
+++ b/cypherv2/queryConverter.go
@@ -5,10 +5,7 @@ This program has been developed by students from the bachelor Computer Science a
package cypherv2
-import (
- "git.science.uu.nl/graphpolaris/query-conversion"
- "git.science.uu.nl/graphpolaris/query-conversion/entityv2"
-)
+import "git.science.uu.nl/graphpolaris/query-conversion"
/*
Service implements the QueryConverter interface (in the query service)
@@ -20,6 +17,6 @@ type Service struct {
NewService creates a new Cypher conversion service
Return: *Service, the new service
*/
-func NewService() query.Converter[entityv2.IncomingQueryJSON] {
+func NewService() query.Converter {
return &Service{}
}
diff --git a/interface.go b/interface.go
index 3f0f94409e28acd8185db469a3b914ef5cea0dca..d7e93957df2781151d8d3a1e250680ffe09e4504 100644
--- a/interface.go
+++ b/interface.go
@@ -5,7 +5,9 @@
package query
+import "git.science.uu.nl/graphpolaris/query-conversion/entityv2"
+
// A Converter converts an incoming message in our JSON format to a format like AQL or Cypher
-type Converter[T any] interface {
- ConvertQuery(JSONQuery *T) (*string, *[]byte, error)
+type Converter interface {
+ ConvertQuery(JSONQuery *entityv2.IncomingQueryJSON) (*string, *[]byte, error)
}
diff --git a/sparql/convertQuery_test.go b/sparql/convertQuery_test.go
index 47a8372c618d4c2a1cf52b464a5ec339d4dcd23b..9626440f06362d9ad7d0f2f387754c64f14bef56 100644
--- a/sparql/convertQuery_test.go
+++ b/sparql/convertQuery_test.go
@@ -5,252 +5,252 @@ This program has been developed by students from the bachelor Computer Science a
package sparql
-import (
- "encoding/json"
- "errors"
- "regexp"
- "strings"
- "testing"
-
- "git.science.uu.nl/graphpolaris/query-conversion/entity"
- "github.com/stretchr/testify/assert"
-)
-
-/*
-Tests an empty query
- t: *testing.T, makes go recognise this as a test
-*/
-func TestEmptyQueryConversion(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(emptyQuery, &JSONQuery)
-
- convertedResult, convertedtripleMap, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- regExCleaner := regexp.MustCompile(`\s+`)
- convertedCleanedResult := strings.TrimSpace(regExCleaner.ReplaceAllString(*convertedResult, " "))
- correctCleanedResult := strings.TrimSpace(regExCleaner.ReplaceAllString(EmptyQueryResult, " "))
- assert.Equal(t, convertedCleanedResult, correctCleanedResult)
-
- var convertedMetaData entity.MetaData
- var correctMetaData entity.MetaData
- json.Unmarshal(*convertedtripleMap, &convertedMetaData)
- json.Unmarshal([]byte(EmptyQueryTripleMap), &correctMetaData)
-
- metaDataEqual(t, convertedMetaData, correctMetaData)
-}
-
-/*
-Tests a single group by
- t: *testing.T, makes go recognise this as a test
-*/
-func TestSingleGroupByConversion(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(SingleGroupBy, &JSONQuery)
-
- convertedResult, convertedtripleMap, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- regExCleaner := regexp.MustCompile(`\s+`)
- convertedCleanedResult := strings.TrimSpace(regExCleaner.ReplaceAllString(*convertedResult, " "))
- correctCleanedResult := strings.TrimSpace(regExCleaner.ReplaceAllString(SingleGroupByResult, " "))
- assert.Equal(t, convertedCleanedResult, correctCleanedResult)
-
- var convertedMetaData entity.MetaData
- var correctMetaData entity.MetaData
- json.Unmarshal(*convertedtripleMap, &convertedMetaData)
- json.Unmarshal([]byte(SingleGroupByTripleMap), &correctMetaData)
-
- metaDataEqual(t, convertedMetaData, correctMetaData)
-}
-
-/*
-Tests multiple nested group bys with different filter types
- t: *testing.T, makes go recognise this as a test
-*/
-func TestNestingAndFilterTypesConversion(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(NestingAndFilterTypes, &JSONQuery)
-
- convertedResult, convertedtripleMap, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is no error
- assert.NoError(t, err)
-
- regExCleaner := regexp.MustCompile(`\s+`)
- convertedCleanedResult := strings.TrimSpace(regExCleaner.ReplaceAllString(*convertedResult, " "))
- correctCleanedResult := strings.TrimSpace(regExCleaner.ReplaceAllString(NestingAndFilterTypesResult, " "))
- assert.Equal(t, convertedCleanedResult, correctCleanedResult)
-
- var convertedMetaData entity.MetaData
- var correctMetaData entity.MetaData
- json.Unmarshal(*convertedtripleMap, &convertedMetaData)
- json.Unmarshal([]byte(NestingAndFilterTypesTripleMap), &correctMetaData)
-
- metaDataEqual(t, convertedMetaData, correctMetaData)
-}
-
-/*
-Tests a query with no relation field
- t: *testing.T, makes go recognise this as a test
-*/
-func TestNoRelationsField(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(NoRelationsField, &JSONQuery)
-
- _, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is an error
- assert.Equal(t, errors.New("JSONQuery invalid"), err)
-}
-
-/*
-Tests an entity with a lower than -1 in a relation
- t: *testing.T, makes go recognise this as a test
-*/
-func TestIncorrectRelationFrom(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(IncorrectRelationFrom, &JSONQuery)
-
- _, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is an error
- assert.Equal(t, errors.New("JSONQuery invalid"), err)
-}
-
-/*
-Tests two separated chains consisting of 1 relation each
- t: *testing.T, makes go recognise this as a test
-*/
-func TestSeparatedChainSingleRelationPerChain(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(SeparatedChainSingleRelationPerChain, &JSONQuery)
-
- _, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is an error
- assert.Equal(t, errors.New("JSONQuery invalid"), err)
-}
-
-/*
-Tests two separated chains consisting of 1 relation each
- t: *testing.T, makes go recognise this as a test
-*/
-func TestSeparatedChainDoubleRelationPerChain(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(SeparatedChainDoubleRelationPerChain, &JSONQuery)
-
- _, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is an error
- assert.Equal(t, errors.New("JSONQuery invalid"), err)
-}
-
-/*
-Tests two separated chains
- t: *testing.T, makes go recognise this as a test
-*/
-func TestSeperatedChainWithGroupBys(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(SeperatedChainWithGroupBys, &JSONQuery)
-
- _, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is an error
- assert.Equal(t, errors.New("JSONQuery invalid"), err)
-}
-
-/*
-Tests a group by which has different nodes on its group and by
- t: *testing.T, makes go recognise this as a test
-*/
-func TestDifferentNodesOnGroupBy(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(DifferentNodesOnGroupBy, &JSONQuery)
-
- _, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is an error
- assert.Equal(t, errors.New("JSONQuery invalid"), err)
-}
-
-/*
-Tests a group by which has a modifier which aql doesn't recognise
- t: *testing.T, makes go recognise this as a test
-*/
-func TestIncorrectGroupByModifier(t *testing.T) {
- // Setup for test
- // Create query conversion service
- service := NewService()
-
- // Unmarshall the incoming message into an IncomingJSONQuery object
- var JSONQuery entity.IncomingQueryJSON
- json.Unmarshal(IncorrectGroupByModifier, &JSONQuery)
-
- _, _, err := service.ConvertQuery(&JSONQuery)
-
- // Assert that there is an error
- assert.Equal(t, errors.New("JSONQuery invalid"), err)
-}
-
-func metaDataEqual(t *testing.T, convertedMetaData entity.MetaData, correctMetaData entity.MetaData) {
- for key, val1 := range convertedMetaData.Triples {
- val2, ok := correctMetaData.Triples[key]
- assert.True(t, ok)
- assert.Equal(t, val1, val2)
- }
- for key, val1 := range correctMetaData.Triples {
- val2, ok := convertedMetaData.Triples[key]
- assert.True(t, ok)
- assert.Equal(t, val1, val2)
- }
-}
+// import (
+// "encoding/json"
+// "errors"
+// "regexp"
+// "strings"
+// "testing"
+
+// "git.science.uu.nl/graphpolaris/query-conversion/entity"
+// "github.com/stretchr/testify/assert"
+// )
+
+// /*
+// Tests an empty query
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestEmptyQueryConversion(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(emptyQuery, &JSONQuery)
+
+// convertedResult, convertedtripleMap, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// regExCleaner := regexp.MustCompile(`\s+`)
+// convertedCleanedResult := strings.TrimSpace(regExCleaner.ReplaceAllString(*convertedResult, " "))
+// correctCleanedResult := strings.TrimSpace(regExCleaner.ReplaceAllString(EmptyQueryResult, " "))
+// assert.Equal(t, convertedCleanedResult, correctCleanedResult)
+
+// var convertedMetaData entity.MetaData
+// var correctMetaData entity.MetaData
+// json.Unmarshal(*convertedtripleMap, &convertedMetaData)
+// json.Unmarshal([]byte(EmptyQueryTripleMap), &correctMetaData)
+
+// metaDataEqual(t, convertedMetaData, correctMetaData)
+// }
+
+// /*
+// Tests a single group by
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestSingleGroupByConversion(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(SingleGroupBy, &JSONQuery)
+
+// convertedResult, convertedtripleMap, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// regExCleaner := regexp.MustCompile(`\s+`)
+// convertedCleanedResult := strings.TrimSpace(regExCleaner.ReplaceAllString(*convertedResult, " "))
+// correctCleanedResult := strings.TrimSpace(regExCleaner.ReplaceAllString(SingleGroupByResult, " "))
+// assert.Equal(t, convertedCleanedResult, correctCleanedResult)
+
+// var convertedMetaData entity.MetaData
+// var correctMetaData entity.MetaData
+// json.Unmarshal(*convertedtripleMap, &convertedMetaData)
+// json.Unmarshal([]byte(SingleGroupByTripleMap), &correctMetaData)
+
+// metaDataEqual(t, convertedMetaData, correctMetaData)
+// }
+
+// /*
+// Tests multiple nested group bys with different filter types
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestNestingAndFilterTypesConversion(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(NestingAndFilterTypes, &JSONQuery)
+
+// convertedResult, convertedtripleMap, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is no error
+// assert.NoError(t, err)
+
+// regExCleaner := regexp.MustCompile(`\s+`)
+// convertedCleanedResult := strings.TrimSpace(regExCleaner.ReplaceAllString(*convertedResult, " "))
+// correctCleanedResult := strings.TrimSpace(regExCleaner.ReplaceAllString(NestingAndFilterTypesResult, " "))
+// assert.Equal(t, convertedCleanedResult, correctCleanedResult)
+
+// var convertedMetaData entity.MetaData
+// var correctMetaData entity.MetaData
+// json.Unmarshal(*convertedtripleMap, &convertedMetaData)
+// json.Unmarshal([]byte(NestingAndFilterTypesTripleMap), &correctMetaData)
+
+// metaDataEqual(t, convertedMetaData, correctMetaData)
+// }
+
+// /*
+// Tests a query with no relation field
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestNoRelationsField(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(NoRelationsField, &JSONQuery)
+
+// _, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is an error
+// assert.Equal(t, errors.New("JSONQuery invalid"), err)
+// }
+
+// /*
+// Tests an entity with a lower than -1 in a relation
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestIncorrectRelationFrom(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(IncorrectRelationFrom, &JSONQuery)
+
+// _, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is an error
+// assert.Equal(t, errors.New("JSONQuery invalid"), err)
+// }
+
+// /*
+// Tests two separated chains consisting of 1 relation each
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestSeparatedChainSingleRelationPerChain(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(SeparatedChainSingleRelationPerChain, &JSONQuery)
+
+// _, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is an error
+// assert.Equal(t, errors.New("JSONQuery invalid"), err)
+// }
+
+// /*
+// Tests two separated chains consisting of 1 relation each
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestSeparatedChainDoubleRelationPerChain(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(SeparatedChainDoubleRelationPerChain, &JSONQuery)
+
+// _, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is an error
+// assert.Equal(t, errors.New("JSONQuery invalid"), err)
+// }
+
+// /*
+// Tests two separated chains
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestSeperatedChainWithGroupBys(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(SeperatedChainWithGroupBys, &JSONQuery)
+
+// _, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is an error
+// assert.Equal(t, errors.New("JSONQuery invalid"), err)
+// }
+
+// /*
+// Tests a group by which has different nodes on its group and by
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestDifferentNodesOnGroupBy(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(DifferentNodesOnGroupBy, &JSONQuery)
+
+// _, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is an error
+// assert.Equal(t, errors.New("JSONQuery invalid"), err)
+// }
+
+// /*
+// Tests a group by which has a modifier which aql doesn't recognise
+// t: *testing.T, makes go recognise this as a test
+// */
+// func TestIncorrectGroupByModifier(t *testing.T) {
+// // Setup for test
+// // Create query conversion service
+// service := NewService()
+
+// // Unmarshall the incoming message into an IncomingJSONQuery object
+// var JSONQuery entity.IncomingQueryJSON
+// json.Unmarshal(IncorrectGroupByModifier, &JSONQuery)
+
+// _, _, err := service.ConvertQuery(&JSONQuery)
+
+// // Assert that there is an error
+// assert.Equal(t, errors.New("JSONQuery invalid"), err)
+// }
+
+// func metaDataEqual(t *testing.T, convertedMetaData entity.MetaData, correctMetaData entity.MetaData) {
+// for key, val1 := range convertedMetaData.Triples {
+// val2, ok := correctMetaData.Triples[key]
+// assert.True(t, ok)
+// assert.Equal(t, val1, val2)
+// }
+// for key, val1 := range correctMetaData.Triples {
+// val2, ok := convertedMetaData.Triples[key]
+// assert.True(t, ok)
+// assert.Equal(t, val1, val2)
+// }
+// }
diff --git a/sparql/queryConverter.go b/sparql/queryConverter.go
index 6af3da746cc9c5a7fb030d886eb32c84c39e2979..bad99054b75f23577667c2ae1cd9043d7a967674 100644
--- a/sparql/queryConverter.go
+++ b/sparql/queryConverter.go
@@ -4,16 +4,11 @@ This program has been developed by students from the bachelor Computer Science a
*/
package sparql
-import (
- "git.science.uu.nl/graphpolaris/query-conversion"
- "git.science.uu.nl/graphpolaris/query-conversion/entity"
-)
-
// Service implements the QueryConverter interface (in the query service)
type Service struct {
}
// NewService creates a new AQL conversion service
-func NewService() query.Converter[entity.IncomingQueryJSON] {
- return &Service{}
-}
+// func NewService() query.Converter {
+// return &Service{}
+// }
diff --git a/unmarshalJSON.go b/unmarshalJSON.go
index c419510b66873bf617d71ece324ebe854e42a287..d8802fa44b7ad1eb9f5985fa8d3734713ea3a27f 100644
--- a/unmarshalJSON.go
+++ b/unmarshalJSON.go
@@ -1,7 +1,7 @@
-/*
- 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)
-*/
+/*
+ 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 query