ddl_parser 0.0.11 → 0.0.12

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

@@ -94,16 +94,7 @@ 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)
-        }
-        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)
+          str('create').as(:operation) >> (space? >> str('unique').as(:object_property)).maybe >> space? >> str('index').as(:object_type) >> space? >> (identifier).as(:index_name) >> space?
         }
         rule(:index_table)   {
           space? >> str('on') >> space? >> (identifier).as(:table_name) >> space?
@@ -115,9 +106,8 @@ module DDLParser
           spaces.maybe >> alter_table_statement >> spaces >> (alter_table_element.repeat).as(:elements)
         }
         rule(:create_index)     {
-          spaces.maybe >> create_index_statement >> spaces >> index_table >> spaces >> lparen >> element_list_index >> spaces.maybe >> rparen  >> (space? >> index_option).maybe
+          spaces.maybe >> create_index_statement >> spaces >> index_table >> spaces >> lparen >> element_list_index >> spaces.maybe >> rparen  >> (space? >> index_option).maybe >> space?
         }
-
         rule(:expression) { create_table | alter_table | create_index}
         root :expression
       end

data/lib/ddl_parser/parser.rb

@@ -44,7 +44,7 @@ class DDLParser::Parser
       when :alter_table
         DDLParser::Translator::AlterTable.new(parse_tree)
       when :create_index
-        DDLParser::Translator::CreateIndex.new(parse_tree)
+        DDLParser::Translator::CreateIndexHeader.new(parse_tree)
       else
         raise "Unknown statement_type #{statement_type}"
     end

data/lib/ddl_parser/translator/column.rb

@@ -116,7 +116,6 @@ class DDLParser::Translator::Column
     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?(:identity)}.length > 0
     end
   end

data/lib/ddl_parser/translator/create_index_column.rb

@@ -0,0 +1,26 @@
+class DDLParser::Translator::CreateIndexColumn
+
+  attr_accessor :parse_tree
+
+
+  def initialize(index_column_hash)
+    @index_column_hash = index_column_hash.is_a?(Hash) ? index_column_hash : {}
+  end
+
+  def to_hash
+    @index_column_hash
+  end
+
+  def index_column
+    @index_column_hash[:index_column]
+  end
+
+  def sequence_no
+    @index_column_hash[:sequence_no]
+  end
+
+  def sort_type
+    @index_column_hash[:sort_type]
+  end
+
+end

data/lib/ddl_parser/translator/create_index_header.rb

@@ -0,0 +1,45 @@
+class DDLParser::Translator::CreateIndexHeader
+
+  attr_accessor :index_head, :index_columns
+
+
+  def initialize(index_hash)
+
+    if index_hash.is_a?(Array) and index_hash.count > 1
+      @index_head = index_hash.first.is_a?(Hash) ? index_hash.first : {}
+      @index_columns = index_hash[1..-1]
+    else
+      @index_head = {}
+      @index_columns = []
+    end
+  end
+
+  def to_hash
+    {:head => @index_head, :columns => @index_columns}
+  end
+
+  def index_name
+    @index_head[:index_name]
+  end
+
+  def index_table
+    @index_head[:index_table]
+  end
+
+  def table_name
+    @index_head[:table_name]
+  end
+
+  def object_property
+    @index_head[:object_property]
+  end
+
+  def option_reverse_scans
+    @index_head[:option_reverse_scans]
+  end
+
+  def columns
+    index_columns.map{|e|DDLParser::Translator::Column.new(e)}
+  end
+
+end

data/lib/ddl_parser/translator.rb

@@ -1,7 +1,7 @@
-module DDLParser::Translator
-end
-
-require 'ddl_parser/translator/column'
-require 'ddl_parser/translator/create_table'
-require 'ddl_parser/translator/alter_table'
-require 'ddl_parser/translator/create_index'
+module DDLParser::Translator
+end
+
+require 'ddl_parser/translator/column'
+require 'ddl_parser/translator/create_table'
+require 'ddl_parser/translator/alter_table'
+require 'ddl_parser/translator/create_index_header'

data/lib/ddl_parser/version.rb

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

data/spec/ddl_parser/ddl/db2/{create_index_spec.rb → create_index_header_spec.rb}

@@ -42,11 +42,9 @@ EOF
     end
   end
   context 'element list index' do
-    it 'parses one element', pending:true do
+    it 'parses one element' 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'}]}}}
+      parser.element_list_index.parse(sql).should == {:field=> 'deptno',:sort_id=> 'asc'}
     end
     it 'parses two element' do
       sql = 'field1, field2'
@@ -86,32 +84,27 @@ EOF
     end
     it 'parses index_option with reverse scans' do
       sql = 'allow reverse scans'
-      parser.index_option.parse(sql).should == {:index_option => 'allow reverse scans'}
+      parser.index_option.parse(sql).should include(:index_option => 'allow reverse scans')
     end
   end
   context 'create_index_statement' do
-    it 'create_index_statement_unique_1', :pending => true do
+    it 'create_index_statement_1_unique_1' do
       sql = <<EOF
-CREATE
+CREATE UNIQUE INDEX TEST_INDEX
 EOF
-      parser.create_index_statement_1.parse(sql.downcase).should == {:operation=>'create',:object_property=>'unique'}
+      parser.create_index_statement.parse(sql.downcase.strip).should include(:operation=>'create')
 
     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'}
-
+    it 'create_index_test_statement_unique_1_a' do
+      parser.create_index_statement.parse('create unique index test_index').should == {:operation=>'create',:object_property=>'unique',:object_type=>'index',:index_name=>'test_index'}
     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'}
-
+    it 'create_index_test_statement_unique_1_b' do
+      parser.create_index_statement.parse('create unique index test_index').should include(:operation=>'create')
+    end
+    it 'create_index_statement_unique_3' do
+      parser.create_index_statement.parse('create index cost_invoice_1').should == {:operation=>'create',:object_type=>'index',:index_name=>'cost_invoice_1'}
     end
-    it 'create_index_statement_unique', pending:true do
+    it 'create_index_statement_unique_4' do
       sql = <<EOF
 CREATE UNIQUE INDEX COST_INVOICE_1
 EOF
@@ -129,12 +122,33 @@ EOF
     end
   end
   context 'full index example with reverse scan option' do
-    it 'with reverse scan', pending:true do
+    it 'with reverse scan' 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 == 7
+      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')
+      result.should include(:index_option => 'allow reverse scans')
+
+    end
+    it 'without reverse scan' do
+      sql = <<EOF
+CREATE UNIQUE INDEX COST_INVOICE_1
+        ON COST_INVOICE
+                (DOC_NO)
 EOF
       begin
         result = parser.parse(sql.downcase)
@@ -150,5 +164,24 @@ EOF
       result.should include(:field => 'doc_no')
 
     end
+    it 'live example' do
+      sql = <<EOF
+CREATE INDEX COST_JOB_AGR_1
+        ON COST_JOB_AGR
+                (JOB_ID)
+EOF
+      begin
+        result = parser.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+      result.count.should == 5
+      result.should include(:operation => 'create')
+      result.should include(:object_type => 'index')
+      result.should include(:index_name => 'cost_job_agr_1')
+      result.should include(:table_name => 'cost_job_agr')
+      result.should include(:field => 'job_id')
+
+    end
   end
 end

data/spec/ddl_parser/parser_spec.rb

@@ -1,146 +1,146 @@
-require_relative '../../spec/spec_helper'
-
-describe 'DDLParser::Parser' do
-  
-  it "knows if it's valid" do
-    sql = 'CREATE TABLE TEST (ID INT)'
-    parser = DDLParser::Parser.new(sql)
-    parser.valid?.should == true
-  end
-
-  it "knows if it's invalid" do
-    sql = 'CREATE TABLE TEST ()'
-    parser = DDLParser::Parser.new(sql)
-    parser.valid?.should == false
-  end
-
-  it 'can report errors' do
-    sql = 'CREATE TABLE TEST ()'
-    parser = DDLParser::Parser.new(sql)
-    parser.errors.should include('CREATE_TABLE_STATEMENT')
-  end
-
-  it 'statement_type' do
-    sql = 'CREATE TABLE TEST (ID INT, FOO INT)'
-    parser = DDLParser::Parser.new(sql)
-    parser.statement_type.should == :create_table
-  end
-
-  it 'returns the parse tree' do
-    sql = 'CREATE TABLE TEST (ID INT, FOO INT)'
-    parser = DDLParser::Parser.new(sql)
-    parser.parse_tree.should == {:operation=> 'create table', :table_name=> 'test', :elements=>[
-        {:column=>{:field=> 'id', :data_type=> 'int', :options=> ''}},
-        {:column=>{:field=> 'foo', :data_type=> 'int', :options=> ''}}]}
-  end
-
-  context 'create table translate' do
-    it 'translate table_name' do
-      sql = 'CREATE TABLE TEST (ID INT, FOO INT)'
-      parser = DDLParser::Parser.new(sql)
-      parser.translate.table_name.should == 'test'
-    end
-
-
-    it 'translate columns' do
-      sql = 'CREATE TABLE TEST (ID INT, FOO INT)'
-      parser = DDLParser::Parser.new(sql)
-      parser.translate.columns.map(&:to_hash).should == [{:field=> 'id', :data_type=> 'int', :options=> ''}, {:field=> 'foo', :data_type=> 'int', :options=> ''}]
-
-      sql = 'CREATE TABLE TEST (ID INT)'
-      parser = DDLParser::Parser.new(sql)
-      parser.translate.columns.map(&:to_hash).should == [{:field=> 'id', :data_type=> 'int', :options=> ''}]
-    end
-
-    it 'translate primary key' do
-      sql = 'CREATE TABLE TEST (ID   INT, PRIMARY KEY (ID))'
-      parser = DDLParser::Parser.new(sql)
-      parser.translate.primary_key.should == 'id'
-    end
-  end
-
-  context 'alter table translate' do
-    let(:sql) {
-      sql = <<EOF
-            ALTER TABLE BUDGET
-              ADD COLUMN BUDGET_AMOUNT_IN_CO DECIMAL(15,2) NOT NULL DEFAULT 0
-              ADD COLUMN BUDGET_AMOUNT_CURR CHARACTER(4)
-EOF
-      sql
-    }
-
-    it 'translate table_name' do
-      parser = DDLParser::Parser.new(sql)
-      parser.translate.table_name.should == 'budget'
-    end
-
-
-    it 'translate columns' do
-      parser = DDLParser::Parser.new(sql)
-      parser.translate.add_columns.map(&:to_hash).should == [{:field=> 'budget_amount_in_co',
-                                               :data_type=>{:decimal=>{:precision=>{:total=>{:integer=> '15'}, :scale=>{:integer=> '2'}}}},
-                                               :options=>[{:column_option=> 'not null'},
-                                                          {:default_clause=>[{:integer=> '0'}]}]},
-                                              {:field=> 'budget_amount_curr',
-                                               :data_type=>{:char=>{:length=>{:integer=> '4'}}},
-                                               :options=> ''}]
-    end
-
-    it 'translate primary key' do
-      sql = 'CREATE TABLE TEST (ID   INT, PRIMARY KEY (ID))'
-      parser = DDLParser::Parser.new(sql)
-      parser.translate.primary_key.should == 'id'
-    end
-  end
-
-  context 'create index translate' do
-    before :each do
-      sql = 'CREATE UNIQUE INDEX REPLAN_ADDR_1 ON REPLAN_ADDR (CONSIGNMENT ASCENDING, COLLI DESCENDING)'
-      @parser = DDLParser::Parser.new(sql)
-    end
-
-    it 'table name' do
-      @parser.translate.table_name.should == 'replan_addr'
-    end
-    it 'index name' do
-      @parser.translate.index_name.should == 'replan_addr_1'
-    end
-    it 'columns' do
-      @parser.translate.fields.should == [{:field=>"consignment", :sort_id=>"ascending"}, {:field=>"colli", :sort_id=>"descending"}]
-    end
-
-  end
-
-  context 'report errors' do
-    it 'misses right parant' do
-      sql = "Create table USER (FOO CHAR(4) NOT NULL, BAR CHAR(4) NOT NULL"
-      parser = DDLParser::Parser.new(sql)
-      parser.valid?.should == false
-      parser.errors.should include("Premature end of input")
-    end
-
-    it 'misses element delimiter' do
-      sql = "Create table USER (FOO CHAR(4) NOT NULL BAR CHAR(4) NOT NULL)"
-      parser = DDLParser::Parser.new(sql)
-      parser.valid?.should == false
-      parser.errors.should include('Expected ")", but got "b"')
-    end
-
-    it 'must likely error 1' do
-      sql = "Create table USER (FOO CHAR(4) NOT NULL, BAR CHAR(4) NOT NULL"
-      parser = DDLParser::Parser.new(sql)
-      parser.valid?.should == false
-      parser.most_likely_error.should == 'Premature end of input at line 1 char 62.'
-    end
-
-    it 'must likely error 2' do
-      sql = "Create table USER (FOO CHAR(4) NOT NULL BAR CHAR(4) NOT NULL)"
-      parser = DDLParser::Parser.new(sql)
-      parser.valid?.should == false
-      parser.most_likely_error.should == 'Expected ")", but got "b" at line 1 char 41.'
-    end
-
-  end
-
-
+require_relative '../../spec/spec_helper'
+
+describe 'DDLParser::Parser' do
+  
+  it "knows if it's valid" do
+    sql = 'CREATE TABLE TEST (ID INT)'
+    parser = DDLParser::Parser.new(sql)
+    parser.valid?.should == true
+  end
+
+  it "knows if it's invalid" do
+    sql = 'CREATE TABLE TEST ()'
+    parser = DDLParser::Parser.new(sql)
+    parser.valid?.should == false
+  end
+
+  it 'can report errors' do
+    sql = 'CREATE TABLE TEST ()'
+    parser = DDLParser::Parser.new(sql)
+    parser.errors.should include('CREATE_TABLE_STATEMENT')
+  end
+
+  it 'statement_type' do
+    sql = 'CREATE TABLE TEST (ID INT, FOO INT)'
+    parser = DDLParser::Parser.new(sql)
+    parser.statement_type.should == :create_table
+  end
+
+  it 'returns the parse tree' do
+    sql = 'CREATE TABLE TEST (ID INT, FOO INT)'
+    parser = DDLParser::Parser.new(sql)
+    parser.parse_tree.should == {:operation=> 'create table', :table_name=> 'test', :elements=>[
+        {:column=>{:field=> 'id', :data_type=> 'int', :options=> ''}},
+        {:column=>{:field=> 'foo', :data_type=> 'int', :options=> ''}}]}
+  end
+
+  context 'create table translate' do
+    it 'translate table_name' do
+      sql = 'CREATE TABLE TEST (ID INT, FOO INT)'
+      parser = DDLParser::Parser.new(sql)
+      parser.translate.table_name.should == 'test'
+    end
+
+
+    it 'translate columns' do
+      sql = 'CREATE TABLE TEST (ID INT, FOO INT)'
+      parser = DDLParser::Parser.new(sql)
+      parser.translate.columns.map(&:to_hash).should == [{:field=> 'id', :data_type=> 'int', :options=> ''}, {:field=> 'foo', :data_type=> 'int', :options=> ''}]
+
+      sql = 'CREATE TABLE TEST (ID INT)'
+      parser = DDLParser::Parser.new(sql)
+      parser.translate.columns.map(&:to_hash).should == [{:field=> 'id', :data_type=> 'int', :options=> ''}]
+    end
+
+    it 'translate primary key' do
+      sql = 'CREATE TABLE TEST (ID   INT, PRIMARY KEY (ID))'
+      parser = DDLParser::Parser.new(sql)
+      parser.translate.primary_key.should == 'id'
+    end
+  end
+
+  context 'alter table translate' do
+    let(:sql) {
+      sql = <<EOF
+            ALTER TABLE BUDGET
+              ADD COLUMN BUDGET_AMOUNT_IN_CO DECIMAL(15,2) NOT NULL DEFAULT 0
+              ADD COLUMN BUDGET_AMOUNT_CURR CHARACTER(4)
+EOF
+      sql
+    }
+
+    it 'translate table_name' do
+      parser = DDLParser::Parser.new(sql)
+      parser.translate.table_name.should == 'budget'
+    end
+
+
+    it 'translate columns' do
+      parser = DDLParser::Parser.new(sql)
+      parser.translate.add_columns.map(&:to_hash).should == [{:field=> 'budget_amount_in_co',
+                                               :data_type=>{:decimal=>{:precision=>{:total=>{:integer=> '15'}, :scale=>{:integer=> '2'}}}},
+                                               :options=>[{:column_option=> 'not null'},
+                                                          {:default_clause=>[{:integer=> '0'}]}]},
+                                              {:field=> 'budget_amount_curr',
+                                               :data_type=>{:char=>{:length=>{:integer=> '4'}}},
+                                               :options=> ''}]
+    end
+
+    it 'translate primary key' do
+      sql = 'CREATE TABLE TEST (ID   INT, PRIMARY KEY (ID))'
+      parser = DDLParser::Parser.new(sql)
+      parser.translate.primary_key.should == 'id'
+    end
+  end
+
+  context 'create index translate' do
+    before :each do
+      sql = 'CREATE UNIQUE INDEX REPLAN_ADDR_1 ON REPLAN_ADDR (CONSIGNMENT ASCENDING, COLLI DESCENDING)'
+      @parser = DDLParser::Parser.new(sql)
+    end
+
+    it 'table name' do
+      @parser.translate.table_name.should == 'replan_addr'
+    end
+    it 'index name' do
+      @parser.translate.index_name.should == 'replan_addr_1'
+    end
+    it 'columns' do
+      @parser.translate.columns.map(&:to_hash).should == [{:field=>"consignment", :sort_id=>"ascending"}, {:field=>"colli", :sort_id=>"descending"}]
+    end
+
+  end
+
+  context 'report errors' do
+    it 'misses right parant' do
+      sql = "Create table USER (FOO CHAR(4) NOT NULL, BAR CHAR(4) NOT NULL"
+      parser = DDLParser::Parser.new(sql)
+      parser.valid?.should == false
+      parser.errors.should include("Premature end of input")
+    end
+
+    it 'misses element delimiter' do
+      sql = "Create table USER (FOO CHAR(4) NOT NULL BAR CHAR(4) NOT NULL)"
+      parser = DDLParser::Parser.new(sql)
+      parser.valid?.should == false
+      parser.errors.should include('Expected ")", but got "b"')
+    end
+
+    it 'must likely error 1' do
+      sql = "Create table USER (FOO CHAR(4) NOT NULL, BAR CHAR(4) NOT NULL"
+      parser = DDLParser::Parser.new(sql)
+      parser.valid?.should == false
+      parser.most_likely_error.should == 'Premature end of input at line 1 char 62.'
+    end
+
+    it 'must likely error 2' do
+      sql = "Create table USER (FOO CHAR(4) NOT NULL BAR CHAR(4) NOT NULL)"
+      parser = DDLParser::Parser.new(sql)
+      parser.valid?.should == false
+      parser.most_likely_error.should == 'Expected ")", but got "b" at line 1 char 41.'
+    end
+
+  end
+
+
 end

