Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Grammar railroad diagram #1359

Open
mingodad opened this issue Jul 24, 2021 · 6 comments
Open

Grammar railroad diagram #1359

mingodad opened this issue Jul 24, 2021 · 6 comments

Comments

@mingodad
Copy link

With a tool I made to parse jison grammars an convert then to a kind of EBNF (with a bit of manual fixes) understood by https://www.bottlecaps.de/rr/ui , we can see a railroad diagram for the grammar in https://github.com/agershun/alasql/blob/develop/src/alasqlparser.jison, copy and paste the EBNF shown bellow on https://www.bottlecaps.de/rr/ui in the tab Edit Grammar then switching to the tab View Diagram.

main ::= Statements EOF

Literal ::= LITERAL
	| BRALITERAL
	| error NonReserved

LiteralWithSpaces ::= LITERAL
	| LiteralWithSpaces LITERAL

Statements ::= Statements ( SEMICOLON | GO ) AStatement
	| AStatement
	| ExplainStatement

ExplainStatement ::= EXPLAIN AStatement
	| EXPLAIN QUERY PLAN AStatement

AStatement ::= Statement

Statement ::=
	| AlterTable
	| AttachDatabase
	| Call
	| CreateDatabase
	| CreateIndex
	| CreateGraph
	| CreateTable
	| CreateView
	| CreateEdge
	| CreateVertex
	| Declare
	| Delete
	| DetachDatabase
	| DropDatabase
	| DropIndex
	| DropTable
	| DropView
	| If
	| Insert
	| Merge
	| Reindex
	| RenameTable
	| Select
	| ShowCreateTable
	| ShowColumns
	| ShowDatabases
	| ShowIndex
	| ShowTables
	| TruncateTable
	| WithSelect
	| CreateTrigger
	| DropTrigger
	| BeginTransaction
	| CommitTransaction
	| RollbackTransaction
	| EndTransaction
	| UseDatabase
	| Update
	| JavaScript
	| Source
	| Assert
	| While
	| Continue
	| Break
	| BeginEnd
	| Print
	| Require
	| SetVariable
	| ExpressionStatement
	| AddRule
	| Query
	| Echo
	| CreateFunction
	| CreateAggregate

WithSelect ::= WITH WithTablesList Select

WithTablesList ::= WithTablesList COMMA WithTable
	| WithTable

WithTable ::= Literal AS LPAR Select RPAR

Select ::= SelectClause RemoveClause ? IntoClause FromClause PivotClause ? WhereClause GroupClause OrderClause LimitClause UnionClause
	| SEARCH SearchSelector * IntoClause SearchFrom ?

PivotClause ::= PIVOT LPAR Expression FOR Literal PivotClause2 ? RPAR AsLiteral ?
	| UNPIVOT LPAR Literal FOR Literal IN LPAR ColumnsList RPAR RPAR AsLiteral ?

PivotClause2 ::= IN LPAR AsList RPAR

AsLiteral ::= AS Literal
	| Literal

AsList ::= AsList COMMA AsPart
	| AsPart

AsPart ::= Expression
	| Expression AS Literal

RemoveClause ::= REMOVE COLUMN ? RemoveColumnsList

RemoveColumnsList ::= RemoveColumnsList COMMA RemoveColumn
	| RemoveColumn

RemoveColumn ::= Column
	| LIKE StringValue

ArrowDot ::= ARROW
	| DOT

SearchSelector ::= Literal
	| ORDER BY LPAR OrderExpressionsList RPAR
	| ORDER BY LPAR DIRECTION ? RPAR
	| DOTDOT
	| ArrowDot Literal
	| CARET
	| EQ Expression
	| LIKE Expression
	| LPAR SearchSelector + RPAR
	| WITH LPAR SearchSelector + RPAR
	| Literal LPAR ExprList ? RPAR
	| WHERE LPAR Expression RPAR
	| OF LPAR Expression RPAR
	| CLASS LPAR Literal RPAR
	| NUMBER
	| STRING
	| SLASH
	| VERTEX
	| EDGE
	| EXCLAMATION
	| SHARP Literal
	| MODULO Literal
	| MODULO SLASH
	| GT
	| LT
	| GTGT
	| LTLT
	| DOLLAR
	| Json
	| AT Literal
	| AS AT Literal
	| SET LPAR SetColumnsList RPAR
	| TO AT Literal
	| VALUE
	| ROW LPAR ExprList RPAR
	| COLON Literal
	| SearchSelector PlusStar
	| NOT LPAR SearchSelector * RPAR
	| IF LPAR SearchSelector * RPAR
	| Aggregator LPAR SearchSelector * RPAR
	| ( DISTINCT | UNIQUE ) LPAR SearchSelector * RPAR
	| UNION LPAR SearchSelectorList RPAR
	| UNION ALL LPAR SearchSelectorList RPAR
	| ALL LPAR SearchSelector * RPAR
	| ANY LPAR SearchSelector * RPAR
	| INTERSECT LPAR SearchSelectorList RPAR
	| EXCEPT LPAR SearchSelectorList RPAR
	| AND LPAR SearchSelectorList RPAR
	| OR LPAR SearchSelectorList RPAR
	| PATH LPAR SearchSelector RPAR
	| RETURN LPAR ResultColumns RPAR
	| REPEAT LPAR SearchSelector * COMMA ExprList RPAR

SearchSelectorList ::= SearchSelectorList COMMA SearchSelector *
	| SearchSelector *

PlusStar ::= PLUS
	| STAR
	| QUESTION

SearchFrom ::= FROM Expression

SelectClause ::= SelectModifier DISTINCT TopClause ResultColumns
	| SelectModifier UNIQUE TopClause ResultColumns
	| SelectModifier ALL TopClause ResultColumns
	| SelectModifier TopClause ResultColumns ?

SelectModifier ::= SELECT
	| SELECT VALUE
	| SELECT ROW
	| SELECT COLUMN
	| SELECT MATRIX
	| SELECT TEXTSTRING
	| SELECT INDEX
	| SELECT RECORDSET

TopClause ::= TOP NumValue PERCENT ?
	| TOP LPAR NumValue RPAR
	|

IntoClause ::=
	| INTO Table
	| INTO FuncValue
	| INTO ParamValue
	| INTO VarValue
	| INTO STRING

