jdbc-helper 0.6.3 → 0.7.0

data/README.markdown

@@ -12,11 +12,13 @@
 # jdbc-helper
 
 A JDBC helper for Ruby/Database developers.
-JDBCHelper::Connection object wraps around a JDBC connection and provides much nicer interface to
+JDBCHelper::Connection object wraps around a JDBC connection and provides far nicer interface to
 crucial database operations from primitive selects and updates to more complex ones involving
 batch updates, prepared statements and transactions.
 As the name implies, this gem only works on JRuby.
 
+Tested on MySQL 5.5, Oracle 11g R2, PostgreSQL 9.0.4 and MS SQL Server 2008 R2.
+
 ## Installation
 ### Install gem
 ```
@@ -55,12 +57,16 @@ conn.close
 
 
 # MySQL shortcut connector
-conn = JDBCHelper::MySQLConnector.connect('localhost', 'mysql', '', 'test')
-conn.close
+JDBCHelper::MySQLConnector.connect('localhost', 'mysql', '', 'test')
 
 # Oracle shortcut connector
-conn = JDBCHelper::OracleConnector.connect(host, user, password, service_name)
-conn.close
+JDBCHelper::OracleConnector.connect(host, user, password, service_name)
+
+# PostgreSQL shortcut connector
+JDBCHelper::PostgresConnector.connect(host, user, password, db)
+ 
+# MS SQL Server shortcut connector
+JDBCHelper::SqlServerConnector.connect(host, user, password, db)
 ```
 
 ### Querying database table
@@ -154,6 +160,7 @@ p_upd.close
 ### Using table wrappers (since 0.2.0)
 ```ruby
 # For more complex examples, refer to test/test_object_wrapper.rb
+SQL = JDBCHelper::SQL
 
 # Creates a table wrapper
 table = conn.table('test.data')
@@ -175,12 +182,10 @@ end
 sql = table.select('a apple', :b).where(:c => (1..10)).order('b desc', 'a asc').sql
 
 # Updates with conditions
-table.update(:a => 'hello', :b => JDBCHelper::SQL('now()'), :where => { :c => 3 })
-# Or equivalently,
-table.where(:c => 3).update(:a => 'hello', :b => JDBCHelper::SQL('now()'))
+table.where(:c => 3).update(:a => 'hello', :b => SQL.expr('now()'))
 
 # Insert into the table
-table.insert(:a => 10, :b => 20, :c => JDBCHelper::SQL('10 + 20'))
+table.insert(:a => 10, :b => 20, :c => SQL.expr('10 + 20'))
 table.insert_ignore(:a => 10, :b => 20, :c => 30)
 table.replace(:a => 10, :b => 20, :c => 30)
 
@@ -190,7 +195,7 @@ with_defaults.insert(:c => 30)
 with_defaults.where('a != 10 or b != 20').update   # sets a => 10, b => 20
 
 # Batch updates with batch method
-table.batch.insert(:a => 10, :b => 20, :c => JDBCHelper::SQL('10 + 20'))
+table.batch.insert(:a => 10, :b => 20, :c => SQL.expr('10 + 20'))
 table.batch.insert_ignore(:a => 10, :b => 20, :c => 30)
 conn.execute_batch
 
@@ -204,6 +209,30 @@ table.truncate!
 table.drop!
 ```
 
+#### Building complex where clauses
+```ruby
+SQL = JDBCHelper::SQL                  # Shortcut. Or you can just include JDBCHelper
+
+# With Hash
+scope = table.where(
+  :a => 'abc',                         # a = 'abc'
+  :b => (1..10),                       # and b >= 1 and b <= 10
+  :c => (1...10),                      # and c >= 1 and c < 10
+  :d => %w[a b c],                     # and d in ('a', 'b', 'c')
+  :e => SQL.expr('sysdate'),           # and e = sysdate
+  :f => SQL.not_null,                  # and f is not null
+  :g => SQL.gt(100),                   # and g > 100
+  :h => SQL.lt(100),                   # and h < 100
+  :i => SQL.like('ABC%'),              # and i like 'ABC%'
+  :j => SQL.not_like('ABC%'),          # and j not like 'ABC%'
+  :k => SQL.le( SQL.expr('sysdate') )  # and k <= sysdate
+)
+scope.update(:a => 'xyz')
+
+# With Array
+scope = table.where(["a = ? or b > ?", 'abc', 10])
+```
+
 #### Invalid use of dynamic conditions
 
 TableWrapper object internally creates JDBC PreparedStatements.

