oracle-sql-parser 0.8.1 → 0.9.0

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

@@ -0,0 +1,77 @@
+module OracleSqlParser::Grammar::Expression
+  grammar Case
+    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
+      }
+    end
+
+    rule return_expr
+      expr {
+        def ast
+          super
+        end
+      }
+    end
+
+    rule else_expr
+      expr {
+        def ast
+          super
+        end
+      }
+    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
+      }
+    end
+
+    rule else_clause
+      else_keyword space? else_expr {
+        def ast
+          else_expr.ast
+        end
+      }
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module OracleSqlParser::Grammar::Expression
+  grammar Compound
+    rule compound_expression
+      ex:(
+        left_parenthesis:'(' space? left:expr space? right_parenthesis:')' /
+        left:not_loop_sql_expression 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 => ex.try(:left).ast,
+              :op => ex.try(:op).ast,
+              :right => ex.try(:right).ast,
+            ]
+          end
+        }
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module OracleSqlParser::Grammar::Expression
+  grammar Cursor
+    rule cursor_expression
+      cursor_keyword space? '(' space? subquery space? ')' {
+        def ast
+          OracleSqlParser::Ast::CursorExpression[
+            :cursor => cursor_keyword.ast,
+            :subquery => subquery.ast,
+          ]
+        end
+      }
+    end
+  end
+end
+

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

@@ -0,0 +1,36 @@
+module OracleSqlParser::Grammar::Expression
+  grammar Datetime
+    rule datetime_expression
+      not_loop_sql_expression space? d:(
+        at_keyword space? local_keyword /
+        at_keyword space? datetime_timezone_clause
+      ) {
+        def ast
+          OracleSqlParser::Ast::DatetimeExpression[
+            :expr => not_loop_sql_expression.ast,
+            :at => d.try(:at_keyword).ast,
+            :local => d.try(:local_keyword).ast,
+            :timezone => d.try(:datetime_timezone_clause).ast,
+          ]
+        end
+      }
+    end
+
+    rule datetime_timezone_clause
+      time_keyword space? zone_keyword space? expr:(
+        text_literal /
+        dbtimezone_keyword /
+        sessiontimezone_keyword /
+        expr
+      ) {
+        def ast
+          OracleSqlParser::Ast::TimezoneClause[
+            :time => time_keyword.ast,
+            :zone => zone_keyword.ast,
+            :expr => expr.ast,
+          ]
+        end
+      }
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module OracleSqlParser::Grammar::Expression
+  grammar Function
+    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
+      }
+    end
+
+    rule function_name
+      (
+        package_name '.' procedure_name /
+        procedure_name
+      ) {
+        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
+  end
+end
+
+

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

@@ -0,0 +1,47 @@
+module OracleSqlParser::Grammar::Expression
+  grammar Interval
+    rule interval_expression
+      '(' space? left:not_loop_sql_expression space? '-' space? right:expr space? ')'
+      e:(
+        space? day_keyword
+        l:(space? '(' space? leading_field_precision space? ')')?
+        space? to_keyword space? second_keyword
+        f:(space? '(' space? fractional_second_precision space? ')')?
+        /
+        space? year_keyword
+        l:(space? '(' space? leading_field_precision space? ')')?
+        space? to_keyword space? month_keyword
+      ) {
+        def ast
+          OracleSqlParser::Ast::IntervalExpression[
+            :left => left.ast,
+            :right => right.ast,
+            :day => e.try(:day_keyword).ast,
+            :year => e.try(:year_keyword).ast,
+            :leading_field_precision => e.try(:l).try(:leading_field_precision).ast,
+            :to => e.try(:to_keyword).ast,
+            :second => e.try(:second_keyword).ast,
+            :month => e.try(:month_keyword).ast,
+            :fractional_second_precision => e.try(:f).try(:fractional_second_precision).ast,
+          ]
+        end
+      }
+    end
+
+    rule leading_field_precision
+      [0-9] {
+        def ast
+          OracleSqlParser::Ast::NumberLiteral[:value => text_value]
+        end
+      }
+    end
+
+    rule fractional_second_precision
+      [0-9] {
+        def ast
+          OracleSqlParser::Ast::NumberLiteral[:value => text_value]
+        end
+      }
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module OracleSqlParser::Grammar::Expression
+  grammar Simple
+    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
+  end
+end

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

@@ -49,7 +49,7 @@ module OracleSqlParser::Grammar
     end
 
     rule space
-      ' '+
+      [ \n]+
     end
 
     rule hint # not implemented

data/lib/oracle-sql-parser/grammar/reserved_word_generator.rb

@@ -94,14 +94,15 @@ EOS
           'ANY',
           'AS',
           'ASC',
+          'AT',
           'AUDIT',
           'BETWEEN',
           'BY',
           'CASE',
+          'CAST',
           'CHAR',
           'CHECK',
           'CLUSTER',
-          'CURRENT_OF',
           'COLUMN',
           'COLUMN_VALUE',
           'COMMENT',
@@ -111,8 +112,12 @@ EOS
           'CROSS',
           'CUBE',
           'CURRENT',
+          'CURRENT_OF',
           'CURRVAL',
+          'CURSOR',
           'DATE',
+          'DAY',
+          'DBTIMEZONE',
           'DECIMAL',
           'DEFAULT',
           'DELETE',
@@ -155,6 +160,7 @@ EOS
           'LIKE2',
           'LIKE4',
           'LIKEC',
+          'LOCAL',
           'LOCK',
           'LONG',
           'MAXEXTENTS',
@@ -163,6 +169,7 @@ EOS
           'MLSLABEL',
           'MODE',
           'MODIFY',
+          'MONTH',
           'NAN',
           'NATURAL',
           'NESTED_TABLE_ID',
@@ -198,12 +205,14 @@ EOS
           'ROWID',
           'ROWNUM',
           'ROWS',
+          'SECOND',
           'SELECT',
           'SESSION',
+          'SESSIONTIMEZONE',
           'SET',
           'SHARE',
-          'SIZE',
           'SIBLINGS',
+          'SIZE',
           'SMALLINT',
           'START',
           'SUBMULTISET',
@@ -213,6 +222,7 @@ EOS
           'SYSTIMESTAMP',
           'TABLE',
           'THEN',
+          'TIME',
           'TO',
           'TRIGGER',
           'TYPE',
@@ -231,6 +241,8 @@ EOS
           'WHEN',
           'WHENEVER',
           'WHERE',
+          'YEAR',
+          'ZONE',
         ]
       end
     end

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

@@ -1,5 +1,12 @@
 module OracleSqlParser::Grammar
   grammar Select
+    include OracleSqlParser::Grammar::Select::Order
+    include OracleSqlParser::Grammar::Select::Group
+    include OracleSqlParser::Grammar::Select::Join
+    include OracleSqlParser::Grammar::Select::ForUpdate
+    include OracleSqlParser::Grammar::Select::Union
+    include OracleSqlParser::Grammar::Select::QueryBlock
+
     rule select_statement
       space? subquery for_update:(space for_update_clause)? space? {
         def ast
@@ -20,522 +27,13 @@ module OracleSqlParser::Grammar
       order:(space order_by_clause)? {
         def ast
           OracleSqlParser::Ast::Subquery[
-            :has_parenthesis => has_parenthesis,
-            :query_block => query_block.ast,
-            :subqueries => subqueries.ast,
-            :subquery => subquery.ast,
+            :has_parenthesis => query.try(:left_parenthesis) ? true : nil,
+            :query_block => query.try(:query_block).ast,
+            :subqueries => query.try(:subqueries).ast,
+            :subquery => query.try(:subquery).ast,
             :order_by_clause => order.try(:order_by_clause).ast,
           ]
         end
-
-        def has_parenthesis
-          true if query.respond_to? :left_parenthesis
-        end
-
-        def query_block
-          query.query_block if query.respond_to? :query_block
-        end
-
-        def subqueries
-          query.subqueries if query.respond_to? :subqueries
-        end
-
-        def subquery
-          query.subquery if query.respond_to? :subquery
-        end
-      }
-    end
-
-    rule subqueries_with_union
-      query_block space? more:(union_or_intersect_or_minus space? subquery)+
-      {
-        def ast
-          OracleSqlParser::Ast::Array[
-            query_block.ast,
-            *more_queries.map(&:ast),
-          ]
-        end
-
-        def more_queries
-          more.elements.map{|e| [e.union_or_intersect_or_minus, e.subquery]}.flatten
-        end
-      }
-    end
-
-    rule union_or_intersect_or_minus
-      (
-        union:union_all /
-        intersect:intersect_keyword /
-        minus:minus_keyword
-      ) {
-        def ast
-          if respond_to? :union
-            union.ast
-          elsif respond_to? :intersect
-            OracleSqlParser::Ast::Array[intersect.ast]
-          elsif respond_to? :minus
-            OracleSqlParser::Ast::Array[minus.ast]
-          end
-        end
-      }
-    end
-
-    rule union_all
-      union_keyword all:(space all_keyword)? {
-        def ast
-          OracleSqlParser::Ast::Array[
-            union_keyword.ast,
-            all.try(:all_keyword).ast
-          ]
-        end
-      }
-    end
-
-    rule query_block
-      (subquery_factoring_clause:subquery_factoring_clause space)?
-      select_keyword space
-      hint:hint?
-      mod:(modifier:(all_keyword / distinct_keyword / unique_keyword) space)?
-      select_list space
-      from_keyword
-      select:(space select_sources)?
-      where:(space where_clause)?
-      group:(space group_by_clause)?
-      model:(space model_clause)? {
-        def ast
-          OracleSqlParser::Ast::QueryBlock[
-            :hint => hint.ast,
-            :modifier => modifier.ast,
-            :select_list => select_list.ast,
-            :select_sources => select.try(:select_sources).ast,
-            :where_clause => where.try(:where_clause).ast,
-            :group_by_clause => group.try(:group_by_clause).ast,
-            :model_clause => model.try(:model_clause).ast]
-        end
-
-        def modifier
-          mod.modifier if mod.respond_to? :modifier
-        end
-      }
-    end
-
-    rule select_sources
-      select_source more:(space? ',' space? select_source)* {
-        def ast
-          OracleSqlParser::Ast::Array[
-            select_source.ast,
-            *more_select_sources.map(&:ast),
-          ]
-        end
-
-        def more_select_sources
-          more.elements.map(&:select_source)
-        end
-      }
-    end
-
-    rule select_source
-      join_clause /
-      '(' space? join_clause:join_clause space? ')' /
-      table_reference /
-      subquery
-      {
-        def ast
-          if respond_to? :join_clause
-            join_clause.ast
-          else
-            super
-          end
-        end
-      }
-    end
-
-    rule join_clause
-      table_reference space
-      join:(
-        outer_join_clause /
-        inner_cross_join_clause
-      ) {
-        def ast
-          result = join.ast
-          result.table1 = table_reference.ast
-          result
-        end
-      }
-    end
-
-    rule inner_cross_join_clause
-      inner_join_clause /
-      cross_join_clause {
-        def ast
-          super
-        end
-      }
-    end
-
-    rule inner_join_clause
-      inner_join space? table_reference space? on_or_using_clause {
-        def ast
-          OracleSqlParser::Ast::InnerJoinClause[
-            :inner => inner_join.inner_keyword.ast,
-            :join => inner_join.try(:join_keyword).ast,
-            :table2 => table_reference.ast,
-            :on_or_using_clause => on_or_using_clause.ast
-          ]
-        end
-      }
-    end
-
-    rule inner_join
-      inner_keyword space? join_keyword
-    end
-
-    rule on_or_using_clause
-      on_clause /
-      using_clause {
-        def ast
-          super
-        end
-      }
-    end
-
-    rule on_clause
-      on_keyword space? condition {
-        def ast
-          OracleSqlParser::Ast::OnClause[
-            :on => on_keyword.ast,
-            :condition => condition.ast
-          ]
-        end
-      }
-    end
-
-    rule using_clause
-      using_keyword space? '(' space? column_list space? ')' {
-        def ast
-          OracleSqlParser::Ast::UsingClause[
-            :using => using_keyword.ast,
-            :column_list => column_list.ast
-          ]
-        end
-      }
-    end
-
-    rule cross_join_clause
-      cross_natural_join space table_reference {
-        def ast
-          OracleSqlParser::Ast::CrossNaturalJoinClause[
-            :cross => cross_natural_join.cross_keyword.ast,
-            :natural => cross_natural_join.natural_keyword.ast,
-            :inner => cross_natural_join.inner_keyword.ast,
-            :join => cross_natural_join.try(:join_keyword).ast,
-            :table2 => table_reference.ast
-          ]
-        end
-      }
-    end
-
-    rule cross_natural_join
-      (
-        cross_keyword:cross_keyword /
-        natural_keyword:natural_keyword inner:(space inner_keyword)?
-      ) space join_keyword {
-
-        def cross_keyword
-          elements.first.try(:cross_keyword)
-        end
-
-        def natural_keyword
-          elements.first.try(:natural_keyword)
-        end
-
-        def inner_keyword
-          elements.first.try(:inner).try(:inner_keyword)
-        end
-      }
-    end
-
-    rule column_list
-      column_name more:(space? ',' space? column_name)* {
-        def ast
-          OracleSqlParser::Ast::Array[
-            column_name.ast,
-            *more_column_names.map(&:ast)
-          ]
-        end
-
-        def more_column_names
-          more.elements.map(&:column_name)
-        end
-      }
-    end
-
-    rule outer_join_clause
-      query_partition_clause?
-      join_type:(
-        natural_keyword:natural_keyword? space? outer_join_type:outer_join_type? space? join_keyword
-      ) space
-      table_reference space
-      (query_partition_clause space)?
-      on_or_using_clause {
-        def ast
-          OracleSqlParser::Ast::OuterJoinClause[
-            :natural => join_type.try(:natural_keyword).ast,
-            :join_type => join_type.outer_join_type.try(:type).ast,
-            :outer => join_type.outer_join_type.try(:outer).ast,
-            :join => join_type.join_keyword.ast,
-            :table2 => table_reference.ast,
-            :on_or_using_clause => on_or_using_clause.ast
-          ]
-        end
-      }
-    end
-
-    rule query_partition_clause
-      'query_partition_clause' {
-        def ast
-          'query_partition_clause' # do not supported
-        end
-      }
-    end
-
-    rule outer_join_type
-      type:(
-        full_keyword /
-        left_keyword /
-        right_keyword
-      ) o:(space outer_keyword)? {
-        def outer
-          o.try(:outer_keyword)
-        end
-      }
-    end
-
-    rule for_update_clause
-      for_keyword space update_keyword
-      of:(space of_keyword space for_update_clause_columns)?
-      wait:(
-        space w:wait_keyword space time:integer /
-        space w:nowait_keyword
-      )? {
-        def ast
-          OracleSqlParser::Ast::ForUpdateClause[
-            :columns => of.try(:for_update_clause_columns).ast,
-            :wait => wait.try(:w).ast,
-            :time => wait.try(:time).ast
-          ].remove_nil_values!
-        end
-      }
-    end
-
-    rule for_update_clause_columns
-      for_update_clause_column more:(space? ',' space? for_update_clause_column)* {
-        def ast
-          OracleSqlParser::Ast::Array[
-            for_update_clause_column.ast, *more_for_update_clause_columns.map(&:ast)
-          ]
-        end
-
-        def more_for_update_clause_columns
-          more.elements.map(&:for_update_clause_column)
-        end
-      }
-    end
-
-    rule for_update_clause_column
-      (
-        schema_name space? '.' space? table_name space? '.' space? column_name /
-        table_name space? '.' space? column_name /
-        space? column_name
-      ) {
-        def ast
-          OracleSqlParser::Ast::Identifier[:name => text_value]
-        end
-      }
-    end
-
-    rule subquery_factoring_clause
-      'subquery_factoring_clause' { # not implemented
-        def ast
-          'subquery_factoring_clause'
-        end
-      }
-    end
-
-    rule order_by_clause
-      order_keyword space siblings:siblings_keyword? space? by_keyword space order_by_clause_items {
-        def ast
-          OracleSqlParser::Ast::OrderByClause[
-            :siblings => siblings.ast,
-            :items => order_by_clause_items.ast
-          ]
-        end
-      }
-    end
-
-    rule order_by_clause_items
-      order_by_clause_item
-      more:(space? ',' space? order_by_clause_item space?)* {
-        def ast
-          OracleSqlParser::Ast::Array[
-            order_by_clause_item.ast, *more_order_by_clause_items.map(&:ast)
-          ]
-        end
-
-        def more_order_by_clause_items
-          more.elements.map(&:order_by_clause_item)
-        end
-      }
-    end
-
-    rule order_by_clause_item
-      target:(expr / position / c_alias) space?
-      asc:(asc_keyword / desc_keyword)? space?
-      null:(nulls_keyword space first_or_last:(first_keyword / last_keyword))? {
-        def ast
-          OracleSqlParser::Ast::OrderByClauseItem[
-            :target => target.ast,
-            :asc => asc.ast,
-            :nulls => nulls.ast
-          ]
-        end
-
-        def nulls
-          if null.respond_to? :first_or_last
-            null.first_or_last
-          else
-            nil
-          end
-        end
-      }
-    end
-
-    rule select_list
-      select_one more_list:( space? ',' space? select_one)* {
-        def ast
-          OracleSqlParser::Ast::Array[select_one.ast, *more_columns.map(&:ast)]
-        end
-
-        def more_columns
-          more_list.elements.map(&:select_one)
-        end
-      }
-    end
-
-    rule select_one
-        select_table /
-        select_column
-      {
-        def ast
-          super
-        end
-      }
-    end
-
-    rule select_table
-      (table_name '.')? '*' {
-        def ast
-          OracleSqlParser::Ast::Identifier[:name => text_value]
-        end
-      }
-    end
-
-    rule select_column
-      expr _alias:( space as:( as_keyword space )? c_alias )?  {
-        def ast
-          OracleSqlParser::Ast::SelectColumn[
-            :expr => expr.ast,
-            :as => as_keyword.ast,
-            :c_alias => c_alias.ast,
-          ]
-        end
-
-        def c_alias
-          if _alias.respond_to? :c_alias
-            _alias.c_alias
-          end
-        end
-
-        def as_keyword
-          if respond_to? :_alias and _alias.respond_to? :as
-            _alias.as.as_keyword
-          end
-        end
-      }
-    end
-
-    # group
-    rule group_by_clause
-      group_keyword space by_keyword space target:group_column space?
-        t:(',' space? more_target:group_column space?)*
-        h:(having_keyword space condition:condition)? {
-        def ast
-          OracleSqlParser::Ast::GroupByClause[
-            :targets => OracleSqlParser::Ast::Array[
-              target.ast, *more_targets.map(&:ast)
-            ],
-            :having => condition.ast
-          ]
-        end
-
-        def more_targets
-          t.elements.map{|e| e.more_target}
-        end
-
-        def condition
-          if h.respond_to? :condition
-            h.condition
-          else
-            nil
-          end
-        end
-      }
-    end
-
-    rule group_column
-      (
-        expr /
-        rollup_cube_clause /
-        grouping_sets_clause
-      ) {
-        def ast
-          super
-        end
-      }
-    end
-
-    rule rollup_cube_clause
-      func_name:(rollup_keyword / cube_keyword) space? grouping_expression_list {
-        def ast
-          OracleSqlParser::Ast::RollupCubeClause[
-            :func_name => func_name.ast,
-            :args => grouping_expression_list.ast
-          ]
-        end
-      }
-    end
-
-    rule grouping_sets_clause
-      'grouping_sets_clause' { # not implemented
-        def ast
-          'grouping_sets_clause'
-        end
-      }
-    end
-
-    rule grouping_expression_list
-      expression_list {
-        def ast
-          super
-        end
-      }
-    end
-
-    rule model_clause
-      'model_clause' {
-        def ast
-          'model_clause'
-        end
       }
     end
   end