jdbc-helper 0.7.7 → 0.8.0

data/lib/jdbc-helper/connector.rb

@@ -29,7 +29,9 @@ end#JDBCHelper
 
 require 'jdbc-helper/connector/oracle'
 require 'jdbc-helper/connector/mysql'
+require 'jdbc-helper/connector/mariadb'
 require 'jdbc-helper/connector/postgresql'
 require 'jdbc-helper/connector/mssql'
 require 'jdbc-helper/connector/cassandra'
 require 'jdbc-helper/connector/filemaker'
+require 'jdbc-helper/connector/sqlite'

data/lib/jdbc-helper/constants.rb

@@ -21,6 +21,9 @@ module Constants
         :useServerPrepStmts   => 'true',
         :useCursorFetch       => 'true',
       },
+      :mariadb      => {
+        :driver     => 'org.mariadb.jdbc.Driver',
+      },
       :oracle       => {
         :driver     => 'oracle.jdbc.driver.OracleDriver',
       },
@@ -37,6 +40,9 @@ module Constants
       },
       :filemaker    => {
         :driver     => 'com.filemaker.jdbc.Driver'
+      },
+      :sqlite       => {
+        :driver     => 'org.sqlite.JDBC',
       }
     }
   end#Connector

data/lib/jdbc-helper/sql/expression.rb

@@ -4,141 +4,83 @@
 module JDBCHelper
 # SQL generator class methods for prepared operations.
 # WARNING: Does not perform SQL.check to minimize performance overhead
+# @deprecated
 module SQL
   # Generate SQL snippet, prevents the string from being quoted.
   # @param [String] SQL snippet
   # @return [JDBCHelper::SQL::Expression]
   # @since 0.7.0
+  # @deprecated
   def self.expr sql
-    ScalarExpression.new sql
+    { :sql => sql }
   end
 
   # "is not null" expression for where clauses
+  # @deprecated
   # @return [JDBCHelper::SQL::Expression]
   def self.not_nil
-    NotNullExpression.singleton
+    { :not => nil }
   end
   class << self
     alias not_null not_nil
   end
 
   # Greater-than expression for where clauses
+  # @deprecated
   # @return [JDBCHelper::SQL::Expression]
   # @since 0.7.0
   def self.gt v
-    CriterionExpression.new '>', v
+    { :gt => v }
   end
 
   # Less-than expression for where clauses
+  # @deprecated
   # @return [JDBCHelper::SQL::Expression]
   # @since 0.7.0
   def self.lt v
-    CriterionExpression.new '<', v
+    { :lt => v }
   end
 
   # Less-than-or-equal-to expression for where clauses
+  # @deprecated
   # @return [JDBCHelper::SQL::Expression]
   # @since 0.7.0
   def self.le v
-    CriterionExpression.new '<=', v
+    { :le => v }
   end
 
   # Greater-than-or-equal-to expression for where clauses
+  # @deprecated
   # @return [JDBCHelper::SQL::Expression]
   # @since 0.7.0
   def self.ge v
-    CriterionExpression.new '>=', v
+    { :ge => v }
   end
 
   # Not-equal expression for where clauses
+  # @deprecated
   # @return [JDBCHelper::SQL::Expression]
   # @since 0.7.0
   def self.ne v
-    CriterionExpression.new '<>', v
+    { :ne => v }
   end
 
   # Like expression for where clauses
+  # @deprecated
   # @return [JDBCHelper::SQL::Expression]
   # @since 0.7.0
   def self.like v
-    raise ArgumentError.new('Like expression must be given as a String') unless v.is_a?(String)
-    CriterionExpression.new 'like', v
+    raise ArgumentError, "expected String" unless v.is_a?(String)
+    { :like => v }
   end
 
   # "Not like" expression for where clauses
+  # @deprecated
   # @return [JDBCHelper::SQL::Expression]
   # @since 0.7.0
   def self.not_like v
