Module: OracleSqlParser::Grammar::Expression::Interval

Includes:

Treetop::Runtime

Included in:

OracleSqlParser::Grammar::Expression, IntervalParser

Defined in:

lib/oracle-sql-parser/grammar/expression/interval.rb

Defined Under Namespace

Modules: FractionalSecondPrecision0, IntervalExpression0, IntervalExpression1, IntervalExpression2, IntervalExpression3, IntervalExpression4, IntervalExpression5, IntervalExpression6, LeadingFieldPrecision0

Instance Method Summary

• #_nt_fractional_second_precision ⇒ Object
• #_nt_interval_expression ⇒ Object
• #_nt_leading_field_precision ⇒ Object
• #root ⇒ Object

Instance Method Details

#_nt_fractional_second_precision ⇒ Object

# File 'lib/oracle-sql-parser/grammar/expression/interval.rb', line 540

def _nt_fractional_second_precision
  start_index = index
  if node_cache[:fractional_second_precision].has_key?(index)
    cached = node_cache[:fractional_second_precision][index]
    if cached
      node_cache[:fractional_second_precision][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    r0.extend(FractionalSecondPrecision0)
    r0.extend(FractionalSecondPrecision0)
    @index += 1
  else
    terminal_parse_failure('[0-9]')
    r0 = nil
  end

  node_cache[:fractional_second_precision][start_index] = r0

  r0
end

#_nt_interval_expression ⇒ Object

# File 'lib/oracle-sql-parser/grammar/expression/interval.rb', line 103

def _nt_interval_expression
  start_index = index
  if node_cache[:interval_expression].has_key?(index)
    cached = node_cache[:interval_expression][index]
    if cached
      node_cache[:interval_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?('(', false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('\'(\'')
    r1 = nil
  end
  s0 << r1
  if r1
    r3 = _nt_space
    if r3
      r2 = r3
    else
      r2 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r2
    if r2
      r4 = _nt_not_loop_sql_expression
      s0 << r4
      if r4
        r6 = _nt_space
        if r6
          r5 = r6
        else
          r5 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r5
        if r5
          if (match_len = has_terminal?('-', false, index))
            r7 = true
            @index += match_len
          else
            terminal_parse_failure('\'-\'')
            r7 = nil
          end
          s0 << r7
          if r7
            r9 = _nt_space
            if r9
              r8 = r9
            else
              r8 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r8
            if r8
              r10 = _nt_expr
              s0 << r10
              if r10
                r12 = _nt_space
                if r12
                  r11 = r12
                else
                  r11 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r11
                if r11
                  if (match_len = has_terminal?(')', false, index))
                    r13 = true
                    @index += match_len
                  else
                    terminal_parse_failure('\')\'')
                    r13 = nil
                  end
                  s0 << r13
                  if r13
                    i14 = index
                    i15, s15 = index, []
                    r17 = _nt_space
                    if r17
                      r16 = r17
                    else
                      r16 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s15 << r16
                    if r16
                      r18 = _nt_day_keyword
                      s15 << r18
                      if r18
                        i20, s20 = index, []
                        r22 = _nt_space
                        if r22
                          r21 = r22
                        else
                          r21 = instantiate_node(SyntaxNode,input, index...index)
                        end
                        s20 << r21
                        if r21
                          if (match_len = has_terminal?('(', false, index))
                            r23 = true
                            @index += match_len
                          else
                            terminal_parse_failure('\'(\'')
                            r23 = nil
                          end
                          s20 << r23
                          if r23
                            r25 = _nt_space
                            if r25
                              r24 = r25
                            else
                              r24 = instantiate_node(SyntaxNode,input, index...index)
                            end
                            s20 << r24
                            if r24
                              r26 = _nt_leading_field_precision
                              s20 << r26
                              if r26
                                r28 = _nt_space
                                if r28
                                  r27 = r28
                                else
                                  r27 = instantiate_node(SyntaxNode,input, index...index)
                                end
                                s20 << r27
                                if r27
                                  if (match_len = has_terminal?(')', false, index))
                                    r29 = true
                                    @index += match_len
                                  else
                                    terminal_parse_failure('\')\'')
                                    r29 = nil
                                  end
                                  s20 << r29
                                end
                              end
                            end
                          end
                        end
                        if s20.last
                          r20 = instantiate_node(SyntaxNode,input, i20...index, s20)
                          r20.extend(IntervalExpression0)
                        else
                          @index = i20
                          r20 = nil
                        end
                        if r20
                          r19 = r20
                        else
                          r19 = instantiate_node(SyntaxNode,input, index...index)
                        end
                        s15 << r19
                        if r19
                          r31 = _nt_space
                          if r31
                            r30 = r31
                          else
                            r30 = instantiate_node(SyntaxNode,input, index...index)
                          end
                          s15 << r30
                          if r30
                            r32 = _nt_to_keyword
                            s15 << r32
                            if r32
                              r34 = _nt_space
                              if r34
                                r33 = r34
                              else
                                r33 = instantiate_node(SyntaxNode,input, index...index)
                              end
                              s15 << r33
                              if r33
                                r35 = _nt_second_keyword
                                s15 << r35
                                if r35
                                  i37, s37 = index, []
                                  r39 = _nt_space
                                  if r39
                                    r38 = r39
                                  else
                                    r38 = instantiate_node(SyntaxNode,input, index...index)
                                  end
                                  s37 << r38
                                  if r38
                                    if (match_len = has_terminal?('(', false, index))
                                      r40 = true
                                      @index += match_len
                                    else
                                      terminal_parse_failure('\'(\'')
                                      r40 = nil
                                    end
                                    s37 << r40
                                    if r40
                                      r42 = _nt_space
                                      if r42
                                        r41 = r42
                                      else
                                        r41 = instantiate_node(SyntaxNode,input, index...index)
                                      end
                                      s37 << r41
                                      if r41
                                        r43 = _nt_fractional_second_precision
                                        s37 << r43
                                        if r43
                                          r45 = _nt_space
                                          if r45
                                            r44 = r45
                                          else
                                            r44 = instantiate_node(SyntaxNode,input, index...index)
                                          end
                                          s37 << r44
                                          if r44
                                            if (match_len = has_terminal?(')', false, index))
                                              r46 = true
                                              @index += match_len
                                            else
                                              terminal_parse_failure('\')\'')
                                              r46 = nil
                                            end
                                            s37 << r46
                                          end
                                        end
                                      end
                                    end
                                  end
                                  if s37.last
                                    r37 = instantiate_node(SyntaxNode,input, i37...index, s37)
                                    r37.extend(IntervalExpression1)
                                  else
                                    @index = i37
                                    r37 = nil
                                  end
                                  if r37
                                    r36 = r37
                                  else
                                    r36 = instantiate_node(SyntaxNode,input, index...index)
                                  end
                                  s15 << r36
                                end
                              end
                            end
                          end
                        end
                      end
                    end
                    if s15.last
                      r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
                      r15.extend(IntervalExpression2)
                    else
                      @index = i15
                      r15 = nil
                    end
                    if r15
                      r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
                      r14 = r15
                    else
                      i47, s47 = index, []
                      r49 = _nt_space
                      if r49
                        r48 = r49
                      else
                        r48 = instantiate_node(SyntaxNode,input, index...index)
                      end
                      s47 << r48
                      if r48
                        r50 = _nt_year_keyword
                        s47 << r50
                        if r50
                          i52, s52 = index, []
                          r54 = _nt_space
                          if r54
                            r53 = r54
                          else
                            r53 = instantiate_node(SyntaxNode,input, index...index)
                          end
                          s52 << r53
                          if r53
                            if (match_len = has_terminal?('(', false, index))
                              r55 = true
                              @index += match_len
                            else
                              terminal_parse_failure('\'(\'')
                              r55 = nil
                            end
                            s52 << r55
                            if r55
                              r57 = _nt_space
                              if r57
                                r56 = r57
                              else
                                r56 = instantiate_node(SyntaxNode,input, index...index)
                              end
                              s52 << r56
                              if r56
                                r58 = _nt_leading_field_precision
                                s52 << r58
                                if r58
                                  r60 = _nt_space
                                  if r60
                                    r59 = r60
                                  else
                                    r59 = instantiate_node(SyntaxNode,input, index...index)
                                  end
                                  s52 << r59
                                  if r59
                                    if (match_len = has_terminal?(')', false, index))
                                      r61 = true
                                      @index += match_len
                                    else
                                      terminal_parse_failure('\')\'')
                                      r61 = nil
                                    end
                                    s52 << r61
                                  end
                                end
                              end
                            end
                          end
                          if s52.last
                            r52 = instantiate_node(SyntaxNode,input, i52...index, s52)
                            r52.extend(IntervalExpression3)
                          else
                            @index = i52
                            r52 = nil
                          end
                          if r52
                            r51 = r52
                          else
                            r51 = instantiate_node(SyntaxNode,input, index...index)
                          end
                          s47 << r51
                          if r51
                            r63 = _nt_space
                            if r63
                              r62 = r63
                            else
                              r62 = instantiate_node(SyntaxNode,input, index...index)
                            end
                            s47 << r62
                            if r62
                              r64 = _nt_to_keyword
                              s47 << r64
                              if r64
                                r66 = _nt_space
                                if r66
                                  r65 = r66
                                else
                                  r65 = instantiate_node(SyntaxNode,input, index...index)
                                end
                                s47 << r65
                                if r65
                                  r67 = _nt_month_keyword
                                  s47 << r67
                                end
                              end
                            end
                          end
                        end
                      end
                      if s47.last
                        r47 = instantiate_node(SyntaxNode,input, i47...index, s47)
                        r47.extend(IntervalExpression4)
                      else
                        @index = i47
                        r47 = nil
                      end
                      if r47
                        r47 = SyntaxNode.new(input, (index-1)...index) if r47 == true
                        r14 = r47
                      else
                        @index = i14
                        r14 = nil
                      end
                    end
                    s0 << r14
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(IntervalExpression5)
    r0.extend(IntervalExpression6)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:interval_expression][start_index] = r0

  r0
end

#_nt_leading_field_precision ⇒ Object

# File 'lib/oracle-sql-parser/grammar/expression/interval.rb', line 508

def _nt_leading_field_precision
  start_index = index
  if node_cache[:leading_field_precision].has_key?(index)
    cached = node_cache[:leading_field_precision][index]
    if cached
      node_cache[:leading_field_precision][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    r0.extend(LeadingFieldPrecision0)
    r0.extend(LeadingFieldPrecision0)
    @index += 1
  else
    terminal_parse_failure('[0-9]')
    r0 = nil
  end

  node_cache[:leading_field_precision][start_index] = r0

  r0
end

#root ⇒ Object

# File 'lib/oracle-sql-parser/grammar/expression/interval.rb', line 8

def root
  @root ||= :interval_expression
end