#!/usr/bin/env python
"""
PyBison file automatically generated from grammar file sql1.y
You can edit this module, or import it and subclass the Parser class
"""
import sys
from bison import BisonParser, BisonNode, BisonError
bisonFile = "sql1.y" # original bison file
lexFile = "scn1.l" # original flex file
class Parser(BisonParser):
"""
bison Parser class generated automatically by bison2py from the
grammar file "sql1.y" and lex file "scn1.l"
You may (and probably should) edit the methods in this class.
You can freely edit the rules (in the method docstrings), the
tokens list, the start symbol, and the precedences.
Each time this class is instantiated, a hashing technique in the
base class detects if you have altered any of the rules. If any
changes are detected, a new dynamic lib for the parser engine
will be generated automatically.
"""
# -------------------------------------------------
# Default class to use for creating new parse nodes
# -------------------------------------------------
defaultNodeClass = BisonNode
# --------------------------------------------
# basename of binary parser engine dynamic lib
# --------------------------------------------
bisonEngineLibName = "libsqlparse-engine"
# ----------------------------------------------------------------
# lexer tokens - these must match those in your lex script (below)
# ----------------------------------------------------------------
tokens = ['NAME', 'STRING', 'INTNUM', 'APPROXNUM', 'ALL', 'AMMSC', 'ANY', 'AS', 'ASC', 'AUTHORIZATION', 'BETWEEN', 'BY', 'CHARACTER', 'CHECK', 'CLOSE', 'COMMIT', 'CONTINUE', 'CREATE', 'CURRENT', 'CURSOR', 'DECIMAL', 'DECLARE', 'DEFAULT', 'DELETE', 'DESC', 'DISTINCT', 'DOUBLE', 'ESCAPE', 'EXISTS', 'FETCH', 'FLOAT', 'FOR', 'FOREIGN', 'FOUND', 'FROM', 'GOTO', 'GRANT', 'GROUP', 'HAVING', 'IN', 'INDICATOR', 'INSERT', 'INTEGER', 'INTO', 'IS', 'KEY', 'LANGUAGE', 'LIKE', 'MODULE', 'NULLX', 'NUMERIC', 'OF', 'ON', 'OPEN', 'OPTION', 'ORDER', 'PRECISION', 'PRIMARY', 'PRIVILEGES', 'PROCEDURE', 'PUBLIC', 'REAL', 'REFERENCES', 'ROLLBACK', 'SCHEMA', 'SELECT', 'SET', 'SMALLINT', 'SOME', 'SQLCODE', 'SQLERROR', 'TABLE', 'TO', 'UNION', 'UNIQUE', 'UPDATE', 'USER', 'VALUES', 'VIEW', 'WHENEVER', 'WHERE', 'WITH', 'WORK', 'COBOL', 'FORTRAN', 'PASCAL', 'PLI', 'C', 'ADA', 'PLUS', 'MINUS', 'TIMES', 'DIV', 'UMINUS', 'OR', 'AND', 'NOT', 'RPAREN', 'LPAREN', 'COMMA', 'PERIOD', 'SEMICOLON', 'COLON', 'ASSIGN_OP']
# ------------------------------
# precedences
# ------------------------------
precedences = (
("left", ['OR'],),
("left", ['AND'],),
("left", ['NOT'],),
("left", ['COMPARISON'],),
("left", ['PLUS', 'MINUS'],),
("left", ['TIMES', 'DIV'],),
("nonassoc", ['UMINUS'],),
)
# ---------------------------------------------------------------
# Declare the start target here (by name)
# ---------------------------------------------------------------
start = "sql_list"
# ---------------------------------------------------------------
# These methods are the python handlers for the bison targets.
# (which get called by the bison code each time the corresponding
# parse target is unambiguously reached)
#
# WARNING - don't touch the method docstrings unless you know what
# you are doing - they are in bison rule syntax, and are passed
# verbatim to bison to build the parser engine library.
# ---------------------------------------------------------------
def on_sql_list(self, target, option, names, values):
"""
sql_list
: sql SEMICOLON
| sql_list sql SEMICOLON
"""
return self.defaultNodeClass(
target="sql_list",
option=option,
names=names,
values=values)
def on_sql(self, target, option, names, values):
"""
sql
: schema
| module_def
| manipulative_statement
| WHENEVER NOT FOUND when_action
| WHENEVER SQLERROR when_action
"""
return self.defaultNodeClass(
target="sql",
option=option,
names=names,
values=values)
def on_schema(self, target, option, names, values):
"""
schema
: CREATE SCHEMA AUTHORIZATION user opt_schema_element_list
"""
return self.defaultNodeClass(
target="schema",
option=option,
names=names,
values=values)
def on_opt_schema_element_list(self, target, option, names, values):
"""
opt_schema_element_list
: | schema_element_list
"""
return self.defaultNodeClass(
target="opt_schema_element_list",
option=option,
names=names,
values=values)
def on_schema_element_list(self, target, option, names, values):
"""
schema_element_list
: schema_element
| schema_element_list schema_element
"""
return self.defaultNodeClass(
target="schema_element_list",
option=option,
names=names,
values=values)
def on_schema_element(self, target, option, names, values):
"""
schema_element
: base_table_def
| view_def
| privilege_def
"""
return self.defaultNodeClass(
target="schema_element",
option=option,
names=names,
values=values)
def on_base_table_def(self, target, option, names, values):
"""
base_table_def
: CREATE TABLE table LPAREN base_table_element_commalist RPAREN
"""
return self.defaultNodeClass(
target="base_table_def",
option=option,
names=names,
values=values)
def on_base_table_element_commalist(self, target, option, names, values):
"""
base_table_element_commalist
: base_table_element
| base_table_element_commalist COMMA base_table_element
"""
return self.defaultNodeClass(
target="base_table_element_commalist",
option=option,
names=names,
values=values)
def on_base_table_element(self, target, option, names, values):
"""
base_table_element
: column_def
| table_constraint_def
"""
return self.defaultNodeClass(
target="base_table_element",
option=option,
names=names,
values=values)
def on_column_def(self, target, option, names, values):
"""
column_def
: column data_type column_def_opt_list
"""
return self.defaultNodeClass(
target="column_def",
option=option,
names=names,
values=values)
def on_column_def_opt_list(self, target, option, names, values):
"""
column_def_opt_list
: | column_def_opt_list column_def_opt
"""
return self.defaultNodeClass(
target="column_def_opt_list",
option=option,
names=names,
values=values)
def on_column_def_opt(self, target, option, names, values):
"""
column_def_opt
: NOT NULLX
| NOT NULLX UNIQUE
| NOT NULLX PRIMARY KEY
| DEFAULT literal
| DEFAULT NULLX
| DEFAULT USER
| CHECK LPAREN search_condition RPAREN
| REFERENCES table
| REFERENCES table LPAREN column_commalist RPAREN
"""
return self.defaultNodeClass(
target="column_def_opt",
option=option,
names=names,
values=values)
def on_table_constraint_def(self, target, option, names, values):
"""
table_constraint_def
: UNIQUE LPAREN column_commalist RPAREN
| PRIMARY KEY LPAREN column_commalist RPAREN
| FOREIGN KEY LPAREN column_commalist RPAREN REFERENCES table
| FOREIGN KEY LPAREN column_commalist RPAREN REFERENCES table LPAREN column_commalist RPAREN
| CHECK LPAREN search_condition RPAREN
"""
return self.defaultNodeClass(
target="table_constraint_def",
option=option,
names=names,
values=values)
def on_column_commalist(self, target, option, names, values):
"""
column_commalist
: column
| column_commalist COMMA column
"""
return self.defaultNodeClass(
target="column_commalist",
option=option,
names=names,
values=values)
def on_view_def(self, target, option, names, values):
"""
view_def
: CREATE VIEW table opt_column_commalist AS query_spec opt_with_check_option
"""
return self.defaultNodeClass(
target="view_def",
option=option,
names=names,
values=values)
def on_opt_with_check_option(self, target, option, names, values):
"""
opt_with_check_option
: | WITH CHECK OPTION
"""
return self.defaultNodeClass(
target="opt_with_check_option",
option=option,
names=names,
values=values)
def on_opt_column_commalist(self, target, option, names, values):
"""
opt_column_commalist
: | LPAREN column_commalist RPAREN
"""
return self.defaultNodeClass(
target="opt_column_commalist",
option=option,
names=names,
values=values)
def on_privilege_def(self, target, option, names, values):
"""
privilege_def
: GRANT privileges ON table TO grantee_commalist opt_with_grant_option
"""
return self.defaultNodeClass(
target="privilege_def",
option=option,
names=names,
values=values)
def on_opt_with_grant_option(self, target, option, names, values):
"""
opt_with_grant_option
: | WITH GRANT OPTION
"""
return self.defaultNodeClass(
target="opt_with_grant_option",
option=option,
names=names,
values=values)
def on_privileges(self, target, option, names, values):
"""
privileges
: ALL PRIVILEGES
| ALL
| operation_commalist
"""
return self.defaultNodeClass(
target="privileges",
option=option,
names=names,
values=values)
def on_operation_commalist(self, target, option, names, values):
"""
operation_commalist
: operation
| operation_commalist COMMA operation
"""
return self.defaultNodeClass(
target="operation_commalist",
option=option,
names=names,
values=values)
def on_operation(self, target, option, names, values):
"""
operation
: SELECT
| INSERT
| DELETE
| UPDATE opt_column_commalist
| REFERENCES opt_column_commalist
"""
return self.defaultNodeClass(
target="operation",
option=option,
names=names,
values=values)
def on_grantee_commalist(self, target, option, names, values):
"""
grantee_commalist
: grantee
| grantee_commalist COMMA grantee
"""
return self.defaultNodeClass(
target="grantee_commalist",
option=option,
names=names,
values=values)
def on_grantee(self, target, option, names, values):
"""
grantee
: PUBLIC
| user
"""
return self.defaultNodeClass(
target="grantee",
option=option,
names=names,
values=values)
def on_module_def(self, target, option, names, values):
"""
module_def
: MODULE opt_module LANGUAGE lang AUTHORIZATION user opt_cursor_def_list procedure_def_list
"""
return self.defaultNodeClass(
target="module_def",
option=option,
names=names,
values=values)
def on_opt_module(self, target, option, names, values):
"""
opt_module
: | module
"""
return self.defaultNodeClass(
target="opt_module",
option=option,
names=names,
values=values)
def on_lang(self, target, option, names, values):
"""
lang
: COBOL
| FORTRAN
| PASCAL
| PLI
| C
| ADA
"""
return self.defaultNodeClass(
target="lang",
option=option,
names=names,
values=values)
def on_opt_cursor_def_list(self, target, option, names, values):
"""
opt_cursor_def_list
: | cursor_def_list
"""
return self.defaultNodeClass(
target="opt_cursor_def_list",
option=option,
names=names,
values=values)
def on_cursor_def_list(self, target, option, names, values):
"""
cursor_def_list
: cursor_def
| cursor_def_list cursor_def
"""
return self.defaultNodeClass(
target="cursor_def_list",
option=option,
names=names,
values=values)
def on_cursor_def(self, target, option, names, values):
"""
cursor_def
: DECLARE cursor CURSOR FOR query_exp opt_order_by_clause
"""
return self.defaultNodeClass(
target="cursor_def",
option=option,
names=names,
values=values)
def on_opt_order_by_clause(self, target, option, names, values):
"""
opt_order_by_clause
: | ORDER BY ordering_spec_commalist
"""
return self.defaultNodeClass(
target="opt_order_by_clause",
option=option,
names=names,
values=values)
def on_ordering_spec_commalist(self, target, option, names, values):
"""
ordering_spec_commalist
: ordering_spec
| ordering_spec_commalist COMMA ordering_spec
"""
return self.defaultNodeClass(
target="ordering_spec_commalist",
option=option,
names=names,
values=values)
def on_ordering_spec(self, target, option, names, values):
"""
ordering_spec
: INTNUM opt_asc_desc
| column_ref opt_asc_desc
"""
return self.defaultNodeClass(
target="ordering_spec",
option=option,
names=names,
values=values)
def on_opt_asc_desc(self, target, option, names, values):
"""
opt_asc_desc
: | ASC
| DESC
"""
return self.defaultNodeClass(
target="opt_asc_desc",
option=option,
names=names,
values=values)
def on_procedure_def_list(self, target, option, names, values):
"""
procedure_def_list
: procedure_def
| procedure_def_list procedure_def
"""
return self.defaultNodeClass(
target="procedure_def_list",
option=option,
names=names,
values=values)
def on_procedure_def(self, target, option, names, values):
"""
procedure_def
: PROCEDURE procedure parameter_def_list SEMICOLON manipulative_statement_list
"""
return self.defaultNodeClass(
target="procedure_def",
option=option,
names=names,
values=values)
def on_manipulative_statement_list(self, target, option, names, values):
"""
manipulative_statement_list
: manipulative_statement
| manipulative_statement_list manipulative_statement
"""
return self.defaultNodeClass(
target="manipulative_statement_list",
option=option,
names=names,
values=values)
def on_parameter_def_list(self, target, option, names, values):
"""
parameter_def_list
: parameter_def
| parameter_def_list parameter_def
"""
return self.defaultNodeClass(
target="parameter_def_list",
option=option,
names=names,
values=values)
def on_parameter_def(self, target, option, names, values):
"""
parameter_def
: parameter data_type
| SQLCODE
"""
return self.defaultNodeClass(
target="parameter_def",
option=option,
names=names,
values=values)
def on_manipulative_statement(self, target, option, names, values):
"""
manipulative_statement
: close_statement
| commit_statement
| delete_statement_positioned
| delete_statement_searched
| fetch_statement
| insert_statement
| open_statement
| rollback_statement
| select_statement
| update_statement_positioned
| update_statement_searched
"""
return self.defaultNodeClass(
target="manipulative_statement",
option=option,
names=names,
values=values)
def on_close_statement(self, target, option, names, values):
"""
close_statement
: CLOSE cursor
"""
return self.defaultNodeClass(
target="close_statement",
option=option,
names=names,
values=values)
def on_commit_statement(self, target, option, names, values):
"""
commit_statement
: COMMIT WORK
"""
return self.defaultNodeClass(
target="commit_statement",
option=option,
names=names,
values=values)
def on_delete_statement_positioned(self, target, option, names, values):
"""
delete_statement_positioned
: DELETE FROM table WHERE CURRENT OF cursor
"""
return self.defaultNodeClass(
target="delete_statement_positioned",
option=option,
names=names,
values=values)
def on_delete_statement_searched(self, target, option, names, values):
"""
delete_statement_searched
: DELETE FROM table opt_where_clause
"""
return self.defaultNodeClass(
target="delete_statement_searched",
option=option,
names=names,
values=values)
def on_fetch_statement(self, target, option, names, values):
"""
fetch_statement
: FETCH cursor INTO target_commalist
"""
return self.defaultNodeClass(
target="fetch_statement",
option=option,
names=names,
values=values)
def on_insert_statement(self, target, option, names, values):
"""
insert_statement
: INSERT INTO table opt_column_commalist values_or_query_spec
"""
return self.defaultNodeClass(
target="insert_statement",
option=option,
names=names,
values=values)
def on_values_or_query_spec(self, target, option, names, values):
"""
values_or_query_spec
: VALUES LPAREN insert_atom_commalist RPAREN
| query_spec
"""
return self.defaultNodeClass(
target="values_or_query_spec",
option=option,
names=names,
values=values)
def on_insert_atom_commalist(self, target, option, names, values):
"""
insert_atom_commalist
: insert_atom
| insert_atom_commalist COMMA insert_atom
"""
return self.defaultNodeClass(
target="insert_atom_commalist",
option=option,
names=names,
values=values)
def on_insert_atom(self, target, option, names, values):
"""
insert_atom
: atom
| NULLX
"""
return self.defaultNodeClass(
target="insert_atom",
option=option,
names=names,
values=values)
def on_open_statement(self, target, option, names, values):
"""
open_statement
: OPEN cursor
"""
return self.defaultNodeClass(
target="open_statement",
option=option,
names=names,
values=values)
def on_rollback_statement(self, target, option, names, values):
"""
rollback_statement
: ROLLBACK WORK
"""
return self.defaultNodeClass(
target="rollback_statement",
option=option,
names=names,
values=values)
def on_select_statement(self, target, option, names, values):
"""
select_statement
: SELECT opt_all_distinct selection INTO target_commalist table_exp
"""
return self.defaultNodeClass(
target="select_statement",
option=option,
names=names,
values=values)
def on_opt_all_distinct(self, target, option, names, values):
"""
opt_all_distinct
: | ALL
| DISTINCT
"""
return self.defaultNodeClass(
target="opt_all_distinct",
option=option,
names=names,
values=values)
def on_update_statement_positioned(self, target, option, names, values):
"""
update_statement_positioned
: UPDATE table SET assignment_commalist WHERE CURRENT OF cursor
"""
return self.defaultNodeClass(
target="update_statement_positioned",
option=option,
names=names,
values=values)
def on_assignment_commalist(self, target, option, names, values):
"""
assignment_commalist
: | assignment
| assignment_commalist COMMA assignment
"""
return self.defaultNodeClass(
target="assignment_commalist",
option=option,
names=names,
values=values)
def on_assignment(self, target, option, names, values):
"""
assignment
: column ASSIGN_OP scalar_exp
| column ASSIGN_OP NULLX
"""
return self.defaultNodeClass(
target="assignment",
option=option,
names=names,
values=values)
def on_update_statement_searched(self, target, option, names, values):
"""
update_statement_searched
: UPDATE table SET assignment_commalist opt_where_clause
"""
return self.defaultNodeClass(
target="update_statement_searched",
option=option,
names=names,
values=values)
def on_target_commalist(self, target, option, names, values):
"""
target_commalist
: target
| target_commalist COMMA target
"""
return self.defaultNodeClass(
target="target_commalist",
option=option,
names=names,
values=values)
def on_target(self, target, option, names, values):
"""
target
: parameter_ref
"""
return self.defaultNodeClass(
target="target",
option=option,
names=names,
values=values)
def on_opt_where_clause(self, target, option, names, values):
"""
opt_where_clause
: | where_clause
"""
return self.defaultNodeClass(
target="opt_where_clause",
option=option,
names=names,
values=values)
def on_query_exp(self, target, option, names, values):
"""
query_exp
: query_term
| query_exp UNION query_term
| query_exp UNION ALL query_term
"""
return self.defaultNodeClass(
target="query_exp",
option=option,
names=names,
values=values)
def on_query_term(self, target, option, names, values):
"""
query_term
: query_spec
| LPAREN query_exp RPAREN
"""
return self.defaultNodeClass(
target="query_term",
option=option,
names=names,
values=values)
def on_query_spec(self, target, option, names, values):
"""
query_spec
: SELECT opt_all_distinct selection table_exp
"""
return self.defaultNodeClass(
target="query_spec",
option=option,
names=names,
values=values)
def on_selection(self, target, option, names, values):
"""
selection
: scalar_exp_commalist
| TIMES
"""
return self.defaultNodeClass(
target="selection",
option=option,
names=names,
values=values)
def on_table_exp(self, target, option, names, values):
"""
table_exp
: from_clause opt_where_clause opt_group_by_clause opt_having_clause
"""
return self.defaultNodeClass(
target="table_exp",
option=option,
names=names,
values=values)
def on_from_clause(self, target, option, names, values):
"""
from_clause
: FROM table_ref_commalist
"""
return self.defaultNodeClass(
target="from_clause",
option=option,
names=names,
values=values)
def on_table_ref_commalist(self, target, option, names, values):
"""
table_ref_commalist
: table_ref
| table_ref_commalist COMMA table_ref
"""
return self.defaultNodeClass(
target="table_ref_commalist",
option=option,
names=names,
values=values)
def on_table_ref(self, target, option, names, values):
"""
table_ref
: table
| table range_variable
"""
return self.defaultNodeClass(
target="table_ref",
option=option,
names=names,
values=values)
def on_where_clause(self, target, option, names, values):
"""
where_clause
: WHERE search_condition
"""
return self.defaultNodeClass(
target="where_clause",
option=option,
names=names,
values=values)
def on_opt_group_by_clause(self, target, option, names, values):
"""
opt_group_by_clause
: | GROUP BY column_ref_commalist
"""
return self.defaultNodeClass(
target="opt_group_by_clause",
option=option,
names=names,
values=values)
def on_column_ref_commalist(self, target, option, names, values):
"""
column_ref_commalist
: column_ref
| column_ref_commalist COMMA column_ref
"""
return self.defaultNodeClass(
target="column_ref_commalist",
option=option,
names=names,
values=values)
def on_opt_having_clause(self, target, option, names, values):
"""
opt_having_clause
: | HAVING search_condition
"""
return self.defaultNodeClass(
target="opt_having_clause",
option=option,
names=names,
values=values)
def on_search_condition(self, target, option, names, values):
"""
search_condition
: | search_condition OR search_condition
| search_condition AND search_condition
| NOT search_condition
| LPAREN search_condition RPAREN
| predicate
"""
return self.defaultNodeClass(
target="search_condition",
option=option,
names=names,
values=values)
def on_predicate(self, target, option, names, values):
"""
predicate
: comparison_predicate
| between_predicate
| like_predicate
| test_for_null
| in_predicate
| all_or_any_predicate
| existence_test
"""
return self.defaultNodeClass(
target="predicate",
option=option,
names=names,
values=values)
def on_comparison_predicate(self, target, option, names, values):
"""
comparison_predicate
: scalar_exp COMPARISON scalar_exp
| scalar_exp COMPARISON subquery
"""
return self.defaultNodeClass(
target="comparison_predicate",
option=option,
names=names,
values=values)
def on_between_predicate(self, target, option, names, values):
"""
between_predicate
: scalar_exp NOT BETWEEN scalar_exp AND scalar_exp
| scalar_exp BETWEEN scalar_exp AND scalar_exp
"""
return self.defaultNodeClass(
target="between_predicate",
option=option,
names=names,
values=values)
def on_like_predicate(self, target, option, names, values):
"""
like_predicate
: scalar_exp NOT LIKE atom opt_escape
| scalar_exp LIKE atom opt_escape
"""
return self.defaultNodeClass(
target="like_predicate",
option=option,
names=names,
values=values)
def on_opt_escape(self, target, option, names, values):
"""
opt_escape
: | ESCAPE atom
"""
return self.defaultNodeClass(
target="opt_escape",
option=option,
names=names,
values=values)
def on_test_for_null(self, target, option, names, values):
"""
test_for_null
: column_ref IS NOT NULLX
| column_ref IS NULLX
"""
return self.defaultNodeClass(
target="test_for_null",
option=option,
names=names,
values=values)
def on_in_predicate(self, target, option, names, values):
"""
in_predicate
: scalar_exp NOT IN LPAREN subquery RPAREN
| scalar_exp IN LPAREN subquery RPAREN
| scalar_exp NOT IN LPAREN atom_commalist RPAREN
| scalar_exp IN LPAREN atom_commalist RPAREN
"""
return self.defaultNodeClass(
target="in_predicate",
option=option,
names=names,
values=values)
def on_atom_commalist(self, target, option, names, values):
"""
atom_commalist
: atom
| atom_commalist COMMA atom
"""
return self.defaultNodeClass(
target="atom_commalist",
option=option,
names=names,
values=values)
def on_all_or_any_predicate(self, target, option, names, values):
"""
all_or_any_predicate
: scalar_exp COMPARISON any_all_some subquery
"""
return self.defaultNodeClass(
target="all_or_any_predicate",
option=option,
names=names,
values=values)
def on_any_all_some(self, target, option, names, values):
"""
any_all_some
: ANY
| ALL
| SOME
"""
return self.defaultNodeClass(
target="any_all_some",
option=option,
names=names,
values=values)
def on_existence_test(self, target, option, names, values):
"""
existence_test
: EXISTS subquery
"""
return self.defaultNodeClass(
target="existence_test",
option=option,
names=names,
values=values)
def on_subquery(self, target, option, names, values):
"""
subquery
: LPAREN SELECT opt_all_distinct selection table_exp RPAREN
"""
return self.defaultNodeClass(
target="subquery",
option=option,
names=names,
values=values)
def on_scalar_exp(self, target, option, names, values):
"""
scalar_exp
: scalar_exp PLUS scalar_exp
| scalar_exp MINUS scalar_exp
| scalar_exp TIMES scalar_exp
| scalar_exp DIV scalar_exp
| PLUS scalar_exp %prec UMINUS
| MINUS scalar_exp %prec UMINUS
| atom
| column_ref
| function_ref
| LPAREN scalar_exp RPAREN
"""
return self.defaultNodeClass(
target="scalar_exp",
option=option,
names=names,
values=values)
def on_scalar_exp_commalist(self, target, option, names, values):
"""
scalar_exp_commalist
: scalar_exp
| scalar_exp_commalist COMMA scalar_exp
"""
return self.defaultNodeClass(
target="scalar_exp_commalist",
option=option,
names=names,
values=values)
def on_atom(self, target, option, names, values):
"""
atom
: parameter_ref
| literal
| USER
"""
return self.defaultNodeClass(
target="atom",
option=option,
names=names,
values=values)
def on_parameter_ref(self, target, option, names, values):
"""
parameter_ref
: parameter
| parameter parameter
| parameter INDICATOR parameter
"""
return self.defaultNodeClass(
target="parameter_ref",
option=option,
names=names,
values=values)
def on_function_ref(self, target, option, names, values):
"""
function_ref
: AMMSC LPAREN TIMES RPAREN
| AMMSC LPAREN DISTINCT column_ref RPAREN
| AMMSC LPAREN ALL scalar_exp RPAREN
| AMMSC LPAREN scalar_exp RPAREN
"""
return self.defaultNodeClass(
target="function_ref",
option=option,
names=names,
values=values)
def on_literal(self, target, option, names, values):
"""
literal
: STRING
| INTNUM
| APPROXNUM
"""
return self.defaultNodeClass(
target="literal",
option=option,
names=names,
values=values)
def on_table(self, target, option, names, values):
"""
table
: NAME
| NAME PERIOD NAME
"""
return self.defaultNodeClass(
target="table",
option=option,
names=names,
values=values)
def on_column_ref(self, target, option, names, values):
"""
column_ref
: NAME
| NAME PERIOD NAME
| NAME PERIOD NAME PERIOD NAME
"""
return self.defaultNodeClass(
target="column_ref",
option=option,
names=names,
values=values)
def on_data_type(self, target, option, names, values):
"""
data_type
: CHARACTER
| CHARACTER LPAREN INTNUM RPAREN
| NUMERIC
| NUMERIC LPAREN INTNUM RPAREN
| NUMERIC LPAREN INTNUM COMMA INTNUM RPAREN
| DECIMAL
| DECIMAL LPAREN INTNUM RPAREN
| DECIMAL LPAREN INTNUM COMMA INTNUM RPAREN
| INTEGER
| SMALLINT
| FLOAT
| FLOAT LPAREN INTNUM RPAREN
| REAL
| DOUBLE PRECISION
"""
return self.defaultNodeClass(
target="data_type",
option=option,
names=names,
values=values)
def on_column(self, target, option, names, values):
"""
column
: NAME
"""
return self.defaultNodeClass(
target="column",
option=option,
names=names,
values=values)
def on_cursor(self, target, option, names, values):
"""
cursor
: NAME
"""
return self.defaultNodeClass(
target="cursor",
option=option,
names=names,
values=values)
def on_module(self, target, option, names, values):
"""
module
: NAME
"""
return self.defaultNodeClass(
target="module",
option=option,
names=names,
values=values)
def on_parameter(self, target, option, names, values):
"""
parameter
: COLON NAME
"""
return self.defaultNodeClass(
target="parameter",
option=option,
names=names,
values=values)
def on_procedure(self, target, option, names, values):
"""
procedure
: NAME
"""
return self.defaultNodeClass(
target="procedure",
option=option,
names=names,
values=values)
def on_range_variable(self, target, option, names, values):
"""
range_variable
: NAME
"""
return self.defaultNodeClass(
target="range_variable",
option=option,
names=names,
values=values)
def on_user(self, target, option, names, values):
"""
user
: NAME
"""
return self.defaultNodeClass(
target="user",
option=option,
names=names,
values=values)
def on_when_action(self, target, option, names, values):
"""
when_action
: GOTO NAME
| CONTINUE
"""
return self.defaultNodeClass(
target="when_action",
option=option,
names=names,
values=values)
# -----------------------------------------
# raw lex script, verbatim here
# -----------------------------------------
lexscript = r"""
%{
//int yylineno = 0;
#include
#include
#include "Python.h"
#define YYSTYPE void *
#include "tokens.h"
extern void *py_parser;
extern void (*py_input)(PyObject *parser, char *buf, int *result, int max_size);
#define returntoken(tok) yylval = PyString_FromString(strdup(yytext)); return (tok);
#define YY_INPUT(buf,result,max_size) { (*py_input)(py_parser, buf, &result, max_size); }
%}
%%
"ADA" { returntoken(ADA); }
"ALL" { returntoken(ALL); }
"AND" { returntoken(AND); }
"AVG" { returntoken(AMMSC); }
"MIN" { returntoken(AMMSC); }
"MAX" { returntoken(AMMSC); }
"SUM" { returntoken(AMMSC); }
"COUNT" { returntoken(AMMSC); }
"ANY" { returntoken(ANY); }
"AS" { returntoken(AS); }
"ASC" { returntoken(ASC); }
"AUTHORIZATION" { returntoken(AUTHORIZATION); }
"BETWEEN" { returntoken(BETWEEN); }
"BY" { returntoken(BY); }
"C" { returntoken(C); }
"CHAR" { returntoken(CHARACTER); }
"CHARACTER" { returntoken(CHARACTER); }
"CHECK" { returntoken(CHECK); }
"CLOSE" { returntoken(CLOSE); }
"COBOL" { returntoken(COBOL); }
"COMMIT" { returntoken(COMMIT); }
"CONTINUE" { returntoken(CONTINUE); }
"CREATE" { returntoken(CREATE); }
"CURRENT" { returntoken(CURRENT); }
"CURSOR" { returntoken(CURSOR); }
"DECIMAL" { returntoken(DECIMAL); }
"DECLARE" { returntoken(DECLARE); }
"DEFAULT" { returntoken(DEFAULT); }
"DELETE" { returntoken(DELETE); }
"DESC" { returntoken(DESC); }
"DISTINCT" { returntoken(DISTINCT); }
"DOUBLE" { returntoken(DOUBLE); }
"ESCAPE" { returntoken(ESCAPE); }
"EXISTS" { returntoken(EXISTS); }
"FETCH" { returntoken(FETCH); }
"FLOAT" { returntoken(FLOAT); }
"FOR" { returntoken(FOR); }
"FOREIGN" { returntoken(FOREIGN); }
"FORTRAN" { returntoken(FORTRAN); }
"FOUND" { returntoken(FOUND); }
"FROM" { returntoken(FROM); }
"GOTO" { returntoken(GOTO); }
"GO TO" { returntoken(GOTO); }
"GRANT" { returntoken(GRANT); }
"GROUP" { returntoken(GROUP); }
"HAVING" { returntoken(HAVING); }
"IN" { returntoken(IN); }
"INDICATOR" { returntoken(INDICATOR); }
"INSERT" { returntoken(INSERT); }
"INT" { returntoken(INTEGER); }
"INTEGER" { returntoken(INTEGER); }
"INTO" { returntoken(INTO); }
"IS" { returntoken(IS); }
"KEY" { returntoken(KEY); }
"LANGUAGE" { returntoken(LANGUAGE); }
"LIKE" { returntoken(LIKE); }
"MODULE" { returntoken(MODULE); }
"NOT" { returntoken(NOT); }
"NULL" { returntoken(NULLX); }
"NUMERIC" { returntoken(NUMERIC); }
"OF" { returntoken(OF); }
"ON" { returntoken(ON); }
"OPEN" { returntoken(OPEN); }
"OPTION" { returntoken(OPTION); }
"OR" { returntoken(OR); }
"ORDER" { returntoken(ORDER); }
"PASCAL" { returntoken(PASCAL); }
"PLI" { returntoken(PLI); }
"PRECISION" { returntoken(PRECISION); }
"PRIMARY" { returntoken(PRIMARY); }
"PRIVILEGES" { returntoken(PRIVILEGES); }
"PROCEDURE" { returntoken(PROCEDURE); }
"PUBLIC" { returntoken(PUBLIC); }
"REAL" { returntoken(REAL); }
"REFERENCES" { returntoken(REFERENCES); }
"ROLLBACK" { returntoken(ROLLBACK); }
"SCHEMA" { returntoken(SCHEMA); }
"SELECT" { returntoken(SELECT); }
"SET" { returntoken(SET); }
"SMALLINT" { returntoken(SMALLINT); }
"SOME" { returntoken(SOME); }
"SQLCODE" { returntoken(SQLCODE); }
"TABLE" { returntoken(TABLE); }
"TO" { returntoken(TO); }
"UNION" { returntoken(UNION); }
"UNIQUE" { returntoken(UNIQUE); }
"UPDATE" { returntoken(UPDATE); }
"USER" { returntoken(USER); }
"VALUES" { returntoken(VALUES); }
"VIEW" { returntoken(VIEW); }
"WHENEVER" { returntoken(WHENEVER); }
"WHERE" { returntoken(WHERE); }
"WITH" { returntoken(WITH); }
"WORK" { returntoken(WORK); }
("=="|"<>"|"<"|">"|"<="|">=") { returntoken(COMPARISON); }
"-" { returntoken(MINUS); }
"+" { returntoken(PLUS); }
"*" { returntoken(TIMES); }
"/" { returntoken(DIV); }
":" { returntoken(COLON); }
"(" { returntoken(LPAREN); }
")" { returntoken(RPAREN); }
"," { returntoken(COMMA); }
"." { returntoken(PERIOD); }
";" { returntoken(SEMICOLON); }
"=" { returntoken(ASSIGN_OP); }
[A-Za-z][A-Za-z0-9_]* { returntoken(NAME); }
[0-9]+ |
[0-9]+"."[0-9]* |
"."[0-9]* { returntoken(INTNUM); }
[0-9]+[eE][+-]?[0-9]+ |
[0-9]+"."[0-9]*[eE][+-]?[0-9]+ |
"."[0-9]*[eE][+-]?[0-9]+ { returntoken(APPROXNUM); }
"'"[^'\n]*"'" {
int c = input();
unput(c); /* just peeking */
if(c != '\'') {
returntoken(STRING);
} else
yymore();
}
"'"[^'\n]*$ { yyerror("Unterminated string"); }
\n { yylineno++; }
[ \t\r]+ { }
"--".*$ { }
%%
int yywrap()
{
return(1);
}
main(int ac, char **av)
{
if(ac > 1 && (yyin = fopen(av[1], "4")) == NULL) {
perror(av[1]);
exit(1);
}
if(!yyparse())
printf("SQL parse worked\n");
else
printf("SQL parse failed\n");
}
"""
# -----------------------------------------
# end raw lex script
# -----------------------------------------
def usage():
print "%s: PyBison parser derived from %s and %s" % (sys.argv[0], bisonFile, lexFile)
print "Usage: %s [-k] [-v] [-d] [filename]" % sys.argv[0]
print " -k Keep temporary files used in building parse engine lib"
print " -v Enable verbose messages while parser is running"
print " -d Enable garrulous debug messages from parser engine"
print " filename path of a file to parse, defaults to stdin"
def main(*args):
"""
Unit-testing func
"""
keepfiles = 0
verbose = 0
debug = 0
filename = None
for s in ["-h", "-help", "--h", "--help", "-?"]:
if s in args:
usage()
sys.exit(0)
if len(args) > 0:
if "-k" in args:
keepfiles = 1
args.remove("-k")
if "-v" in args:
verbose = 1
args.remove("-v")
if "-d" in args:
debug = 1
args.remove("-d")
if len(args) > 0:
filename = args[0]
p = Parser(verbose=verbose, keepfiles=keepfiles)
tree = p.run(file=filename, debug=debug)
return tree
if __name__ == "__main__":
main(*(sys.argv[1:]))