ddl_parser 0.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MTc1NWY4Y2ViMWVhNmM3OTNmNTk5NWFhZDZlYzNhZDg5ZmJlYTRiYw==
+  data.tar.gz: !binary |-
+    ZjQzNjgwOTZkZmJhMWY3M2M2NTNlN2RkMzlmOTIwZmY4YzNkOWUwYg==
+SHA512:
+  metadata.gz: !binary |-
+    YTJmZjViYzQwOGQ1NmVmNWE0ODZkZTI4NDk0MTYzZmQwNjg5NDllODE2ODYw
+    YWM0ODMzNjI5YzI5NzkzYjI1ZmVkOWIyOTU0OWY4YTk0YjcyYmQwZTY1NjBk
+    MGNiODU1OTcyN2IwNjA3ZjU0ODlhZjAwMWNlNmQ4N2U0ZjU2ZmU=
+  data.tar.gz: !binary |-
+    N2U4YzIyNTcwNTQzNTc3NmRlYzYzYTMwZWFlNWU4ZDI4ZGMwODM5ZGI1ZTI5
+    NWQ0Nzk5ZjhiNzZmNDRlNjUwM2Q4YTI5OWEwNDQyODMxN2MyNjIxY2JmYzk2
+    MTZkNTk5NWM0NWI0MWY4NDcwM2JkNWE0MTdmYzg1YTAzZTI0ZmM=

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+.idea/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ddl_parser.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Rasmus Bergholdt
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# DDLParser
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'DDL_parser'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install DDL_parser
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/ddl_parser.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ddl_parser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ddl_parser"
+  spec.version       = DDLParser::VERSION
+  spec.authors       = ["Rasmus Bergholdt"]
+  spec.email         = ["raber@eg.dk"]
+  spec.description   = %q{Parse SQL and DDL statements}
+  spec.summary       = %q{will parse statements and make it possible to extract content }
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "parslet", "~> 1.5"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.1"
+  spec.add_development_dependency "rspec", "~> 2.2"
+end

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

@@ -0,0 +1,112 @@
+module DDLParser
+  module DDL
+    module DB2
+      class Parser < Parslet::Parser
+
+        include DDLParser::SharedRules::Constants
+        include DDLParser::SharedRules::LogicalOperators
+        include DDLParser::SharedRules::DataTypes
+
+        # column options
+        rule(:option_not_null)   { str("not null") }
+        rule(:column_option)     { (option_not_null).as(:column_option) }
+        #rule(:lob_options)
+        rule(:primary_key)       { (str("primary key") >> spaces >> references).as(:primary_key) }
+        rule(:constraint)        { (str("constraint") >> spaces >> identifier.as(:column_name) >> spaces >> (str("unique") | str("foreign key")).as(:constraint_type) >> 
+                                   spaces >> references.as(:constraint_arglist) >> spaces >> reference_clause.maybe).as(:constraint)}
+        #rule(:unique)
+        rule(:references)        { lparen >> space? >> arglist >> space? >> rparen }
+        rule(:reference_clause)  { str("references") >> spaces >> identifier >> spaces >> references.as(:reference_arglist) >> (identifier >> spaces).repeat }
+        #rule(:check)
+        #rule(:check_condition)
+        #rule(:constraint_attr)
+        rule(:gen_col_def)       { str("generated always") | str("generated by default") }
+        rule(:default_value)     { const | current_timestamp | function }
+        rule(:default_values)    { (default_value >> space?).repeat }
+        rule(:default_clause)    { ((str("with") >> space?).maybe >> str("default") >> space? >> default_values).as(:default_clause) }
+        rule(:identity_options)  { (str("as identity") >> space? >> lparen >> str("start with") >> spaces >>
+                                   integer.as(:start_value) >> (comma|space) >> spaces.maybe >>str("increment by") >> spaces >> integer.as(:increment_value)>> (spaces >> str("cache")>>spaces>>integer.as(:cache_value)).maybe >> spaces.maybe >>rparen).as(:identity) }
+
+        rule(:column_options)    { ((gen_col_def | column_option | default_clause | identity_options) >> spaces).repeat }
+
+        rule(:column_name)       { identifier }
+        rule(:constraint_name)   { identifier }
+        rule(:column_sort)       { str("ascending") | str("descending")}
+
+        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(:element_list)      { (lparen >> space? >> (column_definition | constraint | primary_key) >> space? >>
+                                    (comma >> space? >> (column_definition | constraint | primary_key) >> space?).repeat >> rparen).as(:elements)
+                                 }
+
+        rule(:element_list_index) { space? >> index_column_definition >>
+                                    (comma >> space? >> index_column_definition).repeat
+                                  }
+
+        rule(:add_constraint_clause)  { (str("add constraint") >> space? >>
+                                    constraint_name.as(:constraint_name) >> space? >>
+                                    foreign_key_clause.as(:foreign_key_clause)).as(:add_constraint)
+                                  }
+        rule(:foreign_key_clause)  {str("foreign key") >> space? >> lparen >>
+                                    element_list_index.as(:member_fields) >> space? >> rparen >> space?  >>
+                                    reference_clause.as(:reference_clause) >> space? >>
+                                    (on_delete_clause.as(:on_delete_clause) >> space?).maybe >>
+                                    (on_update_clause >> space?).maybe
+                                  }
+        rule(:on_delete_clause)    {str("on delete") >> space? >>
+                                    (str('no action')|str('restrict')|str('cascade')|str('set null')).as(:on_delete_option) >> space?
+                                  }
+        rule(:on_update_clause)    {str("on update") >> space? >>
+            (str('no action')|str('restrict')).as(:on_update_option) >> space?
+                                  }
+
+        rule(:alter_table_add_column) do
+          (str("add") >> space? >> (str("column") >> space? >> column_definition) | primary_key).as(:add)
+        end
+
+        rule(:alter_table_element) { (alter_table_add_column | add_constraint_clause) >> spaces.maybe }
+
+        #rule(:alter_table_alter) { }
+        #rule(:alter_table_drop)  { }
+
+        rule(:term)       { const | item }
+
+        rule(:function)   {
+          identifier.as(:function) >> space? >>
+              lparen >> arglist.as(:arguments) >> rparen
+        }
+
+        rule(:item)       { function | identifier | string }
+        rule(:arglist)    {
+          item.as(:item) >> (comma >> item.as(:item)).repeat
+        }
+
+        rule(:create_table_statement)   {
+          str('create table').as(:operation) >> space? >> (identifier).as(:table_name)
+        }
+        rule(:alter_table_statement)   {
+          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)
+        }
+        rule(:create_table)     {
+          spaces.maybe >> create_table_statement >> spaces >> element_list >> spaces.maybe >> (item >> spaces.maybe).repeat
+        }
+        rule(:alter_table)     {
+          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
+        }
+
+        rule(:expression) { create_table | alter_table | create_index}
+        root :expression
+      end
+    end
+  end
+end
+

data/lib/ddl_parser/ddl/db2.rb

@@ -0,0 +1,4 @@
+module DB2
+end
+
+require "ddl_parser/ddl/db2/parser"

data/lib/ddl_parser/ddl.rb

@@ -0,0 +1,4 @@
+module DDLParser::DDL
+end
+
+require "ddl_parser/ddl/db2"

data/lib/ddl_parser/parser.rb

@@ -0,0 +1,48 @@
+class DDLParser::Parser
+
+  attr_accessor :statement_type, :parse_tree
+
+  def initialize(statement)
+    @statement = statement
+    @parse_tree = nil
+    @parse_error = nil
+    begin
+      case @statement.strip
+        when /\Acreate\stable.*/i
+          @statement_type = :create_table
+          @parse_tree = DDLParser::DDL::DB2::Parser.new.create_table.parse(@statement)
+        when /\Aalter\stable.*/i
+          @statement_type = :alter_table
+          @parse_tree = DDLParser::DDL::DB2::Parser.new.alter_table.parse(@statement)
+        when /\Acreate.*index.*/i
+          @statement_type = :create_index
+          @parse_tree = DDLParser::DDL::DB2::Parser.new.create_index.parse(@statement)
+        else
+          raise "Unknown DDL statement"
+      end
+    rescue Parslet::ParseFailed => error
+      @parse_error = error
+    end
+  end
+
+  def valid?
+    @parse_error == nil && @parse_tree && @parse_tree.count > 0
+  end
+
+  def errors
+    @parse_error.to_s if @parse_error
+  end
+
+  def translate
+    case statement_type
+      when :create_table
+        DDLParser::Translater::CreateTable.new(parse_tree)
+      when :alter_table
+        DDLParser::Translater::AlterTable.new(parse_tree)
+      when :create_index
+        DDLParser::Translater::Createindex.new(parse_tree)
+    end
+  end
+
+
+end

data/lib/ddl_parser/shared_rules/constants.rb

