simpleSqlParser/parse.peg at master · logzer0/simpleSqlParser · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
package simpleSqlParser

type SQL Peg {
	sType
	SelectStatement
	InsertStatement
	CreateStatement
	DropStatement
	DeleteStatement
}

G <- SelectStatement / InsertStatement / CreateStatement / DropStatement / DeleteStatement !.


DropStatement <- _  "DROP" _  DropTable _ ";"_

# Select
SelectStatement <- _  "SELECT" _ Columns _ "FROM" _ SelectTable _ WHERESELECT* _ LIMIT* _ ";" _

#Delete
DeleteStatement <- "DELETE" _ "FROM" _ DeleteTable _ WHEREDELETE _ ";" _

#Insert
InsertStatement <-   _ "INSERT" _ "INTO" _ InsertBody     { p.validateInsert() }

# Create
CreateStatement <- _ "CREATE" _  "Table" _ CreateTable _ CreateParaColList _ ';' { p.setPartitionKey(buffer[begin:end])}

# Columns defn
Columns  <-  SelectParaColList / SelectColList / Asterisk
SelectParaColList <- '(' _ SelectColList  _ ')'
SelectColList <- (SelectColName _  ',' _  )* SelectColName
SelectColName <- < AlphaNum+ > { p.SelectStatement.Columns = append(p.SelectStatement.Columns, buffer[begin:end]) }

InsertParaColList <- '(' _ InsertColList  _ ')'
InsertColList <- (_ InsertColName _  ',' _  )* InsertColName
InsertColName <- < AlphaNum+ > { p.InsertStatement.Columns = append(p.InsertStatement.Columns,buffer[begin:end]) }

CreateParaColList <- '(' _ CreateColList _  ')'
CreateColList <- ( _ CreateColName _ ',' _  )* CreateColName
CreateColName <- < AlphaNum+ > { p.CreateStatement.Columns = append(p.CreateStatement.Columns, buffer[begin:end]) }

# Insert Body
InsertBody <-   InsertTable  _ Values _ ";"

# Values defn
Values <- InsertParaColList? _ "VALUES" _ ValuesBody

# ValuesBody defn
ValuesBody <- '(' _ ValList  _ ')'

ValList <- ( _ InsertValue _ ',' _  )* _ InsertValue
InsertValue <- '"'? EachValue '"'?
EachValue <- <   AlphaNum+  > { p.captureValues(buffer[begin:end]) }

# Symbols
Asterisk <- '*' { p.SelectStatement.AllColumns = true }


# Comments and whitespace
lineComment  <- '//' (!'\n' .)*
blockComment <- '/*' (!'*/' (. / '\n'))* '*/'
ws           <- [ \t\n\r]
_            <- (ws / lineComment / blockComment)*


# Numbers and letters
Letter   <- [a-zA-Z_]
Number   <- [0-9] ('.' [0-9])*
AlphaNum <- (Letter / Number)

# Table defn
SelectTable <- SelectKeyspace "." SelectTableName
SelectKeyspace <- < AlphaNum+ > {p.SelectStatement.Keyspace = buffer[begin:end] }
SelectTableName <-  < AlphaNum+ >  { p.SelectStatement.TableName = buffer[begin:end] }

InsertTable <- InsertKeyspace "." InsertTableName
InsertKeyspace <- < AlphaNum+ > { p.InsertStatement.Keyspace = buffer[begin:end] }
InsertTableName <- < AlphaNum+ > { p.InsertStatement.TableName = buffer[begin:end] }

CreateTable <- CreateKeyspace "." CreateTableName
CreateKeyspace <- < AlphaNum+ > { p.CreateStatement.Keyspace =buffer[begin:end] }
CreateTableName <- < AlphaNum+ > { p.CreateStatement.TableName = buffer[begin:end] }

DropTable <- DropTableKeyspace "." DropTableName
DropTableKeyspace <- < AlphaNum+ > { p.DropStatement.Keyspace = buffer[begin:end] }
DropTableName <- < AlphaNum+ > {p.DropStatement.TableName = buffer[begin:end] }

DeleteTable <- DeleteKeyspace "." DeleteTableName
DeleteKeyspace <- < AlphaNum+ > {p.DeleteStatement.Keyspace = buffer[begin:end] }
DeleteTableName <-  < AlphaNum+ >  { p.DeleteStatement.TableName = buffer[begin:end] }

#WHERESELECT defn
WHERESELECT <- "WHERE" _  SELECTFILTERS+
SELECTFILTERS <- (SELECTFILTER _  "and" )* SELECTFILTER
SELECTFILTER <- _ SelectFilterColumn _ SelectOperation _ SelectFilterValue _

SelectOperation <- SelectEquality / SelectLessThan / SelectGreaterThan

SelectEquality <- < "=" > { p.SelectStatement.Operators= append(p.SelectStatement.Operators, buffer[begin:end]) }
SelectLessThan <- < "<" "="? >{ p.SelectStatement.Operators= append(p.SelectStatement.Operators, buffer[begin:end]) }
SelectGreaterThan <- < ">" "="? > { p.SelectStatement.Operators= append(p.SelectStatement.Operators, buffer[begin:end]) }


SelectFilterColumn <- < AlphaNum+ >  { p.SelectStatement.WhereColumns = append(p.SelectStatement.WhereColumns, buffer[begin:end])  }
SelectFilterValue  <-  < AlphaNum+ > { p.SelectStatement.WhereValues = append(p.SelectStatement.WhereValues, buffer[begin:end]) }


#WHEREDELETE defn
WHEREDELETE <- "WHERE" _  DELETEFILTER
DELETEFILTER <- _ DeleteFilterColumn _ DeleteOperation _ DeleteFilterValue _

DeleteOperation <- DeleteEquality / DeleteLessThan / DeleteGreaterThan

DeleteEquality <- < "=" > { p.DeleteStatement.Operator=  buffer[begin:end] }
DeleteLessThan <- < "<" "="? >{ p.DeleteStatement.Operator=  buffer[begin:end] }
DeleteGreaterThan <- < ">" "="? > { p.DeleteStatement.Operator=  buffer[begin:end] }


DeleteFilterColumn <- < AlphaNum+ >  { p.DeleteStatement.WhereColumn =  buffer[begin:end]  }
DeleteFilterValue  <-  < AlphaNum+ > { p.DeleteStatement.WhereValue =  buffer[begin:end] }


#LIMIT Defn
LIMIT <- "LIMIT" _ LimitVal
LimitVal <- < Number+ > { var err error;  p.SelectStatement.Limit,err = strconv.Atoi(buffer[begin:end]); if err!=nil{ p.SelectStatement.Limit = -1  };   }