FromClause ::= FROM FromTablesList
	| FROM FromTablesList JoinTablesList
	| FROM LPAR FromTablesList JoinTablesList RPAR
	|

ApplyClause ::= CROSS APPLY LPAR Select RPAR Literal
	| CROSS APPLY LPAR Select RPAR AS Literal
	| OUTER APPLY LPAR Select RPAR Literal
	| OUTER APPLY LPAR Select RPAR AS Literal

FromTablesList ::= FromTable
	| FromTablesList COMMA FromTable

FromTable ::= LPAR Select RPAR Literal
	| LPAR Select RPAR AS Literal
	| LPAR Select RPAR
	| Json AS ? Literal ?
	| Table Literal
	| Table AS Literal
	| Table
	| Table NOT INDEXED
	| ParamValue Literal
	| ParamValue AS Literal
	| ParamValue
	| FuncValue
	| FuncValue Literal
	| FuncValue AS Literal
	| INSERTED
	| VarValue
	| VarValue Literal
	| VarValue AS Literal
	| FromString
	| FromString Literal
	| FromString AS Literal

FromString ::= STRING

Table ::= Literal DOT Literal
	| Literal

JoinTablesList ::= JoinTablesList JoinTable
	| JoinTablesList ApplyClause
	| JoinTable
	| ApplyClause

JoinTable ::= JoinMode JoinTableAs OnClause

JoinTableAs ::= Table
	| Table Literal
	| Table AS Literal
	| Json AS ? Literal ?
	| ParamValue Literal
	| ParamValue AS Literal
	| LPAR Select RPAR Literal
	| LPAR Select RPAR AS Literal
	| FuncValue
	| FuncValue Literal
	| FuncValue AS Literal
	| VarValue
	| VarValue Literal
	| VarValue AS Literal

JoinMode ::= JoinModeMode
	| NATURAL JoinModeMode

JoinModeMode ::= JOIN
	| INNER JOIN
	| LEFT JOIN
	| LEFT OUTER JOIN
	| RIGHT JOIN
	| RIGHT OUTER JOIN
	| OUTER JOIN
	| FULL OUTER JOIN
	| SEMI JOIN
	| ANTI JOIN
	| CROSS JOIN

OnClause ::= ON Expression
	| USING ColumnsList
	|

WhereClause ::=
	| WHERE Expression

GroupClause ::=
	| GROUP BY GroupExpressionsList HavingClause

GroupExpressionsList ::= GroupExpression
	| GroupExpressionsList COMMA GroupExpression

GroupExpression ::= GROUPING SET LPAR GroupExpressionsList RPAR
	| ROLLUP LPAR GroupExpressionsList RPAR
	| CUBE LPAR GroupExpressionsList RPAR
	| Expression

HavingClause ::=
	| HAVING Expression

UnionClause ::=
	| UNION Select
	| UNION ALL Select
	| EXCEPT Select
	| INTERSECT Select
	| UNION CORRESPONDING Select
	| UNION ALL CORRESPONDING Select
	| EXCEPT CORRESPONDING Select
	| INTERSECT CORRESPONDING Select

OrderClause ::=
	| ORDER BY OrderExpressionsList

OrderExpressionsList ::= OrderExpression
	| OrderExpressionsList COMMA OrderExpression

NullsOrder ::= NULLS FIRST
	| NULLS LAST

OrderExpression ::= Expression
	| Expression DIRECTION
	| Expression DIRECTION NullsOrder
	| Expression COLLATE NOCASE
	| Expression COLLATE NOCASE DIRECTION

LimitClause ::=
	| LIMIT NumValue OffsetClause
	| OFFSET NumValue ROWS ? FETCH NEXT ? NumValue ROWS ? ONLY ?

OffsetClause ::=
	| OFFSET NumValue

ResultColumns ::= ResultColumns COMMA ResultColumn
	| ResultColumn

ResultColumn ::= Expression AS Literal
	| Expression Literal
	| Expression AS NUMBER
	| Expression NUMBER
	| Expression AS StringValue
	| Expression StringValue
	| Expression

Star ::= Literal DOT Literal DOT STAR
	| Literal DOT STAR
	| STAR

Column ::= Literal DOT Literal DOT Literal
	| Literal DOT Literal
	| Literal DOT VALUE
	| Literal

Expression ::= AggrValue
	| FuncValue
	| Op
	| Column
	| Star
	| NumValue
	| LogicValue
	| StringValue
	| NullValue
	| ParamValue
	| VarValue
	| ExistsValue
	| CaseValue
	| CastClause
	| VALUE
	| Json
	| ArrayValue
	| NewClause
	| LPAR Select RPAR
	| LPAR Insert RPAR
	| LPAR ( CreateVertex | CreateEdge ) RPAR
	| JavaScript
	| CURRENT_TIMESTAMP

JavaScript ::= JAVASCRIPT

CreateFunction ::= CREATE FUNCTION LITERAL AS JAVASCRIPT

CreateAggregate ::= CREATE AGGREGATE LITERAL AS JAVASCRIPT

NewClause ::= NEW Literal
	| NEW FuncValue

CastClause ::= CAST LPAR Expression AS ColumnType RPAR
	| CAST LPAR Expression AS ColumnType COMMA NUMBER RPAR
	| CONVERT LPAR ColumnType COMMA Expression RPAR
	| CONVERT LPAR ColumnType COMMA Expression COMMA NUMBER RPAR

PrimitiveValue ::= NumValue
	| StringValue
	| LogicValue
	| NullValue
	| ParamValue
	| FuncValue
	| CURRENT_TIMESTAMP

AggrValue ::= Aggregator LPAR ExprList RPAR OverClause
	| Aggregator LPAR DISTINCT Expression RPAR OverClause
	| Aggregator LPAR ALL Expression RPAR OverClause

OverClause ::=
	| OVER LPAR OverPartitionClause RPAR
	| OVER LPAR OverOrderByClause RPAR
	| OVER LPAR OverPartitionClause OverOrderByClause RPAR

OverPartitionClause ::= PARTITION BY GroupExpressionsList

OverOrderByClause ::= ORDER BY OrderExpressionsList

Aggregator ::= SUM
	| COUNT
	| MIN
	| MAX
	| AVG
	| FIRST
	| LAST
	| AGGR
	| ARRAY

FuncValue ::= Literal LPAR ( DISTINCT | ALL ) ? ExprList RPAR
	| Literal LPAR RPAR
	| IF LPAR ExprList RPAR
	| REPLACE LPAR ExprList RPAR
	| DATEADD LPAR Literal COMMA Expression COMMA Expression RPAR
	| DATEADD LPAR STRING COMMA Expression COMMA Expression RPAR
	| DATEDIFF LPAR Literal COMMA Expression COMMA Expression RPAR
	| DATEDIFF LPAR STRING COMMA Expression COMMA Expression RPAR
	| INTERVAL Expression Literal

ExprList ::= Expression
	| ExprList COMMA Expression

NumValue ::= NUMBER

LogicValue ::= TRUE
	| FALSE

StringValue ::= STRING
	| NSTRING

NullValue ::= NULL

VarValue ::= AT Literal

ExistsValue ::= EXISTS LPAR Select RPAR

ArrayValue ::= ARRAYLBRA ExprList RBRA

ParamValue ::= DOLLAR ( Literal | NUMBER )
	| COLON Literal
	| QUESTION
	| BRAQUESTION

CaseValue ::= CASE Expression WhensList ElseClause END
	| CASE WhensList ElseClause END

WhensList ::= WhensList When
	| When

When ::= WHEN Expression THEN Expression

ElseClause ::= ELSE Expression
	|

Op ::= Expression REGEXP Expression
	| Expression TILDA Expression
	| Expression GLOB Expression
	| Expression LIKE Expression
	| Expression LIKE Expression ESCAPE Expression
	| Expression NOT_LIKE Expression
	| Expression NOT_LIKE Expression ESCAPE Expression
	| Expression BARBAR Expression
	| Expression PLUS Expression
	| Expression MINUS Expression
	| Expression STAR Expression
	| Expression SLASH Expression
	| Expression MODULO Expression
	| Expression CARET Expression
	| Expression GTGT Expression
	| Expression LTLT Expression
	| Expression AMPERSAND Expression
	| Expression BAR Expression
	| Expression ArrowDot Literal
	| Expression ArrowDot NumValue
	| Expression ArrowDot LPAR Expression RPAR
	| Expression ArrowDot FuncValue
	| Expression EXCLAMATION Literal
	| Expression EXCLAMATION NumValue
	| Expression EXCLAMATION LPAR Expression RPAR
	| Expression EXCLAMATION FuncValue
	| Expression GT Expression
	| Expression GE Expression
	| Expression LT Expression
	| Expression LE Expression
	| Expression EQ Expression
	| Expression EQEQ Expression
	| Expression EQEQEQ Expression
	| Expression NE Expression
	| Expression NEEQEQ Expression
	| Expression NEEQEQEQ Expression
	| Expression CondOp AllSome LPAR Select RPAR
	| Expression CondOp AllSome LPAR ExprList RPAR
	| Expression AND Expression
	| Expression OR Expression
	| NOT Expression
	| MINUS Expression
	| PLUS Expression
	| TILDA Expression
	| SHARP Expression
	| LPAR Expression RPAR
	| Expression IN LPAR Select RPAR
	| Expression NOT IN LPAR Select RPAR
	| Expression IN LPAR ExprList RPAR
	| Expression NOT IN LPAR ExprList RPAR
	| Expression IN LPAR RPAR
	| Expression NOT IN LPAR RPAR
	| Expression IN ColFunc
	| Expression NOT IN ColFunc
	| Expression IN VarValue
	| Expression NOT IN VarValue
	| Expression BETWEEN Expression
	| Expression NOT_BETWEEN Expression
	| Expression IS Expression
	| Expression NOT NULL
	| Expression DOUBLECOLON ColumnType

ColFunc ::= Column
	| FuncValue
	| AT LPAR Expression RPAR

CondOp ::= GT
	| GE
	| LT
	| LE
	| EQ
	| NE

AllSome ::= ALL
	| SOME
	| ANY

Update ::= UPDATE Table SET SetColumnsList WHERE Expression
	| UPDATE Table SET SetColumnsList

SetColumnsList ::= SetColumn
	| SetColumnsList COMMA SetColumn

SetColumn ::= Column EQ Expression
	| ( AT | DOLLAR ) Literal EQ Expression

Delete ::= DELETE FROM Table WHERE Expression
	| DELETE FROM Table

Insert ::= INSERT Into Table Values ValuesListsList
	| INSERT Into Table ValuesListsList
	| INSERT OR REPLACE Into Table Values ValuesListsList
	| INSERT OR REPLACE Into Table ValuesListsList
	| REPLACE Into Table Values ValuesListsList
	| REPLACE Into Table ValuesListsList
	| INSERT Into Table DEFAULT Values
	| INSERT Into Table LPAR ColumnsList RPAR Values ValuesListsList
	| INSERT Into Table LPAR ColumnsList RPAR ValuesListsList
	| INSERT Into Table Select
	| INSERT OR REPLACE Into Table Select
	| INSERT Into Table LPAR ColumnsList RPAR Select

Values ::= VALUES
	| VALUE

Into ::= /*empty*/
	| INTO

ValuesListsList ::= LPAR ValuesList RPAR
	| Json
	| ParamValue
	| ValuesListsList COMMA LPAR ValuesList RPAR
	| ValuesListsList COMMA Json
	| ValuesListsList COMMA ParamValue

ValuesList ::= Expression
	| ValuesList COMMA Expression

Value ::= NumValue
	| StringValue
	| LogicValue
	| NullValue
	| DateValue
	| ParamValue

ColumnsList ::= Column
	| ColumnsList COMMA Column

CreateTable ::= CREATE TemporaryClause TableClass IfNotExists Table LPAR CreateTableDefClause RPAR CreateTableOptionsClause
	| CREATE TemporaryClause TableClass IfNotExists Table

TableClass ::= TABLE
	| CLASS

CreateTableOptionsClause ::= /*empty*/
	| CreateTableOptions

CreateTableOptions ::= CreateTableOptions CreateTableOption
	| CreateTableOption

CreateTableOption ::= DEFAULT
	| LITERAL EQ Literal
	| IDENTITY EQ NumValue
	| COLLATE EQ Literal

TemporaryClause ::=
	| TEMP

IfNotExists ::=
	| IF NOT EXISTS

CreateTableDefClause ::= ColumnDefsList COMMA ConstraintsList
	| ColumnDefsList
	| AS Select

