ddl_parser 0.0.2

data/spec/ddl_parser/parser_spec.rb

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

data/spec/ddl_parser/shared_rules/constants_spec.rb

@@ -0,0 +1,126 @@
+require "spec_helper"
+
+class DummyParser < Parslet::Parser
+  include DDLParser::SharedRules::Constants
+end
+
+describe DDLParser::SharedRules::Constants do
+  let(:parser) { DummyParser.new }
+
+  it "digits" do
+    (0..9).each do |digit|
+      expect(parser.digit).to     parse(digit.to_s)
+    end
+    ("a".."z").each do |non_digit|
+      expect(parser.digit).not_to     parse(non_digit.to_s)
+    end
+  end
+
+  it "integer" do
+    expect(parser.integer).to     parse("1")
+    expect(parser.integer).to     parse("123456789")
+    expect(parser.integer).to     parse("-123456789")
+    expect(parser.integer).to     parse("0123")
+    expect(parser.integer).not_to parse("1.2")
+  end
+
+  it "float" do
+    expect(parser.float).to     parse("-1.1")
+    expect(parser.float).to     parse("1.1")
+    expect(parser.float).to     parse("123456.789")
+    expect(parser.float).to     parse("-123456.789")
+    expect(parser.float).not_to parse("12")
+  end
+
+  it "space" do
+    expect(parser.space).to     parse(" ")
+    expect(parser.space).to     parse("  ")
+    expect(parser.space).to     parse("\t")
+    expect(parser.space).not_to parse("")
+    expect(parser.space).not_to parse("1")
+  end
+
+  it "space?" do
+    expect(parser.space?).to     parse("")
+    expect(parser.space?).to     parse(" ")
+    expect(parser.space?).to     parse("  ")
+    expect(parser.space?).not_to parse("1")
+  end
+
+  it "newline" do
+    expect(parser.newline).to     parse("\n")
+    expect(parser.newline).not_to parse(" ")
+    expect(parser.newline).not_to parse("\t")
+  end
+
+  it "spaces" do
+    expect(parser.spaces).to     parse("\n")
+    expect(parser.spaces).to     parse(" \n \n")
+    expect(parser.spaces).to     parse("\t ")
+  end
+
+  it "comment?" do
+    expect(parser.comment?).to     parse("-- foobar")
+    expect(parser.comment?).not_to parse("--\nfoobar")
+  end
+
+  it "comma" do
+    expect(parser.comma).to     parse(",")
+    expect(parser.comma).to     parse(", ")
+    expect(parser.comma).not_to parse(" , ")
+  end
+
+  it "lparen" do
+    expect(parser.lparen).to     parse("(")
+    expect(parser.lparen).to     parse("( ")
+    expect(parser.lparen).not_to parse(" (")
+  end
+
+  it "rparen" do
+    expect(parser.rparen).to     parse(")")
+    expect(parser.rparen).to     parse(") ")
+    expect(parser.rparen).not_to parse(" )")
+  end
+
+  it "boolean" do
+    expect(parser.boolean).to     parse("true")
+    expect(parser.boolean).to     parse("false")
+    expect(parser.boolean).not_to parse("false ")
+  end
+
+  it "datetime" do
+    expect(parser.datetime).to    parse("2014-02-28T12:01:02Z")
+  end
+
+  it "string" do
+    expect(parser.string).to      parse("'foobar'")
+    expect(parser.string).to      parse("'foo bar'")
+    expect(parser.string).not_to  parse("'foo bar")
+    expect(parser.string).not_to  parse('"foobar"')
+  end
+
+  it "const" do
+    expect(parser.const).to      parse("'foobar'")
+    expect(parser.const).to      parse("1")
+    expect(parser.const).to      parse("1.1")
+    expect(parser.const).to      parse("true")
+    expect(parser.const).to      parse("2014-02-28T12:01:02Z")
+    expect(parser.const).not_to  parse("(")
+    expect(parser.const).not_to  parse(',')
+  end
+
+  it "identifier" do
+    expect(parser.identifier).to      parse("foobar")
+    expect(parser.identifier).not_to  parse("foo bar")
+    expect(parser.identifier).to     parse("a")
+    expect(parser.identifier).to     parse("aB")
+    expect(parser.identifier).to     parse("A1")
+    expect(parser.identifier).to     parse("A1_2")
+    expect(parser.identifier).not_to parse("A B")
+  end
+
+  it "current_timestamp" do
+    expect(parser.current_timestamp).to      parse("current timestamp")
+  end
+
+end

data/spec/ddl_parser/shared_rules/data_types_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+class DummyParser < Parslet::Parser
+  include DDLParser::SharedRules::DataTypes
+end
+
+describe DDLParser::SharedRules::DataTypes do
+  let(:parser) { DummyParser.new }
+
+  it "parses data types" do
+    parser.data_type.parse("smallint").should       == {:data_type=>"smallint"}
+    parser.data_type.parse("int").should            == {:data_type=>"int"}
+    parser.data_type.parse("decimal(1,2)").should   == {:data_type=>{:decimal=>{:precision => {:total=>{:integer=>"1"}, :scale=>{:integer=>"2"}}}}}
+    parser.data_type.parse("float(1)").should       == {:data_type=>{:float=>{:precision=>{:integer=>"1"}}}}
+    parser.data_type.parse("real").should           == {:data_type=>"real"}
+    parser.data_type.parse("double").should         == {:data_type=>"double"}
+    parser.data_type.parse("char(1)").should        == {:data_type=>{:char=>{:length=>{:integer=>"1"}}}}
+    parser.data_type.parse("varchar(1)").should     == {:data_type=>{:varchar=>{:length=>{:integer=>"1"}}}}
+    parser.data_type.parse("clob(50000)").should     == {:data_type=>{:clob=>{:length=>{:integer=>"50000"}}}}
+    parser.data_type.parse("date").should           == {:data_type=>"date"}
+    parser.data_type.parse("time").should           == {:data_type=>"time"}
+    parser.data_type.parse("timestamp").should      == {:data_type=>"timestamp"}
+  end
+
+
+  end
+

data/spec/ddl_parser/sql/db2/select_parser_spec.rb

@@ -0,0 +1,166 @@
+require "spec_helper"
+
+describe DDLParser::SQL::DB2::SelectParser do
+  let(:parser) { DDLParser::SQL::DB2::SelectParser.new }
+
+  context "value parsing" do
+
+    it "parses integers" do
+      expect(parser.const).to     parse("1")
+      expect(parser.const).to     parse("-123")
+      expect(parser.const).to     parse("120381")
+      expect(parser.const).to     parse("181")
+      expect(parser.const).to     parse("0181")
+    end
+
+    it "parses floats" do
+      expect(parser.const).to     parse("0.1")
+      expect(parser.const).to     parse("3.14159")
+      expect(parser.const).to     parse("-0.00001")
+      expect(parser.const).to_not parse(".1")
+    end
+
+    it "parses booleans" do
+      expect(parser.const).to     parse("true")
+      expect(parser.const).to     parse("false")
+      expect(parser.const).to_not parse("truefalse")
+    end
+
+    it "parses datetimes" do
+      expect(parser.const).to     parse("1979-05-27T07:32:00Z")
+      expect(parser.const).to     parse("2013-02-24T17:26:21Z")
+      expect(parser.const).to_not parse("1979l05-27 07:32:00")
+    end
+
+    it "parses strings" do
+      expect(parser.const).to     parse("''")
+      expect(parser.const).to     parse("'hello world'")
+      expect(parser.const).to     parse("'120.0, ~!@#$\%^&*+_\}{ asdfasf'")
+      expect(parser.const).not_to parse('"hello world"')
+    end
+
+  end
+
+  context "namelist parsing" do
+    it "simple" do
+      expect(parser.namelist).to     parse('a,b,c')
+      expect(parser.namelist).to     parse('a, b, C')
+    end
+
+    it "not parse invalid" do
+      expect(parser.namelist).not_to     parse('a b')
+      expect(parser.namelist).not_to     parse('a: b')
+      expect(parser.namelist).not_to     parse("a; b" )
+      expect(parser.namelist).not_to     parse("a, b, 'foo'" )
+      expect(parser.namelist).not_to     parse("a, b, max(c)" )
+    end
+
+  end
+
+  context "arglist parsing" do
+    it "simple" do
+      expect(parser.arglist).to     parse('a,b,c')
+      expect(parser.arglist).to     parse('a, b, c')
+      expect(parser.arglist).to     parse("a, b, 'foo'" )
+      expect(parser.arglist).to     parse("a, b, max(c)" )
+    end
+
+    it "not parse invalid" do
+      expect(parser.arglist).not_to     parse('a b')
+      expect(parser.arglist).not_to     parse('a: b')
+      expect(parser.arglist).not_to     parse("a; b" )
+    end
+
+  end
+
+  context "between parsing" do
+    it "should parse between" do
+      expect(parser.single_cond).to   parse("a between 1 and 2")
+      expect(parser.single_cond).to   parse("a between 1 and 2")
+      expect(parser.single_cond.parse("a between 1 and 2")).to eq(:lhs=>"a", :op=>"between", :rhs=>{:btw_from=>{:integer=>"1"}, :btw_to=>{:integer=>"2"}})
+    end
+  end
+
+  context "like parsing" do
+    it "should parse" do
+      expect(parser.single_cond).to   parse("a like '%foo%bar'")
+    end
+
+  end
+
+  context "condition parsing" do
+    it "should parse single" do
+      expect(parser.condition).to   parse("a = a")
+      expect(parser.condition).to   parse("a=a")
+      expect(parser.condition).to   parse("a > a")
+      expect(parser.condition).to   parse("a < a")
+      expect(parser.condition).to   parse("a between 1 and 2")
+      expect(parser.condition).to   parse("a like '%foo%bar'")
+    end
+
+    it "should parse multible" do
+      expect(parser.condition).to   parse("a = a or b = b")
+      expect(parser.condition).to   parse("a = a and b = b")
+      expect(parser.condition).to   parse("a > a and a between 'foo' and 'bar'")
+      expect(parser.condition).to   parse("a < a and a like '%foo%bar'")
+    end
+
+  end
+
+  context "select statements" do
+    it "parse simple statements" do
+      [
+          'select a from b',
+          'select a, b from comme',
+          'select b from far',
+          'select c from d',
+          'select a, c, d,e,f,f from b ',
+          'select count(a) from d',
+      ].each do |sql|
+        expect(parser).to parse(sql)
+      end
+    end
+
+    it "parse statements with where" do
+      [
+          'select a from b where a > 20',
+          'select a,b from c where a = 20',
+          'select a,b from c where 20 < a and b < 234',
+          'select a,b from c where 20 < a or b = 234',
+          'select a, b from c where a = ''oo''',
+          'select a, b from c where a = ''oo'' and c > 235',
+      ].each do |sql|
+        expect(parser).to parse(sql)
+      end
+    end
+
+    it "parse statements with group by" do
+      [
+          'select a from b group by c',
+          'select a from b where a > 345 group by c',
+          'select a from b where a > 345 and foo = ''hoge'' group by c',
+      ].each do |sql|
+        expect(parser).to parse(sql)
+      end
+    end
+
+    it "not to parse bad selects" do
+      [
+        'select',
+        'select a, b from c where a = "120.0, ~!@#$%^&*+_\}{\" asdfa"sf"',
+      ].each do |sql|
+        expect(parser).not_to parse(sql)
+      end
+    end
+
+  end
+
+  context "extract" do
+    it "should fetch select" do
+      result = parser.parse("select a from b where a = b")
+      #result[:select].should
+    end
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  #config.expect_with :rspec do |c|
+  #  c.syntax = :expect
+  #end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+require "parslet/rig/rspec"
+require "ddl_parser"
+require "yaml"
+
+def fixture(filename)
+  File.read("spec/fixtures/#{filename}")
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: ddl_parser
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Rasmus Bergholdt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+description: Parse SQL and DDL statements
+email:
+- raber@eg.dk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ddl_parser.gemspec
+- lib/ddl_parser.rb
+- lib/ddl_parser/ddl.rb
+- lib/ddl_parser/ddl/db2.rb
+- lib/ddl_parser/ddl/db2/parser.rb
+- lib/ddl_parser/parser.rb
+- lib/ddl_parser/shared_rules.rb
+- lib/ddl_parser/shared_rules/constants.rb
+- lib/ddl_parser/shared_rules/data_types.rb
+- lib/ddl_parser/shared_rules/logical_operators.rb
+- lib/ddl_parser/sql.rb
+- lib/ddl_parser/sql/db2.rb
+- lib/ddl_parser/sql/db2/select_parser.rb
+- lib/ddl_parser/translater.rb
+- lib/ddl_parser/translater/alter_table.rb
+- lib/ddl_parser/translater/create_index.rb
+- lib/ddl_parser/translater/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_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/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+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_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/spec_helper.rb
+has_rdoc: