ddl_parser 0.0.10 → 0.0.11

data/lib/ddl_parser/ddl/db2/parser.rb

@@ -31,11 +31,11 @@ module DDLParser
 
         rule(:column_name)       { identifier }
         rule(:constraint_name)   { identifier }
-        rule(:column_sort)       { str('ascending') | str('descending')}
+        rule(:column_sort)       { str('ascending') |str('asc') | str('descending')|str('desc')}
 
         rule(:column_definition) { (column_name.as(:field) >> space.repeat >> data_type >> space.repeat >> (column_options.maybe).as(:options)).as(:column)}
 
-        rule(:index_column_definition) { column_name.as(:field) >> space.repeat >> (column_sort.as(:sort_id) >> space.repeat).maybe }
+        rule(:index_column_definition) { column_name.as(:field) >> (space? >> column_sort.as(:sort_id) >> space.repeat).maybe }
 
         rule(:element_list)      { (lparen >> space? >> (column_definition | constraint | primary_key) >> space? >>
                                     (comma >> space? >> (column_definition | constraint | primary_key) >> space?).repeat >> rparen).as(:elements)
@@ -77,6 +77,10 @@ module DDLParser
           (identifier.as(:name) >> space? >>
               lparen >> arglist.as(:arguments) >> rparen).as(:function)
         }
+        # index options
+
+        rule(:option_reverse_scans)   { str('allow reverse scans') }
+        rule(:index_option)     { (option_reverse_scans).as(:index_option) }
 
         rule(:item)       { function | identifier | string }
         rule(:arglist)    {
@@ -90,8 +94,19 @@ module DDLParser
           str('alter table').as(:operation) >> space? >> (identifier).as(:table_name)
         }
         rule(:create_index_statement)   {
-          str('create').as(:operation) >> (space? >> str('unique').as(:object_property)).maybe >> space? >> str('index').as(:object_type) >> space? >>
-              (identifier).as(:index_name) >> space? >> str('on') >> space? >> (identifier).as(:table_name)
+          str('create').as(:operation) >> (space? >> str('unique').as(:object_property)).maybe >> space? >> str('index').as(:object_type) >> space? >> (identifier).as(:index_name)
+        }
+        rule(:create_index_statement_1)   {
+          str('create').as(:operation) >> (space? >> str('unique').as(:object_property)).maybe
+        }
+        rule(:create_index_statement_1_a)   {
+          str('create').as(:operation)
+        }
+        rule(:create_index_statement_2)   {
+          str('index').as(:object_type) >> space? >>  (identifier).as(:index_name)
+        }
+        rule(:index_table)   {
+          space? >> str('on') >> space? >> (identifier).as(:table_name) >> space?
         }
         rule(:create_table)     {
           spaces.maybe >> create_table_statement >> spaces >> element_list >> spaces.maybe >> (item >> spaces.maybe).repeat
@@ -100,7 +115,7 @@ module DDLParser
           spaces.maybe >> alter_table_statement >> spaces >> (alter_table_element.repeat).as(:elements)
         }
         rule(:create_index)     {
-          spaces.maybe >> create_index_statement >> spaces >> lparen >> element_list_index >> spaces.maybe >> rparen
+          spaces.maybe >> create_index_statement >> spaces >> index_table >> spaces >> lparen >> element_list_index >> spaces.maybe >> rparen  >> (space? >> index_option).maybe
         }
 
         rule(:expression) { create_table | alter_table | create_index}

data/lib/ddl_parser/translator/column.rb

@@ -67,10 +67,6 @@ class DDLParser::Translator::Column
     @column_hash[:options] if @column_hash[:options].length > 0
   end
 
-  def option(key)
-    # return the right option
-    options.select{|o| o.is_a?(Hash) || o.has_key?(key)}.first
-  end
 
   def not_null
     if options.nil?
@@ -88,10 +84,10 @@ class DDLParser::Translator::Column
           default_value[:default_clause].each do |c|
             # TODO must handle other then integer
             case c.keys.first
-            when :integer
-              return c[:integer].to_i
-            else
-              return c[c.keys.first].to_s
+              when :integer
+                return c[:integer].to_i
+              else
+                return c[c.keys.first].to_s
             end
           end
         else
@@ -101,32 +97,79 @@ class DDLParser::Translator::Column
     end
   end
 
+  def identity_options
+    unless options.nil?
+      start_value = options.select{|h|h.has_key?(:identity_options)}.first
+      if start_value
+        if start_value[:identity_options].is_a?(Array)
+          start_value[:identity_options].each do |c|
+            return c[c.keys.first]
+          end
+        else
+          raise "Unknown identity_options #{start_value.inspect}"
+        end
+      end
+    end
+  end
+
   def identity?
     if options.nil?
       false
     else
-      options.select{|h|h.has_key?(:column_option) && h.has_value?('identity')}.length > 0
+#      options.select{|h|h.has_key?(:column_option) && h.has_value?('identity')}.length > 0
+      options.select{|h|h.has_key?(:identity)}.length > 0
     end
   end
 
-  def start_value?
+  def option(key)
+    return if options.nil?
+    options.select{|h|h.has_key?(:column_option)}.length > 0    # return the right option
+    options.select{|o| o.is_a?(Hash) && o.has_key?(key)}.first
+  end
+
+  def default_value
+    unless option(:default_clause).nil?
+      begin
+        return option(:default_clause)[:default_clause].first[:string]
+      rescue
+      end
+    else
+      return ''
+    end
+  end
+
+  def start_value
     unless option(:identity).nil?
-      option(:identity)[:start_value][:integer].to_i
+      begin
+        return option(:identity)[:identity][:start_value][:integer].to_i
+      rescue
+      end
+    else
+      return 0
     end
   end
 
   def increment_value
-    if options.nil?
-      false
+    unless option(:identity).nil?
+      begin
+        return option(:identity)[:identity][:increment_value][:integer].to_i
+      rescue
+      end
     else
-      options.select{|h|h.has_key?(:column_option) && h.has_value?('identity')}.length > 0
+      return 0
     end
   end
+
   def cache_value
-    if options.nil?
-      false
+    unless option(:identity).nil?
+      begin
+        return option(:identity)[:identity][:cache_value][:integer].to_i
+      rescue
+      end
     else
-      options.select{|h|h.has_key?(:column_option) && h.has_value?('identity')}.length > 0
+      return 0
     end
   end
+
+
 end

data/lib/ddl_parser/translator/create_index.rb

@@ -1,28 +1,29 @@
-class DDLParser::Translator::CreateIndex
-
-  attr_accessor :parse_tree
-  def initialize(parse_tree)
-    @parse_tree=parse_tree
-  end
-
-  def elements
-    [@parse_tree[:elements]].flatten
-  end
-
-  def table_name
-    @parse_tree.first[:table_name].to_s
-  end
-
-  def index_name
-    @parse_tree.first[:index_name].to_s
-  end
-
-  def fields
-    @parse_tree.select{|e|e.has_key?(:field)}.compact
-  end
-
-  def primary_key
-    elements.map{|e| e[:primary_key]}.compact.first[:item]
-  end
-
+class DDLParser::Translator::CreateIndex
+
+  attr_accessor :parse_tree
+
+  def initialize(parse_tree)
+    @parse_tree=parse_tree
+  end
+
+  def elements
+    [@parse_tree[:elements]].flatten
+  end
+
+  def table_name
+    @parse_tree.first[:table_name].to_s
+  end
+
+  def index_name
+    @parse_tree.first[:index_name].to_s
+  end
+
+  def fields
+    @parse_tree.select{|e|e.has_key?(:field)}.compact
+  end
+
+  def primary_key
+    elements.map{|e| e[:primary_key]}.compact.first[:item]
+  end
+
 end