data/lib/jdbc-helper/connection/type_map.rb

@@ -18,21 +18,21 @@ class Connection
     java.sql.Types::INTEGER => :getInt,
     java.sql.Types::BIGINT => :getLong,
 
-    java.sql.Types::CHAR => :getString,
-    java.sql.Types::VARCHAR => :getString,
+    java.sql.Types::CHAR        => :getString,
+    java.sql.Types::VARCHAR     => :getString,
     java.sql.Types::LONGVARCHAR => :getString,
     (java.sql.Types::NCHAR        rescue nil) => :getString,
     (java.sql.Types::NVARCHAR     rescue nil) => :getString,
-    (java.sql.Types::LONGNVARCHAR rescue nil) => :getBlob, # FIXME: MySQL
-    java.sql.Types::BINARY => :getString,
-    java.sql.Types::VARBINARY => :getString,
-    java.sql.Types::LONGVARBINARY => :getBlob,  # FIXME: MySQL
+    (java.sql.Types::LONGNVARCHAR rescue nil) => :getString,
+
+    # !! MySQL function returns VARBINARY type
+    java.sql.Types::BINARY        => :getBinaryStream,
+    java.sql.Types::VARBINARY     => :getBinaryStream,
+    java.sql.Types::LONGVARBINARY => :getBinaryStream,
 
     java.sql.Types::REAL => :getDouble,
     java.sql.Types::FLOAT => :getFloat,
     java.sql.Types::DOUBLE => :getDouble,
-    #java.sql.Types::NUMERIC => :getBigDecimal,
-    #java.sql.Types::DECIMAL => :getBigDecimal,
 
     java.sql.Types::DATE => :getDate,
     java.sql.Types::TIME => :getTime,

data/lib/jdbc-helper/connection.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 # Junegunn Choi (junegunn.c@gmail.com)
 
-require 'insensitive_hash'
+require 'insensitive_hash/minimal'
 
 require 'jdbc-helper/connection/type_map'
 require 'jdbc-helper/connection/parameterized_statement'
@@ -147,7 +147,7 @@ class Connection
   def initialize(args = {})
     # Subsequent deletes should not affect the input
     @args = Marshal.load(Marshal.dump(args))
-    args = Marshal.load(Marshal.dump(args)).insensitive
+    args = InsensitiveHash[ Marshal.load(Marshal.dump(args)) ]
 
     raise ArgumentError.new("driver not given") unless args.has_key? :driver
     raise ArgumentError.new("url not given") unless args.has_key? :url
@@ -424,6 +424,10 @@ class Connection
     JDBCHelper::ProcedureWrapper.new self, proc_name
   end
 
+  def inspect
+    InsensitiveHash[@args].merge({ :closed? => closed? }).delete(:password).inspect
+  end
+
   # Statistics
   class Stat
     attr_accessor :type, :elapsed, :success_count, :fail_count

data/lib/jdbc-helper/connector/postgres_connector.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+# Junegunn Choi (junegunn.c@gmail.com)
+
+module JDBCHelper
+# Shortcut connector for PostgreSQL
+class PostgresConnector < Connector
+  include Constants
+  include Constants::Connector
+
+  # @param [String] host
+  # @param [String] user
+  # @param [String] password
+  # @param [String] db
+  # @param [Fixnum] timeout
+  # @param [Hash] extra_params
+  # @return [JDBCHelper::Connection]
+  def self.connect(host, user, password, db,
+           timeout = DEFAULT_LOGIN_TIMEOUT, 
+           extra_params = DEFAULT_PARAMETERS[:postgres], &block)
+
+    if extra_params && extra_params.is_a?(Hash) == false
+      raise ArgumentError.new('extra_params must be a hash')
+    end
+
+    conn = Connection.new(
+      (extra_params || {}).merge(
+        :driver   => JDBC_DRIVER[:postgres],
+        :url      => "jdbc:postgresql://#{host}/#{db}",
+        :user     => user,
+        :password => password,
+        :timeout  => timeout))
+
+    block_given? ? ensure_close(conn, &block) : conn
+  end
+end#PostgresConnector
+end#JDBCHelper
+

data/lib/jdbc-helper/connector/sql_server_connector.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+# Junegunn Choi (junegunn.c@gmail.com)
+
+module JDBCHelper
+# Shortcut connector for MS SQL Server
+class SqlServerConnector < Connector
+  include Constants
+  include Constants::Connector
+
+  # @param [String] host
+  # @param [String] user
+  # @param [String] password
+  # @param [String] db
+  # @param [Fixnum] timeout
+  # @param [Hash] extra_params
+  # @return [JDBCHelper::Connection]
+  def self.connect(host, user, password, db,
+           timeout = DEFAULT_LOGIN_TIMEOUT, 
+           extra_params = DEFAULT_PARAMETERS[:sqlserver], &block)
+
+    if extra_params && extra_params.is_a?(Hash) == false
+      raise ArgumentError.new('extra_params must be a hash')
+    end
+
+    conn = Connection.new(
+      (extra_params || {}).merge(
+        :driver   => JDBC_DRIVER[:sqlserver],
+        :url      => "jdbc:sqlserver://#{host};databaseName=#{db};",
+        :user     => user,
+        :password => password,
+        :timeout  => timeout))
+
+    block_given? ? ensure_close(conn, &block) : conn
+  end
+end#SqlServerConnector
+end#JDBCHelper
+

data/lib/jdbc-helper/connector.rb

@@ -16,4 +16,6 @@ end#JDBCHelper
 
 require 'jdbc-helper/connector/oracle_connector'
 require 'jdbc-helper/connector/mysql_connector'
+require 'jdbc-helper/connector/postgres_connector'
+require 'jdbc-helper/connector/sql_server_connector'
 

data/lib/jdbc-helper/constants.rb

@@ -13,7 +13,9 @@ module Constants
   module Connector
     JDBC_DRIVER = {
       :oracle => 'oracle.jdbc.driver.OracleDriver',
-      :mysql  => 'com.mysql.jdbc.Driver'
+      :mysql  => 'com.mysql.jdbc.Driver',
+      :postgres => 'org.postgresql.Driver',
+      :sqlserver => 'com.microsoft.sqlserver.jdbc.SQLServerDriver'
     }
 
     DEFAULT_PARAMETERS = {
@@ -23,7 +25,11 @@ module Constants
         # 'rewriteBatchedStatements' => 'true',
         'useServerPrepStmts' => 'true',
         'useCursorFetch' => 'true'
-      }
+      },
+      :postgres => {
+        'stringtype' => 'unspecified'
+      },
+      :sqlserver => {}
     }
   end#Connector
 end#Constants

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

@@ -0,0 +1,145 @@
+# encoding: UTF-8
+# Junegunn Choi (junegunn.c@gmail.com)
+
+module JDBCHelper
+# SQL generator class methods for prepared operations.
+# WARNING: Does not perform SQL.check to minimize performance overhead
+class SQL
+  # Generate SQL snippet, prevents the string from being quoted.
+  # @param [String] SQL snippet
+  # @return [JDBCHelper::SQL::Expression]
+  # @since 0.7.0
+  def self.expr sql
+    ScalarExpression.new sql
+  end
+
+  # "is not null" expression for where clauses
+  # @return [JDBCHelper::SQL::Expression]
+  def self.not_nil
+    NotNullExpression.singleton
+  end
+  class << self
+    alias not_null not_nil
+  end
+
+  # Greater-than expression for where clauses
+  # @return [JDBCHelper::SQL::Expression]
+  # @since 0.7.0
+  def self.gt v
+    CriterionExpression.new '>', v
+  end
+
+  # Less-than expression for where clauses
+  # @return [JDBCHelper::SQL::Expression]
+  # @since 0.7.0
+  def self.lt v
+    CriterionExpression.new '<', v
+  end
+
+  # Less-than-or-equal-to expression for where clauses
+  # @return [JDBCHelper::SQL::Expression]
+  # @since 0.7.0
+  def self.le v
+    CriterionExpression.new '<=', v
+  end
+
+  # Greater-than-or-equal-to expression for where clauses
+  # @return [JDBCHelper::SQL::Expression]
+  # @since 0.7.0
+  def self.ge v
+    CriterionExpression.new '>=', v
+  end
+
+  # Not-equal expression for where clauses
+  # @return [JDBCHelper::SQL::Expression]
+  # @since 0.7.0
+  def self.ne v
+    CriterionExpression.new '<>', v
+  end
+
+  # Like expression for where clauses
+  # @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
+  end
+
+  # "Not like" expression for where clauses
+  # @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
+  end
+end#SQL
+end#JDBCHelper
+

data/lib/jdbc-helper/{sql.rb → sql/sql.rb}

@@ -5,38 +5,31 @@ module JDBCHelper
 
 # Generate SQL snippet, prevents the string from being quoted.
 # @param [String] SQL snippet
-# @return [JDBCHelper::SQL]
+# @return [JDBCHelper::SQL::Expression]
+# @deprecated Use JDBCHelper::SQL.expr instead
 def self.sql str
-  JDBCHelper::SQL.new str
+  JDBCHelper::SQL::ScalarExpression.new str
 end
 class << self
+  # @deprecated Use JDBCHelper::SQL.expr instead
   alias_method :SQL, :sql
 end
 
 # Class representing an SQL snippet. Also has many SQL generator class methods.
 class SQL
-  # Returns NotNilClass singleton object
-  # @return [JDBCHelper::SQL::NotNilClass]
-  def self.not_nil
-    NotNilClass.singleton
-  end
-  class << self
-    alias not_null not_nil
-  end
-
   # Formats the given data so that it can be injected into SQL
   def self.value data
     case data
-    when NilClass
-      'null'
     when BigDecimal
       data.to_s("F")
     when Numeric
       data
-    when JDBCHelper::SQL
-      data.to_s
-    when String
+    when String, Symbol
       "'#{esc data}'"
+    when NilClass
+      'null'
+    when JDBCHelper::SQL::ScalarExpression
+      data.to_s
     else
       raise NotImplementedError.new("Unsupported datatype: #{data.class}")
     end
@@ -124,18 +117,6 @@ class SQL
     return expr
   end
 
-  def to_s
-    @expr
-  end
-
-  def == other
-    self.to_s == other.to_s
-  end
-  
-  def eql? other
-    self.class == other.class && self.to_s == other.to_s
-  end
-  
 protected
   def self.esc str
     str.to_s.gsub("'", "''")
@@ -150,7 +131,7 @@ protected
 
   def self.where_unit conds
     case conds
-    when String, JDBCHelper::SQL
+    when String, JDBCHelper::SQL::ScalarExpression
       conds = conds.to_s.strip
       conds.empty? ? '' : "(#{conds})"
     when Hash
@@ -159,10 +140,10 @@ protected
           case v
           when NilClass
             "is null"
-          when NotNilClass
-            "is not null"
-          when Numeric, JDBCHelper::SQL, String
+          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
@@ -192,19 +173,6 @@ protected
     cols = data_hash.keys
     check "#{cmd} into #{table} (#{cols.join ', '}) values (#{cols.map{|c|value data_hash[c]}.join ', '})"
   end
-
-  def initialize str
-    @expr = JDBCHelper::SQL.check str
-  end
-
-  # Class to represent "(IS) NOT NULL" expression in SQL
-  class NotNilClass
-    # Returns the singleton object of NotNilClass
-    # @return [NotNilClass]
-    def self.singleton
-      @@singleton ||= NotNilClass.new
-    end
-  end
 end#SQL
 end#JDBCHelper
 

data/lib/jdbc-helper/{sql_prepared.rb → sql/sql_prepared.rb}

@@ -36,7 +36,7 @@ class SQLPrepared < JDBCHelper::SQL
     col_binds = []
     sql = ("update #{table} set " + data_hash.map { |k, v|
       case v
-      when JDBCHelper::SQL
+      when JDBCHelper::SQL::ScalarExpression
         "#{k} = #{v}"
       else
         col_binds << v
@@ -101,7 +101,7 @@ class SQLPrepared < JDBCHelper::SQL
     binds = []
 
     clause = case conds
-             when String
+             when String, JDBCHelper::SQL::ScalarExpression
                conds = conds.strip
                conds.empty? ? '' : "(#{conds})"
              when Hash
@@ -110,13 +110,22 @@ class SQLPrepared < JDBCHelper::SQL
                    case v
                    when NilClass
                      "is null"
-                   when NotNilClass
-                     "is not null"
-                   when JDBCHelper::SQL
-                     "= #{v}"
-                   when Fixnum, Bignum, Float
+                   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?} ?"
@@ -125,7 +134,7 @@ class SQLPrepared < JDBCHelper::SQL
                        v.map { |e|
                        case e
                        when String
-                         "'#{esc e}'"
+                         SQL.value e
                        else
                          e.to_s
                        end }.join(', ') + ")"
@@ -151,7 +160,7 @@ class SQLPrepared < JDBCHelper::SQL
     binds = []
     values = data_hash.values.map { |v|
       case v
-      when JDBCHelper::SQL
+      when JDBCHelper::SQL::ScalarExpression
         v
       else
         binds << v

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

@@ -11,9 +11,21 @@ class FunctionWrapper < ObjectWrapper
   # @return [String]
   alias to_s name
 
+  def initialize conn, name
+    super conn, name
+
+    @suffix = 
+      case conn.driver
+      when /oracle/
+        " from dual"
+      else
+        ""
+      end
+  end
+
   # Returns the result of the function call with the given parameters
   def call(*args)
-    pstmt = @connection.prepare("select #{name}(#{args.map{'?'}.join ','}) from dual")
+    pstmt = @connection.prepare("select #{name}(#{args.map{'?'}.join ','})#{@suffix}")
     begin
       pstmt.query(*args)[0][0]
     ensure
@@ -23,4 +35,3 @@ class FunctionWrapper < ObjectWrapper
 end#FunctionWrapper
 end#JDBCHelper
 
-

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

@@ -15,16 +15,29 @@ class SequenceWrapper < ObjectWrapper
   # @return [String]
   alias to_s name
 
+  def initialize(conn, name)
+    super conn, name
+
+    case conn.driver
+    when /oracle/
+      @nextval_sql = "select #{name}.nextval from dual"
+      @currval_sql = "select #{name}.currval from dual"
+    else
+      @nextval_sql = "select nextval('#{name}')"
+      @currval_sql = "select currval('#{name}')"
+    end
+  end
+
   # Increments the sequence and returns the value
   # @return [Fixnum]
   def nextval
-    @connection.query("select #{name}.nextval from dual")[0][0].to_i
+    @connection.query(@nextval_sql)[0][0].to_i
   end
 
   # Returns the incremented value of the sequence
   # @return [Fixnum]
   def currval
-    @connection.query("select #{name}.currval from dual")[0][0].to_i
+    @connection.query(@currval_sql)[0][0].to_i
   end
 
   # Recreates the sequence. Cannot be undone.

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

@@ -269,6 +269,18 @@ class TableWrapper < ObjectWrapper
     @pstmts
   end
 
+  def inspect
+    {
+      :conn => @connection,
+      :name => name,
+      :sqls => @pstmts.values.map(&:keys).flatten,
+      :where => @query_where,
+      :default => @query_default,
+      :order => @query_order,
+      :batch? => batch?
+    }.inspect
+  end
+
 private
   def prepare type, sql
     sql   = JDBCHelper::SQL.check(sql)

data/lib/jdbc-helper.rb

@@ -6,8 +6,9 @@ if RUBY_PLATFORM.match(/java/).nil?
 end
 
 require 'java'
-require 'jdbc-helper/sql'
-require 'jdbc-helper/sql_prepared'
+require 'jdbc-helper/sql/sql'
+require 'jdbc-helper/sql/sql_prepared'
+require 'jdbc-helper/sql/expression'
 require 'jdbc-helper/constants'
 require 'jdbc-helper/connection'
 require 'jdbc-helper/connector'