oracle-sql-parser 0.8.1 → 0.9.0

data/lib/oracle-sql-parser/grammar/condition/between.treetop

@@ -0,0 +1,20 @@
+module OracleSqlParser::Grammar::Condition
+  grammar Between
+    rule between_condition
+      target:expr space n:(not_keyword space)? between_keyword space from:expr space and_keyword space to:expr {
+        def ast
+          OracleSqlParser::Ast::BetweenCondition[
+            :target => target.ast,
+            :not => not_keyword.ast,
+            :from => from.ast,
+            :to => to.ast
+          ]
+        end
+
+        def not_keyword
+          n.elements && n.elements.first
+        end
+      }
+    end
+  end
+end

data/lib/oracle-sql-parser/grammar/condition/comparison.treetop

@@ -0,0 +1,32 @@
+module OracleSqlParser::Grammar::Condition
+  grammar Comparison
+    rule comparison_condition
+      (
+        simple_comparison_condition /
+        group_comparison_condition
+      ) {
+        def ast
+          super
+        end
+      }
+    end
+
+    rule group_comparison_condition
+      'group_comparison_condition'
+    end
+
+    rule simple_comparison_condition
+      (
+        left:expr space? op:('!=' / '^=' / '<>' / '>=' / '<=' / '=' / '>' / '<') space? right:expr /
+        '(' space? left:exprs space? ')' op:space? ('!=' / '^=' / '<>' / '=') space? '(' space? right:subquery space? ')'
+      ) {
+        def ast
+          OracleSqlParser::Ast::SimpleComparisonCondition[
+            :left => left.ast,
+            :op => op.text_value,
+            :right => right.ast]
+        end
+      }
+    end
+  end
+end

data/lib/oracle-sql-parser/grammar/condition/compound.treetop

@@ -0,0 +1,11 @@
+module OracleSqlParser::Grammar::Condition
+  grammar Compound
+    rule compound_condition
+      '(' logical_condition ')' {
+        def ast
+          OracleSqlParser::Ast::CompoundCondition[:condition => logical_condition.ast]
+        end
+      }
+    end
+  end
+end

data/lib/oracle-sql-parser/grammar/condition/exists.treetop

@@ -0,0 +1,13 @@
+module OracleSqlParser::Grammar::Condition
+  grammar Exists
+    rule exists_condition
+      exists_keyword space? '(' space? subquery space? ')' {
+        def ast
+          OracleSqlParser::Ast::ExistsCondition[
+            :target => subquery.ast
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/oracle-sql-parser/grammar/condition/floating_point.treetop

@@ -0,0 +1,20 @@
+module OracleSqlParser::Grammar::Condition
+  grammar FloatingPoint
+    rule floating_point_condition
+      expr space? is_keyword space? not_keyword:not_keyword? space?
+      value:(
+        nan_keyword /
+        infinite_keyword
+      ) {
+        def ast
+          OracleSqlParser::Ast::FloatingPointCondition[
+            :target => expr.ast,
+            :is => is_keyword.ast,
+            :not => not_keyword.ast,
+            :value => value.ast
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/oracle-sql-parser/grammar/condition/in.treetop

@@ -0,0 +1,19 @@
+module OracleSqlParser::Grammar::Condition
+  grammar In
+    rule in_condition
+      target:expr space n:(not_keyword space)? in_keyword space? '(' space? values:( exprs / subquery ) space? ')' {
+        def ast
+          OracleSqlParser::Ast::InCondition[
+            :target => target.ast,
+            :not => not_keyword.ast,
+            :values =>  values.ast
+          ]
+        end
+
+        def not_keyword
+          n.elements && n.elements.first
+        end
+      }
+    end
+  end
+end

data/lib/oracle-sql-parser/grammar/condition/is_of_type.treetop

@@ -0,0 +1,56 @@
+module OracleSqlParser::Grammar::Condition
+  grammar IsOfType
+    rule is_of_type_condition
+      expr space?
+      is_keyword space?
+      not_keyword:not_keyword? space?
+      of_keyword space?
+      type_keyword:type_keyword? space?
+      '(' space? types space? ')' {
+        def ast
+          OracleSqlParser::Ast::IsOfTypeCondition[
+            :target => expr.ast,
+            :is => is_keyword.ast,
+            :not => not_keyword.ast,
+            :of => of_keyword.ast,
+            :type => type_keyword.ast,
+            :types => types.ast
+          ]
+        end
+      }
+    end
+
+    rule types
+      only_and_type space? more:(',' space? only_and_type space?)* {
+        def ast
+          OracleSqlParser::Ast::Array[only_and_type.ast, *more_only_and_types.map(&:ast)]
+        end
+
+        def more_only_and_types
+          more.elements.map(&:only_and_type)
+        end
+      }
+    end
+
+    rule only_and_type
+      only_keyword:only_keyword? space? type {
+        def ast
+          OracleSqlParser::Ast::OnlyAndType[
+            :only => only_keyword.ast,
+            :type => type.ast
+          ]
+        end
+      }
+    end
+
+    rule type
+      schema_name '.' ident /
+      ident {
+        def ast
+          OracleSqlParser::Ast::Identifier[:name => text_value]
+        end
+      }
+    end
+
+  end
+end

data/lib/oracle-sql-parser/grammar/condition/multiset.treetop

@@ -0,0 +1,85 @@
+module OracleSqlParser::Grammar::Condition
+  grammar Multiset
+    rule mutiset_condition
+      is_a_set_condition /
+      is_empty_condition /
+      member_condition /
+      submultiset_condition {
+        def ast
+          super
+        end
+      }
+    end
+
+    rule is_a_set_condition
+      nested_table space? is_keyword space? not_keyword:not_keyword? space? a:[Aa] space? set_keyword {
+        def ast
+          OracleSqlParser::Ast::IsASetCondition[
+            :target => nested_table.ast,
+            :is => is_keyword.ast,
+            :not => not_keyword.ast,
+            :a => OracleSqlParser::Ast::Keyword[:name => a.text_value],
+            :set => set_keyword.ast
+          ]
+        end
+      }
+    end
+
+    rule is_empty_condition
+      nested_table space? is_keyword space? not_keyword:not_keyword? space? empty_keyword {
+        def ast
+          OracleSqlParser::Ast::IsEmptyCondition[
+            :target => nested_table.ast,
+            :is => is_keyword.ast,
+            :not => not_keyword.ast,
+            :empty => empty_keyword.ast
+          ]
+        end
+      }
+    end
+
+    rule member_condition
+      expr space? not_keyword:not_keyword? space? member_keyword space? of_keyword space? nested_table {
+        def ast
+          OracleSqlParser::Ast::MemberCondition[
+            :target => expr.ast,
+            :not => not_keyword.ast,
+            :member => member_keyword.ast,
+            :of => of_keyword.ast,
+            :table => nested_table.ast
+          ]
+        end
+      }
+    end
+
+    rule submultiset_condition
+      table1:nested_table space?
+      not_keyword:not_keyword? space?
+      submultiset_keyword space?
+      of_keyword:of_keyword? space?
+      table2:nested_table {
+        def ast
+          OracleSqlParser::Ast::SubmultisetCondition[
+            :target => table1.ast,
+            :not => not_keyword.ast,
+            :submultiset => submultiset_keyword.ast,
+            :of => of_keyword.ast,
+            :table => table2.ast
+          ]
+        end
+      }
+    end
+
+    rule nested_table
+      ident {
+        def ast
+          super
+        end
+      }
+    end
+
+
+
+  end
+end
+

data/lib/oracle-sql-parser/grammar/condition/null.treetop

@@ -0,0 +1,17 @@
+module OracleSqlParser::Grammar::Condition
+  grammar Null
+    rule null_condition
+      expr space is_keyword space n:(not_keyword space)? null_keyword {
+        def ast
+          OracleSqlParser::Ast::NullCondition[
+            :target => expr.ast,
+            :not => not_keyword.ast]
+        end
+
+        def not_keyword
+          n.elements && n.elements.first
+        end
+      }
+    end
+  end
+end

data/lib/oracle-sql-parser/grammar/condition/pattern_matching.treetop

@@ -0,0 +1,47 @@
+module OracleSqlParser::Grammar::Condition
+  grammar PatternMatching
+    rule pattern_maching_condition
+      (
+        like_condition /
+        regexp_like_condition
+      ) {
+        def ast
+          super
+        end
+      }
+    end
+
+    rule like_condition
+      target:ident space
+      n:(not_keyword:not_keyword space)?
+      like:(like_keyword / like2_keyword / like4_keyword / likec_keyword) space
+      text:text_literal
+      e:(space escape_keyword space escape_text:text_literal)? {
+        def ast
+          OracleSqlParser::Ast::LikeCondition[
+            :target => target.ast,
+            :not => not_keyword.ast,
+            :like => like.ast,
+            :text => text.ast,
+            :escape => e.try(:escape_text).ast
+          ]
+        end
+
+        def not_keyword
+          n.elements && n.elements.first
+        end
+      }
+    end
+
+    rule regexp_like_condition
+      regexp_like_keyword '(' space? target:ident space? ',' space? regexp:text_literal space? ')' {
+        def ast
+          OracleSqlParser::Ast::RegexpCondition[
+            :target => target.ast,
+            :regexp => regexp.ast
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/oracle-sql-parser/grammar/delete.treetop

@@ -7,13 +7,9 @@ module OracleSqlParser::Grammar
         def ast
           OracleSqlParser::Ast::DeleteStatement[
             :target => delete_from_clause.ast,
-            :where_clause => delete_condition.ast
+            :where_clause => condition.try(:delete_condition).ast
           ]
         end
-
-        def delete_condition
-          condition.delete_condition if condition.respond_to? :delete_condition
-        end
       }
     end
 
@@ -38,14 +34,10 @@ module OracleSqlParser::Grammar
           else
             OracleSqlParser::Ast::DeleteTarget[
               :name => t.ast,
-              :alias => t_alias.ast
+              :alias => a.try(:t_alias).ast,
             ]
           end
         end
-
-        def t_alias
-          a.t_alias if a.respond_to? :t_alias
-        end
       }
     end
 

data/lib/oracle-sql-parser/grammar/expression.treetop

@@ -1,64 +1,42 @@
 module OracleSqlParser::Grammar
   grammar Expression
+    include OracleSqlParser::Grammar::Expression::Compound
+    include OracleSqlParser::Grammar::Expression::Function
+    include OracleSqlParser::Grammar::Expression::Case
+    include OracleSqlParser::Grammar::Expression::Simple
+    include OracleSqlParser::Grammar::Expression::Cursor
+    include OracleSqlParser::Grammar::Expression::Datetime
+    include OracleSqlParser::Grammar::Expression::Interval
+
     rule sql_expression
       ex:(
+        interval_expression /
         compound_expression /
         function_expression /
         case_expression /
         cursor_expression /
         datetime_expression /
-        interval_expression /
         object_access_expression /
         scalar_subquery_expression /
         model_expression /
         type_constructor_expression /
         simple_expression /
-        variable_expression
+        variable_expression /
+        column_expression /
+        json_object_access_expression /
+        object_access_expression
         ) {
         def ast
           ex.ast
-#          super
-#          tree = ex.ast
-##          tree[:as] = alias_name.try(:as_keyword).try(:ast)
-#          tree[:alias] = alias_name.try(:ident).try(:ast)
-#          tree
-        end
-      }
-    end
-
-    rule simple_expression
-        rownum_keyword /
-        sysdate_keyword /
-        systimestamp_keyword /
-        null_keyword /
-        text_literal /
-        number_literal /
-        sequence /
-        simple_expression_column {
-        def ast
-          super
-        end
-      }
-    end
-
-    rule simple_expression_column
-      name:(
-        ( schema_name space? '.' space? table_name '.' / table_name space? '.' space? )?
-        ( rowid_keyword / column_name )
-      ) {
-        def ast
-          OracleSqlParser::Ast::Identifier.new(:name => text_value)
         end
       }
     end
 
-    rule not_compound_expressions
+    rule not_loop_sql_expression
       ex:(
         function_expression /
         case_expression /
         cursor_expression /
-        datetime_expression /
-        interval_expression /
         object_access_expression /
         scalar_subquery_expression /
         model_expression /
@@ -72,197 +50,45 @@ module OracleSqlParser::Grammar
       }
     end
 
-    rule compound_expression
-      ex:(
-        left_parenthesis:'(' space? left:expr space? right_parenthesis:')' /
-        left:not_compound_expressions space? op:('*' / '/' / '+' / '-' / '||') space? right:expr /
-        !number_literal op:(prior_keyword / '-' / '+') space? right:expr
-      )
-
-        {
-          def ast
-            OracleSqlParser::Ast::CompoundExpression[
-              :has_parenthesis => ex.respond_to?(:left_parenthesis) ? true : nil,
-              :left => left.ast,
-              :op => op.ast,
-              :right => right.ast,
-            ]
-          end
-
-          def left
-            ex.left if ex.respond_to? :left
-          end
-
-          def not_compound_expressions
-            ex.not_compound_expressions if ex.respond_to? :not_compound_expressions
-          end
-
-          def op
-            ex.op if ex.respond_to? :op
-          end
-
-          def right
-            ex.right if ex.respond_to? :right
-          end
-
-          def right_parenthesis
-            ex.right_parenthesis if ex.respond_to? :right_parenthesis
-          end
-        }
-    end
-
-    rule case_expression
-      case_keyword space? case_expression:(simple_case_expression / searched_case_expression) space?
-      else_clause:else_clause? space? end_keyword {
-        def ast
-          ast = case_expression.ast
-          ast.else_clause = else_clause.ast
-          ast
-        end
-      }
-    end
-
-    rule simple_case_expression
-      expr space w:(when_keyword space comparison_expr space then_keyword space? return_expr space?)+ {
-        def ast
-          OracleSqlParser::Ast::SimpleCaseExpression[
-            :condition => expr.ast,
-            :when_clauses => OracleSqlParser::Ast::Array[*when_clauses]
-          ]
-        end
-
-        def when_clauses
-          w.elements.map do |elem|
-            OracleSqlParser::Ast::Hash[
-              :when_expr => elem.comparison_expr.ast,
-              :return_expr => elem.return_expr.ast
-            ]
-          end
-        end
-      }
-    end
-
-    rule comparison_expr
-      expr {
-        def ast
-          super
-        end
-      }
+    rule object_access_expression
+      'object_access_expression' # not implemented
     end
 
-    rule return_expr
-      expr {
-        def ast
-          super
-        end
-      }
+    rule scalar_subquery_expression
+      'scalar_subquery_expression' # not implemented
     end
 
-    rule else_expr
-      expr {
-        def ast
-          super
-        end
-      }
+    rule model_expression
+      'model_expression' # not implemented
     end
 
-    rule searched_case_expression
-      when_keyword space? condition space? then_keyword space? return_expr {
-        def ast
-          OracleSqlParser::Ast::SearchedCaseExpression[
-            :when_condition => condition.ast,
-            :return_expr => return_expr.ast
-          ]
-        end
-      }
+    rule type_constructor_expression
+      'type_constructor_expression' # not implemented
     end
 
-    rule else_clause
-      else_keyword space? else_expr {
-        def ast
-          else_expr.ast
-        end
-      }
+    rule variable_expression
+      'variable_expression' # not implemented
     end
 
-    rule cursor_expression
-      'cursor_expression' # not implemented
+    rule column_expression
+      'column_expression' # not implemented
     end
 
-    rule datetime_expression
-      'datetime_expression' # not implemented
+    rule json_object_access_expression
+      'json_object_access_expression' # not implemented
     end
 
-    rule function_expression
-      function_name space? '(' space? function_args:function_args? space? ')' {
-        def ast
-          OracleSqlParser::Ast::FunctionExpression[
-            :name => function_name.ast,
-            :args => function_args.ast
-          ]
-        end
-      }
+    rule object_access_expression
+      'object_access_expression' # not implemented
     end
 
-    rule function_name
+    rule expression_list  # from grouping_expression_list
       (
-        package_name '.' procedure_name /
-        procedure_name
+        '(' e:exprs ')' /
+        e:exprs
       ) {
         def ast
-          OracleSqlParser::Ast::Identifier[:name => text_value]
-        end
-      }
-    end
-
-    rule function_args
-      function_arg more:(space? ',' space? function_arg)* {
-        def ast
-          OracleSqlParser::Ast::Array[function_arg.ast, *more_function_args.map(&:ast)]
-        end
-
-        def more_function_args
-          more.elements.map(&:function_arg)
-        end
-      }
-    end
-
-    rule function_arg
-      expr {
-        def ast
-          super
-        end
-      }
-    end
-
-    rule interval_expression
-      'interval_expression' # not implemented
-    end
-
-    rule object_access_expression
-      'object_access_expression'
-    end
-
-    rule scalar_subquery_expression
-      'scalar_subquery_expression'
-    end
-
-    rule model_expression
-      'model_expression' #
-    end
-
-    rule type_constructor_expression
-      'type_constructor_expression'
-    end
-
-    rule variable_expression
-      'variable_expression'
-    end
-
-    rule expr
-      sql_expression {
-        def ast
-          super
+          e.ast
         end
       }
     end
@@ -279,15 +105,14 @@ module OracleSqlParser::Grammar
       }
     end
 
-    rule expression_list
-      (
-        '(' e:exprs ')' /
-        e:exprs
-      ) {
+    rule expr
+      sql_expression {
         def ast
-          e.ast
+          super
         end
       }
     end
+
+
   end
 end