sequel 3.29.0 → 3.30.0

data/lib/sequel/adapters/jdbc/as400.rb

@@ -39,6 +39,9 @@ module Sequel
       # Dataset class for AS400 datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         WILDCARD = Sequel::LiteralString.new('*').freeze
+        FETCH_FIRST_ROW_ONLY = " FETCH FIRST ROW ONLY".freeze
+        FETCH_FIRST = " FETCH FIRST ".freeze
+        ROWS_ONLY = " ROWS ONLY".freeze
         
         # AS400 needs to use a couple of subselects for queries with offsets.
         def select_sql
@@ -60,9 +63,14 @@ module Sequel
 
         # Modify the sql to limit the number of rows returned
         def select_limit_sql(sql)
-          if @opts[:limit]
-            sql << " FETCH FIRST ROW ONLY" if @opts[:limit] == 1
-            sql << " FETCH FIRST #{@opts[:limit]} ROWS ONLY" if @opts[:limit] > 1
+          if l = @opts[:limit]
+            if l == 1
+              sql << FETCH_FIRST_ROW_ONLY
+            elsif l > 1
+              sql << FETCH_FIRST
+              literal_append(sql, l)
+              sql << ROWS_ONLY
+            end
           end
         end
           

data/lib/sequel/adapters/jdbc/db2.rb

@@ -18,6 +18,7 @@ module Sequel
       module DatabaseMethods
         include Sequel::DB2::DatabaseMethods
         include Sequel::JDBC::Transactions
+        IDENTITY_VAL_LOCAL = "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1".freeze
         
         %w'schema_parse_table tables views indexes'.each do |s|
           class_eval("def #{s}(*a) jdbc_#{s}(*a) end", __FILE__, __LINE__)
@@ -27,7 +28,7 @@ module Sequel
         
         def last_insert_id(conn, opts={})
           statement(conn) do |stmt|
-            sql = "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1"
+            sql = IDENTITY_VAL_LOCAL
             rs = log_yield(sql){stmt.executeQuery(sql)}
             rs.next
             rs.getInt(1)

data/lib/sequel/adapters/jdbc/derby.rb

@@ -104,17 +104,31 @@ module Sequel
       
       # Dataset class for Derby datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
+        PAREN_CLOSE = Dataset::PAREN_CLOSE
+        PAREN_OPEN = Dataset::PAREN_OPEN
+        OFFSET = Dataset::OFFSET
+        CAST_STRING_OPEN = "RTRIM(".freeze
+        BITCOMP_OPEN = "((0 - ".freeze
+        BITCOMP_CLOSE = ") - 1)".freeze
+        BLOB_OPEN = "CAST(X'".freeze
+        BLOB_CLOSE = "' AS BLOB)".freeze
+        HSTAR = "H*".freeze
+        TIME_FORMAT = "'%H:%M:%S'".freeze
+        DEFAULT_FROM = " FROM sysibm.sysdummy1".freeze
+        ROWS = " ROWS".freeze
+        FETCH_FIRST = " FETCH FIRST ".freeze
+        ROWS_ONLY = " ROWS ONLY".freeze
         BOOL_TRUE = '(1 = 1)'.freeze
         BOOL_FALSE = '(1 = 0)'.freeze
-        SELECT_CLAUSE_METHODS = clause_methods(:select, %w'distinct columns from join where group having compounds order limit lock')
+        SELECT_CLAUSE_METHODS = clause_methods(:select, %w'select distinct columns from join where group having compounds order limit lock')
 
         # Derby doesn't support an expression between CASE and WHEN,
         # so emulate it by using an equality statement for all of the
         # conditions.
-        def case_expression_sql(ce)
+        def case_expression_sql_append(sql, ce)
           if ce.expression?
             e = ce.expression
-            literal(::Sequel::SQL::CaseExpression.new(ce.conditions.map{|c, r| [::Sequel::SQL::BooleanExpression.new(:'=', e, c), r]}, ce.default))
+            case_expression_sql_append(sql, ::Sequel::SQL::CaseExpression.new(ce.conditions.map{|c, r| [::Sequel::SQL::BooleanExpression.new(:'=', e, c), r]}, ce.default))
           else
             super
           end
@@ -123,27 +137,33 @@ module Sequel
         # If the type is String, trim the extra spaces since CHAR is used instead
         # of varchar.  This can cause problems if you are casting a char/varchar to
         # a string and the ending whitespace is important.
-        def cast_sql(expr, type)
+        def cast_sql_append(sql, expr, type)
           if type == String
-            "RTRIM(#{super})"
+            sql << CAST_STRING_OPEN
+            super
+            sql << PAREN_CLOSE
           else
             super
           end
         end
 
         # Handle Derby specific LIKE, extract, and some bitwise compliment support.
-        def complex_expression_sql(op, args)
+        def complex_expression_sql_append(sql, op, args)
           case op
           when :ILIKE
-            super(:LIKE, [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1)) ])
+            super(sql, :LIKE, [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1))])
           when :"NOT ILIKE"
-            super(:"NOT LIKE", [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1)) ])
+            super(sql, :"NOT LIKE", [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1))])
           when :&, :|, :^, :<<, :>>
             raise Error, "Derby doesn't support the #{op} operator"
           when :'B~'
-            "((0 - #{literal(args.at(0))}) - 1)"
+            sql << BITCOMP_OPEN
+            literal_append(sql, args.at(0))
+            sql << BITCOMP_CLOSE
           when :extract
-            "#{args.at(0)}(#{literal(args.at(1))})"
+            sql << args.at(0).to_s << PAREN_OPEN
+            literal_append(sql, args.at(1))
+            sql << PAREN_CLOSE
           else
             super
           end
@@ -162,11 +182,8 @@ module Sequel
         private
 
         # Derby needs a hex string casted to BLOB for blobs.
-        def literal_blob(v)
-          blob = "CAST(X'"
-          v.each_byte{|x| blob << sprintf('%02x', x)}
-          blob << "' AS BLOB)"
-          blob
+        def literal_blob_append(sql, v)
+          sql << BLOB_OPEN << v.unpack(HSTAR).first << BLOB_CLOSE
         end
 
         # Derby needs the standard workaround to insert all default values into
@@ -183,7 +200,7 @@ module Sequel
 
         # Derby handles fractional seconds in timestamps, but not in times
         def literal_sqltime(v)
-          v.strftime("'%H:%M:%S'")
+          v.strftime(TIME_FORMAT)
         end
 
         # Derby uses an expression yielding true for true values.
@@ -202,14 +219,22 @@ module Sequel
           if @opts[:from]
             super
           else
-            sql << " FROM sysibm.sysdummy1"
+            sql << DEFAULT_FROM
           end
         end
 
         # Offset comes before limit in Derby
         def select_limit_sql(sql)
-          sql << " OFFSET #{literal(@opts[:offset])} ROWS" if @opts[:offset]
-          sql << " FETCH FIRST #{literal(@opts[:limit])} ROWS ONLY" if @opts[:limit]
+          if o = @opts[:offset]
+            sql << OFFSET
+            literal_append(sql, o)
+            sql << ROWS
+          end
+          if l = @opts[:limit]
+            sql << FETCH_FIRST
+            literal_append(sql, l)
+            sql << ROWS_ONLY
+          end
         end
       end
     end

data/lib/sequel/adapters/jdbc/h2.rb

@@ -104,26 +104,32 @@ module Sequel
       
       # Dataset class for H2 datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
-        SELECT_CLAUSE_METHODS = clause_methods(:select, %w'distinct columns from join where group having compounds order limit')
+        SELECT_CLAUSE_METHODS = clause_methods(:select, %w'select distinct columns from join where group having compounds order limit')
         BITWISE_METHOD_MAP = {:& =>:BITAND, :| => :BITOR, :^ => :BITXOR}
+        APOS = Dataset::APOS
+        HSTAR = "H*".freeze
+        BITCOMP_OPEN = "((0 - ".freeze
+        BITCOMP_CLOSE = ") - 1)".freeze
+        ILIKE_PLACEHOLDER = "CAST(? AS VARCHAR_IGNORECASE)".freeze
+        TIME_FORMAT = "'%H:%M:%S'".freeze
         
         # Emulate the case insensitive LIKE operator and the bitwise operators.
-        def complex_expression_sql(op, args)
+        def complex_expression_sql_append(sql, op, args)
           case op
-          when :ILIKE
-            super(:LIKE, [SQL::PlaceholderLiteralString.new("CAST(? AS VARCHAR_IGNORECASE)", [args.at(0)]), args.at(1)])
-          when :"NOT ILIKE"
-            super(:"NOT LIKE", [SQL::PlaceholderLiteralString.new("CAST(? AS VARCHAR_IGNORECASE)", [args.at(0)]), args.at(1)])
+          when :ILIKE, :"NOT ILIKE"
+            super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), [SQL::PlaceholderLiteralString.new(ILIKE_PLACEHOLDER, [args.at(0)]), args.at(1)])
           when :&, :|, :^
-            complex_expression_arg_pairs(args){|a, b| literal(SQL::Function.new(BITWISE_METHOD_MAP[op], a, b))}
+            sql << complex_expression_arg_pairs(args){|a, b| literal(SQL::Function.new(BITWISE_METHOD_MAP[op], a, b))}
           when :<<
-            complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
+            sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
           when :>>
-            complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
+            sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
           when :'B~'
-            "((0 - #{literal(args.at(0))}) - 1)"
+            sql << BITCOMP_OPEN
+            literal_append(sql, args.at(0))
+            sql << BITCOMP_CLOSE
           else
-            super(op, args)
+            super
           end
         end
         
@@ -148,25 +154,32 @@ module Sequel
         end 
 
         private
+
+        #JAVA_H2_CLOB = Java::OrgH2Jdbc::JdbcClob
+
+        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
+          def h2_clob(v) Sequel::SQL::Blob.new(v.getSubString(1, v.length)) end
+        end
+
+        H2_CLOB_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:h2_clob)
       
         # Handle H2 specific clobs as strings.
-        def convert_type(v)
-          case v
-          when Java::OrgH2Jdbc::JdbcClob
-            convert_type(v.getSubString(1, v.length))
+        def convert_type_proc(v)
+          if v.is_a?(Java::OrgH2Jdbc::JdbcClob)
+            H2_CLOB_METHOD
           else
-            super(v)
+            super
           end
         end
         
         # H2 expects hexadecimal strings for blob values
-        def literal_blob(v)
-          literal_string v.unpack("H*").first
+        def literal_blob_append(sql, v)
+          sql << APOS << v.unpack(HSTAR).first << APOS
         end
         
         # H2 handles fractional seconds in timestamps, but not in times
         def literal_sqltime(v)
-          v.strftime("'%H:%M:%S'")
+          v.strftime(TIME_FORMAT)
         end
 
         def select_clause_methods

data/lib/sequel/adapters/jdbc/hsqldb.rb

@@ -83,25 +83,32 @@ module Sequel
         # CTEs in earlier queries might take precedence over CTEs with the same name in later queries.
         # Also, if any CTE is recursive, all CTEs must be recursive.
         # If you want to use CTEs with HSQLDB, you'll have to manually modify the dataset to allow it.
-        SELECT_CLAUSE_METHODS = clause_methods(:select, %w'distinct columns from join where group having compounds order limit lock')
+        SELECT_CLAUSE_METHODS = clause_methods(:select, %w'select distinct columns from join where group having compounds order limit lock')
         SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
+        APOS = Dataset::APOS
+        HSTAR = "H*".freeze
+        BLOB_OPEN = "X'".freeze
+        BITCOMP_OPEN = "((0 - ".freeze
+        BITCOMP_CLOSE = ") - 1)".freeze
+        DEFAULT_FROM = " FROM (VALUES (0))".freeze
+        TIME_FORMAT = "'%H:%M:%S'".freeze
 
         # Handle HSQLDB specific case insensitive LIKE and bitwise operator support.
-        def complex_expression_sql(op, args)
+        def complex_expression_sql_append(sql, op, args)
           case op
-          when :ILIKE
-            super(:LIKE, [SQL::Function.new(:ucase, args.at(0)), SQL::Function.new(:ucase, args.at(1)) ])
-          when :"NOT ILIKE"
-            super(:"NOT LIKE", [SQL::Function.new(:ucase, args.at(0)), SQL::Function.new(:ucase, args.at(1)) ])
+          when :ILIKE, :"NOT ILIKE"
+            super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), [SQL::Function.new(:ucase, args.at(0)), SQL::Function.new(:ucase, args.at(1)) ])
           when :&, :|, :^
             op = BITWISE_METHOD_MAP[op]
-            complex_expression_arg_pairs(args){|a, b| literal(SQL::Function.new(op, a, b))}
+            sql << complex_expression_arg_pairs(args){|a, b| literal(SQL::Function.new(op, a, b))}
           when :<<
-            complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
+            sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
           when :>>
-            complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
+            sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
           when :'B~'
-            "((0 - #{literal(args.at(0))}) - 1)"
+            sql << BITCOMP_OPEN
+            literal_append(sql, args.at(0))
+            sql << BITCOMP_CLOSE
           else
             super
           end
@@ -120,11 +127,8 @@ module Sequel
         private
 
         # Use string in hex format for blob data.
-        def literal_blob(v)
-          blob = "X'"
-          v.each_byte{|x| blob << sprintf('%02x', x)}
-          blob << "'"
-          blob
+        def literal_blob_append(sql, v)
+          sql << BLOB_OPEN << v.unpack(HSTAR).first << APOS
         end
 
         # HSQLDB uses FALSE for false values.
@@ -134,7 +138,7 @@ module Sequel
 
         # HSQLDB handles fractional seconds in timestamps, but not in times
         def literal_sqltime(v)
-          v.strftime("'%H:%M:%S'")
+          v.strftime(TIME_FORMAT)
         end
 
         # HSQLDB uses TRUE for true values.
@@ -152,7 +156,7 @@ module Sequel
           if @opts[:from]
             super
           else
-            sql << " FROM (VALUES (0))"
+            sql << DEFAULT_FROM
           end
         end
         

data/lib/sequel/adapters/jdbc/jtds.rb

@@ -14,11 +14,16 @@ module Sequel
       class Dataset < JDBC::Dataset
         include Sequel::MSSQL::DatasetMethods
 
+        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
+          def jtds_clob(v) Sequel::SQL::Blob.new(v.getSubString(1, v.length)) end
+        end
+
+        JTDS_CLOB_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:jtds_clob)
+      
         # Handle CLOB types retrieved via JTDS.
-        def convert_type(v)
-          case v
-          when Java::NetSourceforgeJtdsJdbc::ClobImpl
-            convert_type(v.getSubString(1, v.length))
+        def convert_type_proc(v)
+          if v.is_a?(Java::NetSourceforgeJtdsJdbc::ClobImpl)
+            JTDS_CLOB_METHOD
           else
             super
           end

data/lib/sequel/adapters/jdbc/mssql.rb

@@ -13,6 +13,8 @@ module Sequel
       # Database instance methods for MSSQL databases accessed via JDBC.
       module DatabaseMethods
         PRIMARY_KEY_INDEX_RE = /\Apk__/i.freeze
+        ATAT_IDENTITY = 'SELECT @@IDENTITY'.freeze
+        SCOPE_IDENTITY = 'SELECT SCOPE_IDENTITY()'.freeze
         
         include Sequel::MSSQL::DatabaseMethods
         