-    raise ArgumentError.new('Like expression must be given as a String') unless v.is_a?(String)
-    CriterionExpression.new 'not like', v
-  end
-
-  # @since 0.7.0
-  class Expression
-    def initialize
-      raise Exception.new("JDBCHelper::SQL::Expression is an abstract class")
-    end
-
-    def == other
-      self.to_s == other.to_s
-    end
-
-    def eql? other
-      self.class == other.class && self.to_s == other.to_s
-    end
-
-    def hash
-      [self.class, self.to_s].hash
-    end
-  end
-
-  # @since 0.7.0
-  class ScalarExpression < Expression
-    def initialize sql
-      @sql = SQL.check sql.to_s
-    end
-
-    def to_s
-      @sql
-    end
-
-    def to_bind
-      [@to_s, []]
-    end
-  end
-
-  # @since 0.7.0
-  class NotNullExpression < Expression
-    def self.singleton
-      @@singleton ||= NotNullExpression.new
-    end
-
-    def initialize
-    end
-
-    def to_s
-      "is not null"
-    end
-
-    def to_bind
-      ["is not null", []]
-    end
-  end
-
-  # @since 0.7.0
-  class CriterionExpression < Expression
-    def initialize operator, param
-      @operator = operator
-      @param = param
-    end
-
-    def to_s
-      [@operator, SQL.value(@param)].join(' ')
-    end
-
-    def to_bind
-      [[@operator, '?'].join(' '), [@param]]
-    end
+    raise ArgumentError, "expected String" unless v.is_a?(String)
+    { :not => { :like => v } }
   end
 end#SQL
 end#JDBCHelper

data/lib/jdbc-helper/sql/sql.rb

@@ -4,13 +4,13 @@
 require 'bigdecimal'
 
 module JDBCHelper
-
 # Generate SQL snippet, prevents the string from being quoted.
+# @deprecated
 # @param [String] SQL snippet
 # @return [JDBCHelper::SQL::Expression]
 # @deprecated Use JDBCHelper::SQL.expr instead
 def self.sql str
-  JDBCHelper::SQL::ScalarExpression.new str
+  { :sql => str }
 end
 class << self
   # @deprecated Use JDBCHelper::SQL.expr instead
@@ -18,89 +18,85 @@ class << self
 end
 
 # Class representing an SQL snippet. Also has many SQL generator class methods.
+# @deprecated
 module SQL
   # Formats the given data so that it can be injected into SQL
+  # @deprecated
   def self.value data
-    case data
-    when BigDecimal
-      data.to_s("F")
-    when Numeric
-      data
-    when String, Symbol
-      "'#{esc data}'"
-    when NilClass
-      'null'
-    when JDBCHelper::SQL::ScalarExpression
-      data.to_s
-    else
-      raise NotImplementedError.new("Unsupported datatype: #{data.class}")
-    end
+    SQLHelper.quote(data)
   end
 
   # Generates SQL where cluase with the given conditions.
   # Parameter can be either Hash of String.
+  # @deprecated
   def self.where *conds
-    where_clause = where_internal conds
-    where_clause.empty? ? where_clause : check(where_clause)
+    SQLHelper.where(*conds)
   end
 
+  # @deprecated
   def self.where_prepared *conds
+    SQLHelper.where_prepared(*conds)
   end
 
   # Generates SQL order by cluase with the given conditions.
+  # @deprecated
   def self.order *criteria
-    str = criteria.map(&:to_s).reject(&:empty?).join(', ')
-    str.empty? ? str : check('order by ' + str)
+    SQLHelper.order(*criteria)
   end
 
   # SQL Helpers
   # ===========
 
   # Generates insert SQL with hash
+  # @deprecated
   def self.insert table, data_hash
-    insert_internal 'insert', table, data_hash
+    SQLHelper.insert :table => table, :data => data_hash, :prepared => false
   end
 
   # Generates insert ignore SQL (Non-standard syntax)