data/spec/ddl_parser/translator/index_column_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../../../spec/spec_helper'
+require_relative '../../../lib/ddl_parser/translator/create_index_column'
+
+describe 'DDLParser::Translator::CreateIndexColumn' do
+
+  let(:unique_no_column) {
+    DDLParser::Translator::CreateIndexColumn.new(
+        {:index_column=> 'test_index_column',
+         :sequence_no=> 5,
+         :sort_type=> 'asc'
+        })
+  }
+
+  let(:index_name_test) {
+    DDLParser::Translator::CreateIndexColumn.new({:field=> 'test_index'})
+  }
+
+  let(:table_name) {
+    DDLParser::Translator::CreateIndexColumn.new({:field=> 'table_name'})
+  }
+
+it 'must receive hash' do
+  DDLParser::Translator::CreateIndexColumn.new('').to_hash.should == {}
+  DDLParser::Translator::CreateIndexColumn.new({:foo => :bar}).to_hash.should == {:foo => :bar}
+end
+
+it 'should return name' do
+  unique_no_column.index_column.should == 'test_index_column'
+  unique_no_column.sequence_no.should == 5
+  unique_no_column.sort_type.should == 'asc'
+end
+
+end

data/spec/ddl_parser/translator/index_header_spec.rb

@@ -0,0 +1,40 @@
+require_relative '../../../spec/spec_helper'
+require_relative '../../../lib/ddl_parser/translator/create_index_header'
+
+describe 'DDLParser::Translator::CreateIndexHeader' do
+
+  let(:unique_no_column) {
+    DDLParser::Translator::CreateIndexHeader.new(
+      [{:index_name=> 'test_index',
+         :index_table=> 'on test_table',
+         :table_name=> 'test_table',
+         :object_property=> 'unique',
+         :option_reverse_scans=>'allow reverse scans'
+        }, {}])
+  }
+
+  let(:index_name_test) {
+    DDLParser::Translator::CreateIndexHeader.new({:field=> 'test_index'})
+
+  #  DDLParser::Translator::Column.new({:field=> 'int_field', :data_type=> 'int', :options=> ''})
+  }
+
+  let(:table_name) {
+    DDLParser::Translator::CreateIndexHeader.new({:field=> 'table_name'})
+  }
+
+it 'must receive Array of hashes' do
+  DDLParser::Translator::CreateIndexHeader.new('').to_hash.should == {:head => {}, :columns => []}
+  DDLParser::Translator::CreateIndexHeader.new([{:foo => :bar}, {:bar => :foo}]).to_hash.
+        should == {:head => {:foo => :bar}, :columns => [{:bar => :foo}]}
+end
+
+it 'should return name' do
+  unique_no_column.index_name.should == 'test_index'
+  unique_no_column.index_table.should == 'on test_table'
+  unique_no_column.table_name.should == 'test_table'
+  unique_no_column.object_property.should == 'unique'
+  unique_no_column.option_reverse_scans.should == 'allow reverse scans'
+end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ddl_parser
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-12 00:00:00.000000000 Z
+date: 2014-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -105,18 +105,21 @@ files:
 - lib/ddl_parser/translator.rb
 - lib/ddl_parser/translator/alter_table.rb
 - lib/ddl_parser/translator/column.rb
