ddl_parser 0.0.2

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

@@ -0,0 +1,156 @@
+require "spec_helper"
+
+describe 'Alter table parsing' do
+  let(:parser) { DDLParser::DDL::DB2::Parser.new }
+  context "alter table" do
+    it "parses alter_table add column" do
+      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
+      begin
+        result = parser.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+
+      #puts result.inspect
+      result.count.should == 3
+      result.should include(:operation, :table_name)
+      result.should include(:operation => "alter table")
+      result[:elements].first[:add][:column].should include(:field, :data_type)
+    end
+
+    it "parses alter_table foreign key constraint without on" do
+      sql = <<EOF
+ALTER TABLE REPLAN_ADDR
+        ADD CONSTRAINT REPLAN_ADDR_FK
+            FOREIGN KEY
+                (CONSIGNMENT,
+                EVENT)
+            REFERENCES REPLAN_MAIN
+                (CONSIGNMENT,
+                EVENT)
+EOF
+      begin
+        result = parser.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+
+      #puts result.inspect #.count.should == 3
+      result.should include({:operation => "alter table" , :table_name=>"replan_addr"})
+      result[:elements].first[:add_constraint].should include({:constraint_name=>"replan_addr_fk"})
+    end
+
+    it "parses foreign key clause" do
+      sql = <<EOF
+FOREIGN KEY
+                (CONSIGNMENT,
+                EVENT)
+            REFERENCES REPLAN_MAIN
+                (CONSIGNMENT,
+                EVENT)
+            ON DELETE RESTRICT
+            ON UPDATE NO ACTION
+EOF
+      begin
+        result = parser.foreign_key_clause.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+
+      #puts result.inspect
+      result.count.should == 2
+      result.should include(:reference_clause)
+      result[:member_fields][0][:field].should == "consignment"
+      result[:member_fields][1][:field].should == "event"
+      result[:reference_clause][:reference_arglist][0][:item].should == "consignment"
+      result[:reference_clause][:reference_arglist][1][:item].should == "event"
+    end
+    it "parses reference_clause" do
+      sql = <<EOF
+REFERENCES REPLAN_MAIN
+                (CONSIGNMENT,
+                EVENT)
+
+EOF
+      begin
+        result = parser.reference_clause.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+
+      #puts result.inspect
+      result.should include(:reference_arglist)
+      result[:reference_arglist][0][:item].should == "consignment"
+      result[:reference_arglist][1][:item].should == "event"
+    end
+    it "parses on_delete_clause" do
+      sql = <<EOF
+ON DELETE RESTRICT
+EOF
+      begin
+        result = parser.on_delete_clause.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+
+      #puts result.inspect
+      result.should include(:on_delete_option => 'restrict')
+    end
+
+    it "parses on_update_clause" do
+      sql = <<EOF
+ON UPDATE NO ACTION
+EOF
+      begin
+        result = parser.on_update_clause.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+
+      #puts result.inspect
+      result.should include(:on_update_option => 'no action')
+    end
+
+
+    it "parses complete alter_table" do
+      sql = <<EOF
+ALTER TABLE REPLAN_ADDR
+        ADD CONSTRAINT REPLAN_ADDR_FK
+            FOREIGN KEY
+                (CONSIGNMENT,
+                EVENT)
+            REFERENCES REPLAN_MAIN
+                (CONSIGNMENT,
+                EVENT)
+            ON DELETE RESTRICT
+            ON UPDATE RESTRICT
+EOF
+      begin
+        result = parser.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+
+      #puts result.inspect
+      result.should include(:operation, :table_name)
+      result.should include(:operation => "alter table")
+      result.should include(:table_name => "replan_addr")
+      result[:elements].first.should include(:add_constraint)
+      result[:elements].first[:add_constraint].should include(:constraint_name => 'replan_addr_fk')
+      result[:elements].first[:add_constraint].should include(:foreign_key_clause)
+      result[:elements].first[:add_constraint][:foreign_key_clause].should include(:member_fields)
+      result[:elements].first[:add_constraint][:foreign_key_clause][:member_fields][0].should include(:field=>'consignment')
+      result[:elements].first[:add_constraint][:foreign_key_clause][:member_fields][1].should include(:field=>'event')
+      result[:elements].first[:add_constraint][:foreign_key_clause].should include(:reference_clause)
+      result[:elements].first[:add_constraint][:foreign_key_clause][:reference_clause].should include(:reference_arglist)
+      result[:elements].first[:add_constraint][:foreign_key_clause][:reference_clause][:reference_arglist][0].should include(:item=>'consignment')
+      result[:elements].first[:add_constraint][:foreign_key_clause][:reference_clause][:reference_arglist][1].should include(:item=>'event')
+
+    end
+
+  end
+end

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

@@ -0,0 +1,26 @@
+require "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
+end

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

@@ -0,0 +1,427 @@
+require "spec_helper"
+
+describe DDLParser::DDL::DB2::Parser do
+  let(:parser) { DDLParser::DDL::DB2::Parser.new }
+
+  context "building blocks" do
+
+    it "parses arglist" do
+      parser.arglist.parse("a").should                == {:item=>"a"}
+      parser.arglist.parse("a,b,c").should            == [{:item=>"a"}, {:item=>"b"}, {:item=>"c"}]
+      parser.arglist.parse("a, b, c").should          == [{:item=>"a"}, {:item=>"b"}, {:item=>"c"}]
+    end
+
+  end
+
+  context "column options parsing" do
+    it "parses not null" do
+      expect(parser.column_options).to     parse("not null")
+    end
+
+    it "parses default values" do
+      expect(parser.column_options).to     parse("default 1")
+      expect(parser.column_options).to     parse("with default 1")
+      expect(parser.column_options).to     parse("default current timestamp")
+      expect(parser.column_options).to     parse("default 'foobar'")
+      expect(parser.column_options).to     parse("default max(foo)")
+
+      expect(
+          parser.column_options.parse("default 1")
+      ).to eq([{:default_clause=>[{:integer=>"1"}]}])
+    end
+
+    it "parses generated by" do
+      sql = "generated by default as identity (start with 1  increment by 1 cache 20 )"
+      begin
+        result = parser.column_options.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+      result.should == [{:identity=>{:start_value=>{:integer=>"1"},
+                                     :increment_value=>{:integer=>"1"},
+                                     :cache_value=>{:integer=>"20"}}}]
+    end
+
+    it "parses identity" do
+      expect(parser.column_options).to     parse("as identity (start with 500, increment by 1)")
+      expect(
+          parser.column_options.parse("as identity (start with 500, increment by 1)")
+      ).to eq([{:identity=>{:start_value=>{:integer=>"500"}, :increment_value=>{:integer=>"1"}}}])
+    end
+
+    it "parses multible" do
+      expect(parser.column_options).to    parse("not null  as identity   (start with 500, increment by 1)")
+
+      result =  parser.column_options.parse("not null  as identity   (start with 500, increment by 1)")
+      result.first.should include(:column_option)
+      result.last.should include(:identity)
+    end
+
+  end
+
+  context "constraint" do
+    it "parses primary key" do
+      sql = "primary key (id)"
+      parser.primary_key.parse(sql).should == {:primary_key=>{:item=>"id"}}
+    end
+
+    it "parses composed primary key" do
+      sql = "primary key (id,foo)"
+      parser.primary_key.parse(sql).should == {:primary_key=>[{:item=>"id"}, {:item=>"foo"}]}
+    end
+
+    it "parses unique" do
+      sql = "constraint emp_act_uniq unique (empno,projno,actno)"
+
+      parser.constraint.parse(sql).should == {:constraint=>{:column_name=>"emp_act_uniq", 
+                                                            :constraint_type=>"unique", 
+                                                            :constraint_arglist=>[{:item=>"empno"}, 
+                                                                                  {:item=>"projno"}, 
+                                                                                  {:item=>"actno"}]}}
+    end
+
+    it "parses foreign key" do
+      sql = "constraint fk_act_proj foreign key (projno) references project (projno) on delete cascade"
+      begin
+        result = parser.constraint.parse(sql)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+      result.should == {:constraint=>{:column_name=>"fk_act_proj", 
+                                      :constraint_type=>"foreign key", 
+                                      :constraint_arglist=>{:item=>"projno"}, 
+                                      :reference_arglist=>{:item=>"projno"}}}
+    end
+
+  end
+
+  context "column definition" do
+    it "parses char not null" do
+      sql = "deptno   char(3)     not null"
+      parser.column_definition.parse(sql).should == {:column => {
+                                                        :field=>"deptno",
+                                                        :data_type=>{:char=>{:length=>{:integer=>"3"}}},
+                                                        :options=>[{:column_option=>"not null"}]
+                                                      }
+                                                    }
+
+    end
+    it "parses char not null - x" do
+      sql = "BUDGET_AMOUNT_IN_CO DECIMAL(15,2) NOT NULL DEFAULT 0"
+      parser.column_definition.parse(sql.downcase).should ==  {:column => {
+                                                                  :field=>"budget_amount_in_co",
+                                                                  :data_type=>{:decimal=>{:precision=>
+                                                                                           {:total=>{:integer=>"15"},
+                                                                                            :scale=>{:integer=>"2"}}}},
+                                                                  :options=>[{:column_option=>"not null"}, {:default_clause=>[{:integer=>"0"}]}]
+                                                                }
+                                                              }
+
+    end
+
+  end
+
+  context "element list" do
+    it "parses one element" do
+      sql = "(deptno   char(3)     not null)"
+      parser.element_list.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   char(1)     not null, field2   char(2))"
+      parser.element_list.parse(sql).should == {:elements => [{:column=>{:field=>"field1",
+                                                                  :data_type=>{:char=>{:length=>{:integer=>"1"}}},
+                                                                  :options=>[{:column_option=>"not null"}]}},
+                                                      {:column=>{:field=>"field2",
+                                                                  :data_type=>{:char=>{:length=>{:integer=>"2"}}},
+                                                                  :options=>""}}]}
+    end
+
+    it "parses with new lines" do
+      sql = <<EOF
+(
+DEPTNO   CHAR(3)     NOT NULL,
+DEPTNAME VARCHAR(36) NOT NULL
+)
+EOF
+      parser.element_list.parse(sql.downcase).should == {:elements => [{:column=>{:field=>"deptno",
+                                                                           :data_type=>{:char=>{:length=>{:integer=>"3"}}},
+                                                                           :options=>[{:column_option=>"not null"}]}},
+                                                               {:column=>{:field=>"deptname",
+                                                                           :data_type=>{:varchar=>{:length=>{:integer=>"36"}}},
+                                                                           :options=>[{:column_option=>"not null"}]}}]}
+
+      end
+  end
+
+  context "create table" do
+    it "parses simple create" do
+      expect(parser.create_table_statement).to     parse("create table foobar")
+      expect(parser.create_table_statement).not_to parse("create table ")
+
+      parser.create_table_statement.parse("create table foobar").should == {:operation=>"create table", :table_name => "foobar"}
+    end
+  end
+
+
+
+  context "simple statements" do
+
+    it "parses Example 1"do
+      sql = <<EOF
+   CREATE TABLE TDEPT
+     (DEPTNO   CHAR(3)     NOT NULL,
+      DEPTNAME VARCHAR(36) NOT NULL,
+      MGRNO    INT,
+      ADMRDEPT DECIMAL(3,1) NOT NULL)
+   IN DEPARTX
+EOF
+      parser.create_table.parse(sql.downcase).should ==  {:operation=>"create table", 
+                                                          :table_name=>"tdept",
+                                                          :elements => [
+                                                            {:column=>{:field=>"deptno",
+                                                                      :data_type=>{:char=>{:length=>{:integer=>"3"}}},
+                                                                      :options=>[{:column_option=>"not null"}]}},
+                                                            {:column=>{:field=>"deptname",
+                                                                      :data_type=>{:varchar=>{:length=>{:integer=>"36"}}},
+                                                                      :options=>[{:column_option=>"not null"}]}},
+                                                            {:column=>{:field=>"mgrno",
+                                                                      :data_type=>"int",
+                                                                      :options=>""}},
+                                                            {:column=>{:field=>"admrdept",
+                                                                      :data_type=>{:decimal=>{:precision=>{:total=>{:integer=>"3"}, :scale=>{:integer=>"1"}}}},
+                                                                      :options=>[{:column_option=>"not null"}]}}
+                                                                    ]}
+    end
+
+    it "parses with primary key" do
+      sql = <<EOF
+   CREATE TABLE TEST
+     (ID   INT,
+      PRIMARY KEY (ID))
+EOF
+      parser.create_table.parse(sql.downcase).should == {:operation=>"create table", 
+                                                         :table_name=>"test", 
+                                                         :elements=>[
+                                                            {:column => {:field=>"id", :data_type=>"int", :options=>""}}, 
+                                                            {:primary_key=>{:item=>"id"}}
+                                                          ]
+                                                        }
+    end
+
+  end
+
+  context "full statements" do
+
+    it "parses Example 2" do
+      sql = <<EOF
+   CREATE TABLE PROJ
+     (PROJNO   CHAR(6)      NOT NULL,
+      PROJNAME VARCHAR(24)  NOT NULL,
+      DEPTNO   CHAR(3)      NOT NULL,
+      RESPEMP  CHAR(6)      NOT NULL,
+      PRSTAFF  DECIMAL(5,2)         ,
+      PRSTDATE DATE                 ,
+      PRENDATE DATE                 ,
+      MAJPROJ  CHAR(6)      NOT NULL)
+   IN SCHED
+EOF
+      expect(parser).to parse(sql.downcase)
+    end
+
+    it "parses Example 3" do
+      sql = <<EOF
+   CREATE TABLE EMPLOYEE_SALARY
+     (DEPTNO   CHAR(3)      NOT NULL,
+      DEPTNAME VARCHAR(36)  NOT NULL,
+      EMPNO    CHAR(6)      NOT NULL,
+      SALARY   DECIMAL(9,2) NOT NULL WITH DEFAULT)
+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
+     (EMPNO       CHAR(6) NOT NULL,
+      PROJNO      CHAR(6) NOT NULL,
+      ACTNO       SMALLINT NOT NULL,
+      EMPTIME     DECIMAL(5,2),
+      EMSTDATE    DATE,
+      EMENDATE    DATE,
+      CONSTRAINT EMP_ACT_UNIQ UNIQUE (EMPNO,PROJNO,ACTNO),
+      CONSTRAINT FK_ACT_PROJ FOREIGN KEY (PROJNO)
+                             REFERENCES PROJECT (PROJNO) ON DELETE CASCADE
+     )
+     IN SCHED
+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",
+                        :elements => [
+                          {:column=>
+                            {:field=>"empno",
+                             :data_type=>{:char=>{:length=>{:integer=>"6"}}},
+                             :options=>[{:column_option=>"not null"}]}},
+                          {:column=>
+                            {:field=>"projno",
+                             :data_type=>{:char=>{:length=>{:integer=>"6"}}},
+                             :options=>[{:column_option=>"not null"}]}},
+                          {:column=>
+                            {:field=>"actno",
+                             :data_type=>"smallint",
+                             :options=>[{:column_option=>"not null"}]}},
+                          {:column=>
+                            {:field=>"emptime",
+                             :data_type=>
+                              {:decimal=>
+                                {:precision=>
+                                  {:total=>{:integer=>"5"}, :scale=>{:integer=>"2"}}}},
+                             :options=>""}},
+                          {:column=>{:field=>"emstdate", :data_type=>"date", :options=>""}},
+                          {:column=>{:field=>"emendate", :data_type=>"date", :options=>""}},
+                          {:constraint=>
+                              {:column_name=>"emp_act_uniq",
+                               :constraint_type=>"unique",
+                               :constraint_arglist=>
+                                [{:item=>"empno"}, {:item=>"projno"}, {:item=>"actno"}]}},
+                          {:constraint=>
+                            {:column_name=>"fk_act_proj",
+                             :constraint_type=>"foreign key",
+                             :constraint_arglist=>{:item=>"projno"},
+                             :reference_arglist=>{:item=>"projno"}}}
+                        ]}
+
+    end
+
+    it "parses Example 12" do
+      sql = <<EOF
+   CREATE TABLE HOCKEY_GOALS
+     ( BY_PLAYER      VARCHAR(30)   NOT NULL,
+       BY_TEAM        VARCHAR(30)   NOT NULL,
+       AGAINST_PLAYER VARCHAR(30)   NOT NULL,
+       AGAINST_TEAM   VARCHAR(30)   NOT NULL,
+       DATE_OF_GOAL   DATE          NOT NULL,
+       DESCRIPTION    CLOB(5000))
+EOF
+      begin
+        result = parser.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+      result.should == {:operation=>"create table", :table_name=>"hockey_goals", 
+                        :elements => [
+                          {:column=>{:field=>"by_player", :data_type=>{:varchar=>{:length=>{:integer=>"30"}}}, :options=>[{:column_option=>"not null"}]}}, 
+                          {:column=>{:field=>"by_team", :data_type=>{:varchar=>{:length=>{:integer=>"30"}}}, :options=>[{:column_option=>"not null"}]}}, 
+                          {:column=>{:field=>"against_player", :data_type=>{:varchar=>{:length=>{:integer=>"30"}}}, :options=>[{:column_option=>"not null"}]}}, 
+                          {:column=>{:field=>"against_team", :data_type=>{:varchar=>{:length=>{:integer=>"30"}}}, :options=>[{:column_option=>"not null"}]}}, 
+                          {:column=>{:field=>"date_of_goal", :data_type=>"date", :options=>[{:column_option=>"not null"}]}}, 
+                          {:column=>{:field=>"description", :data_type=>{:clob=>{:length=>{:integer=>"5000"}}}, :options=>""}}]}
+    end
+
+    it "parses Example 16" do
+      sql = <<EOF
+   CREATE TABLE DEPT
+     (DEPTNO     SMALLINT      NOT NULL
+                    GENERATED ALWAYS AS IDENTITY
+                      (START WITH 500, INCREMENT BY 1),
+      DEPTNAME   VARCHAR(36)   NOT NULL,
+      MGRNO      CHAR(6),
+      ADMRDEPT   SMALLINT      NOT NULL,
+      LOCATION   CHAR(30))
+EOF
+
+      begin
+        result = parser.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+
+      result.should == {:operation=>"create table", 
+                        :table_name=>"dept", 
+                        :elements => [
+                         {:column=>{:field=>"deptno", 
+                                     :data_type=>"smallint", 
+                                     :options=>[{:column_option=>"not null"}, 
+                                                {:identity=>{:start_value=>{:integer=>"500"}, :increment_value=>{:integer=>"1"}}}]}}, 
+                         {:column=>{:field=>"deptname", 
+                                     :data_type=>{:varchar=>{:length=>{:integer=>"36"}}}, 
+                                     :options=>[{:column_option=>"not null"}]}}, 
+                         {:column=>{:field=>"mgrno", 
+                                     :data_type=>{:char=>{:length=>{:integer=>"6"}}}, 
+                                     :options=>""}}, 
+                         {:column=>{:field=>"admrdept", 
+                                     :data_type=>"smallint", 
+                                     :options=>[{:column_option=>"not null"}]}}, 
+                         {:column=>{:field=>"location", 
+                                     :data_type=>{:char=>{:length=>{:integer=>"30"}}}, 
+                                     :options=>""}}]}
+    end
+
+  end
+
+  context "real dsv examples" do
+    it "parses Example 16" do
+
+      sql = <<EOF
+Create table USER (USER_RW CHAR(4) NOT NULL,
+USER_NAME CHAR(20) NOT NULL,
+SECURITY_REPORT CHAR(2) NOT NULL,
+SECURITY_AUTH CHAR(2) NOT NULL,
+SECURITY_CORRECT CHAR(2) NOT NULL,
+SECURITY_REVIEW CHAR(2) NOT NULL,
+SECURITY_CHIEF CHAR(2) NOT NULL,
+PASSWORD CHAR(6) NOT NULL,
+SORT_SEQUENTIAL CHAR(4) NOT NULL,
+CREATE_TS TIMESTAMP NOT NULL With Default CURRENT TIMESTAMP,
+UPDATE_TS TIMESTAMP NOT NULL With Default CURRENT TIMESTAMP,
+UNIQUE_NO INTEGER NOT NULL
+Generated By Default as Identity (Start with 1 Increment by 1 cache 20))
+in CPH_TS001
+EOF
+
+      begin
+        result = parser.parse(sql.downcase)
+      rescue Parslet::ParseFailed => error
+        puts error.cause.ascii_tree
+      end
+
+      result[:operation].should == "create table"
+      result[:table_name].should == "user"
+    end
+
+
+  end
+end