ConstraintsList ::= Constraint
	| ConstraintsList COMMA Constraint

Constraint ::= ConstraintName PrimaryKey
	| ConstraintName ForeignKey
	| ConstraintName UniqueKey
	| ConstraintName IndexKey
	| ConstraintName Check

ConstraintName ::=
	| CONSTRAINT Literal

Check ::= CHECK LPAR Expression RPAR

PrimaryKey ::= PRIMARY KEY Literal ? LPAR ColsList RPAR

ForeignKey ::= FOREIGN KEY LPAR ColsList RPAR REFERENCES Table ParColsList ? OnForeignKeyClause

ParColsList ::= LPAR ColsList RPAR

OnForeignKeyClause ::=
	| OnDeleteClause OnUpdateClause

OnDeleteClause ::= ON DELETE NO ACTION

OnUpdateClause ::= ON UPDATE NO ACTION

UniqueKey ::= UNIQUE KEY ? Literal ? LPAR ColumnsList RPAR

IndexKey ::= INDEX Literal LPAR ColumnsList RPAR
	| KEY Literal LPAR ColumnsList RPAR

ColsList ::= Literal
	| STRING
	| ColsList COMMA Literal
	| ColsList COMMA STRING

ColumnDefsList ::= ColumnDef
	| ColumnDefsList COMMA ColumnDef

ColumnDef ::= Literal ColumnType ColumnConstraintsClause
	| Literal ColumnConstraints
	| Literal

SingularColumnType ::= LiteralWithSpaces LPAR NumberMax COMMA NUMBER RPAR
	| LiteralWithSpaces LPAR NumberMax RPAR
	| LiteralWithSpaces
	| ENUM LPAR ValuesList RPAR

ColumnType ::= SingularColumnType BRALITERAL
	| SingularColumnType

NumberMax ::= NUMBER
	| MAXNUM

ColumnConstraintsClause ::=
	| ColumnConstraintsList

ColumnConstraintsList ::= ColumnConstraintsList ColumnConstraint
	| ColumnConstraint

ParLiteral ::= LPAR Literal RPAR

ColumnConstraint ::= PRIMARY KEY
	| FOREIGN KEY REFERENCES Table ParLiteral ?
	| REFERENCES Table ParLiteral ?
	| IDENTITY LPAR NumValue COMMA NumValue RPAR
	| IDENTITY
	| DEFAULT PrimitiveValue
	| DEFAULT LPAR Expression RPAR
	| DEFAULT FuncValue
	| NULL
	| NOT NULL
	| Check
	| UNIQUE
	| ON UPDATE PrimitiveValue
	| ON UPDATE LPAR Expression RPAR

DropTable ::= DROP ( TABLE | CLASS ) IfExists TablesList

TablesList ::= TablesList COMMA Table
	| Table

IfExists ::=
	| IF EXISTS

AlterTable ::= ALTER TABLE Table RENAME TO Literal
	| ALTER TABLE Table ADD COLUMN ColumnDef
	| ALTER TABLE Table MODIFY COLUMN ColumnDef
	| ALTER TABLE Table RENAME COLUMN Literal TO Literal
	| ALTER TABLE Table DROP COLUMN Literal

RenameTable ::= RENAME TABLE Table TO Literal

AttachDatabase ::= ATTACH Literal DATABASE Literal
	| ATTACH Literal DATABASE Literal LPAR ExprList RPAR
	| ATTACH Literal DATABASE Literal AS Literal
	| ATTACH Literal DATABASE Literal LPAR ExprList RPAR AS Literal

DetachDatabase ::= DETACH DATABASE Literal

CreateDatabase ::= CREATE DATABASE IfNotExists Literal
	| CREATE Literal DATABASE IfNotExists Literal AsClause
	| CREATE Literal DATABASE IfNotExists Literal LPAR ExprList RPAR AsClause
	| CREATE Literal DATABASE IfNotExists StringValue AsClause

AsClause ::=
	| AS Literal

UseDatabase ::= USE DATABASE Literal
	| USE Literal

DropDatabase ::= DROP DATABASE IfExists Literal
	| DROP Literal DATABASE IfExists Literal
	| DROP Literal DATABASE IfExists StringValue

CreateIndex ::= CREATE INDEX Literal ON Table LPAR OrderExpressionsList RPAR
	| CREATE UNIQUE INDEX Literal ON Table LPAR OrderExpressionsList RPAR

DropIndex ::= DROP INDEX Literal

ShowDatabases ::= SHOW DATABASE
	| SHOW DATABASE LIKE StringValue
	| SHOW Literal DATABASE
	| SHOW Literal DATABASE LIKE StringValue

ShowTables ::= SHOW TABLE
	| SHOW TABLE LIKE StringValue
	| SHOW TABLE FROM Literal
	| SHOW TABLE FROM Literal LIKE StringValue

ShowColumns ::= SHOW COLUMN FROM Table
	| SHOW COLUMN FROM Table FROM Literal

ShowIndex ::= SHOW INDEX FROM Table
	| SHOW INDEX FROM Table FROM Literal

ShowCreateTable ::= SHOW CREATE TABLE Table
	| SHOW CREATE TABLE Table FROM Literal

CreateView ::= CREATE TemporaryClause VIEW IfNotExists Table LPAR ColumnsList RPAR AS Select SubqueryRestriction ?
	| CREATE TemporaryClause VIEW IfNotExists Table AS Select SubqueryRestriction ?

SubqueryRestriction ::= WITH READ ONLY
	| WITH CHECK OPTION
	| WITH CHECK OPTION CONSTRAINT Constraint

DropView ::= DROP VIEW IfExists TablesList

ExpressionStatement ::= EQ Expression

Source ::= SOURCE StringValue

Assert ::= ASSERT Json
	| ASSERT PrimitiveValue
	| ASSERT STRING COMMA Json

Json ::= AT LPAR Expression RPAR
	| AT StringValue
	| AT NumValue
	| AT LogicValue
	| AT ParamValue
	| JsonObject
	| AT JsonObject
	| ATLBRA JsonArray

JsonValue ::= Json
	| JsonPrimitiveValue

JsonPrimitiveValue ::= NumValue
	| StringValue
	| LogicValue
	| Column
	| NullValue
	| ParamValue
	| FuncValue
	| LPAR Expression RPAR

JsonObject ::= LCUR JsonPropertiesList RCUR
	| LCUR JsonPropertiesList COMMA RCUR
	| LCUR RCUR

JsonArray ::= JsonElementsList RBRA
	| JsonElementsList COMMA RBRA
	| RBRA

JsonPropertiesList ::= JsonPropertiesList COMMA JsonProperty
	| JsonProperty

JsonProperty ::= STRING COLON JsonValue
	| NUMBER COLON JsonValue
	| Literal COLON JsonValue

JsonElementsList ::= JsonElementsList COMMA JsonValue
	| JsonValue

SetVariable ::= SET Literal EQ OnOff
	| SET Literal OnOff
	| SET Literal EQ Expression
	| SET Literal SetPropsList EQ Expression
	| SET AtDollar Literal EQ Expression
	| SET AtDollar Literal SetPropsList EQ Expression

AtDollar ::= AT
	| DOLLAR

SetPropsList ::= SetPropsList ArrowDot SetProp
	| ArrowDot SetProp

SetProp ::= Literal
	| NUMBER
	| LPAR Expression RPAR

OnOff ::= ON
	| OFF

CommitTransaction ::= COMMIT TRANSACTION

RollbackTransaction ::= ROLLBACK TRANSACTION

BeginTransaction ::= BEGIN TRANSACTION

If ::= IF Expression AStatement ElseStatement
	| IF Expression AStatement

ElseStatement ::= ELSE AStatement

While ::= WHILE Expression AStatement

Continue ::= CONTINUE

Break ::= BREAK

BeginEnd ::= BEGIN Statements END

Print ::= PRINT ExprList
	| PRINT Select

Require ::= REQUIRE StringValuesList
	| REQUIRE PluginsList

Plugin ::= ECHO
	| Literal

Echo ::= ECHO Expression

StringValuesList ::= StringValuesList COMMA StringValue
	| StringValue

PluginsList ::= PluginsList COMMA Plugin
	| Plugin

Declare ::= DECLARE DeclaresList

DeclaresList ::= DeclareItem
	| DeclaresList COMMA DeclareItem

DeclareItem ::= AT Literal ColumnType
	| AT Literal AS ColumnType
	| AT Literal ColumnType EQ Expression
	| AT Literal AS ColumnType EQ Expression

TruncateTable ::= TRUNCATE TABLE Table

Merge ::= MERGE MergeInto MergeUsing MergeOn MergeMatchedList OutputClause

MergeInto ::= FromTable
	| INTO FromTable

MergeUsing ::= USING FromTable

MergeOn ::= ON Expression

MergeMatchedList ::= MergeMatchedList MergeMatched
	| MergeMatchedList MergeNotMatched
	| MergeMatched
	| MergeNotMatched

MergeMatched ::= WHEN MATCHED THEN MergeMatchedAction
	| WHEN MATCHED AND Expression THEN MergeMatchedAction

MergeMatchedAction ::= DELETE
	| UPDATE SET SetColumnsList

MergeNotMatched ::= WHEN NOT MATCHED THEN MergeNotMatchedAction
	| WHEN NOT MATCHED BY TARGET THEN MergeNotMatchedAction
	| WHEN NOT MATCHED AND Expression THEN MergeNotMatchedAction
	| WHEN NOT MATCHED BY TARGET AND Expression THEN MergeNotMatchedAction
	| WHEN NOT MATCHED BY SOURCE THEN MergeNotMatchedAction
	| WHEN NOT MATCHED BY SOURCE AND Expression THEN MergeMatchedAction

MergeNotMatchedAction ::= INSERT VALUES ValuesListsList
	| INSERT LPAR ColumnsList RPAR VALUES ValuesListsList
	| INSERT DEFAULT VALUES
	| INSERT LPAR ColumnsList RPAR DEFAULT VALUES

OutputClause ::= /*empty*/
	| OUTPUT ResultColumns
	| OUTPUT ResultColumns INTO AtDollar Literal
	| OUTPUT ResultColumns INTO Table
	| OUTPUT ResultColumns INTO Table LPAR ColumnsList RPAR

CreateVertex ::= CREATE VERTEX Literal ? SharpValue ? StringValue ? CreateVertexSet

SharpValue ::= SHARP Literal

CreateVertexSet ::=
	| SET SetColumnsList
	| CONTENT ExprList
	| Select

CreateEdge ::= CREATE EDGE StringValue ? FROM Expression TO Expression CreateVertexSet

CreateGraph ::= CREATE GRAPH GraphList
	| CREATE GRAPH FROM Expression

GraphList ::= GraphList COMMA GraphVertexEdge
	| GraphVertexEdge

GraphVertexEdge ::= GraphElement Json ? GraphAsClause ?
	| GraphElementVar GT GraphElement Json ? GraphAsClause ? GT GraphElementVar
	| GraphElementVar GT Json GraphAsClause ? GT GraphElementVar
	| GraphElementVar GTGT GraphElementVar
	| Literal LPAR GraphList RPAR

GraphElementVar ::= GraphElement
	| GraphVar

GraphVar ::= AtDollar Literal

GraphAsClause ::= AS AtDollar Literal

GraphAtClause ::= AtDollar Literal

GraphElement2 ::= Literal ? SharpLiteral ? STRING ? ColonLiteral ?

GraphElement ::= Literal SharpLiteral ? STRING ? ColonLiteral ?
	| SharpLiteral STRING ? ColonLiteral ?
	| STRING ColonLiteral ?
	| ColonLiteral

ColonLiteral ::= COLON Literal

SharpLiteral ::= SHARP Literal
	| SHARP NUMBER

DeleteVertex ::= DELETE VERTEX Expression ( WHERE Expression ) ?

DeleteEdge ::= DELETE EDGE Expression ( FROM Expression ) ? ( TO Expression ) ? ( WHERE Expression ) ?

AddRule ::= Term COLONDASH TermsList
	| COLONDASH TermsList

TermsList ::= TermsList COMMA Term
	| Term

Term ::= Literal
	| Literal LPAR TermsList RPAR

Query ::= QUESTIONDASH FuncValue

Call ::= CALL FuncValue

CreateTrigger ::= CREATE TRIGGER Literal BeforeAfter InsertDeleteUpdate ON Table AS ? AStatement
	| CREATE TRIGGER Literal BeforeAfter InsertDeleteUpdate ON Table Literal
	| CREATE TRIGGER Literal ON Table BeforeAfter InsertDeleteUpdate AS ? AStatement

BeforeAfter ::=
	| FOR
	| BEFORE
	| AFTER
	| INSTEAD OF

InsertDeleteUpdate ::= INSERT
	| DELETE
	| UPDATE

DropTrigger ::= DROP TRIGGER Literal

Reindex ::= REINDEX Literal

NonReserved ::= A
	| ABSENT
	| ABSOLUTE
	| ACCORDING
	| ACTION
	| ADA
	| ADD
	| ADMIN
	| AFTER
	| ALWAYS
	| ASC
	| ASSERTION
	| ASSIGNMENT
	| ATTRIBUTE
	| ATTRIBUTES
	| BASE64
	| BEFORE
	| BERNOULLI
	| BLOCKED
	| BOM
	| BREADTH
	| C
	| CASCADE
	| CATALOG
	| CATALOG_NAME
	| CHAIN
	| CHARACTERISTICS
	| CHARACTERS
	| CHARACTER_SET_CATALOG
	| CHARACTER_SET_NAME
	| CHARACTER_SET_SCHEMA
	| CLASS_ORIGIN
	| COBOL
	| COLLATION
	| COLLATION_CATALOG
	| COLLATION_NAME
	| COLLATION_SCHEMA
	| COLUMNS
	| COLUMN_NAME
	| COMMAND_FUNCTION
	| COMMAND_FUNCTION_CODE
	| COMMITTED
	| CONDITION_NUMBER
	| CONNECTION
	| CONNECTION_NAME
	| CONSTRAINTS
	| CONSTRAINT_CATALOG
	| CONSTRAINT_NAME
	| CONSTRAINT_SCHEMA
	| CONSTRUCTOR
	| CONTENT
	| CONTINUE
	| CONTROL
	| CURSOR_NAME
	| DATA
	| DATETIME_INTERVAL_CODE
	| DATETIME_INTERVAL_PRECISION
	| DB
	| DEFAULTS
	| DEFERRABLE
	| DEFERRED
	| DEFINED
	| DEFINER
	| DEGREE
	| DEPTH
	| DERIVED
	| DESC
	| DESCRIPTOR
	| DIAGNOSTICS
	| DISPATCH
	| DOCUMENT
	| DOMAIN
	| DYNAMIC_FUNCTION
	| DYNAMIC_FUNCTION_CODE
	| EMPTY
	| ENCODING
	| ENFORCED
	| EXCLUDE
	| EXCLUDING
	| EXPRESSION
	| FILE
	| FINAL
	| FIRST
	| FLAG
	| FOLLOWING
	| FORTRAN
	| FOUND
	| FS
	| G
	| GENERAL
	| GENERATED
	| GO
	| GOTO
	| GRANTED
	| HEX
	| HIERARCHY
	| ID
	| IGNORE
	| IMMEDIATE
	| IMMEDIATELY
	| IMPLEMENTATION
	| INCLUDING
	| INCREMENT
	| INDENT
	| INITIALLY
	| INPUT
	| INSTANCE
	| INSTANTIABLE
	| INSTEAD
	| INTEGRITY
	| INVOKER
	| ISOLATION
	| K
	| KEY
	| KEY_MEMBER
	| KEY_TYPE
	| LAST
	| LENGTH
	| LEVEL
	| LIBRARY
	| LIMIT
	| LINK
	| LOCATION
	| LOCATOR
	| M
	| MAP
	| MAPPING
	| MATCHED
	| MAXVALUE
	| MESSAGE_LENGTH
	| MESSAGE_OCTET_LENGTH
	| MESSAGE_TEXT
	| MINVALUE
	| MORE
	| MUMPS
	| NAME
	| NAMES
	| NAMESPACE
	| NESTING
	| NEXT
	| NFC
	| NFD
	| NFKC
	| NFKD
	| NIL
	| NORMALIZED
	| NULLABLE
	| NULLS
	| NUMBER
	| OBJECT
	| OCTETS
	| OFF
	| OPTION
	| OPTIONS
	| ORDERING
	| ORDINALITY
	| OTHERS
	| OUTPUT
	| OVERRIDING
	| P
	| PAD
	| PARAMETER_MODE
	| PARAMETER_NAME
	| PARAMETER_ORDINAL_POSITION
	| PARAMETER_SPECIFIC_CATALOG
	| PARAMETER_SPECIFIC_NAME
	| PARAMETER_SPECIFIC_SCHEMA
	| PARTIAL
	| PASCAL
	| PASSING
	| PASSTHROUGH
	| PATH
	| PERMISSION
	| PLACING
	| PLI
	| PRECEDING
	| PRESERVE
	| PRIOR
	| PRIVILEGES
	| PUBLIC
	| READ
	| RECOVERY
	| RELATIVE
	| REPEATABLE
	| REQUIRING
	| RESPECT
	| RESTART
	| RESTORE
	| RESTRICT
	| RETURNED_CARDINALITY
	| RETURNED_LENGTH
	| RETURNED_OCTET_LENGTH
	| RETURNED_SQLSTATE
	| RETURNING
	| ROLE
	| ROUTINE
	| ROUTINE_CATALOG
	| ROUTINE_NAME
	| ROUTINE_SCHEMA
	| ROW_COUNT
	| SCALE
	| SCHEMA
	| SCHEMA_NAME
	| SCOPE_CATALOG
	| SCOPE_NAME
	| SCOPE_SCHEMA
	| SECTION
	| SECURITY
	| SELECTIVE
	| SELF
	| SEQUENCE
	| SERIALIZABLE
	| SERVER
	| SERVER_NAME
	| SESSION
	| SETS
	| SIMPLE
	| SIZE
	| SOURCE
	| SPACE
	| SPECIFIC_NAME
	| STANDALONE
	| STATE
	| STATEMENT
	| STRIP
	| STRUCTURE
	| STYLE
	| SUBCLASS_ORIGIN
	| T
	| TABLE_NAME
	| TEMPORARY
	| TIES
	| TOKEN
	| TOP_LEVEL_COUNT
	| TRANSACTION
	| TRANSACTIONS_COMMITTED
	| TRANSACTIONS_ROLLED_BACK
	| TRANSACTION_ACTIVE
	| TRANSFORM
	| TRANSFORMS
	| TRIGGER_CATALOG
	| TRIGGER_NAME
	| TRIGGER_SCHEMA
	| TYPE
	| UNBOUNDED
	| UNCOMMITTED
	| UNDER
	| UNLINK
	| UNNAMED
	| UNTYPED
	| URI
	| USAGE
	| USER_DEFINED_TYPE_CATALOG
	| USER_DEFINED_TYPE_CODE
	| USER_DEFINED_TYPE_NAME
	| USER_DEFINED_TYPE_SCHEMA
	| VALID
	| VERSION
	| VIEW
	| WHITESPACE
	| WORK
	| WRAPPER
	| WRITE
	| XMLDECLARATION
	| XMLSCHEMA
	| YES
	| ZONE

// Tokens

/*
VALUE\s+OF\s+SEARCH                          	yytext = 'VALUE';return 'SEARCH'
VALUE\s+OF\s+SELECT                          	yytext = 'VALUE';return 'SELECT'
ROW\s+OF\s+SELECT                           	yytext = 'ROW';return 'SELECT'
COLUMN\s+OF\s+SELECT                          	yytext = 'COLUMN';return 'SELECT'
MATRIX\s+OF\s+SELECT                          	yytext = 'MATRIX';return 'SELECT'
INDEX\s+OF\s+SELECT                           	yytext = 'INDEX';return 'SELECT'
RECORDSET\s+OF\s+SELECT                       	yytext = 'RECORDSET';return 'SELECT'
TEXT\s+OF\s+SELECT                           	yytext = 'TEXT';return 'SELECT'
*/

SELECT ::= "SELECT"

ABSOLUTE ::= "ABSOLUTE"
ACTION ::= "ACTION"
ADD ::= "ADD"
AFTER ::= "AFTER"
AGGR ::= "AGGR"
AGGREGATE ::= "AGGREGATE"
AGGREGATE ::= "AGGREGATOR"
ALL ::= "ALL"
ALTER ::= "ALTER"
AND ::= "AND"
ANTI ::= "ANTI"
ANY ::= "ANY"
APPLY ::= "APPLY"
ARRAY ::= "ARRAY"
AS ::= "AS"
ASSERT ::= "ASSERT"
DIRECTION ::= "ASC"
ATTACH ::= "ATTACH"
//AUTO(_)?INCREMENT                               return 'IDENTITY'
AVG ::= "AVG"

BEFORE ::= "BEFORE"
BEGIN ::= "BEGIN"
BETWEEN ::= "BETWEEN"
BREAK ::= "BREAK"
/*
NOT\s+BETWEEN									return 'NOT_BETWEEN'
NOT\s+LIKE									    return 'NOT_LIKE'
*/
BY ::= "BY"

/* Postgres aliases */
/*
'~~*'											return 'LIKE'
'!~~*'											return 'NOT_LIKE'
'~~'											return 'LIKE'
'!~~'											return 'NOT_LIKE'
'ILIKE'											return 'LIKE'
NOT\s+ILIKE										return 'NOT_LIKE'
*/

CALL ::= "CALL"
CASE ::= "CASE"
CAST ::= "CAST"
CHECK ::= "CHECK"
CLASS ::= "CLASS"
CLOSE ::= "CLOSE"
COLLATE ::= "COLLATE"
/*
COLUMN											return 'COLUMN'
COLUMNS 										return 'COLUMN'
"COMMIT"										return 'COMMIT'
"CONSTRAINT"									return 'CONSTRAINT'
"CONTENT"										return 'CONTENT'
"CONTINUE"										return 'CONTINUE'
"CONVERT"										return 'CONVERT'
"CORRESPONDING"									return 'CORRESPONDING'
"COUNT"											return 'COUNT'
*/
CREATE ::= "CREATE"
CROSS ::= "CROSS"
CUBE ::= "CUBE"
CURRENT_TIMESTAMP ::= "CURRENT_TIMESTAMP"
CURSOR ::= "CURSOR"
//DATABASE(S)?									return 'DATABASE'
DATEADD ::= "DATEADD"
DATEDIFF ::= "DATEDIFF"
DECLARE ::= "DECLARE"
DEFAULT ::= "DEFAULT"
DELETE ::= "DELETE"
DELETED ::= "DELETED"
DIRECTION ::= "DESC"
DETACH ::= "DETACH"
DISTINCT ::= "DISTINCT"
/* DOUBLE\s+PRECISION								return 'LITERAL' */
DROP ::= "DROP"
ECHO ::= "ECHO"
EDGE ::= "EDGE"
END ::= "END"
ENUM ::= "ENUM"
ELSE ::= "ELSE"
ESCAPE ::= "ESCAPE"
EXCEPT ::= "EXCEPT"
CALL ::= "EXEC"
CALL ::= "EXECUTE"
EXISTS ::= "EXISTS"
EXPLAIN ::= "EXPLAIN"
FALSE ::= "FALSE"
FETCH ::= "FETCH"
FIRST ::= "FIRST"
FOR ::= "FOR"
FOREIGN ::= "FOREIGN"
FROM ::= "FROM"
FULL ::= "FULL"
FUNCTION ::= "FUNCTION"
GLOB ::= "GLOB"
GO ::= "GO"
GRAPH ::= "GRAPH"
GROUP ::= "GROUP"
GROUPING ::= "GROUPING"
HAVING ::= "HAVING"
/*'HELP'											return 'HELP'*/
IF ::= "IF"
IDENTITY ::= "IDENTITY"
IS ::= "IS"
IN ::= "IN"
INDEX ::= "INDEX"
INDEXED ::= "INDEXED"
INNER ::= "INNER"
INSTEAD ::= "INSTEAD"
INSERT ::= "INSERT"
INSERTED ::= "INSERTED"
INTERSECT ::= "INTERSECT"
INTERVAL ::= "INTERVAL"
INTO ::= "INTO"
JOIN ::= "JOIN"
KEY ::= "KEY"
LAST ::= "LAST"
LET ::= "LET"
LEFT ::= "LEFT"
LIKE ::= "LIKE"
LIMIT ::= "LIMIT"
MATCHED ::= "MATCHED"
MATRIX ::= "MATRIX"

