module OracleSqlParser::Grammar::Condition::IsOfType

Public Instance Methods

_nt_is_of_type_condition() click to toggle source
# File lib/oracle-sql-parser/grammar/condition/is_of_type.rb, line 52
def _nt_is_of_type_condition
  start_index = index
  if node_cache[:is_of_type_condition].has_key?(index)
    cached = node_cache[:is_of_type_condition][index]
    if cached
      node_cache[:is_of_type_condition][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_expr
  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_is_keyword
      s0 << r4
      if r4
        r6 = _nt_space
        if r6
          r5 = r6
        else
          r5 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r5
        if r5
          r8 = _nt_not_keyword
          if r8
            r7 = r8
          else
            r7 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r7
          if r7
            r10 = _nt_space
            if r10
              r9 = r10
            else
              r9 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r9
            if r9
              r11 = _nt_of_keyword
              s0 << r11
              if r11
                r13 = _nt_space
                if r13
                  r12 = r13
                else
                  r12 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r12
                if r12
                  r15 = _nt_type_keyword
                  if r15
                    r14 = r15
                  else
                    r14 = instantiate_node(SyntaxNode,input, index...index)
                  end
                  s0 << r14
                  if r14
                    r17 = _nt_space
                    if r17
                      r16 = r17
                    else
                      r16 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s0 << r16
                    if r16
                      if (match_len = has_terminal?('(', false, index))
                        r18 = true
                        @index += match_len
                      else
                        terminal_parse_failure('\'(\'')
                        r18 = nil
                      end
                      s0 << r18
                      if r18
                        r20 = _nt_space
                        if r20
                          r19 = r20
                        else
                          r19 = instantiate_node(SyntaxNode,input, index...index)
                        end
                        s0 << r19
                        if r19
                          r21 = _nt_types
                          s0 << r21
                          if r21
                            r23 = _nt_space
                            if r23
                              r22 = r23
                            else
                              r22 = instantiate_node(SyntaxNode,input, index...index)
                            end
                            s0 << r22
                            if r22
                              if (match_len = has_terminal?(')', false, index))
                                r24 = true
                                @index += match_len
                              else
                                terminal_parse_failure('\')\'')
                                r24 = nil
                              end
                              s0 << r24
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(IsOfTypeCondition0)
    r0.extend(IsOfTypeCondition1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:is_of_type_condition][start_index] = r0

  r0
end
_nt_only_and_type() click to toggle source
# File lib/oracle-sql-parser/grammar/condition/is_of_type.rb, line 326
def _nt_only_and_type
  start_index = index
  if node_cache[:only_and_type].has_key?(index)
    cached = node_cache[:only_and_type][index]
    if cached
      node_cache[:only_and_type][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r2 = _nt_only_keyword
  if r2
    r1 = r2
  else
    r1 = instantiate_node(SyntaxNode,input, index...index)
  end
  s0 << r1
  if r1
    r4 = _nt_space
    if r4
      r3 = r4
    else
      r3 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r3
    if r3
      r5 = _nt_type
      s0 << r5
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(OnlyAndType0)
    r0.extend(OnlyAndType1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:only_and_type][start_index] = r0

  r0
end
_nt_type() click to toggle source
# File lib/oracle-sql-parser/grammar/condition/is_of_type.rb, line 388
def _nt_type
  start_index = index
  if node_cache[:type].has_key?(index)
    cached = node_cache[:type][index]
    if cached
      node_cache[:type][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  r2 = _nt_schema_name
  s1 << r2
  if r2
    if (match_len = has_terminal?('.', false, index))
      r3 = true
      @index += match_len
    else
      terminal_parse_failure('\'.\'')
      r3 = nil
    end
    s1 << r3
    if r3
      r4 = _nt_ident
      s1 << r4
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(Type0)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r5 = _nt_ident
    r5.extend(Type1)
    r5.extend(Type1)
    if r5
      r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
      r0 = r5
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:type][start_index] = r0

  r0
end
_nt_types() click to toggle source
# File lib/oracle-sql-parser/grammar/condition/is_of_type.rb, line 220
def _nt_types
  start_index = index
  if node_cache[:types].has_key?(index)
    cached = node_cache[:types][index]
    if cached
      node_cache[:types][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_only_and_type
  s0 << r1
  if r1
    r3 = _nt_space
    if r3
      r2 = r3
    else
      r2 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r2
    if r2
      s4, i4 = [], index
      loop do
        i5, s5 = index, []
        if (match_len = has_terminal?(',', false, index))
          r6 = true
          @index += match_len
        else
          terminal_parse_failure('\',\'')
          r6 = nil
        end
        s5 << r6
        if r6
          r8 = _nt_space
          if r8
            r7 = r8
          else
            r7 = instantiate_node(SyntaxNode,input, index...index)
          end
          s5 << r7
          if r7
            r9 = _nt_only_and_type
            s5 << r9
            if r9
              r11 = _nt_space
              if r11
                r10 = r11
              else
                r10 = instantiate_node(SyntaxNode,input, index...index)
              end
              s5 << r10
            end
          end
        end
        if s5.last
          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
          r5.extend(Types0)
        else
          @index = i5
          r5 = nil
        end
        if r5
          s4 << r5
        else
          break
        end
      end
      r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Types1)
    r0.extend(Types2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:types][start_index] = r0

  r0
end
root() click to toggle source
# File lib/oracle-sql-parser/grammar/condition/is_of_type.rb, line 8
def root
  @root ||= :is_of_type_condition
end