jdbc-helper 0.7.7 → 0.8.0

data/test/test_sql.rb

@@ -2,6 +2,7 @@ require 'helper'
 SQL = JDBCHelper::SQL
 SQLPrepared = JDBCHelper::SQLPrepared
 
+# @deprecated Use of JDBCHelper::SQL and JDBCHelper::SQLPrepared is deprecated
 # WARNING: tests assumes ordered hash
 class TestSQL < Test::Unit::TestCase
   def setup
@@ -11,16 +12,16 @@ class TestSQL < Test::Unit::TestCase
   end
 
   def test_value
-    assert_equal 1,                   SQL.value(1)
-    assert_equal 1.2,                 SQL.value(1.2)
-    assert_equal 9999999999999999999, SQL.value(9999999999999999999)
-    assert_equal "0.00000000000000000000009999999999999999999", 
+    assert_equal '1',                   SQL.value(1)
+    assert_equal '1.2',                 SQL.value(1.2)
+    assert_equal '9999999999999999999', SQL.value(9999999999999999999)
+    assert_equal "0.00000000000000000000009999999999999999999",
         SQL.value(BigDecimal.new("0.00000000000000000000009999999999999999999"))
     assert_equal "'sysdate'",         SQL.value('sysdate')
     assert_equal "'A''s'",            SQL.value("A's")
     assert_equal "sysdate",           SQL.value(SQL.expr('sysdate'))
 
-    assert_raise(NotImplementedError) { SQL.value(Time.now) }
+    # assert_raise(NotImplementedError) { SQL.value(Time.now) }
   end
 
   def test_order
@@ -33,12 +34,12 @@ class TestSQL < Test::Unit::TestCase
     assert_equal "order by a asc", SQL.order('a asc')
     assert_equal "order by a, b asc, c desc", SQL.order(:a, 'b asc', 'c desc')
 
-    assert_raise(ArgumentError) { SQL.order(" -- ") }
-    assert_raise(ArgumentError) { SQL.order(:a, :b, "c 'd") }
+    assert_raise(SyntaxError) { SQL.order(" -- ") }
+    assert_raise(SyntaxError) { SQL.order(:a, :b, "c 'd") }
   end
 
   def test_complex_table_wrapper_query
-    assert_equal "select a + b sum from test where a = 'hello' and b >= 1 and b <= 10 and c >= 1 and c < 10 and d in ('a', 'b', 'c') and e = sysdate and f is not null and g > 100 and h < 100 and i like 'ABC%' and j not like 'ABC%' and k <= sysdate order by a + b desc",
+    assert_equal "select a + b sum from test where a = 'hello' and b between 1 and 10 and c >= 1 and c < 10 and (d = 'a' or d = 'b' or d = 'c') and e = sysdate and f is not null and g > 100 and h < 100 and i like 'ABC%' and not (j like 'ABC%') and k <= sysdate order by a + b desc",
       JDBCHelper::TableWrapper.new(nil, :test).where(
         :a => 'hello',
         :b => (1..10),
@@ -51,20 +52,16 @@ class TestSQL < Test::Unit::TestCase
         :i => SQL.like('ABC%'),
         :j => SQL.not_like('ABC%'),
         :k => SQL.le( SQL.expr('sysdate') )
-      ).select(
-        SQL.expr('a + b sum')
-      ).order(
-        SQL.expr('a + b desc')
-      ).sql
+      ).select('a + b sum').order('a + b desc').sql
   end
 
   def test_where
     assert_equal "where a = 1",                   SQL.where(:a => 1)
-    assert_equal "where a = 12345678901234567890.1234567890123456789", 
+    assert_equal "where a = 12345678901234567890.1234567890123456789",
                                                   SQL.where(:a => BigDecimal.new("12345678901234567890.1234567890123456789"))
     assert_equal "where a = 1.2",                 SQL.where(:a => 1.2)
     assert_equal "where a = 9999999999999999999", SQL.where(:a => 9999999999999999999)
-    assert_equal "where a >= 1 and a <= 2",       SQL.where(:a => 1..2)
+    assert_equal "where a between 1 and 2",       SQL.where(:a => 1..2)
     assert_equal "where a >= 1 and a < 2",        SQL.where(:a => 1...2)
     assert_equal "where a = 'A''s'",              SQL.where(:a => "A's")
     assert_equal "where a is null",               SQL.where(:a => nil)