@@ -0,0 +1,50 @@
+module DDLParser
+  module SharedRules
+    module Constants
+      include Parslet
+
+      rule(:digit)      { match["0-9"] }
+      rule(:integer)    { (str("-").maybe >> digit.repeat(1)).as(:integer) }
+      rule(:float)      { (str("-").maybe >> digit.repeat(1) >> str(".") >> digit.repeat(1)).as(:float) }
+
+      rule(:space)      { match('\s').repeat(1) }
+      rule(:space?)     { space.maybe }
+      rule(:newline)    { str("\n") }
+      rule(:spaces)     { (space | (comment? >> newline)).repeat }
+      rule(:comment?)   { (str("--") >> (newline.absent? >> any).repeat).maybe }
+
+      rule(:comma)      { str(',') >> space? }
+      rule(:lparen)     { str('(') >> space? }
+      rule(:rparen)     { str(')') >> space? }
+
+      rule(:boolean)    { (str("true") | str("false")).as(:boolean) }
+      rule(:datetime)   { (digit.repeat(4) >> str("-") >>
+          digit.repeat(2) >> str("-") >>
+          digit.repeat(2) >> str("T") >>
+          digit.repeat(2) >> str(":") >>
+          digit.repeat(2) >> str(":") >>
+          digit.repeat(2) >> str("Z")).as(:datetime) }
+
+
+      rule(:string)     {
+        str("'") >>
+            (
+            str('\\') >> any |
+                str("'").absent? >> any
+            ).repeat >>
+            str("'")
+      }
+
+      rule(:const)      {
+        integer | float | string | boolean | datetime
+      }
+
+      rule(:identifier)         { match('\\w').repeat(1) }
+      rule(:current_timestamp)  { str("current timestamp") }
+
+    end
+  end
+end
+
+
+

data/lib/ddl_parser/shared_rules/data_types.rb

@@ -0,0 +1,33 @@
+module DDLParser
+  module SharedRules
+    module DataTypes
+      include Parslet
+      include DDLParser::SharedRules::Constants
+
+      # Build-in data types
+      rule(:type_smallint)      {str("smallint")}
+      rule(:type_integer)       {(str("integer")| str("int"))}
+      rule(:type_bigint)        {str("bigint").as(:bigint)}
+      rule(:type_decimal)       {(((str("decimal") | str('dec') | str('numeric') | str('num')) >>
+          (lparen >> integer.as(:total) >> comma >> integer.as(:scale) >> rparen).as(:precision))).as(:decimal)}
+      rule(:type_float)         {(str("float") >> (lparen >> integer >> rparen).as(:precision)).as(:float)}
+      rule(:type_real)          {str("real")}
+      rule(:type_double)        {str("double")}
+      rule(:type_char)          {((str("character") | str("char")) >> (lparen >> integer >> rparen).as(:length)).as(:char)}
+      rule(:type_varchar)       {(str("varchar") >> (lparen >> integer >> rparen).as(:length)).as(:varchar)}
+      rule(:type_clob)          {(str("clob") >> (lparen >> integer >> rparen).as(:length)).as(:clob)}
+      rule(:type_date)          {str("date")}
+      rule(:type_timestamp)     {str("timestamp")}
+      rule(:type_time)          {type_timestamp.absent? >> str("time")}
+
+
+      rule(:data_type)          { (type_smallint | type_integer | type_bigint | type_decimal | type_float | type_real |
+                                   type_double | type_char | type_varchar | type_clob | type_date | type_time | type_timestamp).as(:data_type)}
+
+
+    end
+  end
+end
+
+
+

data/lib/ddl_parser/shared_rules/logical_operators.rb

@@ -0,0 +1,17 @@
+module DDLParser
+  module SharedRules
+    module LogicalOperators
+      include Parslet
+
+      # logical operators
+      rule(:eq)         { str('=') }
+      rule(:neq)        { str('!=') | str('<>') }
+      rule(:gt)         { str('>') }
+      rule(:lt)         { str('<') }
+      rule(:geq)        { str('>=') }
+      rule(:leq)        { str('<=') }
+      rule(:like)       { str('like') }
+      rule(:binop)      { eq | neq | gt | lt | geq | leq | like}
+    end
+  end
+end

data/lib/ddl_parser/shared_rules.rb

@@ -0,0 +1,6 @@
+module DDLParser::SharedRules
+end
+
+require "ddl_parser/shared_rules/constants"
+require "ddl_parser/shared_rules/data_types"
+require "ddl_parser/shared_rules/logical_operators"

data/lib/ddl_parser/sql/db2/select_parser.rb

@@ -0,0 +1,67 @@
+module DDLParser
+  module SQL
+    module DB2
+      class SelectParser < Parslet::Parser
+
+        include DDLParser::SharedRules::Constants
+        include DDLParser::SharedRules::LogicalOperators
+
+        rule(:term)       { const | item }
+
+        rule(:bool_and)   { str('and') }
+        rule(:bool_or)    { str('or') }
+
+        rule(:identifier) { match('\\w').repeat(1) }
+
+        rule(:function)   {
+          identifier.as(:function) >> space? >>
+              lparen >> arglist.as(:arguments) >> rparen
+        }
+
+        rule(:item)       { function | identifier | string }
+
+        rule(:arglist)    {
+          item.as(:item) >> (comma >> item.as(:item)).repeat
+        }
+        rule(:namelist)   {
+          identifier.as(:name) >> (comma >> identifier.as(:name)).repeat
+        }
+
+        rule(:between_cond){
+          term.as(:lhs) >> space? >> str('between').as(:op) >> space? >> (const.as(:btw_from) >> space? >> bool_and >> space? >> const.as(:btw_to)).as(:rhs)
+        }
+
+        rule(:single_cond){
+          (term.as(:lhs) >> space? >> binop.as(:op) >> space? >> term.as(:rhs)) | between_cond
+        }
+
+        rule(:condition)  {
+          single_cond.as(:lhs) >> space? >>
+              ((bool_and.as(:op) | bool_or.as(:op)) >>
+                  space? >>
+                  condition.as(:rhs)).maybe
+        }
+
+        rule(:select_s)   {
+          str('select').as(:op) >> space? >> (arglist | str('*')).as(:select)
+        }
+        rule(:from_s)     {
+          str('from') >> space? >> namelist.as(:from)
+        }
+        rule(:where_s)    {
+          str('where') >> space? >> condition.as(:where)
+        }
+        rule(:group_s)    {
+          str('group') >> space? >> str('by') >> space? >> item.as(:group_by)
+        }
+        rule(:select)     {
+          select_s >> space? >> from_s >> space? >>
+              (where_s >> space? >> group_s.maybe | group_s).maybe
+        }
+
+        rule(:expression) { select } #| insert | create }
+        root :expression
+      end
+    end
+  end
+end

data/lib/ddl_parser/sql/db2.rb

@@ -0,0 +1,4 @@
+module DB2
+end
+
+require "ddl_parser/sql/db2/select_parser"

data/lib/ddl_parser/sql.rb

@@ -0,0 +1,4 @@
+module DDLParser::SQL
+end
+
+require "ddl_parser/sql/db2"

data/lib/ddl_parser/translater/alter_table.rb

@@ -0,0 +1,20 @@
+class DDLParser::Translater::AlterTable
+
+    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]
+    end
+
+    def add_columns
+      elements.map{|e|e[:add]}.compact.map{|e|e[:column]}.compact
+    end
+
+end

data/lib/ddl_parser/translater/create_index.rb

@@ -0,0 +1,24 @@
+class DDLParser::Translater::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[:table_name]
+  end
+
+  def columns
+    elements.map{|e|e[:column]}.compact
+  end
+
+  def primary_key
+    elements.map{|e| e[:primary_key]}.compact.first[:item]
+  end
+
+end

data/lib/ddl_parser/translater/create_table.rb

@@ -0,0 +1,27 @@
+class DDLParser::Translater::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
+    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/translater.rb

@@ -0,0 +1,6 @@
+module DDLParser::Translater
+end
+
+require "ddl_parser/translater/create_table"
+require "ddl_parser/translater/alter_table"
+require "ddl_parser/translater/create_index"

data/lib/ddl_parser/version.rb

@@ -0,0 +1,3 @@
+module DDLParser
+  VERSION = "0.0.2"
+end

data/lib/ddl_parser.rb

@@ -0,0 +1,16 @@
+require "parslet"
+require "time"
+require "parslet_extentions"
+require "ddl_parser/version"
+
+module DDLParser
+  Error          = Class.new StandardError
+  ParseError     = Class.new Error
+end
+
+require "ddl_parser/shared_rules"
+require "ddl_parser/sql"
+require "ddl_parser/ddl"
+require "ddl_parser/parser"
+require "ddl_parser/translater"
+

data/lib/parslet_extentions.rb

@@ -0,0 +1,17 @@
+module Parslet
+
+  class Source
+
+    # make new version thats case insensitive
+    alias sensitive_matches? matches?
+    def matches?(pattern)
+      if pattern.is_a?(String)
+        @str.downcase.index(pattern.downcase, @pos) == @pos
+      else
+        sensitive_matches?(pattern)
+      end
+    end
+
+  end
+
+end