sql_helper 0.1.0

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Junegunn Choi
+
+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,40 @@
+# SQLHelper
+
+A simplistic SQL generator extracted from [jdbc-helper](https://github.com/junegunn/jdbc-helper) gem.
+This gem is not intended to be used independently outside the context of jdbc-helper.
+
+## Example
+
+```ruby
+SQLHelper.select(
+  prepared: true,
+  table:    'mytable',
+  project:  %w[a b c d e],
+  where: [
+    'z <> 100',
+    ['y = ?', 200],
+    {
+      a: "hello 'world'",
+      b: (1..10),
+      c: (1...10),
+      d: ['abc', "'def'"],
+      e: { sql: 'sysdate' },
+      f: { not: nil },
+      g: { gt: 100 },
+      h: { lt: 100 },
+      i: { like: 'ABC%' },
+      j: { not: { like: 'ABC%' } },
+      k: { le: { sql: 'sysdate' } },
+      l: { ge: 100, le: 200 },
+      m: { not: [ 150, { ge: 100, le: 200 } ] },
+      n: nil,
+      o: { not: (1..10) },
+      p: { or: [{ gt: 100 }, { lt: 50 }] },
+      q: { like: ['ABC%', 'DEF%'] },
+      r: { or: [{ like: ['ABC%', 'DEF%'] }, { not: { like: 'XYZ%' } }] }
+    }
+  ],
+  order: 'a desc',
+  limit: 10
+)
+```

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end

data/lib/sql_helper/version.rb

@@ -0,0 +1,3 @@
+module SQLHelper
+  VERSION = "0.1.0"
+end

data/lib/sql_helper.rb

@@ -0,0 +1,348 @@
+require "sql_helper/version"
+require 'set'
+require 'bigdecimal'
+
+module SQLHelper
+  class << self
+    def escape arg
+      arg.to_s.gsub("'", "''")
+    end
+
+    # A naive check
+    def check expr
+      expr = expr.to_s
+      test = expr.to_s.gsub(/(['`"]).*?\1/, '').
+                       gsub(%r{/\*.*?\*/}, '').
+                       strip
+      raise SyntaxError.new("cannot contain unquoted semi-colons: #{expr}") if test.include?(';')
+      raise SyntaxError.new("cannot contain unquoted comments: #{expr}") if test.match(%r{--|/\*|\*/})
+      raise SyntaxError.new("unclosed quotation mark: #{expr}") if test.match(/['"`]/)
+      raise SyntaxError.new("empty expression") if expr.strip.empty?
+      expr
+    end
+
+    def quote arg
+      case arg
+      when String, Symbol
+        "'#{arg.to_s.gsub "'", "''"}'"
+      when BigDecimal
+        arg.to_s('F')
+      when nil
+        'null'
+      else
+        if expr?(arg)
+          arg.values.first
+        else
+          arg.to_s
+        end
+      end
+    end
+
+    def insert arg
+      insert_internal 'insert into', arg
+    end
+
+    def insert_ignore arg
+      insert_internal 'insert ignore into', arg
+    end
+
+    def replace arg
+      insert_internal 'replace into', arg
+    end
+
+    def delete args
+      check_keys args, Set[:table, :where, :prepared]
+
+      wc, *wp = where_internal args[:prepared], args[:where]
+      sql = "delete from #{args.fetch :table} #{wc}".strip
+      if args[:prepared]
+        [sql, *wp]
+      else
+        sql
+      end
+    end
+
+    def update args
+      check_keys args, Set[:prepared, :where, :table, :data]
+      table    = args.fetch(:table)
+      data     = args.fetch(:data)
+      prepared = args[:prepared]
+      where,
+        *wbind = where_internal(args[:prepared], args[:where])
+      bind     = []
+      vals     = data.map { |k, v|
+        if prepared
+          if expr?(v)
+            [k, v.values.first].join(' = ')
+          else
+            bind << v
+            "#{k} = ?"
+          end
+        else
+          [k, quote(v)].join(' = ')
+        end
+      }
+      sql = "update #{check table} set #{vals.join ', '} #{where}".strip
+      if prepared
+        [sql] + bind + wbind
+      else
+        sql
+      end
+    end
+
+    def count args
+      check_keys args, Set[:prepared, :where, :table]
+      select args.merge(:project => 'count(*)')
+    end
+
+    def select args
+      check_keys args, Set[:prepared, :project, :where, :order, :limit, :top, :table]
+
+      top       = args[:top] ? "top #{args[:top]}" : ''
+      project   = project(*args[:project])
+      where,
+        *params = args[:where] ? where_internal(args[:prepared], args[:where]) : ['']
+      order     = order(*args[:order])
+      limit     = limit(*args[:limit])
+
+      sql = ['select', top, project, 'from', args.fetch(:table),
+             where, order, limit].reject(&:empty?).join(' ')
+      if args[:prepared]
+        [ sql, *params ]
+      else
+        sql
+      end
+    end
+
+    def project *args
+      args = args.compact.map(&:to_s).map(&:strip).reject(&:empty?)
+      if args.empty?
+        '*'
+      else
+        check args.join ', '
+      end
+    end
+
+    def order *args
+      args = args.compact.map(&:to_s).map(&:strip).reject(&:empty?)
+      if args.empty?
+        ''
+      else
+        check "order by #{args.join ', '}"
+      end
+    end
+
+    def limit *args
+      limit, offset = args.reverse.map { |e|
+        s = e.to_s.strip
+        s.empty? ? nil : s
+      }
+      arg = arg.to_s.strip
+      if offset
+        check "limit #{offset}, #{limit}"
+      elsif limit
+        check "limit #{limit}"
+      else
+        ''
+      end
+    end
+
+    def where *conds
+      where_internal false, conds
+    end
+
+    def where_prepared *conds
+      where_internal true, conds
+    end
+
+  private
+    OPERATOR_MAP = {
+      :gt   => '>',
+      :ge   => '>=',
+      :lt   => '<',
+      :le   => '<=',
+      :ne   => '<>',
+      :>    => '>',
+      :>=   => '>=',
+      :<    => '>',
+      :<=   => '>=',
+      :like => 'like'
+    }
+
+    def expr? val
+      val.is_a?(Hash) && val.length == 1 && [:sql, :expr].include?(val.keys.first)
+    end
+
+    def check_keys args, known
+      raise ArgumentError, "hash expected" unless args.is_a?(Hash)
+      unknown = Set.new(args.keys) - known
+      raise ArgumentError, "unknown keys: #{unknown.to_a.join ', '}" unless unknown.empty?
+    end
+
+    def where_internal prepared, conds
+      sqls   = []
+      params = []
+
+      conds =
+        case conds
+        when String, Hash
+          [conds]
+        when nil
+          []
+        when Array
+          conds
+        else
+          raise ArgumentError, "invalid argument: #{conds.class}"
+        end
+
+      conds.each do |cond|
+        case cond
+        when String
+          sql = cond.strip
+          next if sql.empty?
+          sqls << "(#{check sql})"
+        when Array
+          sql = cond[0].to_s.strip
+          next if sql.empty?
+          sql = check sql
+          if prepared
+            sqls << "(#{sql})"
+            params += cond[1..-1]
+          else
+            params = cond[1..-1]
+            sql = "(#{sql})".gsub('?') {
+              if params.empty?
+                '?'
+              else
+                quote params.shift
+              end
+            }
+            sqls << sql
+          end
+        when Hash
+          cond.each do |col, cnd|
+            ret = eval_hash_cond col, cnd, prepared
+            sqls << ret[0]
+            params += ret[1..-1] || []
+          end
+        when nil
+        else
+          raise ArgumentError, "invalid condition: #{cond}"
+        end
+      end
+
+      if prepared
+        sqls.empty? ? [''] : ["where #{sqls.join ' and '}"].concat(params)
+      else
+        sqls.empty? ? '' : "where #{sqls.join ' and '}"
+      end
+    end
+
+    def eval_hash_cond col, cnd, prepared
+      case cnd
+      when Numeric, String
+        prepared ? ["#{col} = ?", cnd] : [[col, quote(cnd)].join(' = ')]
+      when Range
+        if cnd.exclude_end?
+          prepared ?
+            ["#{col} >= ? and #{col} < ?", cnd.begin, cnd.end] :
+            ["#{col} >= #{quote cnd.begin} and #{col} < #{quote cnd.end}"]
+        else
+          prepared ?
+            ["#{col} between ? and ?", cnd.begin, cnd.end] :
+            ["#{col} between #{quote cnd.begin} and #{quote cnd.end}"]
+        end
+      when Array
+        sqls   = []
+        params = []
+        cnd.each do |v|
+          ret = eval_hash_cond col, v, prepared
+          sqls << ret[0]
+          params += ret[1..-1]
+        end
+        ["(#{sqls.join(' or ')})", *params]
+      when nil
+        ["#{col} is null"]
+      when Hash
+        rets = cnd.map { |op, val|
+          case op
+          when :expr, :sql
+            ["#{col} = #{check val}"]
+          when :not
+            case val
+            when nil
+              ["#{col} is not null"]
+            when String, Numeric
+              prepared ?
+                ["#{col} <> ?", val] :
+                ["#{col} <> #{quote val}"]
+            else
+              ary = eval_hash_cond col, val, prepared
+              ary[0].prepend 'not '
+              ary
+            end
+          when :or
+            sqls   = []
+            params = []
+            val.each do |v|
+              ret = eval_hash_cond col, v, prepared
+              sqls << ret[0]
+              params += ret[1..-1]
+            end
+            ["(#{sqls.join(' or ')})", *params]
+          when :gt, :>, :ge, :>=, :lt, :<, :le, :<=, :ne, :like
+            if val.is_a?(Hash)
+              if expr?(val)
+                [[col, OPERATOR_MAP[op], check(val.values.first)].join(' ')]
+              else
+                raise ArgumentError, "invalid condition"
+              end
+            elsif val.is_a?(Array)
+              prepared ?
+                ["(#{(["#{col} #{OPERATOR_MAP[op]} ?"] * val.length).join(' or ')})", *val] :
+                ["(#{val.map { |v| [col, OPERATOR_MAP[op], quote(v)].join ' ' }.join(' or ')})"]
+            else
+              prepared ?
+                ["#{col} #{OPERATOR_MAP[op]} ?", val] :
+                [[col, OPERATOR_MAP[op], quote(val)].join(' ')]
+            end
+          else
+            raise ArgumentError, "unexpected operator: #{op}"
+          end
+        }
+        [rets.map(&:first).join(' and '), *rets.inject([]) { |prms, r| prms.concat r[1..-1] }]
+      else
+        raise ArgumentError, "invalid condition: #{cnd}"
+      end
+    end
+
+    def insert_internal prefix, args
+      check_keys args, Set[:table, :data, :prepared]
+      prep = args[:prepared]
+      into = args.fetch(:table)
+      data = args.fetch(:data)
+
+      bind = []
+      cols = data.keys
+      vals = data.values.map { |val|
+        if prep
+          if expr?(val)
+            val.values.first
+          else
+            bind << val
+            '?'
+          end
+        else
+          quote(val)
+        end
+      }
+
+      sql = "#{prefix} #{into} (#{cols.join ', '}) values (#{vals.join ', '})"
+      if args[:prepared]
+        [sql] + bind
+      else
+        sql
+      end
+    end
+  end
+end

data/sql_helper.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sql_helper/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sql_helper"
+  spec.version       = SQLHelper::VERSION
+  spec.authors       = ["Junegunn Choi"]
+  spec.email         = ["junegunn.c@gmail.com"]
+  spec.description   = %q{A simplistic SQL generator}
+  spec.summary       = %q{A simplistic SQL generator}
+  spec.homepage      = "https://github.com/junegunn/sql_helper"
+  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_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+end

data/test/test_sql_helper.rb

@@ -0,0 +1,179 @@
+$VERBOSE = true
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'sql_helper'
+require 'bigdecimal'
+require 'minitest/autorun'
+
+class TestSQLHelper < MiniTest::Unit::TestCase
+  def setup
+    @conds = [
+      'z <> 100',
+      ["y = ? or y = ? or y = ? or z = '???'", 200, "Macy's???", BigDecimal('3.141592')],
+      {
+        :a => "hello 'world'???",
+        :b => (1..10),
+        :c => (1...10),
+        :d => ['abc', "'def'"],
+        :e => { :sql  => 'sysdate' },
+        :f => { :not  => nil },
+        :g => { :gt   => 100 },
+        :h => { :lt   => 100 },
+        :i => { :like => 'ABC%' },
+        :j => { :not  => { :like => 'ABC%' } },
+        :k => { :le   => { :sql => 'sysdate' } },
+        :l => { :ge   => 100, :le => 200 },
+        :m => { :not  => [ 150, { :ge => 100, :le => 200 } ] },
+        :n => nil,
+        :o => { :not  => (1..10) },
+        :p => { :or   => [{ :gt => 100 }, { :lt => 50 }] },
+        :q => { :like => ['ABC%', 'DEF%'] },
+        :r => { :or   => [{ :like => ['ABC%', 'DEF%'] }, { :not => { :like => 'XYZ%' } }] },
+        :s => { :not  => 100 },
+        :t => { :not  => 'str' },
+        :u => ('aa'..'zz')
+      },
+      [],
+      [nil],
+      '',
+      ['  '],
+      '  '
+    ]
+
+    @wherep = ["where (z <> 100) and (y = ? or y = ? or y = ? or z = 'xxx') and a = ? and b between ? and ? and c >= ? and c < ? and (d = ? or d = ?) and e = sysdate and f is not null and g > ? and h < ? and i like ? and not j like ? and k <= sysdate and l >= ? and l <= ? and not (m = ? or m >= ? and m <= ?) and n is null and not o between ? and ? and (p > ? or p < ?) and (q like ? or q like ?) and ((r like ? or r like ?) or not r like ?) and s <> ? and t <> ? and u between ? and ?",
+      200, "Macy's???", BigDecimal("3.141592"),
+      "hello 'world'???",
+      1, 10,
+      1, 10,
+      'abc', "'def'",
+      100,
+      100,
+      'ABC%',
+      'ABC%',
+      100, 200,
+      150, 100, 200,
+      1, 10,
+      100, 50,
+      'ABC%', 'DEF%',
+      'ABC%', 'DEF%', 'XYZ%',
+      100,
+      'str',
+      'aa', 'zz'
+    ]
+
+    params = @wherep[1..-1]
+    @where = @wherep[0].gsub('?') {
+      if params.empty?
+        '?'
+      else
+        SQLHelper.quote params.shift
+      end
+    }.sub('xxx', '???')
+    @wherep[0].sub!('xxx', '???')
+  end
+
+  def test_where
+    assert_equal @where, SQLHelper.where(*@conds)
+    assert_equal @where, SQLHelper.where(*(@conds + [nil, [], nil]))
+  end
+
+  def test_where_prepared
+    assert_equal @wherep, SQLHelper.where_prepared(*@conds)
+  end
+
+  def test_where_invalid
+    assert_raises(ArgumentError) { SQLHelper.where(5) }
+    assert_raises(ArgumentError) { SQLHelper.where(:true) }
+  end
+
+  def test_select
+    sql, *params = SQLHelper.select(
+      :prepared => true,
+      :project  => [:a, :b, :c],
+      :table    => :mytable,
+      :top      => 10,
+      :where    => @conds,
+      :order    => 'a desc',
+      :limit    => 100
+    )
+    assert_equal "select top 10 a, b, c from mytable #{@wherep[0]} order by a desc limit 100", sql
+    assert_equal @wherep[1..-1], params
+
+    sql, *params = SQLHelper.select(
+      :prepared => true,
+      :project  => '*',
+      :table    => 'mytable',
+      :where    => @conds,
+      :order    => ['a desc', 'b asc'],
+      :limit    => [100, 300]
+    )
+    assert_equal "select * from mytable #{@wherep[0]} order by a desc, b asc limit 100, 300", sql
+    assert_equal @wherep[1..-1], params
+  end
+
+  def test_count
+    sql, *params = SQLHelper.count(
+      :prepared => true,
+      :table     => :mytable,
+      :where    => @conds
+    )
+    assert_equal "select count(*) from mytable #{@wherep[0]}", sql
+    assert_equal @wherep[1..-1], params
+    assert_equal "select count(*) from mytable where a is not null",
+      SQLHelper.count(:prepared => false, :table => :mytable, :where => { :a => { :not => nil } })
+  end
+
+  def test_insert
+    [:insert, :insert_ignore, :replace].each do |m|
+      sql, *binds = SQLHelper.send(m,
+        :table => :mytable,
+        :data => { :a => 100, :b => 200, :c => { :sql => 'sysdate' }, :d => "hello 'world'" },
+        :prepared => true
+      )
+      assert_equal %[#{m.to_s.gsub '_', ' '} into mytable (a, b, c, d) values (?, ?, sysdate, ?)], sql
+      assert_equal [100, 200, "hello 'world'"], binds
+
+      sql = SQLHelper.send(m,
+        :table => :mytable,
+        :data => { :a => 100, :b => 200, :c => { :sql => 'sysdate' }, :d => "hello 'world'" },
+        :prepared => false
+      )
+      assert_equal %[#{m.to_s.gsub '_', ' '} into mytable (a, b, c, d) values (100, 200, sysdate, 'hello ''world''')], sql
+    end
+  end
+
+  def test_delete
+    del = SQLHelper.delete(:table => 'mytable', :where => @conds, :prepared => true)
+    assert_equal "delete from mytable #{@wherep.first}", del.first
+    assert_equal @wherep[1..-1], del[1..-1]
+
+    assert_equal "delete from mytable #{@where}",
+      SQLHelper.delete(:table => :mytable, :where => @conds, :prepared => false)
+  end
+
+  def test_update
+    data = { :a => 100, :b => 200, :c => { :sql => 'sysdate' }, :d => "hello 'world'" }
+    sql, *binds = SQLHelper.update(:table => :mytable, :data => data, :where => @conds, :prepared => true)
+
+    assert_equal "update mytable set a = ?, b = ?, c = sysdate, d = ? #{@wherep.first}", sql
+    assert_equal [100, 200, "hello 'world'"] + @wherep[1..-1], binds
+
+    sql = SQLHelper.update(:table => :mytable, :data => data, :where => @conds, :prepared => false)
+    assert_equal "update mytable set a = 100, b = 200, c = sysdate, d = 'hello ''world''' #{@where}", sql
+  end
+
+  def test_check
+    [
+      %['hello],
+      %['hell'o'],
+      %[hel--lo],
+      %[hel;lo],
+      %[hel/*lo],
+      %[hel*/lo],
+    ].each do |sql|
+      assert_raises(SyntaxError) { SQLHelper.check sql   }
+      assert_raises(SyntaxError) { SQLHelper.project sql }
+      assert_raises(SyntaxError) { SQLHelper.limit sql   }
+      assert_raises(SyntaxError) { SQLHelper.order sql   }
+    end
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: sql_helper
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Junegunn Choi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simplistic SQL generator
+email:
+- junegunn.c@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sql_helper.rb
+- lib/sql_helper/version.rb
+- sql_helper.gemspec
+- test/test_sql_helper.rb
+homepage: https://github.com/junegunn/sql_helper
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1991983397644293356
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1991983397644293356
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: A simplistic SQL generator
+test_files:
+- test/test_sql_helper.rb