@@ -72,12 +69,11 @@ class TestSQL < Test::Unit::TestCase
     assert_equal "where a is not null",           SQL.where(:a => SQL.not_null)
     assert_equal "where a = sysdate",             SQL.where(:a => SQL.expr('sysdate'))
     assert_equal "where a = sysdate",             SQL.where(:a => SQL.expr('sysdate'))
-    assert_equal "where sysdate = sysdate",       SQL.where(SQL.expr('sysdate') => SQL.expr('sysdate'))
-    assert_equal "where a in ('aa', 'bb', 'cc')", SQL.where(:a => %w[aa bb cc])
-    assert_equal "where a in ('aa', 'bb', 'cc', 4)", SQL.where(:a => %w[aa bb cc] + [4])
+    assert_equal "where sysdate = sysdate",       SQL.where('sysdate' => SQL.expr('sysdate'))
+    assert_equal "where (a = 'aa' or a = 'bb' or a = 'cc')", SQL.where(:a => %w[aa bb cc])
+    assert_equal "where (a = 'aa' or a = 'bb' or a = 'cc' or a = 4)", SQL.where(:a => %w[aa bb cc] + [4])
     assert_equal "where a = 1 and b = 'A''s'",    SQL.where(:a => 1, :b => "A's")
     assert_equal "where (a = 1 or b = 1)",        SQL.where("a = 1 or b = 1")
-    assert_equal "where (a = 1 or b = 1)",        SQL.where(SQL.expr("a = 1 or b = 1"))
     assert_equal "where (a = 1 or b = 1) and c = 2", SQL.where("a = 1 or b = 1", :c => 2)
     assert_equal "where c = 2 and (a = 1 or b = 1)", SQL.where({:c => 2}, "a = 1 or b = 1")
     assert_equal "where c = 2 and (a = 1 or b = 1) and (e = 2) and f = 3 and (abc not like % || 'abc???' || % or def != 100 and ghi = '??') and (1 = 1)",
@@ -103,7 +99,7 @@ class TestSQL < Test::Unit::TestCase
     assert_raise(ArgumentError) { SQL.like(123) }
     assert_raise(ArgumentError) { SQL.not_like(BigDecimal.new('1.23')) }
     assert_equal "where a like 'abc'",     SQL.where(:a => SQL.like('abc'))
-    assert_equal "where a not like 'abc'", SQL.where(:a => SQL.not_like('abc'))
+    assert_equal "where not (a like 'abc')", SQL.where(:a => SQL.not_like('abc'))
 
     # 0.7.0: with where
     assert_equal "where a > 1",        SQL.where(:a => SQL.gt(1))
@@ -112,31 +108,32 @@ class TestSQL < Test::Unit::TestCase
     assert_equal "where a <= sysdate", SQL.where(:a => SQL.le(SQL.expr 'sysdate'))
     assert_equal "where a <> 'z'",     SQL.where(:a => SQL.ne(:z))
     assert_equal "where a like 'hello''%'", SQL.where(:a => SQL.like("hello'%"))
-    assert_equal "where a not like 'hello''%'", SQL.where(:a => SQL.not_like("hello'%"))
+    assert_equal "where not (a like 'hello''%')", SQL.where(:a => SQL.not_like("hello'%"))
 
     # Non-primitive datatypes not implemented (TODO?)
-    assert_raise(NotImplementedError) { SQL.where(:a => Time.now) }
-    assert_raise(NotImplementedError) { SQL.where(5) }
-    assert_raise(NotImplementedError) { SQL.where(Time.now) }
+    # assert_raise(ArgumentError) { SQL.where(:a => Time.now) }
+    assert_raise(ArgumentError) { SQL.where(5) }
+    assert_raise(ArgumentError) { SQL.where(Time.now) }
 
     # Invalid SQL detection
-    assert_raise(ArgumentError) { SQL.where(" 'a--b' -- cde") }
-    assert_raise(ArgumentError) { SQL.where(" 'a--b' ;") }
-    assert_raise(ArgumentError) { SQL.where(" 'a--b' -- cde", :a => 1) }
-    assert_raise(ArgumentError) { SQL.where(" 'a--b' -- cde", :a => 1) }
-    assert_raise(ArgumentError) { SQL.where({:a => 1}, "/* a") }
-    assert_raise(ArgumentError) { SQL.where(:a => SQL.expr(" 'a--b' -- cde")) }
-    assert_raise(ArgumentError) { SQL.where(:a => SQL.expr(" 'aabbb''dd")) }
-    assert_raise(ArgumentError) { SQL.where(:a => SQL.expr(" 'aabbb''dd' /* aaa */")) }
-    assert_raise(ArgumentError) { SQL.where(:a => SQL.expr(' aabbb"""  ')) }
-    assert_raise(ArgumentError) { SQL.where(:a => SQL.expr(' aab`bb``  ')) }
+    assert_raise(SyntaxError) { SQL.where(" 'a--b' -- cde") }
+    assert_raise(SyntaxError) { SQL.where(" 'a--b' ;") }
+    assert_raise(SyntaxError) { SQL.where(" 'a--b' -- cde", :a => 1) }
+    assert_raise(SyntaxError) { SQL.where(" 'a--b' -- cde", :a => 1) }
+    assert_raise(SyntaxError) { SQL.where({:a => 1}, "/* a") }
+    assert_raise(SyntaxError) { SQL.where(:a => SQL.expr(" 'a--b' -- cde")) }
+    assert_raise(SyntaxError) { SQL.where(:a => SQL.expr(" 'aabbb''dd")) }
+    assert_raise(SyntaxError) { SQL.where(:a => SQL.expr(" 'aabbb''dd' /* aaa ")) }
+    assert_raise(SyntaxError) { SQL.where(:a => SQL.expr(" 'aabbb''dd'  aaa */")) }
+    assert_raise(SyntaxError) { SQL.where(:a => SQL.expr(' aabbb"""  ')) }
+    assert_raise(SyntaxError) { SQL.where(:a => SQL.expr(' aab`bb``  ')) }
   end
 
   def test_where_prepared
     assert_equal ["where a = ?", [1]],                  SQLPrepared.where(:a => 1)
     assert_equal ["where a = ?", [1.2]],               SQLPrepared.where(:a => 1.2)
     assert_equal ["where a = ?", [9999999999999999999]], SQLPrepared.where(:a => 9999999999999999999)
-    assert_equal ["where a >= ? and a <= ?", [1,2]],      SQLPrepared.where(:a => 1..2)
+    assert_equal ["where a between ? and ?", [1,2]],      SQLPrepared.where(:a => 1..2)
     assert_equal ["where a >= ? and a < ?", [1,2]],       SQLPrepared.where(:a => 1...2)
     assert_equal ["where a = ?", ["A's"]],            SQLPrepared.where(:a => "A's")
     assert_equal ["where a is null", []],             SQLPrepared.where(:a => nil)
@@ -144,9 +141,9 @@ class TestSQL < Test::Unit::TestCase
     assert_equal ["where a is not null", []],         SQLPrepared.where(:a => SQL.not_null)
     assert_equal ["where a = sysdate", []],           SQLPrepared.where(:a => SQL.expr('sysdate'))
     assert_equal ["where a = sysdate", []],           SQLPrepared.where(:a => SQL.expr('sysdate'))
-    assert_equal ["where sysdate = sysdate", []],     SQLPrepared.where(SQL.expr('sysdate') => SQL.expr('sysdate'))
-    assert_equal ["where a in ('aa', 'bb', 'cc')", []], SQLPrepared.where(:a => %w[aa bb cc])
-    assert_equal ["where a in ('aa', 'bb', 'cc', 4)", []], SQLPrepared.where(:a => %w[aa bb cc] + [4])
+    assert_equal ["where sysdate = sysdate", []],     SQLPrepared.where('sysdate' => SQL.expr('sysdate'))
+    assert_equal ["where (a = ? or a = ? or a = ?)", ["aa", "bb", "cc"]], SQLPrepared.where(:a => %w[aa bb cc])
+    assert_equal ["where (a = ? or a = ? or a = ? or a = ?)", ["aa", "bb", "cc", 4]], SQLPrepared.where(:a => %w[aa bb cc] + [4])
     assert_equal ["where a = ? and b = ?", [1, "A's"]],   SQLPrepared.where(:a => 1, :b => "A's")
     assert_equal ["where (a = 1 or b = 1)", []],        SQLPrepared.where("a = 1 or b = 1")
     assert_equal ["where (a = 1 or b = 1) and c = ?", [2]], SQLPrepared.where("a = 1 or b = 1", :c => 2)
@@ -156,25 +153,25 @@ class TestSQL < Test::Unit::TestCase
     assert_equal ["where c = ? and (a = 1 or b = 1) and (e = 2) and f = ? and (abc not like % || ? || % or def != ?) and (1 = 1)", [2, 3, 'abc', 100]],
         SQLPrepared.where({:c => 2}, "a = 1 or b = 1", nil, "", "e = 2", nil, {:f => 3}, {},
                   ["abc not like % || ? || % or def != ?", 'abc', 100], [], ['1 = 1'])
-    assert_equal [nil, []], SQLPrepared.where(nil)
-    assert_equal [nil, []], SQLPrepared.where(" ")
+    assert_equal ['', []], SQLPrepared.where(nil)
+    assert_equal ['', []], SQLPrepared.where(" ")
 
     # 0.7.0: with where
-    assert_equal ["where a > ?", [1]],        SQLPrepared.where(:a => SQL.gt(1))
-    assert_equal ["where a < ?", ['z']],      SQLPrepared.where(:a => SQL.lt('z'))
-    assert_equal ["where a >= sysdate", []], SQLPrepared.where(:a => SQL.ge(SQL.expr 'sysdate'))
-    assert_equal ["where a <= sysdate", []], SQLPrepared.where(:a => SQL.le(SQL.expr 'sysdate'))
-    assert_equal ["where a like ?", ["hello'%"]], SQLPrepared.where(:a => SQL.like("hello'%"))
-    assert_equal ["where a not like ?", ["hello'%"]], SQLPrepared.where(:a => SQL.not_like("hello'%"))
+    assert_equal ["where a > ?", [1]],                SQLPrepared.where(:a => SQL.gt(1))
+    assert_equal ["where a < ?", ['z']],              SQLPrepared.where(:a => SQL.lt('z'))
+    assert_equal ["where a >= sysdate", []],          SQLPrepared.where(:a => SQL.ge(SQL.expr 'sysdate'))
+    assert_equal ["where a <= sysdate", []],          SQLPrepared.where(:a => SQL.le(SQL.expr 'sysdate'))
+    assert_equal ["where a like ?", ["hello'%"]],     SQLPrepared.where(:a => SQL.like("hello'%"))
+    assert_equal ["where not (a like ?)", ["hello'%"]], SQLPrepared.where(:a => SQL.not_like("hello'%"))
   end
 
   def test_select
     assert_equal "select * from a.b", SQL.select('a.b')
     assert_equal "select aa, bb from a.b where a is not null",
         SQL.select('a.b', :select => %w[aa bb], :where => {:a => SQL.not_nil})
-    assert_equal "select aa, bb from a.b where a is not null and b >= 1 and b <= 10 order by cc, dd", 
+    assert_equal "select aa, bb from a.b where a is not null and b between 1 and 10 order by cc, dd",
         SQL.select('a.b',
-               :select => %w[aa bb], 
+               :select => %w[aa bb],
                :where => {:a => SQL.not_null, :b => (1..10)},
                :order => %w[cc dd]
               )
@@ -197,10 +194,10 @@ class TestSQL < Test::Unit::TestCase
   end
 
   def test_update
-    assert_equal "update a.b set a = 1, b = 'A''s', c = now()", 
+    assert_equal "update a.b set a = 1, b = 'A''s', c = now()",
       SQL.update('a.b', {:a => 1, :b => "A's", :c => SQL.expr('now()')}, {})
 
-    assert_equal "update a.b set a = 1, b = 'A''s', c = now() where a is not null", 
+    assert_equal "update a.b set a = 1, b = 'A''s', c = now() where a is not null",
       SQL.update('a.b', {:a => 1, :b => "A's", :c => SQL.expr('now()')}, { :a => SQL.not_nil })
 
     assert_equal ["update a.b set a = ?, b = ?, c = now()", [1, "A's"]],
@@ -222,12 +219,12 @@ class TestSQL < Test::Unit::TestCase
 
   def test_sql_expression_equality
     # Backward-compatibility
-    assert_equal "a = b", JDBCHelper.SQL('a = b').to_s
+    # assert_equal "a = b", JDBCHelper.SQL('a = b').to_s
     assert_equal JDBCHelper.SQL('a = b'), JDBCHelper.SQL('a = b')
 
     # type conversion across ==, but not across eql (TODO TBD)
     assert JDBCHelper.SQL('a = b') == (JDBCHelper.SQL('a = b'))
-    assert JDBCHelper.SQL('a = b') == 'a = b'
+    # assert JDBCHelper.SQL('a = b') == 'a = b'
     assert       JDBCHelper.SQL('a = b').eql?(JDBCHelper.SQL('a = b'))
     assert_equal JDBCHelper.SQL('a = b').hash, JDBCHelper.SQL('a = b').hash
     assert_false JDBCHelper.SQL('a = b').eql?('a = b')
@@ -235,7 +232,7 @@ class TestSQL < Test::Unit::TestCase
     assert JDBCHelper.SQL('a = b') != JDBCHelper.SQL('a = c')
 
     h = {}
-    h[SQL.expr 'a = b'] = 1 
+    h[SQL.expr 'a = b'] = 1
     h[SQL.expr 'a = b'] = 2
     assert_equal 1, h.keys.length
     assert_equal 2, h[SQL.expr 'a = b']

metadata

@@ -2,46 +2,60 @@
 name: jdbc-helper
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.7.7
+  version: 0.8.0
 platform: ruby
 authors:
 - Junegunn Choi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-01-14 00:00:00.000000000 Z
+date: 2013-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: insensitive_hash
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.2.4
     none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.2.4
     none: false
   prerelease: false
   type: :runtime
+- !ruby/object:Gem::Dependency
+  name: sql_helper
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+    none: false
+  prerelease: false
+  type: :runtime
 - !ruby/object:Gem::Dependency
   name: bundler
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
+        version: '0'
     none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
+        version: '0'
     none: false
   prerelease: false
   type: :development
@@ -49,17 +63,15 @@ dependencies:
   name: simplecov
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
+        version: '0'
     none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
+        version: '0'
     none: false
   prerelease: false
   type: :development
@@ -67,17 +79,15 @@ dependencies:
   name: test-unit
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
+        version: '0'
     none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
+        version: '0'
     none: false
   prerelease: false
   type: :development
@@ -89,10 +99,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
-- CHANGELOG.markdown
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
-- README.markdown
+- README.md
 - Rakefile
 - VERSION
 - jdbc-helper.gemspec
@@ -101,17 +111,19 @@ files:
 - lib/jdbc-helper/connection/callable_statement.rb
 - lib/jdbc-helper/connection/parameterized_statement.rb
 - lib/jdbc-helper/connection/prepared_statement.rb
-- lib/jdbc-helper/connection/result_set_enumerator.rb
+- lib/jdbc-helper/connection/result_set.rb
 - lib/jdbc-helper/connection/row.rb
 - lib/jdbc-helper/connection/statement_pool.rb
 - lib/jdbc-helper/connection/type_map.rb
 - lib/jdbc-helper/connector.rb
 - lib/jdbc-helper/connector/cassandra.rb
 - lib/jdbc-helper/connector/filemaker.rb
+- lib/jdbc-helper/connector/mariadb.rb
 - lib/jdbc-helper/connector/mssql.rb
 - lib/jdbc-helper/connector/mysql.rb
 - lib/jdbc-helper/connector/oracle.rb
 - lib/jdbc-helper/connector/postgresql.rb
+- lib/jdbc-helper/connector/sqlite.rb
 - lib/jdbc-helper/constants.rb
 - lib/jdbc-helper/sql.rb
 - lib/jdbc-helper/sql/expression.rb
@@ -129,6 +141,7 @@ files:
 - test/test_connection.rb
 - test/test_connectors.rb
 - test/test_object_wrapper.rb
+- test/test_object_wrapper_0.7.rb
 - test/test_sql.rb
 - test/testrb
 homepage: https://github.com/junegunn/jdbc-helper
@@ -139,17 +152,15 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
-      version: !binary |-
-        MA==
+      version: '0'
   none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
-      version: !binary |-
-        MA==
+      version: '0'
   none: false
 requirements: []
 rubyforge_project:
@@ -164,5 +175,6 @@ test_files:
 - test/test_connection.rb
 - test/test_connectors.rb
 - test/test_object_wrapper.rb
+- test/test_object_wrapper_0.7.rb
 - test/test_sql.rb
 - test/testrb