sql-parser 0.0.1 → 0.0.2

data/lib/sql-parser.rb

@@ -5,9 +5,9 @@ module SQLParser
   
   require 'racc/parser'
 
-  require_relative 'sql/version'
-  require_relative 'sql/statement'
-  require_relative 'sql/sql_visitor'
-  require_relative 'sql/parser.racc.rb'
+  require_relative 'sql-parser/version'
+  require_relative 'sql-parser/statement'
+  require_relative 'sql-parser/sql_visitor'
+  require_relative 'sql-parser/parser.racc.rb'
 
 end

data/lib/sql-parser/parser.racc

@@ -9,12 +9,12 @@ rule
     : direct_select_statement_multiple_rows
 
   direct_select_statement_multiple_rows
-    : query_expression order_by_clause { result = SQL::Statement::DirectSelect.new(val[0], val[1]) }
+    : 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 = SQL::Statement::OrderBy.new(val[2]) }
+    | 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]) }
@@ -25,47 +25,47 @@ rule
 
   sort_key
     : column_name
-    | unsigned_integer { result = SQL::Statement::Integer.new(val[0]) }
+    | unsigned_integer { result = SQLParser::Statement::Integer.new(val[0]) }
 
   ordering_specification
-    : { result = SQL::Statement::Ascending } # default
-    | ASC { result = SQL::Statement::Ascending }
-    | DESC { result = SQL::Statement::Descending }
+    : { 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 = SQL::Statement::Subquery.new(val[1]) }
+    : left_paren query_expression right_paren { result = SQLParser::Statement::Subquery.new(val[1]) }
 
   query_expression
     : query_specification
 
   query_specification
-    : SELECT select_list table_expression { result = SQL::Statement::Select.new(val[1], val[2]) }
-    | SELECT select_list { result = SQL::Statement::Select.new(val[1]) }
+    : 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 = SQL::Statement::All.new }
-    | select_sublist { result = SQL::Statement::SelectList.new(val[0]) }
+    : 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 = SQL::Statement::As.new(val[0], val[2]) }
-    | value_expression column_name { result = SQL::Statement::As.new(val[0], val[1]) }
+    : 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 = SQL::Statement::TableExpression.new(val[0], val[1], val[2], val[3]) }
+    : 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 = SQL::Statement::FromClause.new(val[1]) }
+    : FROM table_reference { result = SQLParser::Statement::FromClause.new(val[1]) }
 
   table_reference
-    : table_name AS column_name { result = SQL::Statement::As.new(val[0], val[2]) }
-    | table_name column_name { result = SQL::Statement::As.new(val[0], val[1]) }
+    : 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
 
@@ -77,41 +77,41 @@ rule
     | qualified_join
 
   cross_join
-    : table_reference comma table_name { result = SQL::Statement::CrossJoin.new(val[0], val[2]) }
-    | table_reference CROSS JOIN table_name { result = SQL::Statement::CrossJoin.new(val[0], val[3]) }
+    : 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 = SQL::Statement::InnerJoin }
-    | LEFT OUTER { result = SQL::Statement::LeftOuterJoin }
-    | LEFT { result = SQL::Statement::LeftJoin }
-    | RIGHT OUTER { result = SQL::Statement::RightOuterJoin }
-    | RIGHT { result = SQL::Statement::RightJoin }
-    | FULL { result = SQL::Statement::FullJoin }
-    | FULL OUTER { result = SQL::Statement::FullOuterJoin }
+    : 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 = SQL::Statement::On.new(val[1]) }
+    : ON search_condition { result = SQLParser::Statement::On.new(val[1]) }
 
   named_columns_join
-    : USING left_paren join_column_list right_paren { result = SQL::Statement::Using.new(val[2]) }
+    : 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 = SQL::Statement::WhereClause.new(val[1]) }
+    | WHERE search_condition { result = SQLParser::Statement::WhereClause.new(val[1]) }
 
   group_by_clause
     : # no action
