mirror of
https://github.com/pikami/cosmium.git
synced 2024-12-11 23:08:37 +00:00
497 lines
15 KiB
Plaintext
497 lines
15 KiB
Plaintext
{
|
|
package nosql
|
|
|
|
import "github.com/pikami/cosmium/parsers"
|
|
|
|
func makeSelectStmt(columns, table, whereClause interface{}, count interface{}, orderList interface{}) (parsers.SelectStmt, error) {
|
|
selectStmt := parsers.SelectStmt{
|
|
SelectItems: columns.([]parsers.SelectItem),
|
|
Table: table.(parsers.Table),
|
|
}
|
|
|
|
if filters, ok := whereClause.(parsers.ComparisonExpression); ok {
|
|
selectStmt.Filters = filters
|
|
} else if filters, ok := whereClause.(parsers.LogicalExpression); ok {
|
|
selectStmt.Filters = filters
|
|
} else if filters, ok := whereClause.(parsers.Constant); ok {
|
|
selectStmt.Filters = filters
|
|
} else if filters, ok := whereClause.(parsers.SelectItem); ok {
|
|
selectStmt.Filters = filters
|
|
}
|
|
|
|
if n, ok := count.(int); ok {
|
|
selectStmt.Count = n
|
|
}
|
|
|
|
if orderExpressions, ok := orderList.([]parsers.OrderExpression); ok {
|
|
selectStmt.OrderExpressions = orderExpressions
|
|
}
|
|
|
|
return selectStmt, nil
|
|
}
|
|
|
|
func makeSelectItem(name interface{}, path interface{}, selectItemType parsers.SelectItemType) (parsers.SelectItem, error) {
|
|
ps := path.([]interface{})
|
|
|
|
paths := make([]string, 1)
|
|
paths[0] = name.(string)
|
|
for _, p := range ps {
|
|
paths = append(paths, p.(string))
|
|
}
|
|
|
|
return parsers.SelectItem{Path: paths, Type: selectItemType}, nil
|
|
}
|
|
|
|
func makeColumnList(column interface{}, other_columns interface{}) ([]parsers.SelectItem, error) {
|
|
collsAsArray := other_columns.([]interface{})
|
|
columnList := make([]parsers.SelectItem, len(collsAsArray) + 1)
|
|
columnList[0] = column.(parsers.SelectItem)
|
|
|
|
for i, v := range collsAsArray {
|
|
if col, ok := v.(parsers.SelectItem); ok {
|
|
columnList[i+1] = col
|
|
}
|
|
}
|
|
|
|
return columnList, nil
|
|
}
|
|
|
|
func makeSelectArray(columns interface{}) (parsers.SelectItem, error) {
|
|
return parsers.SelectItem{
|
|
SelectItems: columns.([]parsers.SelectItem),
|
|
Type: parsers.SelectItemTypeArray,
|
|
}, nil
|
|
}
|
|
|
|
func makeSelectObject(field interface{}, other_fields interface{}) (parsers.SelectItem, error) {
|
|
fieldsAsArray := other_fields.([]interface{})
|
|
fieldsList := make([]parsers.SelectItem, len(fieldsAsArray)+1)
|
|
fieldsList[0] = field.(parsers.SelectItem)
|
|
|
|
for i, v := range fieldsAsArray {
|
|
if col, ok := v.(parsers.SelectItem); ok {
|
|
fieldsList[i+1] = col
|
|
}
|
|
}
|
|
|
|
return parsers.SelectItem{
|
|
SelectItems: fieldsList,
|
|
Type: parsers.SelectItemTypeObject,
|
|
}, nil
|
|
}
|
|
|
|
func makeOrderByClause(ex1 interface{}, others interface{}) ([]parsers.OrderExpression, error) {
|
|
othersArray := others.([]interface{})
|
|
orderList := make([]parsers.OrderExpression, len(othersArray)+1)
|
|
orderList[0] = ex1.(parsers.OrderExpression)
|
|
|
|
for i, v := range othersArray {
|
|
if col, ok := v.(parsers.OrderExpression); ok {
|
|
orderList[i+1] = col
|
|
}
|
|
}
|
|
|
|
return orderList, nil
|
|
}
|
|
|
|
func makeOrderExpression(field interface{}, order interface{}) (parsers.OrderExpression, error) {
|
|
value := parsers.OrderExpression{
|
|
SelectItem: field.(parsers.SelectItem),
|
|
Direction: parsers.OrderDirectionAsc,
|
|
}
|
|
|
|
if orderValue, ok := order.(parsers.OrderDirection); ok {
|
|
value.Direction = orderValue
|
|
}
|
|
|
|
return value, nil
|
|
}
|
|
|
|
func createFunctionCall(functionType parsers.FunctionCallType, arguments []interface{}) (parsers.FunctionCall, error) {
|
|
return parsers.FunctionCall{Type: functionType, Arguments: arguments}, nil
|
|
}
|
|
|
|
func joinStrings(array []interface{}) string {
|
|
var stringsArray []string
|
|
for _, elem := range array {
|
|
str, ok := elem.(string)
|
|
if !ok {
|
|
continue
|
|
}
|
|
stringsArray = append(stringsArray, str)
|
|
}
|
|
|
|
return strings.Join(stringsArray, "")
|
|
}
|
|
|
|
func combineExpressions(ex1 interface{}, exs interface{}, operation parsers.LogicalExpressionType) (interface{}, error) {
|
|
if exs == nil || len(exs.([]interface{})) < 1 {
|
|
return ex1, nil
|
|
}
|
|
|
|
return parsers.LogicalExpression{
|
|
Expressions: append([]interface{}{ex1}, exs.([]interface{})...),
|
|
Operation: operation,
|
|
}, nil
|
|
}
|
|
|
|
}
|
|
|
|
Input <- selectStmt:SelectStmt {
|
|
return selectStmt, nil
|
|
}
|
|
|
|
SelectStmt <- Select ws topClause:TopClause? ws columns:Selection ws
|
|
From ws table:TableName ws
|
|
whereClause:(ws Where ws condition:Condition { return condition, nil })?
|
|
orderByClause:OrderByClause? {
|
|
return makeSelectStmt(columns, table, whereClause, topClause, orderByClause)
|
|
}
|
|
|
|
TopClause <- Top ws count:Integer {
|
|
return count, nil
|
|
}
|
|
|
|
Selection <- SelectValueSpec / ColumnList / SelectAsterisk
|
|
|
|
SelectAsterisk <- "*" {
|
|
selectItem, _ := makeSelectItem("c", make([]interface{}, 0), parsers.SelectItemTypeField)
|
|
selectItem.IsTopLevel = true
|
|
return makeColumnList(selectItem, make([]interface{}, 0))
|
|
}
|
|
|
|
ColumnList <- column:SelectItem other_columns:(ws "," ws coll:SelectItem {return coll, nil })* {
|
|
return makeColumnList(column, other_columns)
|
|
}
|
|
|
|
SelectValueSpec <- "VALUE"i 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
|
|
}
|
|
|
|
SelectArray <- "[" ws columns:ColumnList ws "]" {
|
|
return makeSelectArray(columns)
|
|
}
|
|
|
|
SelectObject <- "{" ws field:SelectObjectField ws other_fields:(ws "," ws coll:SelectObjectField {return coll, nil })* ws "}" {
|
|
return makeSelectObject(field, other_fields)
|
|
}
|
|
|
|
SelectObjectField <- name:(Identifier / "\"" key:Identifier "\"" { return key, nil }) ws ":" ws selectItem:SelectItem {
|
|
item := selectItem.(parsers.SelectItem)
|
|
item.Alias = name.(string)
|
|
return item, nil
|
|
}
|
|
|
|
SelectProperty <- name:Identifier path:(DotFieldAccess / ArrayFieldAccess)* {
|
|
return makeSelectItem(name, path, parsers.SelectItemTypeField)
|
|
}
|
|
|
|
SelectItem <- selectItem:(Literal / FunctionCall / SelectArray / SelectObject / SelectProperty) asClause:AsClause? {
|
|
var itemResult parsers.SelectItem
|
|
switch typedValue := selectItem.(type) {
|
|
case parsers.SelectItem:
|
|
itemResult = typedValue
|
|
case parsers.Constant:
|
|
itemResult = parsers.SelectItem{
|
|
Type: parsers.SelectItemTypeConstant,
|
|
Value: typedValue,
|
|
}
|
|
case parsers.FunctionCall:
|
|
itemResult = parsers.SelectItem{
|
|
Type: parsers.SelectItemTypeFunctionCall,
|
|
Value: typedValue,
|
|
}
|
|
}
|
|
|
|
if aliasValue, ok := asClause.(string); ok {
|
|
itemResult.Alias = aliasValue
|
|
}
|
|
|
|
return itemResult, nil
|
|
}
|
|
|
|
AsClause <- ws As ws alias:Identifier { return alias, nil }
|
|
|
|
DotFieldAccess <- "." id:Identifier {
|
|
return id, nil
|
|
}
|
|
|
|
ArrayFieldAccess <- "[\"" id:Identifier "\"]" {
|
|
return id, nil
|
|
}
|
|
|
|
Identifier <- [a-zA-Z_][a-zA-Z0-9_]* {
|
|
return string(c.text), nil
|
|
}
|
|
|
|
Condition <- expression:OrExpression {
|
|
return expression, nil
|
|
}
|
|
|
|
OrExpression <- ex1:AndExpression ex2:(ws Or ws ex:AndExpression { return ex, nil })* {
|
|
return combineExpressions(ex1, ex2, parsers.LogicalExpressionTypeOr)
|
|
}
|
|
|
|
AndExpression <- ex1:ComparisonExpression ex2:(ws And ws ex:ComparisonExpression { return ex, nil })* {
|
|
return combineExpressions(ex1, ex2, parsers.LogicalExpressionTypeAnd)
|
|
}
|
|
|
|
ComparisonExpression <- "(" ws ex:OrExpression ws ")" { return ex, nil }
|
|
/ left:SelectItem ws op:ComparisonOperator ws right:SelectItem {
|
|
return parsers.ComparisonExpression{Left:left,Right:right,Operation:op.(string)}, nil
|
|
} / ex:BooleanLiteral { return ex, nil }
|
|
/ ex:SelectItem { return ex, nil }
|
|
|
|
OrderByClause <- OrderBy ws ex1:OrderExpression others:(ws "," ws ex:OrderExpression { return ex, nil })* {
|
|
return makeOrderByClause(ex1, others)
|
|
}
|
|
|
|
OrderExpression <- field:SelectProperty ws order:OrderDirection? {
|
|
return makeOrderExpression(field, order)
|
|
}
|
|
|
|
OrderDirection <- ("ASC"i / "DESC"i) {
|
|
if strings.EqualFold(string(c.text), "DESC") {
|
|
return parsers.OrderDirectionDesc, nil
|
|
}
|
|
|
|
return parsers.OrderDirectionAsc, nil
|
|
}
|
|
|
|
Select <- "SELECT"i
|
|
|
|
Top <- "TOP"i
|
|
|
|
As <- "AS"i
|
|
|
|
From <- "FROM"i
|
|
|
|
Where <- "WHERE"i
|
|
|
|
And <- "AND"i
|
|
|
|
Or <- "OR"i
|
|
|
|
OrderBy <- "ORDER"i ws "BY"i
|
|
|
|
ComparisonOperator <- ("=" / "!=" / "<" / "<=" / ">" / ">=") {
|
|
return string(c.text), nil
|
|
}
|
|
|
|
StringEquals <- "STRINGEQUALS"i
|
|
|
|
Literal <- FloatLiteral / IntegerLiteral / StringLiteral / BooleanLiteral / ParameterConstant / NullConstant
|
|
|
|
ParameterConstant <- "@" Identifier {
|
|
return parsers.Constant{Type: parsers.ConstantTypeParameterConstant, Value: string(c.text)}, nil
|
|
}
|
|
NullConstant <- "null" {
|
|
return parsers.Constant{Value: nil}, nil
|
|
}
|
|
|
|
IntegerLiteral <- number:Integer {
|
|
return parsers.Constant{Type: parsers.ConstantTypeInteger, Value: number.(int)}, nil
|
|
}
|
|
StringLiteral <- "\"" chars:StringCharacter* "\"" {
|
|
return parsers.Constant{Type: parsers.ConstantTypeString,Value: joinStrings(chars.([]interface{}))}, nil
|
|
}
|
|
FloatLiteral <- [0-9]+"."[0-9]+ {
|
|
floatValue, _ := strconv.ParseFloat(string(c.text), 64)
|
|
return parsers.Constant{Type: parsers.ConstantTypeFloat, Value: floatValue}, nil
|
|
}
|
|
BooleanLiteral <- ("true"i / "false"i) {
|
|
boolValue, _ := strconv.ParseBool(string(c.text))
|
|
return parsers.Constant{Type: parsers.ConstantTypeBoolean, Value: boolValue}, nil
|
|
}
|
|
|
|
FunctionCall <- StringFunctions
|
|
/ TypeCheckingFunctions
|
|
/ InFunction
|
|
|
|
TypeCheckingFunctions <- IsDefined
|
|
/ IsArray
|
|
/ IsBool
|
|
/ IsFiniteNumber
|
|
/ IsInteger
|
|
/ IsNull
|
|
/ IsNumber
|
|
/ IsObject
|
|
/ IsPrimitive
|
|
/ IsString
|
|
|
|
StringFunctions <- StringEqualsExpression
|
|
/ ToStringExpression
|
|
/ ConcatExpression
|
|
/ ThreeArgumentStringFunctionExpression
|
|
/ UpperExpression
|
|
/ LowerExpression
|
|
/ LeftExpression
|
|
/ LengthExpression
|
|
/ LTrimExpression
|
|
/ ReplaceExpression
|
|
/ ReplicateExpression
|
|
/ ReverseExpression
|
|
/ RightExpression
|
|
/ RTrimExpression
|
|
/ SubstringExpression
|
|
/ TrimExpression
|
|
|
|
UpperExpression <- "UPPER"i ws "(" ex:SelectItem ")" {
|
|
return createFunctionCall(parsers.FunctionCallUpper, []interface{}{ex})
|
|
}
|
|
|
|
LowerExpression <- "LOWER"i ws "(" ex:SelectItem ")" {
|
|
return createFunctionCall(parsers.FunctionCallLower, []interface{}{ex})
|
|
}
|
|
|
|
StringEqualsExpression <- StringEquals ws "(" ws ex1:SelectItem ws "," ws ex2:SelectItem ws ignoreCase:("," ws boolean:SelectItem { return boolean, nil })? ")" {
|
|
return createFunctionCall(parsers.FunctionCallStringEquals, []interface{}{ex1, ex2, ignoreCase})
|
|
}
|
|
|
|
ToStringExpression <- "TOSTRING"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallToString, []interface{}{ex})
|
|
}
|
|
|
|
ConcatExpression <- "CONCAT"i ws "(" ws ex1:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })+ ws ")" {
|
|
arguments := append([]interface{}{ex1}, others.([]interface{})...)
|
|
return createFunctionCall(parsers.FunctionCallConcat, arguments)
|
|
}
|
|
|
|
LeftExpression <- "LEFT"i ws "(" ws ex:SelectItem ws "," ws length:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallLeft, []interface{}{ex, length})
|
|
}
|
|
|
|
LengthExpression <- "LENGTH"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallLength, []interface{}{ex})
|
|
}
|
|
|
|
LTrimExpression <- "LTRIM"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallLTrim, []interface{}{ex})
|
|
}
|
|
|
|
ReplaceExpression <- "REPLACE"i ws "(" ws ex1:SelectItem ws "," ws ex2:SelectItem ws "," ws ex3:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallReplace, []interface{}{ex1, ex2, ex3})
|
|
}
|
|
|
|
ReplicateExpression <- "REPLICATE"i ws "(" ws ex1:SelectItem ws "," ws ex2:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallReplicate, []interface{}{ex1, ex2})
|
|
}
|
|
|
|
ReverseExpression <- "REVERSE"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallReverse, []interface{}{ex})
|
|
}
|
|
|
|
RightExpression <- "RIGHT"i ws "(" ws ex:SelectItem ws "," ws length:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallRight, []interface{}{ex, length})
|
|
}
|
|
|
|
RTrimExpression <- "RTRIM"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallRTrim, []interface{}{ex})
|
|
}
|
|
|
|
SubstringExpression <- "SUBSTRING"i ws "(" ws ex:SelectItem ws "," ws startPos:SelectItem ws "," ws length:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallSubstring, []interface{}{ex, startPos, length})
|
|
}
|
|
|
|
TrimExpression <- "TRIM"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallTrim, []interface{}{ex})
|
|
}
|
|
|
|
ThreeArgumentStringFunctionExpression <- function:ThreeArgumentStringFunction ws "(" ws ex1:SelectItem ws "," ws ex2:SelectItem ws ignoreCase:("," ws boolean:SelectItem { return boolean, nil })? ")" {
|
|
var functionType parsers.FunctionCallType
|
|
|
|
lowerFunction := strings.ToUpper(function.(string))
|
|
switch lowerFunction {
|
|
case "CONTAINS":
|
|
functionType = parsers.FunctionCallContains
|
|
case "ENDSWITH":
|
|
functionType = parsers.FunctionCallEndsWith
|
|
case "STARTSWITH":
|
|
functionType = parsers.FunctionCallStartsWith
|
|
case "INDEX_OF":
|
|
functionType = parsers.FunctionCallIndexOf
|
|
}
|
|
|
|
return parsers.FunctionCall{Type: functionType, Arguments: []interface{}{ex1, ex2, ignoreCase}}, nil
|
|
}
|
|
|
|
ThreeArgumentStringFunction <- ("CONTAINS"i / "ENDSWITH"i / "STARTSWITH"i / "INDEX_OF"i) {
|
|
return string(c.text), nil
|
|
}
|
|
|
|
IsDefined <- "IS_DEFINED"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallIsDefined, []interface{}{ex})
|
|
}
|
|
|
|
IsArray <- "IS_ARRAY"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallIsArray, []interface{}{ex})
|
|
}
|
|
|
|
IsBool <- "IS_BOOL"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallIsBool, []interface{}{ex})
|
|
}
|
|
|
|
IsFiniteNumber <- "IS_FINITE_NUMBER"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallIsFiniteNumber, []interface{}{ex})
|
|
}
|
|
|
|
IsInteger <- "IS_INTEGER"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallIsInteger, []interface{}{ex})
|
|
}
|
|
|
|
IsNull <- "IS_NULL"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallIsNull, []interface{}{ex})
|
|
}
|
|
|
|
IsNumber <- "IS_NUMBER"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallIsNumber, []interface{}{ex})
|
|
}
|
|
|
|
IsObject <- "IS_OBJECT"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallIsObject, []interface{}{ex})
|
|
}
|
|
|
|
IsPrimitive <- "IS_PRIMITIVE"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallIsPrimitive, []interface{}{ex})
|
|
}
|
|
|
|
IsString <- "IS_STRING"i ws "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallIsString, []interface{}{ex})
|
|
}
|
|
|
|
InFunction <- ex1:SelectProperty ws "IN"i ws "(" ws ex2:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" {
|
|
arguments := append([]interface{}{ex1, ex2}, others.([]interface{})...)
|
|
return parsers.FunctionCall{Type: parsers.FunctionCallIn, Arguments: arguments}, nil
|
|
}
|
|
|
|
Integer <- [0-9]+ {
|
|
return strconv.Atoi(string(c.text))
|
|
}
|
|
|
|
StringCharacter <- !('"' / "\\") . { return string(c.text), nil }
|
|
/ "\\" seq:EscapeSequenceCharacter { return seq, nil }
|
|
|
|
EscapeSequenceCharacter <- char:EscapeCharacter
|
|
|
|
EscapeCharacter <- "'"
|
|
/ '"'
|
|
/ "\\"
|
|
/ "b" { return "\b", nil }
|
|
/ "f" { return "\f", nil }
|
|
/ "n" { return "\n", nil }
|
|
/ "r" { return "\r", nil }
|
|
/ "t" { return "\t", nil }
|
|
|
|
non_escape_character <- !(escape_character) char:.
|
|
{ return string(c.text), nil }
|
|
|
|
ws <- [ \t\n\r]*
|
|
|
|
EOF <- !.
|