data/lib/ddl_parser/translator/create_table.rb

@@ -1,27 +1,29 @@
-class DDLParser::Translator::CreateTable
-    attr_accessor :parse_tree
-    def initialize(parse_tree)
-      @parse_tree=parse_tree
-    end
-
-    def elements
-      [@parse_tree[:elements]].flatten
-    end
-
-    def table_name
-      @parse_tree[:table_name].to_s
-    end
-
-    def columns
-      elements.map{|e|e[:column]}.compact.map{|e|DDLParser::Translator::Column.new(e)}
-    end
-
-    def primary_key
-      elements.map{|e| e[:primary_key]}.compact.first[:item]
-    end
-
-    def constraints
-      elements.map{|e|e[:constraint]}.compact
-    end
-
+class DDLParser::Translator::CreateTable
+
+  attr_accessor :parse_tree
+
+  def initialize(parse_tree)
+    @parse_tree=parse_tree
+  end
+
+  def elements
+    [@parse_tree[:elements]].flatten
+  end
+
+  def table_name
+    @parse_tree[:table_name].to_s
+  end
+
+  def columns
+    elements.map{|e|e[:column]}.compact.map{|e|DDLParser::Translator::Column.new(e)}
+  end
+
+  def primary_key
+    elements.map{|e| e[:primary_key]}.compact.first[:item]
+  end
+
+  def constraints
+    elements.map{|e|e[:constraint]}.compact
+  end
+
 end

data/lib/ddl_parser/version.rb

@@ -1,3 +1,3 @@
-module DDLParser
-  VERSION = '0.0.10'
-end
+module DDLParser
+  VERSION = '0.0.11'
+end

data/spec/ddl_parser/ddl/db2/create_index_spec.rb