+  # @deprecated
   def self.insert_ignore table, data_hash
-    insert_internal 'insert ignore', table, data_hash
+    SQLHelper.insert_ignore :table => table, :data => data_hash, :prepared => false
   end
 
   # Generates replace SQL (Non-standard syntax)
+  # @deprecated
   def self.replace table, data_hash
-    insert_internal 'replace', table, data_hash
+    SQLHelper.replace :table => table, :data => data_hash, :prepared => false
   end
 
   # Generates update SQL with hash.
   # :where element of the given hash is taken out to generate where clause.
+  # @deprecated
   def self.update table, data_hash, where
-    where_clause = where_internal where
-    updates = data_hash.map { |k, v| "#{k} = #{value v}" }.join(', ')
-    check "update #{table} set #{updates} #{where_clause}".strip
+    SQLHelper.update :table => table, :data => data_hash, :where => where, :prepared => false
   end
 
   # Generates select SQL with the given conditions
+  # @deprecated
   def self.select table, opts = {}
-    opts = opts.reject { |k, v| v.nil? }
-    check [
-      "select #{opts.fetch(:select, ['*']).join(', ')} from #{table}",
-      where_internal(opts.fetch(:where, {})),
-      order(opts.fetch(:order, []).join(', '))
-    ].reject(&:empty?).join(' ')
+    SQLHelper.select :table    => table,
+                     :project  => opts[:select],
+                     :where    => opts[:where],
+                     :order    => opts[:order],
+                     :prepared => false
   end
 
   # Generates count SQL with the given conditions
+  # @deprecated
   def self.count table, conds = nil
-    check "select count(*) from #{table} #{where_internal conds}".strip
+    SQLHelper.count :table => table, :where => conds, :prepared => false
   end
 
   # Generates delete SQL with the given conditions
+  # @deprecated
   def self.delete table, conds = nil
-    check "delete from #{table} #{where_internal conds}".strip
+    SQLHelper.delete :table => table, :where => conds, :prepared => false
   end
 
   # FIXME: Naive protection for SQL Injection
   # TODO: check caching?
+  # @deprecated
   def self.check expr, is_name = false
     return nil if expr.nil?
 
@@ -118,63 +114,6 @@ module SQL
 
     return expr
   end
-
-protected
-  def self.esc str
-    str.to_s.gsub("'", "''")
-  end
-
-  # No check
-  def self.where_internal conds
-    conds = [conds] unless conds.is_a? Array
-    where_clause = conds.compact.map { |cond| where_unit cond }.reject(&:empty?).join(' and ')
-    where_clause.empty? ? '' : 'where ' + where_clause
-  end
-
-  def self.where_unit conds
-    case conds
-    when String, JDBCHelper::SQL::ScalarExpression
-      conds = conds.to_s.strip
-      conds.empty? ? '' : "(#{conds})"
-    when Hash
-      conds.map { |k, v|
-        "#{k} " +
-          case v
-          when NilClass
-            "is null"
-          when Numeric, String, JDBCHelper::SQL::ScalarExpression
-            "= #{value v}"
-          when JDBCHelper::SQL::Expression
-            v.to_s
-          when Range
-            ">= #{v.first} and #{k} <#{'=' unless v.exclude_end?} #{v.last}"
-          when Array
-            "in (#{ v.map { |e| value(e) }.join(', ') })"
-          else
-            raise NotImplementedError.new("Unsupported class: #{v.class}")
-          end
-      }.join(' and ')
-    when Array
-      if conds.empty?
-        ''
-      else
-        base = conds.first.to_s
-        params = conds[1..-1] || []
-        '(' +
-        base.gsub('?') {
-          param = params.shift
-          param ? value(param) : '?'
-        } + ')'
-      end
-    else
-      raise NotImplementedError.new("Parameter to where must be either Hash or String")
-    end
-  end
-
-  def self.insert_internal cmd, table, data_hash
-    cols = data_hash.keys
-    check "#{cmd} into #{table} (#{cols.join ', '}) values (#{cols.map{|c|value data_hash[c]}.join ', '})"
-  end
 end#SQL
 end#JDBCHelper
 

data/lib/jdbc-helper/sql/sql_prepared.rb

@@ -4,163 +4,72 @@
 module JDBCHelper
 # SQL generator class methods for prepared operations.
 # WARNING: Does not perform SQL.check to minimize performance overhead
+# @deprecated
 module SQLPrepared
   # Generates SQL where cluase with the given conditions.
   # Parameter can be either Hash of String.
+  # @deprecated
   def self.where *conds
-    where_internal conds
+    sql, *binds = SQLHelper.where_prepared(*conds)
+    [sql, binds]
   end
 
   # SQL Helpers
   # ===========
   # Generates insert SQL with hash
+  # @deprecated
   def self.insert table, data_hash
-    insert_internal 'insert', table, data_hash
+    sql, *binds = SQLHelper.insert :table => table, :data => data_hash, :prepared => true
+    [sql, binds]
   end
 
   # Generates insert ignore SQL (Non-standard syntax)
+  # @deprecated
   def self.insert_ignore table, data_hash
-    insert_internal 'insert ignore', table, data_hash
+    sql, *binds = SQLHelper.insert_ignore :table => table, :data => data_hash, :prepared => true
+    [sql, binds]
   end
 
   # Generates replace SQL (Non-standard syntax)
+  # @deprecated
   def self.replace table, data_hash
-    insert_internal 'replace', table, data_hash
+    sql, *binds = SQLHelper.replace :table => table, :data => data_hash, :prepared => true
+    [sql, binds]
   end
 
   # Generates update SQL with hash.
   # :where element of the given hash is taken out to generate where clause.
+  # @deprecated
   def self.update table, data_hash, where
-    where_clause, where_binds = where_internal where
-
-    col_binds = []
-    sql = ("update #{table} set " + data_hash.map { |k, v|
-      case v
-      when JDBCHelper::SQL::ScalarExpression
-        "#{k} = #{v}"
-      else
-        col_binds << v
-        "#{k} = ?"
-      end
-    }.join(', ') + " #{where_clause}").strip
-
-    return sql, col_binds + where_binds
+    sql, *binds =
+      SQLHelper.update :table => table, :data => data_hash, :where => where, :prepared => true
+    [sql, binds]
   end
 
   # Generates select SQL with the given conditions
+  # @deprecated
   def self.select table, opts = {}
-    opts = opts.reject { |k, v| v.nil? }
-    w_c, w_b = where_internal(opts.fetch(:where, {}))
-    sql = [
-      "select #{opts.fetch(:select, ['*']).join(', ')} from #{table}",
-      w_c.to_s,
-      SQL.order(opts.fetch(:order, []).join(', '))
-    ].reject(&:empty?).join(' ')
-
-    return sql, w_b
+    sql, *binds = SQLHelper.select :table => table,
+                     :project  => opts[:select],
+                     :where    => opts[:where],
+                     :order    => opts[:order],
+                     :prepared => true
+    [sql, binds]
   end
 
   # Generates count SQL with the given conditions
+  # @deprecated
   def self.count table, conds = nil
-    w_c, w_b = where_internal(conds)
-    sql = "select count(*) from #{table} #{w_c}".strip
-
-    return sql, w_b
+    sql, *binds =
+      SQLHelper.count :table => table, :where => conds, :prepared => true
+    [sql, binds]
   end
 
   # Generates delete SQL with the given conditions
+  # @deprecated
   def self.delete table, conds = nil
-    w_c, w_b = where_internal(conds)
-    sql =  "delete from #{table} #{w_c}".strip
-    return sql, w_b
-  end
-
-  private
-  def self.where_internal conds
-    conds   = [conds] unless conds.is_a? Array
-    binds   = []
-    clauses = []
-    conds.compact.each do |cond|
-      c, b = where_unit cond
-      next if c.empty?
-
-      binds += b
-      clauses << c
-    end
-    where_clause = clauses.join(' and ')
-    if where_clause.empty?
-      return nil, []
-    else
-      where_clause = 'where ' + where_clause
-      return where_clause, binds
-    end
-  end
-
-  def self.where_unit conds
-    binds = []
-
-    clause = case conds
-             when String, JDBCHelper::SQL::ScalarExpression
-               conds = conds.strip
-               conds.empty? ? '' : "(#{conds})"
-             when Hash
-               conds.map { |k, v|
-                 "#{k} " +
-                   case v
-                   when NilClass
-                     "is null"
-                   when Numeric
-                     binds << v
-                     "= ?"
-                   when JDBCHelper::SQL::ScalarExpression
-                     "= #{v.to_s}"
-                   when JDBCHelper::SQL::NotNullExpression
-                     v.to_s
-                   when JDBCHelper::SQL::CriterionExpression
-                     e, b = v.to_bind
-                     case b.first
-                     when JDBCHelper::SQL::ScalarExpression
-                       v.to_s
-                     else
-                       binds += b
-                       e
-                     end
-                   when Range
-                     binds << v.begin << v.end
-                     ">= ? and #{k} <#{'=' unless v.exclude_end?} ?"
-                   when Array
-                     "in (" + v.map { |ie| SQL.value ie }.join(', ') + ")"
-                   else
-                     binds << v
-                     "= ?"
-                   end
-               }.join(' and ')
-             when Array
-               if conds.empty?
-                 ''
-               else
-                 binds += conds[1..-1] if conds.length > 1
-                 "(#{conds.first})"
-               end
-             else
-               raise NotImplementedError.new("Parameter to where must be either Hash or String")
-             end
-    return clause, binds
-  end
-
-  def self.insert_internal cmd, table, data_hash
-    binds  = []
-    values = data_hash.values.map { |v|
-      case v
-      when JDBCHelper::SQL::ScalarExpression
-        v
-      else
-        binds << v
-        '?'
-      end
-    }
-    sql = "#{cmd} into #{table} (#{data_hash.keys.join ', '}) values (#{values.join(', ')})"
-    return sql, binds
+    sql, *binds = SQLHelper.delete :table => table, :where => conds, :prepared => true
+    [sql, binds]
   end
 end#SQL
 end#JDBCHelper

data/lib/jdbc-helper/version.rb

@@ -1,3 +1,3 @@
 module JDBCHelper
-  VERSION = '0.7.7'
+  VERSION = '0.8.0'
 end

data/lib/jdbc-helper/wrapper/function_wrapper.rb

@@ -27,7 +27,7 @@ class FunctionWrapper < ObjectWrapper
   def call(*args)
     pstmt = @connection.prepare("select #{name}(#{args.map{'?'}.join ','})#{@suffix}")
     begin
-      pstmt.query(*args)[0][0]
+      pstmt.query(*args).to_a[0][0]
     ensure
       pstmt.close
     end

data/lib/jdbc-helper/wrapper/sequence_wrapper.rb

@@ -31,13 +31,13 @@ class SequenceWrapper < ObjectWrapper
   # Increments the sequence and returns the value
   # @return [Fixnum]
   def nextval
-    @connection.query(@nextval_sql)[0][0].to_i
+    @connection.query(@nextval_sql).to_a[0][0].to_i
   end
 
   # Returns the incremented value of the sequence
   # @return [Fixnum]
   def currval
-    @connection.query(@currval_sql)[0][0].to_i
+    @connection.query(@currval_sql).to_a[0][0].to_i
   end
 
   # Recreates the sequence. Cannot be undone.