/*"MAX"											return 'MAX'*/
/*"MIN"											return 'MIN'*/
/*
'MAX'(\s+)?/'('									return 'MAX'
'MAX'(\s+)?/(','|')')							return 'MAXNUM'
'MIN'(\s+)?/'('									return 'MIN'
*/
MERGE ::= "MERGE"
EXCEPT ::= "MINUS"
MODIFY ::= "MODIFY"
NATURAL ::= "NATURAL"
NEXT ::= "NEXT"
NEW ::= "NEW"
NOCASE ::= "NOCASE"
NO ::= "NO"
NOT ::= "NOT"
NULL ::= "NULL"
NULLS ::= "NULLS"
OFF ::= "OFF"
ON ::= "ON"
ONLY ::= "ONLY"
OF ::= "OF"
OFFSET ::= "OFFSET"
OPEN ::= "OPEN"
OPTION ::= "OPTION"
OR ::= "OR"
ORDER ::= "ORDER"
OUTER ::= "OUTER"
OVER ::= "OVER"
PATH ::= "PATH"
PARTITION ::= "PARTITION"
PERCENT ::= "PERCENT"
PIVOT ::= "PIVOT"
PLAN ::= "PLAN"
PRIMARY ::= "PRIMARY"
PRINT ::= "PRINT"
PRIOR ::= "PRIOR"
QUERY ::= "QUERY"
READ ::= "READ"
RECORDSET ::= "RECORDSET"
REDUCE ::= "REDUCE"
REFERENCES ::= "REFERENCES"
REGEXP ::= "REGEXP"
REINDEX ::= "REINDEX"
RELATIVE ::= "RELATIVE"
REMOVE ::= "REMOVE"
RENAME ::= "RENAME"
REPEAT ::= "REPEAT"
REPLACE ::= "REPLACE"
REQUIRE ::= "REQUIRE"
RESTORE ::= "RESTORE"
RETURN ::= "RETURN"
RETURN ::= "RETURNS"
RIGHT ::= "RIGHT"
ROLLBACK ::= "ROLLBACK"
ROLLUP ::= "ROLLUP"
ROW ::= "ROW"
ROWS ::= "ROWS"
//SCHEMA(S)?                                      return 'DATABASE'
SEARCH ::= "SEARCH"

SEMI ::= "SEMI"
SET 	                                       	return 'SET'
SETS                                        	return 'SET'
SHOW ::= "SHOW"
SOME ::= "SOME"
SOURCE ::= "SOURCE"
STRATEGY ::= "STRATEGY"
STORE ::= "STORE"
SUM ::= "SUM"
TABLE ::= "TABLE"
TABLE ::= "TABLES"
TARGET ::= "TARGET"
TEMP ::= "TEMP"
TEMP ::= "TEMPORARY"
TEXTSTRING ::= "TEXTSTRING"
THEN ::= "THEN"
TIMEOUT ::= "TIMEOUT"
TO ::= "TO"
TOP ::= "TOP"
TRANSACTION ::= "TRAN"
TRANSACTION ::= "TRANSACTION"
TRIGGER ::= "TRIGGER"
TRUE ::= "TRUE"
TRUNCATE ::= "TRUNCATE"
UNION ::= "UNION"
UNIQUE ::= "UNIQUE"
UNPIVOT ::= "UNPIVOT"
UPDATE ::= "UPDATE"
USE ::= "USE"
/* USER ::= "USER" */
USING ::= "USING"
VALUE ::= "VALUE"
VALUES ::= "VALUES"
VERTEX ::= "VERTEX"
VIEW ::= "VIEW"
WHEN ::= "WHEN"
WHERE ::= "WHERE"
WHILE ::= "WHILE"
WITH ::= "WITH"
TRANSACTION ::= "WORK"  /* Is this keyword required? */


ARROW ::= "->"
SHARP ::= "#"
PLUS ::= "+"
MINUS ::= "-"
STAR ::= "*"
SLASH ::= "/"
MODULO ::= "%"
NEEQEQEQ ::= "!==="
EQEQEQ ::= "==="
NEEQEQ ::= "!=="
EQEQ ::= "=="
GE ::= ">="
AMPERSAND ::= "&"
BAR ::= "|"
LTLT ::= "<<"
GTGT ::= ">>"
GT ::= ">"
LE ::= "<="
NE ::= "<>"
LT ::= "<"
EQ ::= "="
NE ::= "!="
LPAR ::= "("
RPAR ::= ")"
AT ::= "@"
LCUR ::= "{"
RCUR ::= "}"

RBRA ::= "]"

COLONDASH ::= ":-"
QUESTIONDASH ::= "?-"
DOTDOT ::= ".."
DOT ::= "."
COMMA ::= ","
DOUBLECOLON ::= "::"
COLON ::= ":"
SEMICOLON ::= ";"
DOLLAR ::= "$"
QUESTION ::= "?"
EXCLAMATION ::= "!"
CARET ::= "^"

TILDA ::= "~"
@mingodad
Copy link
Author

Also it seems that there is an error in https://github.com/agershun/alasql/blob/develop/src/websql/sqliteparser.jison:

@@ -222,11 +222,11 @@ X(['](\\.|[^']|\\\')*?['])+                     return 'XSTRING'
 %right NOT
 %left IS MATCH LIKE IN ISNULL NOTNULL NE EQ
 %left ESCAPE
 %left GT LE LT GE
 %left BITAND BITOR LSHIFT RSHIFT
-$left PLUS MINUS
+%left PLUS MINUS
 %left STAR SLASH REM
 %left CONCAT
 %left COLLATE
 %right BITNOT 

@mathiasrw
Copy link
Member

That would be really really interesting to see.

You are more than welcome to see if you can sort out the errors. They have been there since 2014 and we dont know how to solve it. I am actually surprised that it can build when I look at how many errors Jison is spitting out when we run it.

Any inputs are more than welcome.

@mathiasrw
Copy link
Member

Any news on this?

@mingodad
Copy link
Author

I've been looking at https://cgsql.dev/ they have a good grammar and probably compile it to webassemby would be a killer.

@mathiasrw
Copy link
Member

@mingodad Any progress on this?

@mingodad
Copy link
Author

I have done a wasm build of CGSQL with Lua and a preprocessor here https://github.com/mingodad/CG-SQL-Lua-playground and here (https://github.com/mingodad/CG-SQL-Lua-playground) is the online playground with examples .

I'm also trying a different parser with online playground here https://meimporta.eu/lalr-playground/ and here is the repository for it https://github.com/mingodad/lalr/tree/playground .

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

No branches or pull requests

2 participants