mirror of https://github.com/pikami/cosmium.git
681 lines
25 KiB
Plaintext
681 lines
25 KiB
Plaintext
{
|
|
package nosql
|
|
|
|
import "github.com/pikami/cosmium/parsers"
|
|
|
|
func makeSelectStmt(
|
|
columns, table, joinItems,
|
|
whereClause interface{}, distinctClause interface{},
|
|
count interface{}, groupByClause interface{}, orderList interface{},
|
|
offsetClause interface{},
|
|
) (parsers.SelectStmt, error) {
|
|
selectStmt := parsers.SelectStmt{
|
|
SelectItems: columns.([]parsers.SelectItem),
|
|
Table: table.(parsers.Table),
|
|
}
|
|
|
|
if joinItemsArray, ok := joinItems.([]interface{}); ok && len(joinItemsArray) > 0 {
|
|
selectStmt.JoinItems = make([]parsers.JoinItem, len(joinItemsArray))
|
|
for i, joinItem := range joinItemsArray {
|
|
selectStmt.JoinItems[i] = joinItem.(parsers.JoinItem)
|
|
}
|
|
}
|
|
|
|
switch v := whereClause.(type) {
|
|
case parsers.ComparisonExpression, parsers.LogicalExpression, parsers.Constant, parsers.SelectItem:
|
|
selectStmt.Filters = v
|
|
}
|
|
|
|
if distinctClause != nil {
|
|
selectStmt.Distinct = true
|
|
}
|
|
|
|
if n, ok := count.(int); ok {
|
|
selectStmt.Count = n
|
|
}
|
|
|
|
if offsetArr, ok := offsetClause.([]interface{}); ok && len(offsetArr) == 2 {
|
|
if n, ok := offsetArr[0].(int); ok {
|
|
selectStmt.Offset = n
|
|
}
|
|
|
|
if n, ok := offsetArr[1].(int); ok {
|
|
selectStmt.Count = n
|
|
}
|
|
}
|
|
|
|
if orderExpressions, ok := orderList.([]parsers.OrderExpression); ok {
|
|
selectStmt.OrderExpressions = orderExpressions
|
|
}
|
|
|
|
if groupByClause != nil {
|
|
selectStmt.GroupBy = groupByClause.([]parsers.SelectItem)
|
|
}
|
|
|
|
return selectStmt, nil
|
|
}
|
|
|
|
func makeJoin(table interface{}, column interface{}) (parsers.JoinItem, error) {
|
|
return parsers.JoinItem{
|
|
Table: table.(parsers.Table),
|
|
SelectItem: column.(parsers.SelectItem),
|
|
}, 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
|
|
distinctClause:DistinctClause? ws
|
|
topClause:TopClause? ws
|
|
columns:Selection ws
|
|
From ws table:TableName ws
|
|
joinClauses:JoinClause* ws
|
|
whereClause:(ws Where ws condition:Condition { return condition, nil })?
|
|
groupByClause:(ws GroupBy ws columns:ColumnList { return columns, nil })?
|
|
orderByClause:OrderByClause?
|
|
offsetClause:OffsetClause? {
|
|
return makeSelectStmt(columns, table, joinClauses, whereClause,
|
|
distinctClause, topClause, groupByClause, orderByClause, offsetClause)
|
|
}
|
|
|
|
DistinctClause <- "DISTINCT"i
|
|
|
|
TopClause <- Top ws count:Integer {
|
|
return count, nil
|
|
}
|
|
|
|
JoinClause <- Join ws table:TableName ws "IN"i ws column:SelectItem {
|
|
return makeJoin(table, column)
|
|
}
|
|
|
|
OffsetClause <- "OFFSET"i ws offset:IntegerLiteral ws "LIMIT"i ws limit:IntegerLiteral {
|
|
return []interface{}{offset.(parsers.Constant).Value, limit.(parsers.Constant).Value}, 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 }
|
|
/ "[" id:Integer "]" { return strconv.Itoa(id.(int)), 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
|
|
|
|
Join <- "JOIN"i
|
|
|
|
Where <- "WHERE"i
|
|
|
|
And <- "AND"i
|
|
|
|
Or <- "OR"i
|
|
|
|
GroupBy <- "GROUP"i ws "BY"i
|
|
|
|
OrderBy <- "ORDER"i ws "BY"i
|
|
|
|
ComparisonOperator <- ("=" / "!=" / "<" / "<=" / ">" / ">=") {
|
|
return string(c.text), nil
|
|
}
|
|
|
|
Literal <- FloatLiteral / IntegerLiteral / StringLiteral / BooleanLiteral / ParameterConstant / NullConstant
|
|
|
|
ParameterConstant <- "@" Identifier {
|
|
return parsers.Constant{Type: parsers.ConstantTypeParameterConstant, Value: string(c.text)}, nil
|
|
}
|
|
NullConstant <- "null"i {
|
|
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
|
|
/ ArrayFunctions
|
|
/ InFunction
|
|
/ AggregateFunctions
|
|
/ MathFunctions
|
|
|
|
StringFunctions <- StringEqualsExpression
|
|
/ ToStringExpression
|
|
/ ConcatExpression
|
|
/ ThreeArgumentStringFunctionExpression
|
|
/ UpperExpression
|
|
/ LowerExpression
|
|
/ LeftExpression
|
|
/ LengthExpression
|
|
/ LTrimExpression
|
|
/ ReplaceExpression
|
|
/ ReplicateExpression
|
|
/ ReverseExpression
|
|
/ RightExpression
|
|
/ RTrimExpression
|
|
/ SubstringExpression
|
|
/ TrimExpression
|
|
|
|
TypeCheckingFunctions <- IsDefined
|
|
/ IsArray
|
|
/ IsBool
|
|
/ IsFiniteNumber
|
|
/ IsInteger
|
|
/ IsNull
|
|
/ IsNumber
|
|
/ IsObject
|
|
/ IsPrimitive
|
|
/ IsString
|
|
|
|
AggregateFunctions <- AvgAggregateExpression
|
|
/ CountAggregateExpression
|
|
/ MaxAggregateExpression
|
|
/ MinAggregateExpression
|
|
/ SumAggregateExpression
|
|
|
|
ArrayFunctions <- ArrayConcatExpression
|
|
/ ArrayLengthExpression
|
|
/ ArraySliceExpression
|
|
/ SetIntersectExpression
|
|
/ SetUnionExpression
|
|
|
|
MathFunctions <- MathAbsExpression
|
|
/ MathAcosExpression
|
|
/ MathAsinExpression
|
|
/ MathAtanExpression
|
|
/ MathCeilingExpression
|
|
/ MathCosExpression
|
|
/ MathCotExpression
|
|
/ MathDegreesExpression
|
|
/ MathExpExpression
|
|
/ MathFloorExpression
|
|
/ MathIntBitNotExpression
|
|
/ MathLog10Expression
|
|
/ MathRadiansExpression
|
|
/ MathRoundExpression
|
|
/ MathSignExpression
|
|
/ MathSinExpression
|
|
/ MathSqrtExpression
|
|
/ MathSquareExpression
|
|
/ MathTanExpression
|
|
/ MathTruncExpression
|
|
/ MathAtn2Expression
|
|
/ MathIntAddExpression
|
|
/ MathIntBitAndExpression
|
|
/ MathIntBitLeftShiftExpression
|
|
/ MathIntBitOrExpression
|
|
/ MathIntBitRightShiftExpression
|
|
/ MathIntBitXorExpression
|
|
/ MathIntDivExpression
|
|
/ MathIntModExpression
|
|
/ MathIntMulExpression
|
|
/ MathIntSubExpression
|
|
/ MathPowerExpression
|
|
/ MathLogExpression
|
|
/ MathNumberBinExpression
|
|
/ MathPiExpression
|
|
/ MathRandExpression
|
|
|
|
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"i 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 createFunctionCall(functionType, []interface{}{ex1, ex2, ignoreCase})
|
|
}
|
|
|
|
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})
|
|
}
|
|
|
|
ArrayConcatExpression <- "ARRAY_CONCAT"i ws "(" ws arrays:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })+ ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallArrayConcat, append([]interface{}{arrays}, others.([]interface{})...))
|
|
}
|
|
|
|
ArrayLengthExpression <- "ARRAY_LENGTH"i ws "(" ws array:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallArrayLength, []interface{}{array})
|
|
}
|
|
|
|
ArraySliceExpression <- "ARRAY_SLICE"i ws "(" ws array:SelectItem ws "," ws start:SelectItem length:(ws "," ws ex:SelectItem { return ex, nil })? ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallArraySlice, []interface{}{array, start, length})
|
|
}
|
|
|
|
SetIntersectExpression <- "SetIntersect"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallSetIntersect, []interface{}{set1, set2})
|
|
}
|
|
|
|
SetUnionExpression <- "SetUnion"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallSetUnion, []interface{}{set1, set2})
|
|
}
|
|
|
|
MathAbsExpression <- "ABS"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAbs, []interface{}{ex}) }
|
|
MathAcosExpression <- "ACOS"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAcos, []interface{}{ex}) }
|
|
MathAsinExpression <- "ASIN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAsin, []interface{}{ex}) }
|
|
MathAtanExpression <- "ATAN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAtan, []interface{}{ex}) }
|
|
MathCeilingExpression <- "CEILING"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathCeiling, []interface{}{ex}) }
|
|
MathCosExpression <- "COS"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathCos, []interface{}{ex}) }
|
|
MathCotExpression <- "COT"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathCot, []interface{}{ex}) }
|
|
MathDegreesExpression <- "DEGREES"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathDegrees, []interface{}{ex}) }
|
|
MathExpExpression <- "EXP"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathExp, []interface{}{ex}) }
|
|
MathFloorExpression <- "FLOOR"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathFloor, []interface{}{ex}) }
|
|
MathIntBitNotExpression <- "IntBitNot"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitNot, []interface{}{ex}) }
|
|
MathLog10Expression <- "LOG10"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathLog10, []interface{}{ex}) }
|
|
MathRadiansExpression <- "RADIANS"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathRadians, []interface{}{ex}) }
|
|
MathRoundExpression <- "ROUND"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathRound, []interface{}{ex}) }
|
|
MathSignExpression <- "SIGN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathSign, []interface{}{ex}) }
|
|
MathSinExpression <- "SIN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathSin, []interface{}{ex}) }
|
|
MathSqrtExpression <- "SQRT"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathSqrt, []interface{}{ex}) }
|
|
MathSquareExpression <- "SQUARE"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathSquare, []interface{}{ex}) }
|
|
MathTanExpression <- "TAN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathTan, []interface{}{ex}) }
|
|
MathTruncExpression <- "TRUNC"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathTrunc, []interface{}{ex}) }
|
|
|
|
MathAtn2Expression <- "ATN2"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAtn2, []interface{}{set1, set2}) }
|
|
MathIntAddExpression <- "IntAdd"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntAdd, []interface{}{set1, set2}) }
|
|
MathIntBitAndExpression <- "IntBitAnd"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitAnd, []interface{}{set1, set2}) }
|
|
MathIntBitLeftShiftExpression <- "IntBitLeftShift"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitLeftShift, []interface{}{set1, set2}) }
|
|
MathIntBitOrExpression <- "IntBitOr"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitOr, []interface{}{set1, set2}) }
|
|
MathIntBitRightShiftExpression <- "IntBitRightShift"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitRightShift, []interface{}{set1, set2}) }
|
|
MathIntBitXorExpression <- "IntBitXor"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitXor, []interface{}{set1, set2}) }
|
|
MathIntDivExpression <- "IntDiv"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntDiv, []interface{}{set1, set2}) }
|
|
MathIntModExpression <- "IntMod"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntMod, []interface{}{set1, set2}) }
|
|
MathIntMulExpression <- "IntMul"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntMul, []interface{}{set1, set2}) }
|
|
MathIntSubExpression <- "IntSub"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntSub, []interface{}{set1, set2}) }
|
|
MathPowerExpression <- "POWER"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathPower, []interface{}{set1, set2}) }
|
|
|
|
MathLogExpression <- "LOG"i ws "(" ws ex1:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallMathLog, append([]interface{}{ex1}, others.([]interface{})...))
|
|
}
|
|
MathNumberBinExpression <- "NumberBin"i ws "(" ws ex1:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallMathNumberBin, append([]interface{}{ex1}, others.([]interface{})...))
|
|
}
|
|
MathPiExpression <- "PI"i ws "(" ws ")" { return createFunctionCall(parsers.FunctionCallMathPi, []interface{}{}) }
|
|
MathRandExpression <- "RAND"i ws "(" ws ")" { return createFunctionCall(parsers.FunctionCallMathRand, []interface{}{}) }
|
|
|
|
InFunction <- ex1:SelectProperty ws "IN"i ws "(" ws ex2:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallIn, append([]interface{}{ex1, ex2}, others.([]interface{})...))
|
|
}
|
|
|
|
AvgAggregateExpression <- "AVG"i "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallAggregateAvg, []interface{}{ex})
|
|
}
|
|
|
|
CountAggregateExpression <- "COUNT"i "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallAggregateCount, []interface{}{ex})
|
|
}
|
|
|
|
MaxAggregateExpression <- "MAX"i "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallAggregateMax, []interface{}{ex})
|
|
}
|
|
|
|
MinAggregateExpression <- "MIN"i "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallAggregateMin, []interface{}{ex})
|
|
}
|
|
|
|
SumAggregateExpression <- "SUM"i "(" ws ex:SelectItem ws ")" {
|
|
return createFunctionCall(parsers.FunctionCallAggregateSum, []interface{}{ex})
|
|
}
|
|
|
|
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 <- !.
|