-- lib/ddl_parser/translator/create_index.rb
+- lib/ddl_parser/translator/create_index_column.rb
+- lib/ddl_parser/translator/create_index_header.rb
 - lib/ddl_parser/translator/create_table.rb
 - lib/ddl_parser/version.rb
 - lib/parslet_extentions.rb
 - spec/ddl_parser/ddl/db2/alter_table_spec.rb
-- spec/ddl_parser/ddl/db2/create_index_spec.rb
+- spec/ddl_parser/ddl/db2/create_index_header_spec.rb
 - spec/ddl_parser/ddl/db2/create_table_spec.rb
 - spec/ddl_parser/parser_spec.rb
 - spec/ddl_parser/shared_rules/constants_spec.rb
 - spec/ddl_parser/shared_rules/data_types_spec.rb
 - spec/ddl_parser/sql/db2/select_parser_spec.rb
 - spec/ddl_parser/translator/column_spec.rb
+- spec/ddl_parser/translator/index_column_spec.rb
+- spec/ddl_parser/translator/index_header_spec.rb
 - spec/spec_helper.rb
 homepage: ''
 licenses:
@@ -145,11 +148,13 @@ specification_version: 3
 summary: will parse statements and make it possible to extract content
 test_files:
 - spec/ddl_parser/ddl/db2/alter_table_spec.rb
-- spec/ddl_parser/ddl/db2/create_index_spec.rb
+- spec/ddl_parser/ddl/db2/create_index_header_spec.rb
 - spec/ddl_parser/ddl/db2/create_table_spec.rb
 - spec/ddl_parser/parser_spec.rb
 - spec/ddl_parser/shared_rules/constants_spec.rb
 - spec/ddl_parser/shared_rules/data_types_spec.rb
 - spec/ddl_parser/sql/db2/select_parser_spec.rb
 - spec/ddl_parser/translator/column_spec.rb
+- spec/ddl_parser/translator/index_column_spec.rb
+- spec/ddl_parser/translator/index_header_spec.rb
 - spec/spec_helper.rb

data/lib/ddl_parser/translator/create_index.rb

@@ -1,29 +0,0 @@
-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