pk/cosmium
1
0
Fork 0
mirror of https://github.com/pikami/cosmium.git synced 2025-12-19 17:00:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added support for 'SELECT VALUE' statement

Browse Source
This commit is contained in:
Pijus Kamandulis
2024-02-13 21:22:55 +02:00
parent 9c56d01d27
commit e89f2e5611
7 changed files with 431 additions and 310 deletions
Download Patch File Download Diff File Expand all files Collapse all files

564
parsers/nosql/nosql.go
View File

File diff suppressed because it is too large Load Diff

36
parsers/nosql/nosql.peg
View File

@@ -5,7 +5,7 @@ import "github.com/pikami/cosmium/parsers"
func makeSelectStmt(columns, table, whereClause interface{}) (parsers.SelectStmt, error) {
selectStmt := parsers.SelectStmt{
Columns: columns.([]parsers.FieldPath),
SelectItems: columns.([]parsers.SelectItem),
Table: table.(parsers.Table),
}
@@ -18,7 +18,7 @@ func makeSelectStmt(columns, table, whereClause interface{}) (parsers.SelectStmt
return selectStmt, nil
}
func makeFieldPath(name interface{}, path interface{}, alias interface{}) (parsers.FieldPath, error) {
func makeSelectItem(name interface{}, path interface{}, alias interface{}, selectItemType parsers.SelectItemType) (parsers.SelectItem, error) {
ps := path.([]interface{})
paths := make([]string, 1)
@@ -27,21 +27,21 @@ func makeFieldPath(name interface{}, path interface{}, alias interface{}) (parse
paths = append(paths, p.(string))
}
fieldPath := parsers.FieldPath{Path: paths}
selectItem := parsers.SelectItem{Path: paths, Type: selectItemType}
if aliasValue, ok := alias.(string); ok {
fieldPath.Alias = aliasValue
selectItem.Alias = aliasValue
}
return fieldPath, nil
return selectItem, nil
}
func makeColumnList(column interface{}, other_columns interface{}) ([]parsers.FieldPath, error) {
func makeColumnList(column interface{}, other_columns interface{}) ([]parsers.SelectItem, error) {
collsAsArray := other_columns.([]interface{})
columnList := make([]parsers.FieldPath, len(collsAsArray) + 1)
columnList[0] = column.(parsers.FieldPath)
columnList := make([]parsers.SelectItem, len(collsAsArray) + 1)
columnList[0] = column.(parsers.SelectItem)
for i, v := range collsAsArray {
if col, ok := v.(parsers.FieldPath); ok {
if col, ok := v.(parsers.SelectItem); ok {
columnList[i+1] = col
}
}
@@ -79,23 +79,31 @@ Input <- selectStmt:SelectStmt {
return selectStmt, nil
}
SelectStmt <- Select ws columns:ColumnList ws
SelectStmt <- Select ws columns:Selection ws
From ws table:TableName ws
whereClause:(ws Where ws condition:Condition { return condition, nil })? {
return makeSelectStmt(columns, table, whereClause)
}
ColumnList <- column:FieldPath other_columns:(ws "," ws coll:FieldPath {return coll, nil })* {
Selection <- SelectValueSpec / ColumnList
ColumnList <- column:SelectItem other_columns:(ws "," ws coll:SelectItem {return coll, nil })* {
return makeColumnList(column, other_columns)
}
SelectValueSpec <- "VALUE" ws column:SelectItem {
selectItem := column.(parsers.SelectItem)
selectItem.IsTopLevel = true
return makeColumnList(selectItem, make([]interface{}, 0))
}
TableName <- key:Identifier {
return parsers.Table{Value: key.(string)}, nil
}
FieldPath <- name:Identifier path:(DotFieldAccess / ArrayFieldAccess)*
SelectItem <- name:Identifier path:(DotFieldAccess / ArrayFieldAccess)*
asClause:(ws "AS" ws alias:Identifier { return alias, nil })? {
return makeFieldPath(name, path, asClause)
return makeSelectItem(name, path, asClause, parsers.SelectItemTypeField)
}
DotFieldAccess <- "." id:Identifier {
@@ -122,7 +130,7 @@ AndExpression <- ex1:ComparisonExpression ex2:(ws "AND" ws ex:ComparisonExpressi
return combineExpressions(ex1, ex2, parsers.LogicalExpressionTypeAnd)
}
ComparisonExpression <- left:(Literal / FieldPath) ws op:ComparisonOperator ws right:(Literal / FieldPath) {
ComparisonExpression <- left:(Literal / SelectItem) ws op:ComparisonOperator ws right:(Literal / SelectItem) {
return parsers.ComparisonExpression{Left:left,Right:right,Operation:string(op.([]uint8))}, nil
}

43
parsers/nosql/nosql_test.go
View File

@@ -12,7 +12,7 @@ import (
// For Parser Debugging
// func Test_ParseTest(t *testing.T) {
// // select c.id, c._self, c._rid, c._ts, [c[\"pk\"]] as _partitionKeyValue from c
// res, err := nosql.Parse("", []byte("select c.id, c._self AS self, c._rid, c._ts FROM c where c.id=\"12345\" AND c.pk=123"))
// res, err := nosql.Parse("", []byte("SELECT VALUE c.id FROM c"))
// if err != nil {
// log.Fatal(err)
// }
@@ -38,12 +38,12 @@ func testQueryParse(t *testing.T, query string, expectedQuery parsers.SelectStmt
}
func Test_Parse(t *testing.T) {
t.Run("Shoul parse simple SELECT", func(t *testing.T) {
t.Run("Should parse simple SELECT", func(t *testing.T) {
testQueryParse(
t,
`SELECT c.id, c["pk"] FROM c`,
parsers.SelectStmt{
Columns: []parsers.FieldPath{
SelectItems: []parsers.SelectItem{
{Path: []string{"c", "id"}},
{Path: []string{"c", "pk"}},
},
@@ -52,6 +52,19 @@ func Test_Parse(t *testing.T) {
)
})
t.Run("Should parse SELECT VALUE", func(t *testing.T) {
testQueryParse(
t,
`SELECT VALUE c.id FROM c`,
parsers.SelectStmt{
SelectItems: []parsers.SelectItem{
{Path: []string{"c", "id"}, IsTopLevel: true},
},
Table: parsers.Table{Value: "c"},
},
)
})
t.Run("Should parse SELECT with single WHERE condition", func(t *testing.T) {
testQueryParse(
t,
@@ -59,13 +72,13 @@ func Test_Parse(t *testing.T) {
FROM c
WHERE c.isCool=true`,
parsers.SelectStmt{
Columns: []parsers.FieldPath{
SelectItems: []parsers.SelectItem{
{Path: []string{"c", "id"}},
},
Table: parsers.Table{Value: "c"},
Filters: parsers.ComparisonExpression{
Operation: "=",
Left: parsers.FieldPath{Path: []string{"c", "isCool"}},
Left: parsers.SelectItem{Path: []string{"c", "isCool"}},
Right: parsers.Constant{Type: parsers.ConstantTypeBoolean, Value: true},
},
},
@@ -79,7 +92,7 @@ func Test_Parse(t *testing.T) {
FROM c
WHERE c.id="12345" OR c.pk=123`,
parsers.SelectStmt{
Columns: []parsers.FieldPath{
SelectItems: []parsers.SelectItem{
{Path: []string{"c", "id"}},
{Path: []string{"c", "_self"}, Alias: "self"},
{Path: []string{"c", "_rid"}},
@@ -91,12 +104,12 @@ func Test_Parse(t *testing.T) {
Expressions: []interface{}{
parsers.ComparisonExpression{
Operation: "=",
Left: parsers.FieldPath{Path: []string{"c", "id"}},
Left: parsers.SelectItem{Path: []string{"c", "id"}},
Right: parsers.Constant{Type: parsers.ConstantTypeString, Value: "12345"},
},
parsers.ComparisonExpression{
Operation: "=",
Left: parsers.FieldPath{Path: []string{"c", "pk"}},
Left: parsers.SelectItem{Path: []string{"c", "pk"}},
Right: parsers.Constant{Type: parsers.ConstantTypeInteger, Value: 123},
},
},
@@ -105,7 +118,7 @@ func Test_Parse(t *testing.T) {
)
})
t.Run("Shoul correctly parse literals in conditions", func(t *testing.T) {
t.Run("Should correctly parse literals in conditions", func(t *testing.T) {
testQueryParse(
t,
`select c.id
@@ -115,27 +128,27 @@ func Test_Parse(t *testing.T) {
AND c.float=6.9
AND c.string="hello"`,
parsers.SelectStmt{
Columns: []parsers.FieldPath{{Path: []string{"c", "id"}, Alias: ""}},
Table: parsers.Table{Value: "c"},
SelectItems: []parsers.SelectItem{{Path: []string{"c", "id"}, Alias: ""}},
Table: parsers.Table{Value: "c"},
Filters: parsers.LogicalExpression{
Expressions: []interface{}{
parsers.ComparisonExpression{
Left: parsers.FieldPath{Path: []string{"c", "boolean"}},
Left: parsers.SelectItem{Path: []string{"c", "boolean"}},
Right: parsers.Constant{Type: 3, Value: true},
Operation: "=",
},
parsers.ComparisonExpression{
Left: parsers.FieldPath{Path: []string{"c", "integer"}},
Left: parsers.SelectItem{Path: []string{"c", "integer"}},
Right: parsers.Constant{Type: 1, Value: 1},
Operation: "=",
},
parsers.ComparisonExpression{
Left: parsers.FieldPath{Path: []string{"c", "float"}},
Left: parsers.SelectItem{Path: []string{"c", "float"}},
Right: parsers.Constant{Type: 2, Value: 6.9},
Operation: "=",
},
parsers.ComparisonExpression{
Left: parsers.FieldPath{Path: []string{"c", "string"}},
Left: parsers.SelectItem{Path: []string{"c", "string"}},
Right: parsers.Constant{Type: 0, Value: "hello"},
Operation: "=",
},