selekt 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9f0c51f50abfadf14590ea0dd7a265758f8137e6
+  data.tar.gz: 326f21878ee0351f692ef97eada92fdd0750c343
+SHA512:
+  metadata.gz: d664f245f8964a696a77a5a47d9b692b3b0126e9fcdc920a24708b238eaa79094eb7eb5cb9046fd3cc87122beb303d9697150cf6bd8490442646d08941536b30
+  data.tar.gz: 84475d3136ae0903eabd60bf1c94f1534bbf217c0ef7692c613b13aba62623815cef0b96e90d9ef307694d1fc3b9edb5da817b4558a6173548f4034e50c973ef

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+script: bundle exec rake
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+  - ruby-head
+  - rbx
+  - jruby-19mode
+matrix:
+  allow_failures:
+    - rvm: rbx
+    - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+gemspec
+
+platform :rbx do
+  gem 'rubysl'
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013, 2014 Willem van Bergen
+
+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,109 @@
+# Selekt [![Build Status](https://travis-ci.org/wvanbergen/selekt.png)](https://travis-ci.org/wvanbergen/selekt)
+
+A toolkit to work with SQL queries, mostly for building test suites around
+applications that use complex SQL queries. It includes:
+
+- A SQL syntax parser, with abstract syntax tree manipulation tools.
+- Stubbing tools to replace tables and subqueries in queries with static data.
+
+The main use case for this library is building test suites for applications with
+a complex database, for which it is infeasible to load fixtures data, due to 
+performance or permission issues.
+
+Personally, I have used it to test complicated view definitions for data
+modeling purposes. Also, I have used it to speed up tests by replace the parts in 
+a SQL query that would require disk access by a static stub.
+
+The SQL syntax that is supported by the parser is ANSI SQL, with some support 
+for PostgreSQL and Vertica extensions.
+
+## Installation
+
+Add this line to your application's Gemfile: `gem 'selekt'` 
+and run `bundle install`.
+
+## Usage
+
+Testing a complex query using stubs:
+
+``` ruby
+# Say we have this view definition, to get a list of your customers
+# and whether they had at least one sale last month:
+view_definition = <<-SQL
+    SELECT c.name, COUNT(s.sale_id) >= 1 AS active
+      FROM customers c 
+      LEFT JOIN sales s ON s.customer_id = c.customer_id
+        AND s.timestamp >= NOW() - INTERVAL '1 MONTH'
+      GROUP BY c.customer_id
+SQL
+
+# To test this definition for different datasets in the
+# customers and sales table, we would have to load different
+# fixture sets, which would be hard and slow. Let's stub them 
+# out instead.
+
+query = Selekt.parse(view_definition)
+
+customers = Selekt::SourceStub.new(:customer_id, :name)
+customers << [1, "Willem"]
+
+single_sale = Selekt::SourceStub.new(:sale_id, :customer_id, :timestamp)
+single_sale << [1, 1, Time.now]
+
+# Replace the c and s source (the customers and sales tables) with our stubs
+stubbed_query = query.stub('c', customers).stub('s', single_sale)
+
+# Now, run the resulting query against your test DB to assert the right behavior.
+result = db.query(stubbed_query.sql)
+assert_equal 1, result.rows.length 
+assert_equal true, result.rows[0][:active]
+
+# Now let's try it with a sale that should not be counted.
+old_sale = Selekt::SourceStub.new(:sale_id, :customer_id, :timestamp)
+old_sale << [1, 1, Time.now - 2.months]
+stubbed_query = query.stub('c', customers).stub('s', old_sale)
+
+result = db.query(stubbed_query.sql)
+assert_equal 1, result.rows.length
+assert_equal false, result.rows[0][:active]
+
+# Finally, let's try it with an unrelated sale
+no_sale = Selekt::SourceStub.new(:sale_id, :customer_id, :timestamp)
+no_sale << [1, 2, Time.now] # use a different customer_id
+stubbed_query = query.stub('c', customers).stub('s', no_sale)
+
+result = db.query(stubbed_query.sql)
+assert_equal 1, result.rows.length 
+assert_equal false, result.rows[0][:active] # is this going to pass?
+```
+
+This way, you can easily quickly test the behavior of your SQL queries, with
+different sets of source data, without having to load different sets of
+fixtures. This is a lot faster and you won't need data loading permissions
+to run these tests.
+
+### SourceStub
+
+You don't have to use a `Selekt::SourceStub` object when calling 
+`query.stub(name, stub)`; any SQL query that the library can parse will be 
+accepted. A source stub will simply generate a SQL query by joining
+a static SELECT query for every row using UNION ALL:
+
+``` ruby
+customers = Selekt::SourceStub.new(:customer_id, :name)
+customers << [1, "Willem"]
+customers << [2, "Aaron"]
+customers.sql
+
+# SELECT 1 AS customer_id, 'Willem' AS name
+# UNION ALL
+# SELECT 2 AS customer_id, 'Aaron' AS name
+```
+
+## Contributing
+
+1. Fork it, and create your feature branch (`git checkout -b my-new-feature`)
+2. Implement your changes and make sure there is test coverage for them.
+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, and ping @wvanbergen.

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/lib/selekt.rb

@@ -0,0 +1,50 @@
+require "treetop"
+require "date"
+
+module Selekt
+  extend self
+
+  RESERVED_SQL_KEYWORDS = [
+    'select', 'from', 'where', 'group', 'order', 'having', 'union', 'all',
+    'limit', 'offset', 'as', 'by', 'with', 'distinct',
+    'left', 'right', 'inner', 'full', 'outer', 'join', 'on', 'using', 'natural',
+    'case', 'when', 'then', 'else', 'end', 'interval',
+    'over', 'partition', 'range', 'rows', 'window'
+  ]
+
+  class ParseError < StandardError; end
+  class StubError < StandardError; end
+
+  def parser
+    @parser ||= begin
+      Treetop.load(File.expand_path('./selekt/sql.treetop', File.dirname(__FILE__)))
+      Selekt::SQLParser.new
+    end
+  end
+
+  def parse(sql)
+    Selekt::Query.new(sql)    
+  end
+
+  def safe_identifier(id)
+    id =~ /\A[a-z][a-z0-9_]*\z/i ? id : '"' + id.gsub('"', '""') + '"'
+  end
+
+  def quote(val)
+    case val
+      when NilClass; 'NULL'
+      when TrueClass; 'TRUE'
+      when FalseClass; 'FALSE'
+      when Numeric; val.to_s
+      when String; "'" + val.gsub("'", "''") + "'"
+      when DateTime, Time; quote(val.strftime('%F %X')) + '::timestamp'
+      when Date; quote(val.strftime('%F')) + '::date'
+      else raise "Don't know how to quote #{val.inspect}!"
+    end
+  end
+end
+
+require "selekt/version"
+require "selekt/sql"
+require "selekt/query"
+require "selekt/source_stub"

data/lib/selekt/query.rb

@@ -0,0 +1,58 @@
+class Selekt::Query
+
+  class Relation < Struct.new(:schema_name, :table_name)
+    def to_s
+      if schema_name.nil?
+        Selekt.safe_identifier(table_name)
+      else
+        Selekt.safe_identifier(schema_name) + '.' + Selekt.safe_identifier(table_name)
+      end
+    end
+  end
+
+  attr_reader :ast
+
+  def initialize(sql)
+    @ast = Selekt.parser.parse(sql) or raise Selekt::ParseError.new("Could not parse SQL query: #{sql}")
+  end
+
+  def relations
+    find_nodes(ast, Selekt::SQL::TableReference).map { |tr| Relation.new(tr.schema_name, tr.table_name) }.uniq
+  end
+
+  def sources
+    find_nodes(ast, Selekt::SQL::Source)
+  end
+
+  def source_names
+    sources.map(&:variable_name).uniq
+  end
+
+  def stub(source_name, source_stub)
+    stub_sql = source_stub.respond_to?(:sql) ? source_stub.sql : source_stub.to_s
+    self.class.new(render_stubbed_sql(ast, source_name.to_s, stub_sql))
+  end
+
+  def sql
+    ast.input
+  end
+
+  protected
+
+  def render_stubbed_sql(ast, source, stubbed_query)
+    return ast.text_value if ast.elements.nil?
+    return "(#{stubbed_query}) AS #{source}" if ast.respond_to?(:variable_name) && ast.variable_name == source
+    ast.elements.map { |a| render_stubbed_sql(a, source, stubbed_query) }.join('')
+  end
+
+
+  def find_nodes(ast, ext_module)
+    return [] if ast.elements.nil?
+    results = ast.elements.map do |element|
+      find_nodes(element, ext_module)
+    end.flatten
+      
+    results.unshift(ast) if ast.extension_modules.include?(ext_module)
+    return results
+  end
+end

