sql_parser 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/Rakefile

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

data/lib/..rb

@@ -0,0 +1,5 @@
+require "./version"
+
+module .
+  # Your code goes here...
+end

data/lib/sql_parser.rb

@@ -0,0 +1,21 @@
+require "rubygems"
+require "treetop"
+
+dir = File.expand_path(File.dirname(__FILE__))
+Treetop.load File.expand_path("#{dir}/sql_parser/sql_parser")
+
+class SqlParser::ItemsNode < Treetop::Runtime::SyntaxNode
+  def values
+    items.values.unshift(item.value)
+  end
+end
+
+class SqlParser::ItemNode < Treetop::Runtime::SyntaxNode
+  def values
+    [value]
+  end
+  
+  def value
+    text_value.to_sym
+  end
+end

data/lib/sql_parser/sql_parser.treetop

@@ -0,0 +1,183 @@
+grammar Sql
+  rule statement
+    select from where {
+      def tree
+        {
+          :operator => operator,
+          :set_quantifier => set_quantifier,
+          :fields => fields,
+          :tables => tables,
+          :conditions => conditions
+        }
+      end
+
+      def operator
+        :select
+      end
+
+      def set_quantifier
+        select.set_quantifier
+      end
+
+      def fields
+        select.fields
+      end
+
+      def tables
+        from.tables
+      end
+
+      def conditions
+        where.conditions
+      end
+    }
+  end
+
+  rule select
+    "select" quantifier:set_quantifier items {
+      def fields
+        items.values
+      end
+
+      def set_quantifier
+        quantifier.value
+      end
+    }
+  end
+
+  rule set_quantifier
+    (
+      required_space 'distinct' required_space
+      /
+      required_space 'all' required_space
+    ) {
+      def value
+        text_value.strip.downcase.to_sym
+      end
+    }
+    /
+    required_space {
+      def value
+        nil
+      end
+    }
+  end
+
+  rule from
+    required_space "from" required_space items {
+      def tables
+        items.values
+      end
+    }
+    /
+    space {
+      def tables
+        []
+      end
+    }
+  end
+
+  rule where
+    required_space "where" required_space conditional_items {
+      def conditions
+        conditional_items.node
+      end
+    }
+    /
+    space {
+      def conditions
+        []
+      end
+    }
+  end
+
+  rule conditional_items
+    conditional_item required_space boolean_join required_space conditional_items {
+      def node
+        all_nodes = []
+        all_nodes.concat(conditional_item.node)
+        all_nodes << {:operator => boolean_join.operator}
+        all_nodes.concat(conditional_items.node)
+        all_nodes
+      end
+    }
+    /
+    conditional_item
+  end
+
+  rule boolean_join
+    ('and' / 'or') {
+      def operator
+        text_value.to_sym
+      end
+    }
+  end
+
+  rule conditional_item
+    assignment_field space conditional_operator space assignment_value {
+      def node
+        [{
+          :operator => conditional_operator.value,
+          :field => assignment_field.text_value.to_sym,
+          :value => assignment_value.value
+        }]
+      end
+    }
+  end
+
+  rule conditional_operator
+    ('<>' / '>=' / '<=' / '=' / '>' / '<') {
+      def value
+        text_value.to_sym
+      end
+    }
+  end
+
+  rule assignment_field
+    !keyword [a-zA-Z_] [a-zA-Z0-9_]*
+  end
+
+  rule assignment_value
+    string_assignment_value
+    /
+    numeric_assignment_value
+  end
+
+  rule string_assignment_value
+    "'" [^']* "'" {
+      def value
+        text_value[1..-2]
+      end
+    }
+  end
+
+  rule numeric_assignment_value
+    !keyword [0-9]+ {
+      def value
+        Integer(text_value)
+      end
+    }
+  end
+
+  rule items
+    item space [,]+ space items <SqlParser::ItemsNode>
+    /
+    item
+  end
+
+  rule item
+    !keyword [a-z_0-9*]+ <SqlParser::ItemNode>
+  end
+
+  rule keyword
+    'select' / 'from'
+  end
+
+  rule required_space
+    ' '+
+  end
+
+  rule space
+    ' '*
+  end
+end

data/lib/sql_parser/version.rb

@@ -0,0 +1,3 @@
+class SqlParser
+  VERSION = "0.0.1"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift("#{dir}/../lib")
+require "sql_parser"
+
+# require "spec"

data/spec/sql_parser_spec.rb

@@ -0,0 +1,231 @@
+dir = File.dirname(__FILE__)
+require File.expand_path("#{dir}/spec_helper")
+
+shared_context "SqlParser" do
+  before do
+    @parser = SqlParser.new
+  end
+
+  def parse(input)
+    result = @parser.parse(input)
+    if !result
+      puts result.failure_reason
+    end
+    result.should be
+    result
+  end
+end
+
+describe SqlParser, "parsing" do
+  include_context "SqlParser"
+  
+  it "when conditions are not joined with an :and or :or, does not succeed" do
+    @parser.parse("select first_name from users where first_name='joe' last_name='bob'").should be_nil
+  end
+end
+
+describe SqlParser, "#tree when parsing select statement" do
+  include_context "SqlParser"
+
+  it "parses a multi field, table, and where clause statement" do
+    parse("select distinct *, first_name, last_name, middle_name from users, accounts, logins where first_name='joe' and last_name='bob' or age > 25").tree.should == {
+      :operator => :select,
+      :set_quantifier => :distinct,
+      :fields => [:'*', :first_name, :last_name, :middle_name],
+      :tables => [:users, :accounts, :logins],
+      :conditions => [
+        {:operator => :'=', :field => :first_name, :value => 'joe'},
+        {:operator => :and},
+        {:operator => :'=', :field => :last_name, :value => 'bob'},
+        {:operator => :or},
+        {:operator => :'>', :field => :age, :value => 25}
+      ]
+    }
+  end
+end
+
+describe SqlParser, "#operator when parsing select statement" do
+  include_context "SqlParser"
+
+  it "returns :select" do
+    parse("select first_name").operator.should == :select
+  end
+end
+
+describe SqlParser, "#set_quantifier when parsing select statement" do
+  include_context "SqlParser"
+
+  it "when parsing distinct, returns :distinct" do
+    parse("select distinct first_name").set_quantifier.should == :distinct
+  end
+
+  it "when parsing all, returns :all" do
+    parse("select all first_name").set_quantifier.should == :all
+  end
+end
+
+describe SqlParser, "#fields when parsing select statement" do
+  include_context "SqlParser"
+
+  it "returns the fields in the statement" do
+    parse("select first_name").fields.should == [:first_name]
+    parse("select first_name, last_name, middle_name").fields.should == [
+      :first_name, :last_name, :middle_name
+    ]
+  end
+
+  it "when receiving *, returns * in the fields list" do
+    parse("select *").fields.should == [:'*']
+  end
+end
+
+describe SqlParser, "#tables when parsing select statement" do
+  include_context "SqlParser"
+
+  it "returns tables from the statement" do
+    parse("select first_name from users").tables.should == [:users]
+    parse("select first_name from users, accounts, logins").tables.should == [
+      :users, :accounts, :logins
+    ]
+  end
+end
+
+describe SqlParser, "#conditions when parsing select statement" do
+  include_context "SqlParser"
+  
+  it "when no where conditions, returns empty hash" do
+    parse("select first_name from users").conditions.should == []
+  end
+
+  it "returns equality conditions from the statement" do
+    parse("select first_name from users where id=3").conditions.should == [
+      { :operator => :'=', :field => :id, :value => 3 }
+    ]
+    parse("select first_name from users where first_name='joe'").conditions.should == [
+      { :operator => :'=', :field => :first_name, :value => 'joe' }
+    ]
+    parse("select first_name from users where first_name='joe' and last_name='bob'").conditions.should == [
+      {:operator => :'=', :field => :first_name, :value => 'joe'},
+      {:operator => :and},
+      {:operator => :'=', :field => :last_name, :value => 'bob'}
+    ]
+  end
+
+  it "returns greater than conditions from the statement" do
+    parse("select first_name from users where id>3").conditions.should == [
+      { :operator => :'>', :field => :id, :value => 3 }
+    ]
+
+    parse("select first_name from users where id>3 and age>25").conditions.should == [
+      {:operator => :'>', :field => :id, :value => 3},
+      {:operator => :and},
+      {:operator => :'>', :field => :age, :value => 25}
+    ]
+  end
+
+  it "returns less than conditions from the statement" do
+    parse("select first_name from users where id<3").conditions.should == [
+      { :operator => :'<', :field => :id, :value => 3 }
+    ]
+
+    parse("select first_name from users where id<3 and age<25").conditions.should == [
+      {:operator => :'<', :field => :id, :value => 3},
+      {:operator => :and},
+      {:operator => :'<', :field => :age, :value => 25}
+    ]
+  end
+
+  it "returns greater than or equal to conditions from the statement" do
+    parse("select first_name from users where id>=3").conditions.should == [
+      { :operator => :'>=', :field => :id, :value => 3 }
+    ]
+
+    parse("select first_name from users where id>=3 and age>=25").conditions.should == [
+      {:operator => :'>=', :field => :id, :value => 3},
+      {:operator => :and},
+      {:operator => :'>=', :field => :age, :value => 25}
+    ]
+  end
+
+  it "returns less than or equal to conditions from the statement" do
+    parse("select first_name from users where id<=3").conditions.should == [
+      { :operator => :'<=', :field => :id, :value => 3 }
+    ]
+
+    parse("select first_name from users where id<=3 and age<=25").conditions.should == [
+      {:operator => :'<=', :field => :id, :value => 3},
+      {:operator => :and},
+      {:operator => :'<=', :field => :age, :value => 25}
+    ]
+  end
+
+  it "returns not equal to conditions from the statement" do
+    parse("select first_name from users where id<>3").conditions.should == [
+      { :operator => :'<>', :field => :id, :value => 3 }
+    ]
+
+    parse("select first_name from users where id<>3 and age<>25").conditions.should == [
+      {:operator => :'<>', :field => :id, :value => 3},
+      {:operator => :and},
+      {:operator => :'<>', :field => :age, :value => 25}
+    ]
+  end
+end
+
+describe SqlParser, "#conditions when parsing select statement with :and operators" do
+  include_context "SqlParser"
+
+  it "returns single level :and operation" do
+    parse("select first_name from users where first_name='joe' and last_name='bob'").conditions.should == [
+      {:operator => :'=', :field => :first_name, :value => 'joe'},
+      {:operator => :and},
+      {:operator => :'=', :field => :last_name, :value => 'bob'}
+    ]
+  end
+
+  it "returns nested :and operations from the statement" do
+    parse("select first_name from users where first_name='joe' and last_name='bob' and middle_name='pat'").conditions.should == [
+      {:operator => :'=', :field => :first_name, :value => 'joe'},
+      {:operator => :and},
+      {:operator => :'=', :field => :last_name, :value => 'bob'},
+      {:operator => :and},
+      {:operator => :'=', :field => :middle_name, :value => 'pat'}
+    ]
+  end
+end
+
+describe SqlParser, "#conditions when parsing select statement with :or operators" do
+  include_context "SqlParser"
+
+  it "returns single level :and operation" do
+    parse("select first_name from users where first_name='joe' or last_name='bob'").conditions.should == [
+      {:operator => :'=', :field => :first_name, :value => 'joe'},
+      {:operator => :or},
+      {:operator => :'=', :field => :last_name, :value => 'bob'}
+    ]
+  end
+
+  it "returns nested :or operations from the statement" do
+    parse("select first_name from users where first_name='joe' or last_name='bob' or middle_name='pat'").conditions.should == [
+      {:operator => :'=', :field => :first_name, :value => 'joe'},
+      {:operator => :or},
+      {:operator => :'=', :field => :last_name, :value => 'bob'},
+      {:operator => :or},
+      {:operator => :'=', :field => :middle_name, :value => 'pat'}
+    ]
+  end
+end
+
+describe SqlParser, "#conditions when parsing select statement with :and and :or operators" do
+  include_context "SqlParser"
+
+  it "returns :and having precedence over :or" do
+    parse("select first_name from users where age > 25 and first_name='joe' or last_name='bob'").conditions.should == [
+      {:operator => :'>', :field => :age, :value => 25},
+      {:operator => :and},
+      {:operator => :'=', :field => :first_name, :value => 'joe'},
+      {:operator => :or},
+      {:operator => :'=', :field => :last_name, :value => 'bob'}
+    ]
+  end
+end

data/sql_parser.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sql_parser/version"
+
+Gem::Specification.new do |s|
+  s.name        = "sql_parser"
+  s.version     = SqlParser::VERSION
+  s.authors     = ["Jingwen Owen Ou"]
+  s.email       = ["jingweno@gmail.com"]
+  s.homepage    = "https://github.com/jingweno/sql_parser"
+  s.summary     = %q{A Ruby SQL parser based on Treetop.}
+  s.description = %q{A Ruby SQL parser based on Treetop.}
+
+  s.rubyforge_project = "."
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  s.add_runtime_dependency "treetop"
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: sql_parser
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jingwen Owen Ou
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-19 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70225085717560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70225085717560
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: &70225085717080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70225085717080
+description: A Ruby SQL parser based on Treetop.
+email:
+- jingweno@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- lib/..rb
+- lib/sql_parser.rb
+- lib/sql_parser/sql_parser.treetop
+- lib/sql_parser/version.rb
+- spec/spec_helper.rb
+- spec/sql_parser_spec.rb
+- sql_parser.gemspec
+homepage: https://github.com/jingweno/sql_parser
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: .
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: A Ruby SQL parser based on Treetop.
+test_files:
+- spec/spec_helper.rb
+- spec/sql_parser_spec.rb