@@ -1,26 +1,154 @@
-require_relative '../../../../spec/spec_helper'
-
-describe 'Create index parsing' do
-  let(:parser) { DDLParser::DDL::DB2::Parser.new }
-  it 'parses create_unique_index' do
-    sql = <<EOF
-CREATE UNIQUE INDEX REPLAN_ADDR_1 ON REPLAN_ADDR
- (CONSIGNMENT ASCENDING, COLLI DESCENDING )
-EOF
-    begin
-      result = parser.parse(sql.downcase)
-    rescue Parslet::ParseFailed => error
-      puts error.cause.ascii_tree
-    end
-
-    result.count.should == 3
-    result[0].should include(:operation, :object_property, :object_type, :index_name)
-    result[0].should include(:operation => 'create')
-    result[0].should include(:object_property => 'unique')
-    result[0].should include(:object_type => 'index')
-    result[1].should include(:field)
-    result[1].should include(:sort_id)
-    result[2].should include(:field)
-    result[2].should include(:sort_id)
-  end
+require_relative '../../../../spec/spec_helper'
+
+describe 'Create index parsing' do
+  let(:parser) { DDLParser::DDL::DB2::Parser.new }
+  context 'create index 1' do
+    it 'parses create_unique_index' do
+      sql = <<EOF
+CREATE UNIQUE INDEX COST_INVOICE_1 ON COST_INVOICE
+ (DOC_NO, DOC_NO_2 )
+EOF
+      begin
+        result = parser.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+
+      result.count.should == 3
+      result[0].should include(:operation, :object_property, :object_type, :index_name)
+      result[0].should include(:operation => 'create')
+      result[0].should include(:object_property => 'unique')
+      result[0].should include(:object_type => 'index')
+      result[1].should include(:field)
+    end
+    it 'parses create_unique_index with one column' do
+      sql = <<EOF
+CREATE UNIQUE INDEX COST_INVOICE_1 ON COST_INVOICE
+ (DOC_NO)
+EOF
+      begin
+        result = parser.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+
+      result.count.should == 6
+      result.should include(:operation => 'create')
+      result.should include(:object_property => 'unique')
+      result.should include(:object_type => 'index')
+      result.should include(:index_name => 'cost_invoice_1')
+      result.should include(:table_name => 'cost_invoice')
+      result.should include(:field => 'doc_no')
+    end
+  end
+  context 'element list index' do
+    it 'parses one element', pending:true do
+      sql = 'deptno asc'
+      parser.element_list_index.parse(sql).should == {:elements => {:column=>{:field=> 'deptno',
+                                                                        :data_type=>{:char=>{:length=>{:integer=> '3'}}},
+                                                                        :options=>[{:column_option=> 'not null'}]}}}
+    end
+    it 'parses two element' do
+      sql = 'field1, field2'
+      parser.element_list_index.parse(sql).should == [{:field=> 'field1'},
+                                                      {:field=> 'field2'}]
+
+    end
+
+    it 'parses with new lines' do
+      sql = <<EOF
+DEPTNO desc,
+DEPTNAME asc
+EOF
+      parser.element_list_index.parse(sql.downcase).should == [{:field=> 'deptno',:sort_id=> 'desc'},
+                                                               {:field=> 'deptname',:sort_id=> 'asc'}]
+    end
+  end
+  context 'index column definition' do
+    it 'parses two element' do
+      sql = 'field1'
+      parser.index_column_definition.parse(sql).should == {:field=> 'field1'}
+
+
+    end
+
+    it 'parses with new lines' do
+      sql = <<EOF
+DEPTNO descending
+EOF
+      parser.index_column_definition.parse(sql.downcase).should == {:field=> 'deptno',:sort_id=> 'descending'}
+
+    end
+  end
+  context 'reverse scan' do
+    it 'parses reverse scans option' do
+      sql = 'allow reverse scans'
+    end
+    it 'parses index_option with reverse scans' do
+      sql = 'allow reverse scans'
+      parser.index_option.parse(sql).should == {:index_option => 'allow reverse scans'}
+    end
+  end
+  context 'create_index_statement' do
+    it 'create_index_statement_unique_1', :pending => true do
+      sql = <<EOF
+CREATE
+EOF
+      parser.create_index_statement_1.parse(sql.downcase).should == {:operation=>'create',:object_property=>'unique'}
+
+    end
+    it 'create_index_statement_unique_1_a', :pending => true do
+      sql = <<EOF
+CREATE
+EOF
+      parser.create_index_statement_1_a.parse(sql.downcase).should == {:operation=>'create',:object_property=>'unique'}
+
+    end
+    it 'create_index_statement_unique_2', pending:true do
+      sql = <<EOF
+INDEX COST_INVOICE_1
+EOF
+      parser.create_index_statement_2.parse(sql.downcase).should == {:object_type=>'index',:index_name=>'cost_invoice_1'}
+
+    end
+    it 'create_index_statement_unique', pending:true do
+      sql = <<EOF
+CREATE UNIQUE INDEX COST_INVOICE_1
+EOF
+      parser.create_index_statement.parse(sql.downcase).should == {:operation=>'create',:object_property=>'unique',:object_type=>'index',:index_name=>'cost_invoice_1'}
+
+    end
+  end
+  context 'index_table' do
+    it 'index_table_example' do
+      sql = <<EOF
+ON COST_INVOICE
+EOF
+      parser.index_table.parse(sql.downcase).should == {:table_name => 'cost_invoice'}
+
+    end
+  end
+  context 'full index example with reverse scan option' do
+    it 'with reverse scan', pending:true do
+      sql = <<EOF
+CREATE UNIQUE INDEX COST_INVOICE_1
+        ON COST_INVOICE
+                (DOC_NO)
+        ALLOW REVERSE SCANS
+EOF
+      begin
+        result = parser.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+      result.count.should == 6
+      result.should include(:operation => 'create')
+      result.should include(:object_property => 'unique')
+      result.should include(:object_type => 'index')
+      result.should include(:index_name => 'cost_invoice_1')
+      result.should include(:table_name => 'cost_invoice')
+      result.should include(:field => 'doc_no')
+
+    end
+  end
 end

data/spec/ddl_parser/ddl/db2/create_table_spec.rb

@@ -42,7 +42,7 @@ describe DDLParser::DDL::DB2::Parser do
                                      :cache_value=>{:integer=> '20'}}}]
     end
 
-    it 'parses generated by' do
+    it 'parses 1 generated by 1' do
       sql = 'generated by default as identity (start with 1,  increment by 1, cache 20 )'
       begin
         result = parser.column_options.parse(sql.downcase)
@@ -254,31 +254,6 @@ EOF
       expect(parser).to parse(sql.downcase)
     end
 
-    it 'parses Example 6' do
-      pending 'we do not support CHECK statements'
-      sql = <<EOF
-   CREATE TABLE EMPLOYEE
-     (ID          SMALLINT NOT NULL,
-      NAME        VARCHAR(9),
-      DEPT        SMALLINT CHECK (DEPT BETWEEN 10 AND 100),
-      JOB         CHAR(5) CHECK (JOB IN ('Sales','Mgr','Clerk')),
-      HIREDATE    DATE,
-      SALARY      DECIMAL(7,2),
-      COMM        DECIMAL(7,2),
-      PRIMARY KEY (ID),
-      CONSTRAINT  YEARSAL CHECK (YEAR(HIREDATE) > 1986
-        OR SALARY > 40500)
-     )
-     IN HUMRES
-EOF
-      begin
-        result = parser.parse(sql.downcase)
-#      rescue Parslet::ParseFailed => error
-#        puts error.cause.ascii_tree
-      end
-      result.should == [{:operation=> 'create table', :table_name=> 'emp_act'}]
-    end
-
     it 'parses Example 11' do
       sql = <<EOF
    CREATE TABLE EMP_ACT
@@ -515,4 +490,46 @@ EOF
     end
 
   end
+  context 'create table one column' do
+    it 'parses Example 19' do
+      sql = <<EOF
+   CREATE TABLE COSTINVOICEX
+    (DOC_NO CHARACTER(8) NOT NULL DEFAULT 'TEST DEFAULT')
+
+EOF
+
+      begin
+        result = parser.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+
+      result.should == {:operation=>"create table",
+                        :table_name=>"costinvoicex",
+                        :elements=>{:column=>{:field=>"doc_no",
+                                              :data_type=>{:char=>{:length=>{:integer=>"8"}}},
+                                              :options=>[{:column_option=>"not null"},
+                                                         {:default_clause=>[{:string=>"'test default'"}]}]}}}
+    end
+
+    it 'parses Example 19 1 simple column' do
+      sql = <<EOF
+   CREATE TABLE COSTINVOICEX
+    (DOC_NO INTEGER)
+
+EOF
+
+      begin
+        result = parser.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+
+      result.should == {:operation=>"create table",
+                        :table_name=>"costinvoicex",
+                        :elements=>{:column=>{:field=>"doc_no",
+                                              :data_type=> 'integer', :options=>""}}}
+    end
+
+  end
 end

data/spec/ddl_parser/translator/column_spec.rb

@@ -4,7 +4,18 @@ require_relative '../../../lib/ddl_parser/translator/column'
 describe 'DDLParser::Translator::Column' do
 
   let(:unique_no_column) {
-    DDLParser::Translator::Column.new({:field=> 'unique_no', :data_type=> 'integer', :options=>[{:column_option=> 'identity'}, {:identity=>{:start_value=>{:integer=> '1'}, :increment_value=>{:integer=> '1'}, :cache_value=>{:integer=> '20'}}}]})
+    DDLParser::Translator::Column.new(
+      {:field=> 'unique_no',
+      :data_type=> 'integer',
+      :options=>
+        [{:column_option=> 'identity'},
+        {:identity=>
+          {:start_value=>{:integer=> '1'},
+          :increment_value=>{:integer=> '1'},
+          :cache_value=>{:integer=> '20'}
+          }
+        }]
+      })
   }
 
   let(:int_column) {
@@ -43,6 +54,8 @@ describe 'DDLParser::Translator::Column' do
         })
   }
 
+
+
   it 'must receive hash' do
     DDLParser::Translator::Column.new('').to_hash.should == {}
     DDLParser::Translator::Column.new({:foo => :bar}).to_hash.should == {:foo => :bar}
@@ -88,24 +101,82 @@ describe 'DDLParser::Translator::Column' do
     decimal_column.options.should == [{:column_option=> 'not null'}, {:default_clause=>[{:integer=> '0'}]}]
   end
 
-  it 'should return not null' do
-    int_column.not_null.should == false
-    char_column.not_null.should == false
-    decimal_column.not_null.should == true
-  end
+it 'should return not null' do
+  int_column.not_null.should == false
+  char_column.not_null.should == false
+  decimal_column.not_null.should == true
+end
 
-  it 'should return default clause' do
-    int_column.default_clause.should == nil
-    char_column.default_clause.should == "'foobar'"
-    decimal_column.default_clause.should == 0
-  end
+it 'should return default clause' do
+  int_column.default_clause.should == nil
+  char_column.default_clause.should == "'foobar'"
+  decimal_column.default_clause.should == 0
+end
 
-  it 'should return identity flag' do
-    unique_no_column.identity?.should == true
-  end
 
-  it 'should return start value for identity' do
-    unique_no_column.start_value?.should == 1
-  end
+it 'should return default value' do
+  char_column.default_value.should == "'foobar'"
+end
+
+it 'should return identity flag' do
+  unique_no_column.identity?.should == true
+end
+
+it 'should return start value for identity' do
+  unique_no_column.start_value.should == 1
+end
+
+
+it 'should return start value 0 for int_column' do
+  int_column.start_value.should == 0
+end
+
+it 'should return start value 0 for decimal_column' do
+  decimal_column.start_value.should == 0
+end
+
+  it 'should return increment value for identity' do
+  unique_no_column.increment_value.should == 1
+end
+
+it 'should return cache value for identity' do
+  unique_no_column.cache_value.should == 20
+end
+
+it 'should return name via int_column_identity' do
+  int_column_identity.name.should == 'identity_field'
+end
+
+it 'should return data_type via int_column_identity' do
+  int_column_identity.data_type.should == :integer
+end
+
+it 'should return length via int_column_identity' do
+  int_column_identity.length.should == nil
+end
+
+it 'should return precision via int_column_identity' do
+  int_column_identity.precision.should == nil
+end
+
+it 'should return scale via int_column_identity' do
+  int_column_identity.scale.should == nil
+end
+
+let(:int_column_identity) {
+  DDLParser::Translator::Column.new(
+      {:field=> 'identity_field',
+       :data_type=>{:integer=> '1'},
+       :options=>[{:column_option=> 'identity'}, {:identity_options=>[{:start_value=>[{:integer=> '1'},{:increment_value=>[{:integer=> '1'}]},{:cache_value=>[{:integer=> '20'}]}]}]
+       }]})
+}
+
+it 'should return options via int_column_identity' do
+  int_column_identity.options.should == [{:column_option=> 'identity'}, {:identity_options=>[{:start_value=>[{:integer=> '1'},{:increment_value=>[{:integer=> '1'}]},{:cache_value=>[{:integer=> '20'}]}]}]}]
+end
+
+it 'should return options alt via int_column_identity' do
+  int_column_identity.identity_options.should == [{:integer=>'1'},{:increment_value=>[{:integer=>'1'}]},{:cache_value=>[{:integer=>'20'}]}]
+end
 
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ddl_parser
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
   prerelease: 
 platform: ruby
 authors: