sql-parser-tl 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 538346a6ead5e964823de08bbb90338566ba2a8ef9e6d15039f9b0f138ea5f99
+  data.tar.gz: e3735029f0489e0c11483e2ec4418c7a7372e40b0815698085cc262c538e7945
+SHA512:
+  metadata.gz: 2bd9d4bcd605bc659623a865694201a0e55f97856221e44581517b002b11c2552cfa9ea1af6b15aa5a6aa9c8ab61745861bd80beb76fbc8d8214dc29c99e765a
+  data.tar.gz: 78782ebcec7162b855d88a51ea7b848936aa9f619f88dc54314b53dba120d128f4d54252a20ae9fb7346c9d3d7f4a94c3a1183691d403f2fa63346c1e74800b0

data/lib/sql-parser/parser.racc

@@ -0,0 +1,369 @@
+class SQLParser::Parser
+
+rule
+# dynamic sql
+
+  direct_sql_statement
+    : direct_sql_data_statement
+
+  direct_sql_data_statement
+    : direct_select_statement_multiple_rows
+    | insert_specification
+
+  direct_select_statement_multiple_rows
+    : query_expression order_by_clause limit_clause { result = SQLParser::Statement::DirectSelect.new(val[0], val[1], val[2]) }
+
+# module contents
+  limit_clause
+    : # no action
+    | LIMIT unsigned_integer OFFSET unsigned_integer { result = SQLParser::Statement::LimitClause.new(val[1], val[3]) }
+    | LIMIT unsigned_integer comma unsigned_integer { result = SQLParser::Statement::LimitClause.new(val[3], val[1]) }
+    | LIMIT unsigned_integer { result = SQLParser::Statement::LimitClause.new(val[1], 0) }
+
+  order_by_clause
+    : # no action
+    | ORDER BY sort_specification_list { result = SQLParser::Statement::OrderBy.new(val[2]) }
+
+  sort_specification_list
+    : sort_specification_list comma sort_specification { result = Array(val[0]) + Array(val[2]) }
+    | sort_specification
+
+  sort_specification
+    : sort_key ordering_specification { result = val[1].new(val[0]) }
+
+  sort_key
+    : column_reference
+    | unsigned_integer { result = SQLParser::Statement::Integer.new(val[0]) }
+
+  ordering_specification
+    : { result = SQLParser::Statement::Ascending } # default
+    | ASC { result = SQLParser::Statement::Ascending }
+    | DESC { result = SQLParser::Statement::Descending }
+
+# queries
+  subquery
+    # FIXME: shortcut
+    : left_paren query_expression right_paren { result = SQLParser::Statement::Subquery.new(val[1]) }
+
+  query_expression
+    : query_specification
+
+  insert_specification 
+    : INSERT INTO table_reference value_list { result = SQLParser::Statement::Insert.new(val[2], nil, val[3]) }
+    | INSERT INTO table_reference column_list value_list { result = SQLParser::Statement::Insert.new(val[2], val[3], val[4]) }
+
+  column_list
+    : left_paren in_column_list right_paren { result = SQLParser::Statement::InColumnList.new(val[1]) }
+ 
+  in_column_list
+    : value_expression comma in_column_list { result = Array(val[0]) + Array(val[2]) }
+	  | value_expression
+  
+  value_list
+    : VALUES left_paren in_value_list right_paren { result = SQLParser::Statement::InValueList.new(val[2]) }
+
+  query_specification
+    : SELECT select_list table_expression { result = SQLParser::Statement::Select.new(val[1], val[2]) }
+    | SELECT select_list { result = SQLParser::Statement::Select.new(val[1]) }
+
+  select_list
+    : asterisk { result = SQLParser::Statement::All.new }
+    | select_sublist { result = SQLParser::Statement::SelectList.new(val[0]) }
+
+  select_sublist
+    : derived_column comma select_sublist { result = Array(val[0]) + Array(val[2]) }
+    | derived_column
+
+  derived_column
+    : value_expression AS column_name { result = SQLParser::Statement::As.new(val[0], val[2]) }
+    | value_expression column_name { result = SQLParser::Statement::As.new(val[0], val[1]) }
+    | value_expression
+
+  table_expression
+    : from_clause where_clause group_by_clause having_clause { result = SQLParser::Statement::TableExpression.new(val[0], val[1], val[2], val[3]) }
+
+  from_clause
+    : FROM table_reference { result = SQLParser::Statement::FromClause.new(val[1]) }
+
+  table_reference
+    : table_name AS column_name { result = SQLParser::Statement::As.new(val[0], val[2]) }
+    | table_name column_name { result = SQLParser::Statement::As.new(val[0], val[1]) }
+    | table_name
+    | joined_table
+    | left_paren table_reference right_paren { result = val[1] }
+    | table_reference hint_type INDEX left_paren identifier right_paren { result = val[1].new(val[0], val[4]) }
+
+  table_subquery
+    : subquery
+
+  joined_table
+    : cross_join
+    | qualified_join
+
+  cross_join
+    : table_reference comma table_reference { result = SQLParser::Statement::CrossJoin.new(val[0], val[2]) }
+    | table_reference CROSS JOIN table_reference { result = SQLParser::Statement::CrossJoin.new(val[0], val[3]) }
+
+  qualified_join
+    : table_reference join_type JOIN table_reference join_specification { result = val[1].new(val[0], val[3], val[4]) }
+
+  join_type
+    : INNER { result = SQLParser::Statement::InnerJoin }
+    | LEFT OUTER { result = SQLParser::Statement::LeftOuterJoin }
+    | LEFT { result = SQLParser::Statement::LeftJoin }
+    | RIGHT OUTER { result = SQLParser::Statement::RightOuterJoin }
+    | RIGHT { result = SQLParser::Statement::RightJoin }
+    | FULL { result = SQLParser::Statement::FullJoin }
+    | FULL OUTER { result = SQLParser::Statement::FullOuterJoin }
+
+  join_specification
+    : join_condition
+    | named_columns_join
+
+  join_condition
+    : ON search_condition { result = SQLParser::Statement::On.new(val[1]) }
+
+  named_columns_join
+    : USING left_paren join_column_list right_paren { result = SQLParser::Statement::Using.new(val[2]) }
+
+  join_column_list
+    : column_name_list
+
+  hint_type
+    : FORCE { result = SQLParser::Statement::ForceIndex }
+    | USE { result = SQLParser::Statement::UseIndex }
+    | IGNORE { result = SQLParser::Statement::IgnoreIndex }
+
+  where_clause
+    : # no action
+    | WHERE search_condition { result = SQLParser::Statement::WhereClause.new(val[1]) }
+
+  group_by_clause
+    : # no action
+    | GROUP BY grouping_column_reference_list { result = SQLParser::Statement::GroupByClause.new(val[2]) }
+
+  grouping_column_reference_list
+    : grouping_column_reference_list comma grouping_column_reference { result = Array(val[0]) + Array(val[2]) }
+    | grouping_column_reference
+
+  grouping_column_reference
+    : column_reference
+
+  having_clause
+    : # no action
+    | HAVING search_condition { result = SQLParser::Statement::HavingClause.new(val[1]) }
+
+# query expression components
+  row_subquery
+    : subquery
+
+  between_predicate
+    : row_value_constructor NOT BETWEEN row_value_constructor AND row_value_constructor {
+      result = SQLParser::Statement::Not.new(SQLParser::Statement::Between.new(val[0], SQLParser::Statement::BetweenRange.new(val[3], val[5])))
+    }
+    | row_value_constructor BETWEEN row_value_constructor AND row_value_constructor {
+      result = SQLParser::Statement::Between.new(val[0], SQLParser::Statement::BetweenRange.new(val[2], val[4]))
+    }
+
+  in_predicate
+    : row_value_constructor NOT IN in_predicate_value { result = SQLParser::Statement::Not.new(SQLParser::Statement::In.new(val[0], val[3])) }
+    | row_value_constructor IN in_predicate_value { result = SQLParser::Statement::In.new(val[0], val[2]) }
+
+  in_predicate_value
+    : table_subquery
+    | left_paren in_value_list right_paren { result = SQLParser::Statement::InValueList.new(val[1]) }
+
+  in_value_list
+    : value_expression comma in_value_list { result = Array(val[0]) + Array(val[2]) }
+    | value_expression
+
+  like_predicate
+    # FIXME: the SQL-92 grammar indicates these should be
+    # character_value_expression nodes, but changing them causes reduce/reduce
+    # conflicts.
+    : row_value_constructor NOT LIKE row_value_constructor { result = SQLParser::Statement::Not.new(SQLParser::Statement::Like.new(val[0], val[3])) }
+    | row_value_constructor LIKE row_value_constructor { result = SQLParser::Statement::Like.new(val[0], val[2]) }
+
+  null_predicate
+    : row_value_constructor IS NOT NULL { result = SQLParser::Statement::Not.new(SQLParser::Statement::Is.new(val[0], SQLParser::Statement::Null.new)) }
+    | row_value_constructor IS NULL { result = SQLParser::Statement::Is.new(val[0], SQLParser::Statement::Null.new) }
+
+  exists_predicate
+    : EXISTS table_subquery { result = SQLParser::Statement::Exists.new(val[1]) }
+
+# constraints
+  table_name
+    : identifier { result = SQLParser::Statement::Table.new(val[0]) }
+
+  column_name_list
+    : column_name_list comma column_name { result = Array(val[0]) + Array(val[2]) }
+    | column_name
+
+# search condition
+  search_condition
+    : boolean_term
+    | search_condition OR boolean_term { result = SQLParser::Statement::Or.new(val[0], val[2]) }
+
+  boolean_term
+    : boolean_factor
+    | boolean_term AND boolean_factor { result = SQLParser::Statement::And.new(val[0], val[2]) }
+
+  boolean_factor:
+    : NOT boolean_test { result = SQLParser::Statement::Not.new(val[1]) }
+    | boolean_test
+
+  boolean_test
+    : boolean_primary
+
+  boolean_primary
+    : predicate
+    | left_paren search_condition right_paren { result = val[1] }
+
+  predicate
+    : comparison_predicate
+    | between_predicate
+    | in_predicate
+    | like_predicate
+    | null_predicate
+    | exists_predicate
+
+  comparison_predicate
+    : row_value_constructor equals_operator row_value_constructor { result = SQLParser::Statement::Equals.new(val[0], val[2]) }
+    | row_value_constructor not_equals_operator row_value_constructor { result = SQLParser::Statement::Not.new(SQLParser::Statement::Equals.new(val[0], val[2])) }
+    | row_value_constructor less_than_operator row_value_constructor { result = SQLParser::Statement::Less.new(val[0], val[2]) }
+    | row_value_constructor greater_than_operator row_value_constructor { result = SQLParser::Statement::Greater.new(val[0], val[2]) }
+    | row_value_constructor less_than_or_equals_operator row_value_constructor { result = SQLParser::Statement::LessOrEquals.new(val[0], val[2]) }
+    | row_value_constructor greater_than_or_equals_operator row_value_constructor { result = SQLParser::Statement::GreaterOrEquals.new(val[0], val[2]) }
+
+  row_value_constructor
+    : row_value_constructor_element
+    | row_subquery
+
+  row_value_constructor_element
+    : value_expression
+
+  aggregate_parameter
+    : value_expression
+    | column_reference
+    | distinct_column_reference
+
+  value_expression
+    : numeric_value_expression
+    | general_literal
+
+  numeric_value_expression
+    : term plus_sign numeric_value_expression { result = SQLParser::Statement::Add.new(val[0], val[2]) }
+    | term minus_sign numeric_value_expression { result = SQLParser::Statement::Subtract.new(val[0], val[2]) }
+    | term
+
+  term
+    : factor asterisk term { result = SQLParser::Statement::Multiply.new(val[0], val[2]) }
+    | factor solidus term { result = SQLParser::Statement::Divide.new(val[0], val[2]) }
+    | factor
+
+  factor
+    : sign value_expression_primary { result = val[0].new(val[1]) }
+    | value_expression_primary
+
+  value_expression_primary
+    : unsigned_value_specification
+    | column_reference
+    | set_function_specification
+    | left_paren value_expression right_paren { result = val[1] }
+    | distinct_column_reference
+
+  unsigned_value_specification
+    : unsigned_literal
+    | general_value_specification
+
+  unsigned_literal
+    : unsigned_numeric_literal
+    | general_literal
+
+  general_value_specification
+    : current_user
+
+  current_user
+    : CURRENT_USER { result = SQLParser::Statement::CurrentUser.new }
+    | CURRENT_USER left_paren right_paren { result = SQLParser::Statement::CurrentUser.new }
+
+  distinct_column_reference
+    : DISTINCT left_paren column_reference right_paren { result = SQLParser::Statement::Distinct.new(val[2]) }
+    | DISTINCT column_reference { result = SQLParser::Statement::Distinct.new(val[1]) }
+
+  column_reference
+    : qualifier period column_name { result = SQLParser::Statement::QualifiedColumn.new(val[0], val[2]) }
+    | column_name
+
+  qualifier
+    : table_name
+
+  set_function_specification
+    : COUNT left_paren asterisk right_paren { result = SQLParser::Statement::Count.new(SQLParser::Statement::All.new) }
+    | general_set_function
+
+  general_set_function
+    : COUNT left_paren aggregate_parameter right_paren { result = SQLParser::Statement::Count.new(val[2]) }
+    | AVG left_paren aggregate_parameter right_paren { result = SQLParser::Statement::Average.new(val[2]) }
+    | MAX left_paren aggregate_parameter right_paren { result = SQLParser::Statement::Maximum.new(val[2]) }
+    | MIN left_paren aggregate_parameter right_paren { result = SQLParser::Statement::Minimum.new(val[2]) }
+    | SUM left_paren aggregate_parameter right_paren { result = SQLParser::Statement::Sum.new(val[2]) }
+
+# literal numbers, strings, dates and times
+  unsigned_numeric_literal
+    : exact_numeric_literal
+    | approximate_numeric_literal
+
+  exact_numeric_literal
+    : unsigned_integer period unsigned_integer { result = SQLParser::Statement::Float.new("#{val[0]}.#{val[2]}".to_f) }
+    | unsigned_integer period { result = SQLParser::Statement::Float.new(val[0]) }
+    | period unsigned_integer { result = SQLParser::Statement::Float.new("0.#{val[1]}".to_f) }
+    | unsigned_integer { result = SQLParser::Statement::Integer.new(val[0]) }
+
+  approximate_numeric_literal
+    : mantissa E exponent { result = SQLParser::Statement::ApproximateFloat.new(val[0], val[2]) }
+
+  mantissa
+    : exact_numeric_literal
+
+  exponent
+    : signed_integer
+
+  signed_integer
+    : sign unsigned_integer { result = val[0].new(SQLParser::Statement::Integer.new(val[1])) }
+    | unsigned_integer { result = SQLParser::Statement::Integer.new(val[0]) }
+
+  sign
+    : plus_sign { result = SQLParser::Statement::UnaryPlus }
+    | minus_sign { result = SQLParser::Statement::UnaryMinus }
+
+# sql module
+  column_name
+    : identifier { result = SQLParser::Statement::Column.new(val[0]) }
+
+# literals
+  general_literal
+    : string_literal
+    | datetime_literal
+
+  string_literal
+    : single_quote character_string_literal single_quote { result = SQLParser::Statement::String.new(val[1].gsub("\\'", "'")) }
+    | single_quote single_quote { result = SQLParser::Statement::String.new('') }
+    | double_quote character_string_literal double_quote { result = SQLParser::Statement::String.new(val[1].gsub('\\"', '"')) }
+    | double_quote double_quote { result = SQLParser::Statement::String.new('') }
+    | string_literal string_literal { result = val[0] + val[1] }
+
+  datetime_literal
+    : date_literal
+
+  date_literal
+    : DATE date_string { result = SQLParser::Statement::Date.new(val[1]) }
+
+---- header ----
+require File.dirname(__FILE__) + '/parser.rex.rb'
+
+---- inner ----
+
+def self.parse(sql)
+  new.scan_str(sql)
+end