data/lib/selekt/source_stub.rb

@@ -0,0 +1,60 @@
+class Selekt::SourceStub
+
+  attr_reader :fields, :rows
+
+  def initialize(*fields)
+    @fields = fields.map { |f| f.to_sym }
+    @rows = []
+  end
+
+  def add_row(row)
+    if row.is_a?(Hash)
+      @rows << fields.map { |f| row[f] }
+    else
+      raise Selekt::StubError, "Row should have #{fields.size} values maximum" if fields.size < row.size
+      @rows << fields.map.with_index { |_, i| row[i] }
+    end
+    return self
+  end
+
+  alias_method :<<, :add_row
+  alias_method :push, :add_row  
+
+  def add_rows(rows)
+    rows.each { |row| add_row(row) }
+    return self
+  end
+
+  alias_method :concat, :add_rows
+
+  def sql
+    first_row_sql = [row_sql_with_names(rows[0])]
+    other_row_sql = rows[1..-1].map { |row| row_sql_without_names(row) }
+    [first_row_sql].concat(other_row_sql).join("\nUNION ALL\n")
+  end
+
+  def size
+    @rows.size
+  end
+
+  def ==(other)
+    return false unless other.is_a?(Selekt::SourceStub)
+    fields == other.fields && rows == other.rows
+  end
+
+  alias_method :length, :size
+
+  protected
+
+  def row_sql_with_names(row)
+    'SELECT ' + fields.map.with_index do |field, index|
+      "#{Selekt.quote(row[index])} AS #{Selekt.safe_identifier(field.to_s)}"
+    end.join(', ')
+  end
+
+  def row_sql_without_names(row)
+    'SELECT ' + fields.map.with_index do |field, index|
+      Selekt.quote(row[index])
+    end.join(', ')
+  end
+end

data/lib/selekt/sql.rb

@@ -0,0 +1,29 @@
+module Selekt
+  module SQL
+    module TableReference
+      def variable_name
+        if elements.last.empty?
+          elements.first.text_value
+        else
+          elements.last.text_value
+        end
+      end
+    end
+
+    module Source
+      def variable_name
+        if elements.last.empty?
+          elements.first.variable_name
+        else
+          elements.last.variable_name
+        end
+      end
+    end
+
+    module Alias
+      def variable_name
+        elements.last.text_value
+      end
+    end
+  end
+end

data/lib/selekt/sql.treetop

@@ -0,0 +1,471 @@
+module Selekt
+
+  grammar SQL
+
+    rule sql_query
+      space? select_statement (space order_by_clause)? (space limit_clause)? space?
+    end
+
+    rule select_statement
+      select_clause 
+      (space from_clause)? 
+      (space where_clause)? 
+      (space group_by_clause)? 
+      (space having_clause)? 
+      (space named_window_clause)?
+      (space set_operator space select_statement)*
+    end
+
+    rule select_clause
+      SELECT space (DISTINCT space)? projection (comma projection)*
+    end
+
+    rule from_clause
+      FROM space source_with_joins (comma source_with_joins)*
+      /
+      FROM space source_with_joins (comma source_with_joins)*
+    end
+
+    rule source_with_joins
+       source (space source_join)*
+       /
+       '(' source (space source_join)* ')'
+    end
+
+    rule source
+      ((table <TableReference>) (alias <Alias>)? / subquery (alias <Alias>)) <Source>
+    end
+
+    rule source_join
+      regular_join_type space source space join_clause
+    end
+
+    rule regular_join_type
+      ((INNER / LEFT / RIGHT / FULL space OUTER) space)? JOIN
+    end
+
+    rule join_clause
+      ON space boolean_expression
+      /
+      USING space? '(' space? identifier (comma identifier)* ')'
+    end
+
+    rule comma
+      space? ',' space?
+    end
+
+    rule subquery
+      '(' space? select_statement space? ')'
+    end
+
+    rule table
+      schema_table / schemaless_table
+    end
+
+    rule schemaless_table
+      identifier {
+        def schema_name
+          nil
+        end
+
+        def table_name
+          elements[0].value
+        end
+      }
+    end
+
+    rule schema_table
+      schema '.' identifier {
+        def schema_name
+          schema.value
+        end
+
+        def table_name
+          elements.last.value
+        end
+      }
+    end
+
+    rule schema
+      identifier
+    end
+
+    rule column
+      table_column / identifier
+    end
+
+    rule table_column
+      identifier '.' identifier
+    end
+
+    rule projection
+      '*' / table '.' '*' / expression alias?
+    end
+
+    rule alias
+      space (AS space)? identifier 
+    end
+
+    rule where_clause
+      WHERE space expression
+    end
+
+    rule group_by_clause
+      GROUP space BY space expression (comma expression)*
+    end
+
+    rule having_clause
+      HAVING space expression
+    end
+
+    rule order_by_clause
+      ORDER space BY space order_expression (comma order_expression)*
+    end
+
+    rule limit_clause
+      LIMIT space integer (space OFFSET space integer)?
+    end
+
+    rule order_expression
+      expression (space (ASC / DESC) (space NULLS space (FIRST / LAST))?)?
+    end
+
+    rule expression
+      boolean_expression
+    end
+
+    rule single_expression
+      (interval_expression / case_expression / function_call / column / literal / subquery / '(' space? expression space? ')') 
+      (space? '::' space? type)?
+    end
+
+    rule case_expression
+      CASE space
+        (expression space)? 
+        (WHEN space expression space THEN space expression space)+
+        (ELSE space expression space)? 
+      END
+    end
+
+    rule interval_expression
+      INTERVAL space expression
+    end
+
+    rule type
+      unquoted_identifier
+    end
+
+    rule function_call
+      (
+        COUNT '(' space? (DISTINCT space)? ('*'  / expression) space? ')'
+        /
+        unquoted_identifier '(' (space? expression (comma expression)*)? space? ')'
+      )
+      (space OVER (space? window_clause / space identifier))?
+    end
+
+    rule window_clause
+      '(' space?
+        (partition_by_clause space)?
+        order_by_clause
+      space? ')'
+    end
+
+    rule named_window_clause
+      WINDOW space identifier space AS space? window_clause
+    end
+
+    rule partition_by_clause
+      PARTITION space BY space expression (comma expression)*
+    end
+
+    rule arithmetic_expression
+      single_expression (space? arithmetic_operator space? single_expression)*
+    end
+
+    rule arithmetic_operator
+      '+' / '-' / '*' / '/' / '%' / '||'
+    end
+
+    rule comparison_expression
+      EXISTS space? subquery
+      /
+      arithmetic_expression space IS (space NOT)? space boolean
+      /
+      arithmetic_expression space (NOT space)? IN space list_of_values
+      /
+      arithmetic_expression (space? comparison_operator space? arithmetic_expression)?
+    end
+
+    rule list_of_values
+      subquery
+      /
+      '(' space? expression (comma expression)* space? ')'
+    end
+
+    rule comparison_operator
+      '<=' / '>=' / '<>' / '>' / '<' / '!=' / '=' / LIKE / ILIKE
+    end
+
+    rule negatable_expression
+      (NOT space)? comparison_expression
+    end
+
+    rule boolean_expression
+      negatable_expression (space boolean_operator space negatable_expression)*
+    end
+
+    rule boolean_operator
+      AND / OR
+    end
+
+    rule set_operator
+      UNION (space ALL)?
+    end
+
+    rule space
+      [ \t\r\n]+ (comment space?)?
+    end
+
+    rule comment
+      '--' [^\r\n]*
+    end
+
+    rule identifier
+      quoted_identifier / unquoted_identifier !{|seq| seq[0].reserved? } {
+        def value
+          elements.first.value
+        end
+      }
+    end
+
+    rule unquoted_identifier
+      [A-Za-z] [_A-Za-z0-9]*
+      {
+        def value
+          text_value
+        end
+
+        def reserved?
+          Selekt::RESERVED_SQL_KEYWORDS.include?(text_value.downcase)
+        end
+      }
+    end
+
+    rule quoted_identifier
+      '"' body:('""' / [^"])* '"' {
+        def value
+          body.text_value.gsub('""', '"')
+        end
+      }
+    end
+
+    rule literal
+      string / float / integer / boolean
+    end
+
+    rule string
+      "'" ("''" / [^'])* "'"
+    end
+
+    rule boolean
+      TRUE / FALSE / NULL
+    end
+
+    rule integer
+      "-"? [0-9]+
+    end
+
+    rule float
+      "-"? [0-9]* '.' [0-9]+
+    end
+
+    rule SELECT
+      [Ss] [Ee] [Ll] [Ee] [Cc] [Tt]      
+    end
+
+    rule DISTINCT
+      [Dd] [Ii] [Ss] [Tt] [Ii] [Nn] [Cc] [Tt]
+    end
+
+    rule FROM
+      [Ff] [Rr] [Oo] [Mm]
+    end
+
+    rule HAVING
+      [Hh] [Aa] [Vv] [Ii] [Nn] [Gg]
+    end
+
+    rule ORDER
+      [Oo] [Rr] [Dd] [Ee] [Rr]
+    end
+
+    rule ASC
+      [Aa] [Ss] [Cc]
+    end
+
+    rule DESC
+      [Dd] [Ee] [Ss] [Cc]
+    end
+
+    rule NULLS
+      [Nn] [Uu] [Ll] [Ll] [Ss]
+    end
+
+    rule FIRST
+      [Ff] [Ii] [Rr] [Ss] [Tt]
+    end
+
+    rule LAST
+      [Ll] [Aa] [Ss] [Tt]
+    end
+
+    rule AS
+      [Aa] [Ss]
+    end
+
+    rule JOIN
+      [Jj] [Oo] [Ii] [Nn]
+    end
+
+    rule FULL
+      [Ff] [Uu] [Ll] [Ll]
+    end
+
+    rule OUTER
+      [Oo] [Uu] [Tt] [Ee] [Rr]
+    end
+
+    rule INNER
+      [Ii] [Nn] [Nn] [Ee] [Rr]
+    end
+
+    rule LEFT
+      [Ll] [Ee] [Ff] [Tt]
+    end
+
+    rule RIGHT
+      [Rr] [Ii] [Gg] [Hh] [Tt]
+    end
+
+    rule ON
+      [Oo] [Nn]
+    end
+
+    rule USING
+      [Uu] [Ss] [Ii] [Nn] [Gg]
+    end
+
+    rule WHERE
+      [Ww] [Hh] [Ee] [Rr] [Ee]
+    end
+
+    rule GROUP
+      [Gg] [Rr] [Oo] [Uu] [Pp]
+    end
+
+    rule BY
+      [Bb] [Yy]
+    end
+
+    rule LIMIT
+      [Ll] [Ii] [Mm] [Ii] [Tt]
+    end
+
+    rule OFFSET
+      [Oo] [Ff] [Ff] [Ss] [Ee] [Tt]
+    end
+
+    rule UNION
+      [Uu] [Nn] [Ii] [Oo] [Nn]
+    end
+
+    rule ALL
+      [Aa] [Ll] [Ll]
+    end
+
+    rule COUNT
+      [Cc] [Oo] [Uu] [Nn] [Tt]
+    end
+
+    rule OVER
+      [Oo] [Vv] [Ee] [Rr]
+    end
+
+    rule PARTITION
+      [Pp] [Aa] [Rr] [Tt] [Ii] [Tt] [Ii] [Oo] [Nn]
+    end
+
+    rule WINDOW
+      [Ww] [Ii] [Nn] [Dd] [Oo] [Ww]
+    end
+
+    rule CASE
+      [Cc] [Aa] [Ss] [Ee]
+    end
+
+    rule WHEN
+      [Ww] [Hh] [Ee] [Nn]
+    end
+
+    rule THEN
+      [Tt] [Hh] [Ee] [Nn]
+    end
+
+    rule ELSE
+      [Ee] [Ll] [Ss] [Ee]
+    end
+
+    rule END
+      [Ee] [Nn] [Dd]
+    end
+
+    rule INTERVAL
+      [Ii] [Nn] [Tt] [Ee] [Rr] [Vv] [Aa] [Ll]
+    end
+
+    rule IS
+      [Ii] [Ss]
+    end
+
+    rule IN
+      [Ii] [Nn]
+    end
+
+    rule EXISTS
+      [Ee] [Xx] [Ii] [Ss] [Tt] [Ss]
+    end
+
+    rule NOT
+      [Nn] [Oo] [Tt]
+    end
+
+    rule AND
+      [Aa] [Nn] [Dd]
+    end
+
+    rule OR
+      [Oo] [Rr]
+    end    
+
+    rule TRUE
+      [Tt] [Rr] [Uu] [Ee]
+    end
+
+    rule FALSE
+      [Ff] [Aa] [Ll] [Ss] [Ee]
+    end
+
+    rule NULL
+      [Nn] [Uu] [Ll] [Ll]
+    end
+
+    rule LIKE
+      [Ll] [Ii] [Kk] [Ee]
+    end
+
+    rule ILIKE
+      [Ii] [Ll] [Ii] [Kk] [Ee]
+    end
+  end
+end

data/lib/selekt/version.rb

@@ -0,0 +1,3 @@
+module Selekt
+  VERSION = "0.0.1"
+end

data/selekt.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'selekt/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "selekt"
+  gem.version       = Selekt::VERSION
+  gem.authors       = ["Willem van Bergen"]
+  gem.email         = ["willem@railsdoctors.com"]
+  gem.description   = %q{A toolkit to work with the SQL language. Incluses a SQL parser, tree manipulations, and tools for testing and monitoring}
+  gem.summary       = %q{Toolkit to work with SQL queries}
+  gem.homepage      = "https://github.com/wvanbergen/selekt"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency('minitest', '~> 5')
+
+  gem.add_runtime_dependency('treetop')
+end

data/test/parser_test.rb

@@ -0,0 +1,164 @@
+require 'test_helper'
+
+class ParserTest < Minitest::Test
+
+  def assert_parses(sql)
+    q = Selekt.parse(sql) rescue nil
+    assert_instance_of Selekt::Query, q, "Expected the provided string to parse as valid SQL"
+  end
+
+  def test_basic_syntax_flexibility
+    assert_parses('select c1')
+    assert_parses('SELECT c1')
+    assert_parses('SeLeCT c1')
+    assert_parses('  select    c1 , c2,    c3,c4   ')
+  end
+
+  def test_literals
+    assert_parses 'select true, false, null'
+    assert_parses "select 'test', 'test''with''quotes'"
+    assert_parses 'select 1, -1, 1.2, .001, -1.2, -.001'
+    assert_parses 'select c1 AS """Cool"" column", "c2"'
+  end
+
+  def test_projections
+    assert_parses('select 1, \'test\', id, "id"')
+    assert_parses('select *')
+    assert_parses('select table.*, other, "fields"')
+    assert_parses('select schema.table.*')
+    assert_parses('select distinct schema.table.*')
+    assert_parses('select min(table)')
+  end
+
+  def test_set_operations
+    assert_parses "select * from t1 union select * from t2"
+    assert_parses "select * from t1 union all select * from t2 union all select * from t3"
+  end
+
+  def test_sources
+    assert_parses('select * from t1')
+    assert_parses('select * from (t1)')
+    assert_parses('select * from table1 "t1"')
+    assert_parses('select * from schema.table1 as t1')
+    assert_parses('select * from table_1 as "first table", table_2 as "second table"')
+  end
+
+  def test_joins
+    assert_parses('select * from table t1 join table t2 on t1.a = t2.a')
+    assert_parses('select * from (table t1 join table t2 on t1.a = t2.a)')
+    assert_parses('select * from t1 full outer join t2 using (country, state)')
+    assert_parses(<<-SQL)
+      SELECT *
+        FROM table1 AS t1
+        JOIN table2 AS t2 on t1.id = t2.id
+        INNER JOIN (
+          SELECT 1 AS id
+        ) t3 ON t3.id = t1.id
+        LEFT JOIN table4 t4 on t1.id = t4.id AND NOT t1.fraud
+    SQL
+  end
+
+  def test_subquery
+    assert_parses('select a from (select b) as b_alias')
+    assert_parses('select a from ( select b from (select c) as c_alias ) as b_alias')
+    assert_parses <<-SQL
+      select * from (SELECT 'test' AS field_1, 123 AS field_2
+      UNION ALL
+      SELECT 'test', 456
+      UNION ALL
+      SELECT 'test', 789) AS t1
+    SQL
+  end
+
+  def test_arithmetic_operators
+    assert_parses("select 'a' + 'b'")
+    assert_parses("select 'a' || ('b' || 'c') || 'd'")
+    assert_parses('select 1 + 2 - (3 * 4)::float / 5 % 6')
+  end
+
+  def test_comparison_operators
+    assert_parses('select 1 > 2')
+    assert_parses('select 1 + 2 > 2')
+    assert_parses('select a > b')
+    assert_raises(Selekt::ParseError) { Selekt.parse('select 1 > 2 > 3') }
+  end
+
+  def test_boolean_tests
+    assert_parses('select column IS NOT TRUE')
+    assert_parses('select column IS NULL')
+  end
+
+  def test_function_calls
+    assert_parses('select MIN(column), now(), complicated_stuff(1, 4 + 2)')
+    assert_parses('select count(*)')
+    assert_parses('select count(distinct *)')
+    assert_parses('select count(distinct id)')
+    assert_parses('select count(1)')
+  end
+
+  def test_over_clause
+    assert_parses "SELECT ROW_NUMBER() OVER (ORDER BY a, b DESC)"
+    assert_parses "SELECT ROW_NUMBER() OVER (PARTITION BY id ORDER BY time)"
+    assert_parses "SELECT ROW_NUMBER() OVER (PARTITION BY id1, id2 ORDER BY time, event_id)"
+    assert_parses "SELECT ROW_NUMBER() OVER w AS index WINDOW w AS (ORDER BY timestamp)"
+  end
+
+  def test_in_construct
+    assert_parses('select 1 IN (1,2,3)')
+  end
+
+  def test_exist_construct
+    assert_parses('select exists (select 1)')
+    assert_parses('select not exists (select 1)')
+  end
+
+  def test_case_expression
+    assert_parses 'select CASE column WHEN 1 THEN TRUE WHEN 2 THEN TRUE ELSE FALSE END'
+    assert_parses 'select CASE column WHEN 1 THEN TRUE END'
+    assert_parses 'select CASE WHEN column = 1 THEN TRUE ELSE FALSE END'
+    assert_parses 'select CASE WHEN column <= 10 THEN TRUE WHEN column > 10 THEN FALSE END'
+  end
+
+  def test_interval_expression
+    assert_parses "select NOW() + interval '10 day'"
+    assert_parses "select NOW() + interval column"
+  end
+
+  def test_boolean_operators
+    assert_parses('select (a > b AND b ilike c) OR a IS NULL OR c IS NULL')
+    assert_parses('select a >= 10 and b <= 0')
+  end
+
+  def test_where
+    assert_parses("select * from t1 where a = 'test' and b >= 10")
+    assert_parses('select a where (false)')
+  end
+
+  def test_group_by_and_having
+    assert_parses('select a, b, min(c) min_c group by a, b')
+    assert_parses('select a, b, min(c) min_c group by a, b having a >= 10 and min_c')
+  end
+
+  def test_order_by
+    assert_parses('select * from table order by field > 10')
+    assert_parses('select * from table order by field1, field2')
+    assert_parses('select * from table order by field ASC')
+    assert_parses('select * from table order by field DESC NULLS FIRST')
+  end
+
+  def test_limit_offset
+    assert_parses('select * from table limit 10')
+    assert_parses('select * from table limit 10 offset 50')
+  end
+
+  def test_comments
+    assert_parses("select 1 -- comment\n")
+    assert_parses("select -- comment\n-- more comments \n 1")
+    assert_parses(<<-SQL)
+      select 1,2,3,4 -- ... and so on
+        from my_first_table,
+             my_second_table
+      -- EOQ
+    SQL
+  end
+end

data/test/query_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class QueryTest < Minitest::Test
+
+  def test_sql_roundtrip
+    query = 'select * from table'
+    assert_equal query, Selekt.parse(query).sql
+  end
+
+  def test_sources
+    source_names = Selekt.parse(<<-SQL).source_names
+      SELECT *
+        FROM schema.table1
+        LEFT JOIN table2 t2 ON t1.id = t2.id
+        WHERE EXISTS (SELECT 1 FROM table3 WHERE value > t1.value)
+          AND t1.id NOT IN (SELECT table1_id FROM table3 t3)
+    SQL
+
+    assert_equal ['table1', 't2', 'table3', 't3'], source_names
+  end
+
+  def test_stubbing_sources
+    query = Selekt.parse('select * from t1')
+    assert_equal "select * from (select 1) AS t1", query.stub('t1', 'select 1').sql
+
+    t1_stub = Selekt::SourceStub.new(:field_1, :field_2)
+    t1_stub << ['test', 123]
+    t1_stub << ['test', 456]
+    t1_stub << ['test', 789]
+
+    assert_equal query.stub(:t1, t1_stub).sql, "select * from (SELECT 'test' AS field_1, 123 AS field_2\nUNION ALL\nSELECT 'test', 456\nUNION ALL\nSELECT 'test', 789) AS t1"
+  end
+
+  def test_relations
+    assert_equal ['a', 'b'], Selekt.parse('select * from a t1, b t2').relations.map(&:table_name)
+
+    query = Selekt.parse('select * from schema.table t1 INNER JOIN schema.table t2 ON 1=1')
+    assert_equal ["schema"], query.relations.map(&:schema_name)
+    assert_equal ["table"], query.relations.map(&:table_name)
+    
+    query = Selekt.parse(<<-SQL)
+      SELECT *
+        FROM schema."table1" t1
+        LEFT JOIN table2 t2 ON t1.id = t2.id
+          AND t1.id NOT IN (SELECT table1_id FROM table3)
+
+      UNION
+
+      SELECT *
+        FROM table5 t5
+        LEFT JOIN (
+          SELECT * FROM schema.table6
+        ) AS t6 ON t6.id = t5.id
+    SQL
+    assert_equal ["schema.table1", "table2", "table3", "table5", "schema.table6"], query.relations.map(&:to_s)
+  end
+end

data/test/source_stub_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+class SourceStubTest < Minitest::Test
+
+  def test_row_size_check
+    ss = Selekt::SourceStub.new(:a, :b)
+    assert_raises(Selekt::StubError) { ss.add_row [1,2,3] }
+    assert_equal 0, ss.rows.size
+
+    ss.add_row [1,2]
+    assert_equal 1, ss.rows.size
+
+    ss.add_row [1]
+    assert_equal 2, ss.rows.size
+  end
+
+  def test_add_row_as_hash
+    s1 = Selekt::SourceStub.new(:a, :b)
+    s2 = Selekt::SourceStub.new(:a, :b)
+
+    s1.push [1, 2]
+    s2.push a: 1, b: 2
+
+    assert_equal s1, s2
+  end
+
+  def test_add_row_as_hash_with_nil_values
+    s1 = Selekt::SourceStub.new(:a, :b)
+    s2 = Selekt::SourceStub.new(:a, :b)
+
+    s1.push [nil, 1]
+    s2.push b: 1
+
+    assert_equal s1, s2
+  end  
+
+  def test_add_rows
+    s1 = Selekt::SourceStub.new(:a, :b)
+    s1.add_rows([
+      [1],
+      { b: 2 }
+    ])
+
+    assert_equal [1, nil], s1.rows[0]
+    assert_equal [nil, 2], s1.rows[1]
+  end
+
+  def test_sql_generation
+    ss = Selekt::SourceStub.new(:a, :b)
+    ss.add_row [nil, 2]
+    assert_equal "SELECT NULL AS a, 2 AS b", ss.sql
+    ss.add_row ['test', 10]
+    ss.add_row ['test2', 123]
+    assert_equal "SELECT NULL AS a, 2 AS b\nUNION ALL\nSELECT 'test', 10\nUNION ALL\nSELECT 'test2', 123", ss.sql
+  end
+
+  def test_value_quoting_for_sql
+    ss = Selekt::SourceStub.new(:a, :b, :c)
+    ss.add_row [DateTime.parse('2012-01-03 12:44:33'), Date.parse('2012-01-01'), "'"]
+    assert_equal "SELECT '2012-01-03 12:44:33'::timestamp AS a, '2012-01-01'::date AS b, '''' AS c", ss.sql
+  end
+end

data/test/sql_toolkit_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+class SelektTest < Minitest::Test
+
+  def test_safe_identifier
+    assert_equal 'test', Selekt.safe_identifier('test')
+    assert_equal %q["test'"], Selekt.safe_identifier(%q[test'])
+    assert_equal %q["""test"""], Selekt.safe_identifier(%q["test"])
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'pp'
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'minitest/mock'
+
+require 'selekt'

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: selekt
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Willem van Bergen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A toolkit to work with the SQL language. Incluses a SQL parser, tree
+  manipulations, and tools for testing and monitoring
+email:
+- willem@railsdoctors.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/selekt.rb
+- lib/selekt/query.rb
+- lib/selekt/source_stub.rb
+- lib/selekt/sql.rb
+- lib/selekt/sql.treetop
+- lib/selekt/version.rb
+- selekt.gemspec
+- test/parser_test.rb
+- test/query_test.rb
+- test/source_stub_test.rb
+- test/sql_toolkit_test.rb
+- test/test_helper.rb
+homepage: https://github.com/wvanbergen/selekt
+licenses: []
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Toolkit to work with SQL queries
+test_files:
+- test/parser_test.rb
+- test/query_test.rb
+- test/source_stub_test.rb
+- test/sql_toolkit_test.rb
+- test/test_helper.rb