sql-parser-vlad 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 75f041d77f950fb458f43d3e7489eb2b3098f9ac780cb09c70a1bde601327fed
+  data.tar.gz: d4dbd3abd54f43cb992f5d726e3b390b1fda1e14feed4a7f4905bd9018da37a1
+SHA512:
+  metadata.gz: 9f1198e58fcde7c0b509e69c6605cafbfc963aaf396f9d9582f78f2a41c4fdeb70ab4185b13c7931356c120ada5400789c467df8f8cf6c90804180560b59e66d
+  data.tar.gz: 40f615ac67cc626027677628dc67685ff3ae4638e7c138a48374dfb0aa4ca6afc2b8b2a21e01eee93213ae55319cf0c0cbcf5694731681855830eb29a5bad7d5

data/lib/sql-parser/parser.racc

@@ -0,0 +1,338 @@
+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 { result = SQLParser::Statement::DirectSelect.new(val[0], val[1]) }
+
+# module contents
+  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_name
+    | 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 DISTINCTROW select_list table_expression { result = SQLParser::Statement::Select.new(val[2], val[3], "DISTINCTROW") }
+    | SELECT DISTINCTROW select_list { result = SQLParser::Statement::Select.new(val[2], nil, "DISTINCTROW") }
+    | SELECT DISTINCT select_list table_expression { result = SQLParser::Statement::Select.new(val[2], val[3], "DISTINCT") }
+    | SELECT DISTINCT select_list { result = SQLParser::Statement::Select.new(val[2], nil, "DISTINCT") }
+    | SELECT ALL select_list table_expression { result = SQLParser::Statement::Select.new(val[2], val[3], "ALL") }
+    | SELECT ALL select_list { result = SQLParser::Statement::Select.new(val[2], nil, "ALL") }
+    | 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
+
+  table_subquery
+    : subquery
+
+  joined_table
+    : cross_join
+    | qualified_join
+
+  cross_join
+    : table_reference comma table_name { result = SQLParser::Statement::CrossJoin.new(val[0], val[2]) }
+    | table_reference CROSS JOIN table_name { 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
+
+  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], val[3], val[5])) }
+    | row_value_constructor BETWEEN row_value_constructor AND row_value_constructor { result = SQLParser::Statement::Between.new(val[0], 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
+
+  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] }
+
+  unsigned_value_specification
+    : unsigned_literal
+    | general_value_specification
+
+  unsigned_literal
+    : unsigned_numeric_literal
+    | general_literal
+
+  general_value_specification
+    : CURRENT_USER { result = SQLParser::Statement::CurrentUser.new }
+
+  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 value_expression right_paren { result = SQLParser::Statement::Count.new(val[2]) }
+    | AVG left_paren value_expression right_paren { result = SQLParser::Statement::Average.new(val[2]) }
+    | MAX left_paren value_expression right_paren { result = SQLParser::Statement::Maximum.new(val[2]) }
+    | MIN left_paren value_expression right_paren { result = SQLParser::Statement::Minimum.new(val[2]) }
+    | SUM left_paren value_expression 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
+    : quote character_string_literal quote { result = SQLParser::Statement::String.new(val[1]) }
+    | quote quote { result = SQLParser::Statement::String.new('') }
+    | datetime_literal
+
+  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