-    | GROUP BY grouping_column_reference_list { result = SQL::Statement::GroupByClause.new(val[2]) }
+    | 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]) }
@@ -122,23 +122,23 @@ rule
 
   having_clause
     : # no action
-    | HAVING search_condition { result = SQL::Statement::HavingClause.new(val[1]) }
+    | 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 = SQL::Statement::Not.new(SQL::Statement::Between.new(val[0], val[3], val[5])) }
-    | row_value_constructor BETWEEN row_value_constructor AND row_value_constructor { result = SQL::Statement::Between.new(val[0], val[2], val[4]) }
+    : 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 = SQL::Statement::Not.new(SQL::Statement::In.new(val[0], val[3])) }
-    | row_value_constructor IN in_predicate_value { result = SQL::Statement::In.new(val[0], val[2]) }
+    : 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 = SQL::Statement::InValueList.new(val[1]) }
+    | 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]) }
@@ -148,19 +148,19 @@ rule
     # 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 = SQL::Statement::Not.new(SQL::Statement::Like.new(val[0], val[3])) }
-    | row_value_constructor LIKE row_value_constructor { result = SQL::Statement::Like.new(val[0], val[2]) }
+    : 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 = SQL::Statement::Not.new(SQL::Statement::Is.new(val[0], SQL::Statement::Null.new)) }
-    | row_value_constructor IS NULL { result = SQL::Statement::Is.new(val[0], SQL::Statement::Null.new) }
+    : 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 = SQL::Statement::Exists.new(val[1]) }
+    : EXISTS table_subquery { result = SQLParser::Statement::Exists.new(val[1]) }
 
 # constraints
   table_name
-    : identifier { result = SQL::Statement::Table.new(val[0]) }
+    : identifier { result = SQLParser::Statement::Table.new(val[0]) }
 
   column_name_list
     : column_name_list comma column_name { result = Array(val[0]) + Array(val[2]) }
@@ -169,14 +169,14 @@ rule
 # search condition
   search_condition
     : boolean_term
-    | search_condition OR boolean_term { result = SQL::Statement::Or.new(val[0], val[2]) }
+    | search_condition OR boolean_term { result = SQLParser::Statement::Or.new(val[0], val[2]) }
 
   boolean_term
     : boolean_factor
-    | boolean_term AND boolean_factor { result = SQL::Statement::And.new(val[0], val[2]) }
+    | boolean_term AND boolean_factor { result = SQLParser::Statement::And.new(val[0], val[2]) }
 
   boolean_factor:
-    : NOT boolean_test { result = SQL::Statement::Not.new(val[1]) }
+    : NOT boolean_test { result = SQLParser::Statement::Not.new(val[1]) }
     | boolean_test
 
   boolean_test
@@ -195,12 +195,12 @@ rule
     | exists_predicate
 
   comparison_predicate
-    : row_value_constructor equals_operator row_value_constructor { result = SQL::Statement::Equals.new(val[0], val[2]) }
-    | row_value_constructor not_equals_operator row_value_constructor { result = SQL::Statement::Not.new(SQL::Statement::Equals.new(val[0], val[2])) }
-    | row_value_constructor less_than_operator row_value_constructor { result = SQL::Statement::Less.new(val[0], val[2]) }
-    | row_value_constructor greater_than_operator row_value_constructor { result = SQL::Statement::Greater.new(val[0], val[2]) }
-    | row_value_constructor less_than_or_equals_operator row_value_constructor { result = SQL::Statement::LessOrEquals.new(val[0], val[2]) }
-    | row_value_constructor greater_than_or_equals_operator row_value_constructor { result = SQL::Statement::GreaterOrEquals.new(val[0], val[2]) }
+    : 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
@@ -213,13 +213,13 @@ rule
     : numeric_value_expression
 
   numeric_value_expression
