jdbc-helper 0.7.7 → 0.8.0

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

@@ -12,31 +12,31 @@ module JDBCHelper
 #
 #  # Counting the records in the table
 #  table.count
-#  table.count(:a => 10)
-#  table.where(:a => 10).count
+#  table.count(a: 10)
+#  table.where(a: 10).count
 #
 #  table.empty?
-#  table.where(:a => 10).empty?
+#  table.where(a: 10).empty?
 #
 #  # Selects the table by combining select, where, and order methods
-#  table.select('a apple', :b).where(:c => (1..10)).order('b desc', 'a asc') do |row|
+#  table.select('a apple', :b).where(c: (1..10)).order('b desc', 'a asc') do |row|
 #    puts row.apple
 #  end
 #
 #  # Updates with conditions
-#  table.update(:a => 'hello', :b => JDBCHelper::SQL('now()'), :where => { :c => 3 })
+#  table.update(a: 'hello', b: { 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: 'now()' })
 #
 #  # Insert into the table
-#  table.insert(:a => 10, :b => 20, :c => JDBCHelper::SQL('10 + 20'))
-#  table.insert_ignore(:a => 10, :b => 20, :c => 30)
-#  table.replace(:a => 10, :b => 20, :c => 30)
+#  table.insert(a: 10, b: 20, c: { sql: '10 + 20' })
+#  table.insert_ignore(a: 10, b: 20, c: 30)
+#  table.replace(a: 10, b: 20, c: 30)
 #
 #  # Delete with conditions
-#  table.delete(:c => 3)
+#  table.delete(c: 3)
 #  # Or equivalently,
-#  table.where(:c => 3).delete
+#  table.where(c: 3).delete
 #
 #  # Truncate or drop table (Cannot be undone)
 #  table.truncate_table!
@@ -50,9 +50,9 @@ class TableWrapper < ObjectWrapper
   # @param [List of Hash/String] where Filter conditions
   # @return [Fixnum] Count of the records.
   def count *where
-    sql, binds = JDBCHelper::SQLPrepared.count(name, @query_where + where)
+    sql, *binds = SQLHelper.count :table => name, :where => @query_where + where, :prepared => true
     pstmt = prepare :count, sql
-    pstmt.query(*binds)[0][0].to_i
+    pstmt.query(*binds).to_a[0][0].to_i
   end
 
   # Sees if the table is empty
@@ -66,7 +66,9 @@ class TableWrapper < ObjectWrapper
   # @param [Hash] data_hash Column values in Hash
   # @return [Fixnum] Number of affected records
   def insert data_hash = {}
-    sql, binds = JDBCHelper::SQLPrepared.insert(name, @query_default.merge(data_hash))
+    sql, *binds = SQLHelper.insert :table => name,
+                                   :data => @query_default.merge(data_hash),
+                                   :prepared => true
     pstmt = prepare :insert, sql
     pstmt.send @update_method, *binds
   end
@@ -77,7 +79,9 @@ class TableWrapper < ObjectWrapper
   # @param [Hash] data_hash Column values in Hash
   # @return [Fixnum] Number of affected records
   def insert_ignore data_hash = {}
-    sql, binds = JDBCHelper::SQLPrepared.insert_ignore(name, @query_default.merge(data_hash))
+    sql, *binds = SQLHelper.insert_ignore :table => name,
+                                          :data => @query_default.merge(data_hash),
+                                          :prepared => true
     pstmt = prepare :insert, sql
     pstmt.set_fetch_size @fetch_size if @fetch_size
     pstmt.send @update_method, *binds
@@ -88,7 +92,9 @@ class TableWrapper < ObjectWrapper
   # @param [Hash] data_hash Column values in Hash
   # @return [Fixnum] Number of affected records
   def replace data_hash = {}
-    sql, binds = JDBCHelper::SQLPrepared.replace(name, @query_default.merge(data_hash))
+    sql, *binds = SQLHelper.replace :table => name,
+                                    :data => @query_default.merge(data_hash),
+                                    :prepared => true
     pstmt = prepare :insert, sql
     pstmt.send @update_method, *binds
   end
@@ -101,9 +107,11 @@ class TableWrapper < ObjectWrapper
   def update data_hash_with_where = {}
     where_ext  = data_hash_with_where.delete(:where)
     where_ext  = [where_ext] unless where_ext.is_a? Array
-    sql, binds = JDBCHelper::SQLPrepared.update(name,
-                    @query_default.merge(data_hash_with_where),
-                    @query_where + where_ext.compact)
+    sql, *binds = SQLHelper.update(
+                    :prepared => true,
+                    :table => name,
+                    :data => @query_default.merge(data_hash_with_where),
+                    :where => @query_where + where_ext.compact)
     pstmt = prepare :update, sql
     pstmt.send @update_method, *binds
   end
@@ -112,7 +120,7 @@ class TableWrapper < ObjectWrapper
   # @param [List of Hash/String] where Delete filters
   # @return [Fixnum] Number of affected records
   def delete *where
-    sql, binds = JDBCHelper::SQLPrepared.delete(name, @query_where + where)
+    sql, *binds = SQLHelper.delete(:table => name, :where => @query_where + where, :prepared => true)
     pstmt = prepare :delete, sql
     pstmt.send @update_method, *binds
   end
@@ -121,7 +129,7 @@ class TableWrapper < ObjectWrapper
   # @note This operation cannot be undone
   # @return [JDBCHelper::TableWrapper] Self.
   def truncate!
-    @connection.update(JDBCHelper::SQL.check "truncate table #{name}")
+    @connection.update("truncate table #{name}")
     self
   end
   alias truncate_table! truncate!
@@ -130,7 +138,7 @@ class TableWrapper < ObjectWrapper
   # @note This operation cannot be undone
   # @return [JDBCHelper::TableWrapper] Self.
   def drop!
-    @connection.update(JDBCHelper::SQL.check "drop table #{name}")
+    @connection.update("drop table #{name}")
     self
   end
   alias drop_table! drop!
@@ -149,6 +157,7 @@ class TableWrapper < ObjectWrapper
     obj.instance_variable_set :@query_select, fields unless fields.empty?
     ret obj, &block
   end
+  alias project select
 
   # Returns a new TableWrapper object which can be used to execute a select
   # statement for the table with the specified filter conditions.
@@ -164,6 +173,16 @@ class TableWrapper < ObjectWrapper
     ret obj, &block
   end
 
+  # @overload limit(offset, limit)
+  # @overload limit(limit)
+  # @return [JDBCHelper::TableWrapper]
+  # @since 0.8.0
+  def limit *args, &block
+    obj = self.dup
+    obj.instance_variable_set :@query_limit, args
+    ret obj, &block
+  end
+
   # Returns a new TableWrapper object which can be used to execute a select
   # statement for the table with the given sorting criteria.
   # If a block is given, executes the select statement and yields each row to the block.
@@ -203,14 +222,16 @@ class TableWrapper < ObjectWrapper
 
   # Executes a select SQL for the table and returns an Enumerable object,
   # or yields each row if block is given.
-  # @return [JDBCHelper::Connection::ResultSetEnumerator]
+  # @return [JDBCHelper::Connection::ResultSet]
   # @since 0.4.0
   def each &block
-    sql, binds = JDBCHelper::SQLPrepared.select(
-        name,
-        :select => @query_select,
-        :where => @query_where,
-        :order => @query_order)
+    sql, *binds = SQLHelper.select(
+        :prepared => true,
+        :table    => name,
+        :project  => @query_select,
+        :where    => @query_where,
+        :order    => @query_order,
+        :limit    => @query_limit)
     pstmt = prepare :select, sql
     pstmt.enumerate(*binds, &block)
   end
@@ -276,25 +297,28 @@ class TableWrapper < ObjectWrapper
   # @return [String] Select SQL
   # @since 0.4.0
   def sql
-    JDBCHelper::SQL.select(
-        name,
-        :select => @query_select,
-        :where => @query_where,
-        :order => @query_order)
+    SQLHelper.select(
+      :prepared => false,
+      :table    => name,
+      :project  => @query_select,
+      :where    => @query_where,
+      :limit    => @query_limit,
+      :order    => @query_order)
   end
 
   def initialize connection, table_name
     super connection, table_name
     @update_method = :update
     @query_default = {}
-    @query_where = []
-    @query_order = nil
-    @query_select = nil
+    @query_where   = []
+    @query_order   = nil
+    @query_limit   = nil
+    @query_select  = nil
     @pstmts = {
       :select => {},
       :insert => {},
       :delete => {},
-      :count => {},
+      :count  => {},
       :update => {}
     }
     @fetch_size = nil
@@ -319,13 +343,14 @@ class TableWrapper < ObjectWrapper
 
   def inspect
     {
-      :conn => @connection,
-      :name => name,
-      :sqls => @pstmts.values.map(&:keys).flatten,
-      :where => @query_where,
+      :conn    => @connection,
+      :name    => name,
+      :sqls    => @pstmts.values.map(&:keys).flatten,
+      :where   => @query_where,
       :default => @query_default,
-      :order => @query_order,
-      :batch? => batch?
+      :order   => @query_order,
+      :limit   => @query_limit,
+      :batch?  => batch?
     }.inspect
   end
 

data/lib/jdbc-helper.rb

@@ -12,4 +12,5 @@ require 'jdbc-helper/sql'
 require 'jdbc-helper/constants'
 require 'jdbc-helper/connection'
 require 'jdbc-helper/connector'
+require 'sql_helper'
 

data/test/helper.rb

@@ -84,7 +84,7 @@ module JDBCHelperTestHelper
 		config.each do | db, conn_info |
 			# Just for quick and dirty testing
 			@type = case conn_info[:driver]
-					when /mysql/i
+					when /mysql/i, /maria/i
 						:mysql
 					when /oracle/i
 						:oracle

data/test/test_connection.rb

@@ -187,9 +187,10 @@ class TestConnection < Test::Unit::TestCase
 
   def test_query_enumerate
     each_connection do | conn |
-      # Query without a block => Array
+      # Query without a block => ResultSet
       query_result = conn.query get_one_two
-      assert query_result.is_a? Array
+      assert query_result.is_a? JDBCHelper::Connection::ResultSet
+      query_result = query_result.to_a
       assert_equal 2, query_result.length
       check_one_two(query_result.first)
       assert_equal query_result.first, query_result.last
@@ -203,13 +204,64 @@ class TestConnection < Test::Unit::TestCase
       assert_equal 2, count
 
       # Enumerate
-      enum = conn.enumerate(get_one_two)
+      enum = conn.query(get_one_two)
       assert enum.is_a? Enumerable
       assert enum.closed? == false
       a = enum.to_a
       assert_equal 2, a.length
       check_one_two a.first
       assert enum.closed? == true
+
+      # Enumerator chain
+      cnt = 0
+      enum = conn.query(get_one_two)
+      assert_equal false, enum.closed?
+      enum.each.each.each.each_slice(1) do |slice|
+        assert_equal Array, slice.class
+        assert_equal 1,     slice.length
+        cnt += 1
+        assert_equal cnt == 2, enum.closed?
+      end
+      assert_equal true, enum.closed?
+      assert_equal 2, cnt
+
+      # Enumerator chain 2
+      cnt = 0
+      enum = conn.query(get_one_two)
+      assert_equal false, enum.closed?
+      enum.each.each.each.with_index.each_slice(2).each do |slice|
+        assert_equal Array,   slice.class
+        assert_equal 2,       slice.length
+        assert_equal Array,   slice[0].class
+        assert_equal 2,       slice[0].length
+        assert_equal cnt,     slice[0][1]
+        assert_equal cnt + 1, slice[1][1]
+        cnt += 2
+        assert_equal cnt == 2, enum.closed?
+      end
+      assert_equal true, enum.closed?
+      assert_equal 2, cnt
+      assert_equal 0, enum.to_a.length
+
+      enum = conn.query('
+        select 1 a from dual union all
+        select 2 a from dual union all
+        select 3 a from dual')
+
+      row = enum.take(1).first
+      assert_equal 0, row.rownum
+      assert_equal false, enum.closed?
+
+      row = enum.take(1).first
+      assert_equal 1, row.rownum
+      assert_equal false, enum.closed?
+
+      row = enum.take(1).first
+      assert_equal 2, row.rownum
+      assert_equal true, enum.closed?
+
+      assert_equal [], enum.take(1)
+      assert_equal true, enum.closed?
     end
   end
 
@@ -217,17 +269,18 @@ class TestConnection < Test::Unit::TestCase
     each_connection do |conn|
       # On error, Statement object must be returned to the StatementPool
       (JDBCHelper::Constants::MAX_STATEMENT_NESTING_LEVEL * 2).times do |i|
-        conn.enumerate('xxx') rescue nil
+        conn.query('xxx') rescue nil
       end
-      assert_equal 'OK', conn.query("select 'OK' from dual")[0][0]
+      assert_equal 'OK', conn.query("select 'OK' from dual").to_a[0][0]
     end
   end
 
   def test_deep_nesting
     nest = lambda { |str, lev|
       if lev > 0
-        "conn.query('select 1 from dual') do |r#{lev}|
+        "conn.query('select 1 a from dual union all select 2 a from dual') do |r#{lev}|
            #{nest.call str, lev - 1}
+           break
          end"
       else
         str
@@ -323,7 +376,8 @@ class TestConnection < Test::Unit::TestCase
 
         # Query without a block => Array
         query_result = sel.query
-        assert query_result.is_a? Array
+        assert query_result.is_a? JDBCHelper::Connection::ResultSet
+        query_result = query_result.to_a
         assert_equal 2, query_result.length
         check_one_two(query_result.first)
 
@@ -336,7 +390,7 @@ class TestConnection < Test::Unit::TestCase
         assert_equal 2, count
 
         # Enumerate
-        enum = sel.enumerate
+        enum = sel.query
         assert enum.is_a? Enumerable
         assert enum.closed? == false
         a = enum.to_a
@@ -475,13 +529,13 @@ class TestConnection < Test::Unit::TestCase
       if @type == :mysql
         conn.prepare("insert into #{TEST_TABLE} (a, b, c) values (?, ?, ?)").update(ts, d, t)
         # MySQL doesn't have subsecond precision
-        assert [lt, lt / 1000 * 1000].include?(conn.query("select a from #{TEST_TABLE}")[0][0].getTime)
+        assert [lt, (lt * 0.001).round * 1000].include?(conn.query("select a from #{TEST_TABLE}").to_a[0][0].getTime)
         # The JDBC spec states that java.sql.Dates have _no_ time component
         # http://bugs.mysql.com/bug.php?id=2876
-        assert_equal d.getTime, conn.query("select b from #{TEST_TABLE}")[0][0].getTime
+        assert_equal d.getTime, conn.query("select b from #{TEST_TABLE}").to_a[0][0].getTime
 
         # http://stackoverflow.com/questions/907170/java-getminutes-and-gethours
-        t2 = conn.query("select c from #{TEST_TABLE}")[0][0]
+        t2 = conn.query("select c from #{TEST_TABLE}").to_a[0][0]
         cal = java.util.Calendar.getInstance
         cal.setTime(t)
         cal2 = java.util.Calendar.getInstance
@@ -498,9 +552,10 @@ class TestConnection < Test::Unit::TestCase
       reset_test_table_ts conn
       ts = Time.now
       conn.prepare("insert into #{TEST_TABLE} (a) values (?)").update(ts)
-      got = conn.query("select a from #{TEST_TABLE}")[0][0]
+      got = conn.query("select a from #{TEST_TABLE}").to_a[0][0]
       arr = [
               ts.to_i * 1000,
+              (ts.to_f.round) * 1000, # MySQL
               (ts.to_f * 1000).to_i,
               # SQL Server seems to round up the millisecond precision
               (ts.to_f * 1000).to_i / 10 * 10
@@ -611,7 +666,7 @@ class TestConnection < Test::Unit::TestCase
     each_connection do | conn |
       reset_test_table conn
 
-      rse_class = JDBCHelper::Connection::ResultSetEnumerator
+      rse_class = JDBCHelper::Connection::ResultSet
 
       # Connection#execute
       assert_equal 1, conn.execute("insert into #{TEST_TABLE} values (0, 'A')")
@@ -659,8 +714,8 @@ class TestConnection < Test::Unit::TestCase
 
       assert_equal 20, 20.times.select {
         conn.execute(q).close
-        conn.enumerate(q).close
-        conn.query q
+        conn.query(q).close
+        conn.query(q).to_a
         conn.update u
 
         conn.execute(q).count == 1

data/test/test_object_wrapper.rb

@@ -119,11 +119,10 @@ class TestObjectWrapper < Test::Unit::TestCase
     end
   end
 
-
   def insert_params
     {
       :alpha => 100,
-      :beta => JDBCHelper::SQL('0.1 + 0.2'),
+      :beta => { :sql => '0.1 + 0.2' },
       :num_f => 1234567890.12345, # 16 digits
       :num_fstr => BigDecimal.new("12345678901234567890.12345"),
       :num_int => 123456789,
@@ -272,7 +271,7 @@ class TestObjectWrapper < Test::Unit::TestCase
       params = {
         :id => 1,
         :alpha => 100,
-        :beta => JDBCHelper::SQL('0.1 + 0.2'),
+        :beta => { :sql => '0.1 + 0.2' },
         :gamma => 'hello world' }
 
       100.times do
@@ -291,7 +290,7 @@ class TestObjectWrapper < Test::Unit::TestCase
       table = conn.table(@table_name)
       params = {
         :id => 1,
-        :beta => JDBCHelper::SQL('0.1 + 0.2'),
+        :beta => { :sql => '0.1 + 0.2' },
         :gamma => 'hello world' }
 
       100.times do |i|
@@ -355,7 +354,7 @@ class TestObjectWrapper < Test::Unit::TestCase
         # SQL Server seems to have a bug in getBinaryStream (FIXME)
         # http://www.herongyang.com/JDBC/SQL-Server-BLOB-getBinaryStream.html
         assert_equal @blob, get_blob_data(blob) unless @type == :sqlserver
-        assert_equal Float,  row.num_f.class
+        assert_equal BigDecimal, row.num_f.class
         assert_equal BigDecimal, row.num_fstr.class
         assert_equal Fixnum, row.num_int.class
         assert_equal Fixnum, row.num_long.class
@@ -382,13 +381,13 @@ class TestObjectWrapper < Test::Unit::TestCase
       assert_equal 10, cnt
 
       assert_equal "select a, b, c cc from tmp_jdbc_helper " +
-          "where id >= 11 and id <= 20 order by id desc, name asc",
+          "where id between 11 and 20 order by id desc, name asc",
           table.where(:id => 11..20).
             select(:a, :b, 'c cc').
             order('id desc', 'name asc').sql
 
       assert_equal "select a, b, c cc from tmp_jdbc_helper " +
-          "where (id != 15) and id >= 11 and id <= 20 order by id desc, name asc",
+          "where (id != 15) and id between 11 and 20 order by id desc, name asc",
           table.where("id != 15", :id => 11..20).
             select(:a, :b, 'c cc').
             order('id desc', 'name asc').sql
@@ -499,7 +498,7 @@ class TestObjectWrapper < Test::Unit::TestCase
       table.clear_batch
       assert_equal 50, table.count
 
-      table.batch.update(:alpha => JDBCHelper::SQL('alpha * 2'))
+      table.batch.update(:alpha => { :sql => 'alpha * 2' })
       assert_equal 100, table.select(:alpha).to_a.first.alpha.to_i
 
       # Independent update inbetween
@@ -517,7 +516,7 @@ class TestObjectWrapper < Test::Unit::TestCase
       assert_equal 200, table.select(:alpha).to_a.first.alpha.to_i
 
       # Order of execution
-      table.batch.update(:alpha => JDBCHelper::SQL('alpha * 4'))
+      table.batch.update(:alpha => { :sql => 'alpha * 4' })
       insert table.batch, 50, 2000
       table.batch.delete
       ret = table.execute_batch :delete, :insert, :update
@@ -733,5 +732,19 @@ class TestObjectWrapper < Test::Unit::TestCase
       conn.table(@table_name).fetch_size("No").count
     end
   end
+
+  def test_limit
+    each_connection do |conn|
+      next unless [:mysql].include?(@type)
+
+      create_table conn
+      t = conn.table(@table_name)
+      insert t, 100
+      assert_equal 100, t.to_a.count
+
+      assert_equal 30, t.limit(30).to_a.count
+      assert_equal 100, t.limit(30).count
+    end
+  end
 end