@@ -21,7 +23,7 @@ module Sequel
         # Get the last inserted id using SCOPE_IDENTITY().
         def last_insert_id(conn, opts={})
           statement(conn) do |stmt|
-            sql = opts[:prepared] ? 'SELECT @@IDENTITY' : 'SELECT SCOPE_IDENTITY()'
+            sql = opts[:prepared] ? ATAT_IDENTITY : SCOPE_IDENTITY
             rs = log_yield(sql){stmt.executeQuery(sql)}
             rs.next
             rs.getInt(1)

data/lib/sequel/adapters/jdbc/mysql.rb

@@ -8,6 +8,7 @@ module Sequel
       # Database instance methods for MySQL databases accessed via JDBC.
       module DatabaseMethods
         include Sequel::MySQL::DatabaseMethods
+        LAST_INSERT_ID = 'SELECT LAST_INSERT_ID()'.freeze
         
         private
         
@@ -34,7 +35,7 @@ module Sequel
             end
           else
             statement(conn) do |stmt|
-              rs = stmt.executeQuery('SELECT LAST_INSERT_ID()')
+              rs = stmt.executeQuery(LAST_INSERT_ID)
               rs.next
               rs.getInt(1)
             end

data/lib/sequel/adapters/jdbc/oracle.rb

@@ -67,21 +67,35 @@ module Sequel
 
         private
 
-        def convert_type(v)
-          case v
-          when Java::JavaMath::BigDecimal
+        JAVA_BIG_DECIMAL = ::Sequel::JDBC::Dataset::JAVA_BIG_DECIMAL
+
+        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
+          def oracle_decimal(v)
             if v.scale == 0
               i = v.long_value
-              if v.equals(Java::JavaMath::BigDecimal.new(i))
+              if v.equals(JAVA_BIG_DECIMAL.new(i))
                 i
               else
-                super
+                decimal(v)
               end
             else
-              super
+              decimal(v)
             end
+          end
+        end
+
+        ORACLE_DECIMAL_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:oracle_decimal)
+
+        def convert_type_oracle_timestamp(v)
+          db.to_application_timestamp(v.to_string)
+        end
+      
+        def convert_type_proc(v)
+          case v
+          when JAVA_BIG_DECIMAL
+            ORACLE_DECIMAL_METHOD
           when Java::OracleSql::TIMESTAMP
-            db.to_application_timestamp(v.to_string)
+            method(:convert_type_oracle_timestamp)
           else
             super
           end

data/lib/sequel/adapters/jdbc/postgresql.rb

@@ -73,6 +73,7 @@ module Sequel
       # Dataset subclass used for datasets that connect to PostgreSQL via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::Postgres::DatasetMethods
+        APOS = Dataset::APOS
 
         # Add the shared PostgreSQL prepared statement methods
         def prepare(*args)
@@ -82,8 +83,8 @@ module Sequel
         end
         
         # Literalize strings similar to the native postgres adapter
-        def literal_string(v)
-          db.synchronize{|c| "'#{c.escape_string(v)}'"}
+        def literal_string_append(sql, v)
+          sql << APOS << db.synchronize{|c| c.escape_string(v)} << APOS
         end
       end
     end

data/lib/sequel/adapters/jdbc/sqlite.rb

@@ -7,13 +7,14 @@ module Sequel
       # Instance methods for SQLite Database objects accessed via JDBC.
       module DatabaseMethods
         include Sequel::SQLite::DatabaseMethods
+        LAST_INSERT_ROWID = 'SELECT last_insert_rowid()'.freeze
         
         private
         
         # Use last_insert_rowid() to get the last inserted id.
         def last_insert_id(conn, opts={})
           statement(conn) do |stmt|
-            rs = stmt.executeQuery('SELECT last_insert_rowid()')
+            rs = stmt.executeQuery(LAST_INSERT_ROWID)
             rs.next
             rs.getInt(1)
           end