-    : term plus_sign numeric_value_expression { result = SQL::Statement::Add.new(val[0], val[2]) }
-    | term minus_sign numeric_value_expression { result = SQL::Statement::Subtract.new(val[0], val[2]) }
+    : 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 = SQL::Statement::Multiply.new(val[0], val[2]) }
-    | factor solidus term { result = SQL::Statement::Divide.new(val[0], val[2]) }
+    : 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
@@ -241,25 +241,25 @@ rule
     | general_literal
 
   general_value_specification
-    : CURRENT_USER { result = SQL::Statement::CurrentUser.new }
+    : CURRENT_USER { result = SQLParser::Statement::CurrentUser.new }
 
   column_reference
-    : qualifier period column_name { result = SQL::Statement::QualifiedColumn.new(val[0], val[2]) }
+    : 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 = SQL::Statement::Count.new(SQL::Statement::All.new) }
+    : 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 = SQL::Statement::Count.new(val[2]) }
-    | AVG left_paren value_expression right_paren { result = SQL::Statement::Average.new(val[2]) }
-    | MAX left_paren value_expression right_paren { result = SQL::Statement::Maximum.new(val[2]) }
-    | MIN left_paren value_expression right_paren { result = SQL::Statement::Minimum.new(val[2]) }
-    | SUM left_paren value_expression right_paren { result = SQL::Statement::Sum.new(val[2]) }
+    : 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
@@ -267,13 +267,13 @@ rule
     | approximate_numeric_literal
 
   exact_numeric_literal
-    : unsigned_integer period unsigned_integer { result = SQL::Statement::Float.new("#{val[0]}.#{val[2]}".to_f) }
-    | unsigned_integer period { result = SQL::Statement::Float.new(val[0]) }
-    | period unsigned_integer { result = SQL::Statement::Float.new("0.#{val[1]}".to_f) }
-    | unsigned_integer { result = SQL::Statement::Integer.new(val[0]) }
+    : 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 = SQL::Statement::ApproximateFloat.new(val[0], val[2]) }
+    : mantissa E exponent { result = SQLParser::Statement::ApproximateFloat.new(val[0], val[2]) }
 
   mantissa
     : exact_numeric_literal
@@ -282,28 +282,28 @@ rule
     : signed_integer
 
   signed_integer
-    : sign unsigned_integer { result = val[0].new(SQL::Statement::Integer.new(val[1])) }
-    | unsigned_integer { result = SQL::Statement::Integer.new(val[0]) }
+    : 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 = SQL::Statement::UnaryPlus }
-    | minus_sign { result = SQL::Statement::UnaryMinus }
+    : plus_sign { result = SQLParser::Statement::UnaryPlus }
+    | minus_sign { result = SQLParser::Statement::UnaryMinus }
 
 # sql module
   column_name
-    : identifier { result = SQL::Statement::Column.new(val[0]) }
+    : identifier { result = SQLParser::Statement::Column.new(val[0]) }
 
 # literals
   general_literal
-    : quote character_string_literal quote { result = SQL::Statement::String.new(val[1]) }
-    | quote quote { result = SQL::Statement::String.new('') }
+    : 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 = SQL::Statement::Date.new(val[1]) }
+    : DATE date_string { result = SQLParser::Statement::Date.new(val[1]) }
 
 ---- header ----
 require File.dirname(__FILE__) + '/parser.rex.rb'

data/lib/sql-parser/parser.racc.rb

@@ -701,7 +701,7 @@ Racc_debug_parser = false
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 11
   def _reduce_3( val, _values, result )
- result = SQL::Statement::DirectSelect.new(val[0], val[1])
+ result = SQLParser::Statement::DirectSelect.new(val[0], val[1])
    result
   end
 .,.,
@@ -710,7 +710,7 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 11
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 16
   def _reduce_5( val, _values, result )
- result = SQL::Statement::OrderBy.new(val[2])
+ result = SQLParser::Statement::OrderBy.new(val[2])
    result
   end
 .,.,
@@ -735,35 +735,35 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 23
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 27
   def _reduce_10( val, _values, result )
- result = SQL::Statement::Integer.new(val[0])
+ result = SQLParser::Statement::Integer.new(val[0])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 30
   def _reduce_11( val, _values, result )
- result = SQL::Statement::Ascending
+ result = SQLParser::Statement::Ascending
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 31
   def _reduce_12( val, _values, result )
- result = SQL::Statement::Ascending
+ result = SQLParser::Statement::Ascending
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 32
   def _reduce_13( val, _values, result )
- result = SQL::Statement::Descending
+ result = SQLParser::Statement::Descending
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 37
   def _reduce_14( val, _values, result )
- result = SQL::Statement::Subquery.new(val[1])
+ result = SQLParser::Statement::Subquery.new(val[1])
    result
   end
 .,.,
@@ -772,28 +772,28 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 37
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 43
   def _reduce_16( val, _values, result )
- result = SQL::Statement::Select.new(val[1], val[2])
+ result = SQLParser::Statement::Select.new(val[1], val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 44
   def _reduce_17( val, _values, result )
- result = SQL::Statement::Select.new(val[1])
+ result = SQLParser::Statement::Select.new(val[1])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 47
   def _reduce_18( val, _values, result )
- result = SQL::Statement::All.new
+ result = SQLParser::Statement::All.new
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 48
   def _reduce_19( val, _values, result )
- result = SQL::Statement::SelectList.new(val[0])
+ result = SQLParser::Statement::SelectList.new(val[0])
    result
   end
 .,.,
@@ -809,14 +809,14 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 51
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 55
   def _reduce_22( val, _values, result )
- result = SQL::Statement::As.new(val[0], val[2])
+ result = SQLParser::Statement::As.new(val[0], val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 56
   def _reduce_23( val, _values, result )
- result = SQL::Statement::As.new(val[0], val[1])
+ result = SQLParser::Statement::As.new(val[0], val[1])
    result
   end
 .,.,
@@ -825,28 +825,28 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 56
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 60
   def _reduce_25( val, _values, result )
- result = SQL::Statement::TableExpression.new(val[0], val[1], val[2], val[3])
+ result = SQLParser::Statement::TableExpression.new(val[0], val[1], val[2], val[3])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 63
   def _reduce_26( val, _values, result )
- result = SQL::Statement::FromClause.new(val[1])
+ result = SQLParser::Statement::FromClause.new(val[1])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 66
   def _reduce_27( val, _values, result )
- result = SQL::Statement::As.new(val[0], val[2])
+ result = SQLParser::Statement::As.new(val[0], val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 67
   def _reduce_28( val, _values, result )
- result = SQL::Statement::As.new(val[0], val[1])
+ result = SQLParser::Statement::As.new(val[0], val[1])
    result
   end
 .,.,
@@ -863,14 +863,14 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 67
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 79
   def _reduce_34( val, _values, result )
- result = SQL::Statement::CrossJoin.new(val[0], val[2])
+ result = SQLParser::Statement::CrossJoin.new(val[0], val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 80
   def _reduce_35( val, _values, result )
- result = SQL::Statement::CrossJoin.new(val[0], val[3])
+ result = SQLParser::Statement::CrossJoin.new(val[0], val[3])
    result
   end
 .,.,
@@ -884,49 +884,49 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 83
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 86
   def _reduce_37( val, _values, result )
- result = SQL::Statement::InnerJoin
+ result = SQLParser::Statement::InnerJoin
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 87
   def _reduce_38( val, _values, result )
- result = SQL::Statement::LeftOuterJoin
+ result = SQLParser::Statement::LeftOuterJoin
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 88
   def _reduce_39( val, _values, result )
- result = SQL::Statement::LeftJoin
+ result = SQLParser::Statement::LeftJoin
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 89
   def _reduce_40( val, _values, result )
- result = SQL::Statement::RightOuterJoin
+ result = SQLParser::Statement::RightOuterJoin
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 90
   def _reduce_41( val, _values, result )
- result = SQL::Statement::RightJoin
+ result = SQLParser::Statement::RightJoin
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 91
   def _reduce_42( val, _values, result )
- result = SQL::Statement::FullJoin
+ result = SQLParser::Statement::FullJoin
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 92
   def _reduce_43( val, _values, result )
- result = SQL::Statement::FullOuterJoin
+ result = SQLParser::Statement::FullOuterJoin
    result
   end
 .,.,
@@ -937,14 +937,14 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 92
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 99
   def _reduce_46( val, _values, result )
- result = SQL::Statement::On.new(val[1])
+ result = SQLParser::Statement::On.new(val[1])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 102
   def _reduce_47( val, _values, result )
- result = SQL::Statement::Using.new(val[2])
+ result = SQLParser::Statement::Using.new(val[2])
    result
   end
 .,.,
@@ -955,7 +955,7 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 102
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 109
   def _reduce_50( val, _values, result )
- result = SQL::Statement::WhereClause.new(val[1])
+ result = SQLParser::Statement::WhereClause.new(val[1])
    result
   end
 .,.,
@@ -964,7 +964,7 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 109
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 113
   def _reduce_52( val, _values, result )
- result = SQL::Statement::GroupByClause.new(val[2])
+ result = SQLParser::Statement::GroupByClause.new(val[2])
    result
   end
 .,.,
@@ -984,7 +984,7 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 116
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 124
   def _reduce_57( val, _values, result )
- result = SQL::Statement::HavingClause.new(val[1])
+ result = SQLParser::Statement::HavingClause.new(val[1])
    result
   end
 .,.,
@@ -993,28 +993,28 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 124
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 131
   def _reduce_59( val, _values, result )
- result = SQL::Statement::Not.new(SQL::Statement::Between.new(val[0], val[3], val[5]))
+ result = SQLParser::Statement::Not.new(SQLParser::Statement::Between.new(val[0], val[3], val[5]))
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 132
   def _reduce_60( val, _values, result )
- result = SQL::Statement::Between.new(val[0], val[2], val[4])
+ result = SQLParser::Statement::Between.new(val[0], val[2], val[4])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 135
   def _reduce_61( val, _values, result )
- result = SQL::Statement::Not.new(SQL::Statement::In.new(val[0], val[3]))
+ result = SQLParser::Statement::Not.new(SQLParser::Statement::In.new(val[0], val[3]))
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 136
   def _reduce_62( val, _values, result )
- result = SQL::Statement::In.new(val[0], val[2])
+ result = SQLParser::Statement::In.new(val[0], val[2])
    result
   end
 .,.,
@@ -1023,7 +1023,7 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 136
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 140
   def _reduce_64( val, _values, result )
- result = SQL::Statement::InValueList.new(val[1])
+ result = SQLParser::Statement::InValueList.new(val[1])
    result
   end
 .,.,
@@ -1039,42 +1039,42 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 143
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 150
   def _reduce_67( val, _values, result )
- result = SQL::Statement::Not.new(SQL::Statement::Like.new(val[0], val[3]))
+ result = SQLParser::Statement::Not.new(SQLParser::Statement::Like.new(val[0], val[3]))
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 151
   def _reduce_68( val, _values, result )
- result = SQL::Statement::Like.new(val[0], val[2])
+ result = SQLParser::Statement::Like.new(val[0], val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 154
   def _reduce_69( val, _values, result )
- result = SQL::Statement::Not.new(SQL::Statement::Is.new(val[0], SQL::Statement::Null.new))
+ result = SQLParser::Statement::Not.new(SQLParser::Statement::Is.new(val[0], SQLParser::Statement::Null.new))
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 155
   def _reduce_70( val, _values, result )
- result = SQL::Statement::Is.new(val[0], SQL::Statement::Null.new)
+ result = SQLParser::Statement::Is.new(val[0], SQLParser::Statement::Null.new)
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 158
   def _reduce_71( val, _values, result )
- result = SQL::Statement::Exists.new(val[1])
+ result = SQLParser::Statement::Exists.new(val[1])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 162
   def _reduce_72( val, _values, result )
- result = SQL::Statement::Table.new(val[0])
+ result = SQLParser::Statement::Table.new(val[0])
    result
   end
 .,.,
@@ -1092,7 +1092,7 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 165
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 171
   def _reduce_76( val, _values, result )
- result = SQL::Statement::Or.new(val[0], val[2])
+ result = SQLParser::Statement::Or.new(val[0], val[2])
    result
   end
 .,.,
@@ -1101,14 +1101,14 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 171
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 175
   def _reduce_78( val, _values, result )
- result = SQL::Statement::And.new(val[0], val[2])
+ result = SQLParser::Statement::And.new(val[0], val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 178
   def _reduce_79( val, _values, result )
- result = SQL::Statement::Not.new(val[1])
+ result = SQLParser::Statement::Not.new(val[1])
    result
   end
 .,.,
@@ -1140,42 +1140,42 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 186
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 197
   def _reduce_90( val, _values, result )
- result = SQL::Statement::Equals.new(val[0], val[2])
+ result = SQLParser::Statement::Equals.new(val[0], val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 198
   def _reduce_91( val, _values, result )
- result = SQL::Statement::Not.new(SQL::Statement::Equals.new(val[0], val[2]))
+ result = SQLParser::Statement::Not.new(SQLParser::Statement::Equals.new(val[0], val[2]))
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 199
   def _reduce_92( val, _values, result )
- result = SQL::Statement::Less.new(val[0], val[2])
+ result = SQLParser::Statement::Less.new(val[0], val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 200
   def _reduce_93( val, _values, result )
- result = SQL::Statement::Greater.new(val[0], val[2])
+ result = SQLParser::Statement::Greater.new(val[0], val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 201
   def _reduce_94( val, _values, result )
- result = SQL::Statement::LessOrEquals.new(val[0], val[2])
+ result = SQLParser::Statement::LessOrEquals.new(val[0], val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 202
   def _reduce_95( val, _values, result )
- result = SQL::Statement::GreaterOrEquals.new(val[0], val[2])
+ result = SQLParser::Statement::GreaterOrEquals.new(val[0], val[2])
    result
   end
 .,.,
@@ -1190,14 +1190,14 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 202
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 215
   def _reduce_100( val, _values, result )
- result = SQL::Statement::Add.new(val[0], val[2])
+ result = SQLParser::Statement::Add.new(val[0], val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 216
   def _reduce_101( val, _values, result )
- result = SQL::Statement::Subtract.new(val[0], val[2])
+ result = SQLParser::Statement::Subtract.new(val[0], val[2])
    result
   end
 .,.,
@@ -1206,14 +1206,14 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 216
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 220
   def _reduce_103( val, _values, result )
- result = SQL::Statement::Multiply.new(val[0], val[2])
+ result = SQLParser::Statement::Multiply.new(val[0], val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 221
   def _reduce_104( val, _values, result )
- result = SQL::Statement::Divide.new(val[0], val[2])
+ result = SQLParser::Statement::Divide.new(val[0], val[2])
    result
   end
 .,.,
@@ -1252,14 +1252,14 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 232
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 243
   def _reduce_116( val, _values, result )
- result = SQL::Statement::CurrentUser.new
+ result = SQLParser::Statement::CurrentUser.new
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 246
   def _reduce_117( val, _values, result )
- result = SQL::Statement::QualifiedColumn.new(val[0], val[2])
+ result = SQLParser::Statement::QualifiedColumn.new(val[0], val[2])
    result
   end
 .,.,
@@ -1270,7 +1270,7 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 246
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 253
   def _reduce_120( val, _values, result )
- result = SQL::Statement::Count.new(SQL::Statement::All.new)
+ result = SQLParser::Statement::Count.new(SQLParser::Statement::All.new)
    result
   end
 .,.,
@@ -1279,35 +1279,35 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 253
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 257
   def _reduce_122( val, _values, result )
- result = SQL::Statement::Count.new(val[2])
+ result = SQLParser::Statement::Count.new(val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 258
   def _reduce_123( val, _values, result )
- result = SQL::Statement::Average.new(val[2])
+ result = SQLParser::Statement::Average.new(val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 259
   def _reduce_124( val, _values, result )
- result = SQL::Statement::Maximum.new(val[2])
+ result = SQLParser::Statement::Maximum.new(val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 260
   def _reduce_125( val, _values, result )
- result = SQL::Statement::Minimum.new(val[2])
+ result = SQLParser::Statement::Minimum.new(val[2])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 261
   def _reduce_126( val, _values, result )
- result = SQL::Statement::Sum.new(val[2])
+ result = SQLParser::Statement::Sum.new(val[2])
    result
   end
 .,.,
@@ -1318,35 +1318,35 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 261
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 269
   def _reduce_129( val, _values, result )
- result = SQL::Statement::Float.new("#{val[0]}.#{val[2]}".to_f)
+ result = SQLParser::Statement::Float.new("#{val[0]}.#{val[2]}".to_f)
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 270
   def _reduce_130( val, _values, result )
- result = SQL::Statement::Float.new(val[0])
+ result = SQLParser::Statement::Float.new(val[0])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 271
   def _reduce_131( val, _values, result )
- result = SQL::Statement::Float.new("0.#{val[1]}".to_f)
+ result = SQLParser::Statement::Float.new("0.#{val[1]}".to_f)
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 272
   def _reduce_132( val, _values, result )
- result = SQL::Statement::Integer.new(val[0])
+ result = SQLParser::Statement::Integer.new(val[0])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 275
   def _reduce_133( val, _values, result )
- result = SQL::Statement::ApproximateFloat.new(val[0], val[2])
+ result = SQLParser::Statement::ApproximateFloat.new(val[0], val[2])
    result
   end
 .,.,
@@ -1357,49 +1357,49 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 275
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 284
   def _reduce_136( val, _values, result )
- result = val[0].new(SQL::Statement::Integer.new(val[1]))
+ result = val[0].new(SQLParser::Statement::Integer.new(val[1]))
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 285
   def _reduce_137( val, _values, result )
- result = SQL::Statement::Integer.new(val[0])
+ result = SQLParser::Statement::Integer.new(val[0])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 288
   def _reduce_138( val, _values, result )
- result = SQL::Statement::UnaryPlus
+ result = SQLParser::Statement::UnaryPlus
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 289
   def _reduce_139( val, _values, result )
- result = SQL::Statement::UnaryMinus
+ result = SQLParser::Statement::UnaryMinus
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 293
   def _reduce_140( val, _values, result )
- result = SQL::Statement::Column.new(val[0])
+ result = SQLParser::Statement::Column.new(val[0])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 297
   def _reduce_141( val, _values, result )
- result = SQL::Statement::String.new(val[1])
+ result = SQLParser::Statement::String.new(val[1])
    result
   end
 .,.,
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 298
   def _reduce_142( val, _values, result )
- result = SQL::Statement::String.new('')
+ result = SQLParser::Statement::String.new('')
    result
   end
 .,.,
@@ -1410,7 +1410,7 @@ module_eval <<'.,.,', 'lib/sql/parser.racc', 298
 
 module_eval <<'.,.,', 'lib/sql/parser.racc', 305
   def _reduce_145( val, _values, result )
- result = SQL::Statement::Date.new(val[1])
+ result = SQLParser::Statement::Date.new(val[1])
    result
   end
 .,.,

data/lib/sql-parser/version.rb

@@ -1,5 +1,5 @@
 module SQLParser
   
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sql-parser
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors: