sequel 4.9.0 → 4.10.0

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

@@ -3,6 +3,16 @@ Sequel.require 'adapters/jdbc/transactions'
 
 module Sequel
   module JDBC
+    class TypeConvertor
+      def DB2Clob(r, i)
+        if v = r.getClob(i)
+          v = v.getSubString(1, v.length)
+          v = Sequel::SQL::Blob.new(v) if ::Sequel::DB2::use_clob_as_blob
+          v
+        end
+      end
+    end
+
     class Database
       # Alias the generic JDBC versions so they can be called directly later
       alias jdbc_schema_parse_table schema_parse_table
@@ -55,28 +65,17 @@ module Sequel
         def primary_key_index_re
           PRIMARY_KEY_INDEX_RE
         end
+
+        def setup_type_convertor_map
+          super
+          map = @type_convertor_map
+          types = Java::JavaSQL::Types
+          map[types::NCLOB] = map[types::CLOB] = TypeConvertor::INSTANCE.method(:DB2Clob)
+        end
       end
 
       class Dataset < JDBC::Dataset
         include Sequel::DB2::DatasetMethods
-
-        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
-          def db2_clob(v) Sequel::SQL::Blob.new(v.getSubString(1, v.length)) end
-        end
-
-        DB2_CLOB_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:db2_clob)
-      
-        private
-
-        # Return clob as blob if use_clob_as_blob is true
-        def convert_type_proc(v, ctn=nil)
-          case v
-          when JAVA_SQL_CLOB
-            ::Sequel::DB2::use_clob_as_blob ? DB2_CLOB_METHOD : super
-          else
-            super
-          end
-        end
       end
     end
   end

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

@@ -185,7 +185,6 @@ module Sequel
         BOOL_FALSE_OLD = '(1 = 0)'.freeze
         BOOL_TRUE = 'TRUE'.freeze
         BOOL_FALSE = 'FALSE'.freeze
-        SELECT_CLAUSE_METHODS = clause_methods(:select, %w'select distinct columns from join where group having compounds order limit lock')
         EMULATED_FUNCTION_MAP = {:char_length=>'length'.freeze}
 
         # Derby doesn't support an expression between CASE and WHEN,
@@ -240,23 +239,10 @@ module Sequel
 
         private
 
-        JAVA_SQL_CLOB         = Java::JavaSQL::Clob
-
-        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
-          def derby_clob(v) v.getSubString(1, v.length) end
+        def empty_from_sql
+          DEFAULT_FROM
         end
 
-        DERBY_CLOB_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:derby_clob)
-      
-        # Handle clobs on Derby as strings.
-        def convert_type_proc(v, ctn=nil)
-          if v.is_a?(JAVA_SQL_CLOB)
-            DERBY_CLOB_METHOD
-          else
-            super
-          end
-        end
-        
         # Derby needs a hex string casted to BLOB for blobs.
         def literal_blob_append(sql, v)
           sql << BLOB_OPEN << v.unpack(HSTAR).first << BLOB_CLOSE
@@ -293,18 +279,9 @@ module Sequel
           end
         end
 
-        # Derby doesn't support common table expressions.
-        def select_clause_methods
-          SELECT_CLAUSE_METHODS
-        end
-
-        # Use a default FROM table if the dataset does not contain a FROM table.
-        def select_from_sql(sql)
-          if @opts[:from]
-            super
-          else
-            sql << DEFAULT_FROM
-          end
+        # Derby supports multiple rows in INSERT.
+        def multi_insert_sql_strategy
+          :values
         end
 
         # Offset comes before limit in Derby

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

@@ -49,7 +49,7 @@ module Sequel
         # If the :prepare option is given and we aren't in a savepoint,
         # prepare the transaction for a two-phase commit.
         def commit_transaction(conn, opts=OPTS)
-          if (s = opts[:prepare]) && _trans(conn)[:savepoint_level] <= 1
+          if (s = opts[:prepare]) && savepoint_level(conn) <= 1
             log_connection_execute(conn, "PREPARE COMMIT #{s}")
           else
             super
@@ -142,12 +142,12 @@ module Sequel
       
       # Dataset class for H2 datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
-        SELECT_CLAUSE_METHODS = clause_methods(:select, %w'select distinct columns from join where group having compounds order limit')
         APOS = Dataset::APOS
         HSTAR = "H*".freeze
         ILIKE_PLACEHOLDER = ["CAST(".freeze, " AS VARCHAR_IGNORECASE)".freeze].freeze
         TIME_FORMAT = "'%H:%M:%S'".freeze
-        
+        ONLY_OFFSET = " LIMIT -1 OFFSET ".freeze
+
         # Emulate the case insensitive LIKE operator and the bitwise operators.
         def complex_expression_sql_append(sql, op, args)
           case op
@@ -182,23 +182,6 @@ module Sequel
 
         private
 
-        #JAVA_H2_CLOB = Java::OrgH2Jdbc::JdbcClob
-
-        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
-          def h2_clob(v) 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_proc(v, ctn=nil)
-          if v.is_a?(Java::OrgH2Jdbc::JdbcClob)
-            H2_CLOB_METHOD
-          else
-            super
-          end
-        end
-        
         # H2 expects hexadecimal strings for blob values
         def literal_blob_append(sql, v)
           sql << APOS << v.unpack(HSTAR).first << APOS
@@ -209,8 +192,14 @@ module Sequel
           v.strftime(TIME_FORMAT)
         end
 
-        def select_clause_methods
-          SELECT_CLAUSE_METHODS
+        # H2 supports multiple rows in INSERT.
+        def multi_insert_sql_strategy
+          :values
+        end
+
+        def select_only_offset_sql(sql)
+          sql << ONLY_OFFSET
+          literal_append(sql, @opts[:offset])
         end
 
         # H2 supports quoted function names.

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

@@ -32,6 +32,11 @@ module Sequel
           end
         end
         
+        # HSQLDB supports DROP TABLE IF EXISTS
+        def supports_drop_table_if_exists?
+          true
+        end
+
         private
         
         # HSQLDB specific SQL for renaming columns, and changing column types and/or nullity.
@@ -71,6 +76,16 @@ module Sequel
           DATABASE_ERROR_REGEXPS
         end
 
+        # IF EXISTS comes after table name on HSQLDB
+        def drop_table_sql(name, options)
+          "DROP TABLE #{quote_schema_table(name)}#{' IF EXISTS' if options[:if_exists]}#{' CASCADE' if options[:cascade]}"
+        end
+        
+        # IF EXISTS comes after view name on HSQLDB
+        def drop_view_sql(name, options)
+          "DROP VIEW #{quote_schema_table(name)}#{' IF EXISTS' if options[:if_exists]}#{' CASCADE' if options[:cascade]}"
+        end
+
         # Use IDENTITY() to get the last inserted id.
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
@@ -113,12 +128,6 @@ module Sequel
       class Dataset < JDBC::Dataset
         BOOL_TRUE = 'TRUE'.freeze
         BOOL_FALSE = 'FALSE'.freeze
-        # HSQLDB does support common table expressions, but the support is broken.
-        # CTEs operate more like temprorary tables or views, lasting longer than the duration of the expression.
-        # 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'select distinct columns from join where group having compounds order limit lock')
         SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
         APOS = Dataset::APOS
         HSTAR = "H*".freeze
@@ -148,6 +157,15 @@ module Sequel
           true
         end
 
+        # HSQLDB does support common table expressions, but the support is broken.
+        # CTEs operate more like temprorary tables or views, lasting longer than the duration of the expression.
+        # 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.
+        def supports_cte?(type=:select)
+          false
+        end
+
         # HSQLDB does not support IS TRUE.
         def supports_is_true?
           false
@@ -160,6 +178,10 @@ module Sequel
 
         private
 
+        def empty_from_sql
+          DEFAULT_FROM
+        end
+        
         # Use string in hex format for blob data.
         def literal_blob_append(sql, v)
           sql << BLOB_OPEN << v.unpack(HSTAR).first << APOS
@@ -180,20 +202,11 @@ module Sequel
           BOOL_TRUE
         end
 
-        # HSQLDB does not support CTEs well enough for Sequel to enable support for them.
-        def select_clause_methods
-          SELECT_CLAUSE_METHODS
+        # HSQLDB supports multiple rows in INSERT.
+        def multi_insert_sql_strategy
+          :values
         end
 
-        # Use a default FROM table if the dataset does not contain a FROM table.
-        def select_from_sql(sql)
-          if @opts[:from]
-            super
-          else
-            sql << DEFAULT_FROM
-          end
-        end
-        
         # Use WITH RECURSIVE instead of WITH if any of the CTEs is recursive
         def select_with_sql_base
           opts[:with].any?{|w| w[:recursive]} ? SQL_WITH_RECURSIVE : super

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

@@ -25,21 +25,6 @@ module Sequel
       # Dataset class for JTDS datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::MSSQL::DatasetMethods
-
-        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
-          def jtds_clob(v) 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_proc(v, ctn=nil)
-          if v.is_a?(Java::NetSourceforgeJtdsJdbc::ClobImpl)
-            JTDS_CLOB_METHOD
-          else
-            super
-          end
-        end
       end
     end
   end

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

@@ -3,6 +3,21 @@ Sequel.require 'adapters/jdbc/transactions'
 
 module Sequel
   module JDBC
+    class TypeConvertor
+      JAVA_BIG_DECIMAL_CONSTRUCTOR = java.math.BigDecimal.java_class.constructor(Java::long).method(:new_instance)
+
+      def OracleDecimal(r, i)
+        if v = r.getBigDecimal(i)
+          i = v.long_value
+          if v == JAVA_BIG_DECIMAL_CONSTRUCTOR.call(i)
+            i
+          else
+            BigDecimal.new(v.to_string)
+          end
+        end
+      end 
+    end
+
     # Database and Dataset support for Oracle databases accessed via JDBC.
     module Oracle
       # Instance methods for Oracle Database objects accessed via JDBC.
@@ -31,6 +46,11 @@ module Sequel
           super || exception.message =~ /\AClosed Connection/
         end
 
+        # Default the fetch size for statements to 100, similar to the oci8-based oracle adapter.
+        def default_fetch_size
+          100
+        end
+        
         def last_insert_id(conn, opts)
           unless sequence = opts[:sequence]
             if t = opts[:table]
@@ -76,50 +96,31 @@ module Sequel
         def supports_releasing_savepoints?
           false
         end
+
+        def setup_type_convertor_map
+          super
+          @type_convertor_map[:OracleDecimal] = TypeConvertor::INSTANCE.method(:OracleDecimal)
+        end
       end
       
       # Dataset class for Oracle datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::Oracle::DatasetMethods
 
-        private
+        NUMERIC_TYPE = Java::JavaSQL::Types::NUMERIC
+        TIMESTAMP_TYPE = Java::JavaSQL::Types::TIMESTAMP
+        TIMESTAMPTZ_TYPES = [Java::oracle.jdbc.OracleTypes::TIMESTAMPTZ, Java::oracle.jdbc.OracleTypes::TIMESTAMPLTZ]
 
-        JAVA_BIG_DECIMAL = ::Sequel::JDBC::Dataset::JAVA_BIG_DECIMAL
-        JAVA_BIG_DECIMAL_CONSTRUCTOR = java.math.BigDecimal.java_class.constructor(Java::long).method(:new_instance)
-
-        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
-          def oracle_decimal(v)
-            if v.scale == 0
-              i = v.long_value
-              if v.equals(JAVA_BIG_DECIMAL_CONSTRUCTOR.call(i))
-                i
-              else
-                decimal(v)
-              end
+        def type_convertor(map, meta, type, i)
+          case type
+          when NUMERIC_TYPE
+            if meta.getScale(i) == 0
+              map[:OracleDecimal]
             else
-              decimal(v)
+              super
             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_oracle_timestamptz(v)
-          convert_type_oracle_timestamp(db.synchronize(@opts[:server]){|c| v.timestampValue(c)})
-        end
-      
-        def convert_type_proc(v, ctn=nil)
-          case v
-          when JAVA_BIG_DECIMAL
-            ORACLE_DECIMAL_METHOD
-          when Java::OracleSql::TIMESTAMPTZ
-            method(:convert_type_oracle_timestamptz)
-          when Java::OracleSql::TIMESTAMP
-            method(:convert_type_oracle_timestamp)
+          when *TIMESTAMPTZ_TYPES
+            map[TIMESTAMP_TYPE]
           else
             super
           end

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

@@ -4,6 +4,26 @@ module Sequel
   Postgres::CONVERTED_EXCEPTIONS << NativeException
   
   module JDBC
+    class TypeConvertor
+      # Return PostgreSQL array types as ruby Arrays instead of
+      # JDBC PostgreSQL driver-specific array type. Only used if the
+      # database does not have a conversion proc for the type.
+      def RubyPGArray(r, i)
+        if v = r.getArray(i)
+          v.array.to_ary
+        end
+      end 
+
+      # Return PostgreSQL hstore types as ruby Hashes instead of
+      # Java HashMaps.  Only used if the database does not have a
+      # conversion proc for the type.
+      def RubyPGHstore(r, i)
+        if v = r.getObject(i)
+          v.to_hash
+        end
+      end 
+    end
+
     # Adapter, Database, and Dataset support for accessing a PostgreSQL
     # database via JDBC.
     module Postgres
@@ -12,7 +32,7 @@ module Sequel
       module DatabaseMethods
         extend Sequel::Database::ResetIdentifierMangling
         include Sequel::Postgres::DatabaseMethods
-        
+
         # Add the primary_keys and primary_key_sequences instance variables,
         # so we can get the correct return values for inserted rows.
         def self.extended(db)
@@ -81,8 +101,30 @@ module Sequel
           end
         end
 
+        def oid_convertor_proc(oid)
+          if (conv = Sequel.synchronize{@oid_convertor_map[oid]}).nil?
+            conv = if pr = conversion_procs[oid]
+              lambda do |r, i|
+                if v = r.getString(i)
+                  pr.call(v)
+                end
+              end
+            else
+              false
+            end
+             Sequel.synchronize{@oid_convertor_map[oid] = conv}
+          end
+          conv
+        end
+
         private
         
+        # Clear oid convertor map cache when conversion procs are updated.
+        def conversion_procs_updated
+          super
+          Sequel.synchronize{@oid_convertor_map = {}}
+        end
+
         def disconnect_error?(exception, opts)
           super || exception.message =~ /\AThis connection has been closed\.\z|\AFATAL: terminating connection due to administrator command\z/
         end
@@ -101,6 +143,13 @@ module Sequel
           end
           conn
         end
+
+        def setup_type_convertor_map
+          super
+          @oid_convertor_map = {}
+          @type_convertor_map[:RubyPGArray] = TypeConvertor::INSTANCE.method(:RubyPGArray)
+          @type_convertor_map[:RubyPGHstore] = TypeConvertor::INSTANCE.method(:RubyPGHstore)
+        end
       end
       
       # Dataset subclass used for datasets that connect to PostgreSQL via JDBC.
@@ -108,53 +157,6 @@ module Sequel
         include Sequel::Postgres::DatasetMethods
         APOS = Dataset::APOS
         
-        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
-          # Convert Java::OrgPostgresqlUtil::PGobject to ruby strings
-          def pg_object(v)
-            v.to_string
-          end
-        end
-
-        # Handle conversions of PostgreSQL array instances
-        class PGArrayConverter
-          # Set the method that will return the correct conversion
-          # proc for elements of this array.
-          def initialize(meth)
-            @conversion_proc_method = meth
-            @conversion_proc = nil
-          end
-          
-          # Convert Java::OrgPostgresqlJdbc4::Jdbc4Array to ruby arrays
-          def call(v)
-            _pg_array(v.array)
-          end
-
-          private
-
-          # Handle multi-dimensional Java arrays by recursively mapping them
-          # to ruby arrays of ruby values.
-          def _pg_array(v)
-            v.to_ary.map do |i|
-              if i.respond_to?(:to_ary)
-                _pg_array(i)
-              elsif i
-                if @conversion_proc.nil?
-                  @conversion_proc = @conversion_proc_method.call(i)
-                end
-                if @conversion_proc
-                  @conversion_proc.call(i)
-                else
-                  i
-                end
-              else
-                i
-              end
-            end
-          end
-        end
-
-        PG_OBJECT_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:pg_object)
-      
         # Add the shared PostgreSQL prepared statement methods
         def prepare(type, name=nil, *values)
           ps = to_prepared_statement(type, values)
@@ -169,55 +171,35 @@ module Sequel
 
         private
         
-        # Handle PostgreSQL array and object types. Object types are just
-        # turned into strings, similarly to how the native adapter treats
-        # the types.
-        def convert_type_proc(v, ctn=nil)
-          case v
-          when Java::OrgPostgresqlJdbc4::Jdbc4Array
-            if pr = db.conversion_procs[ctn]
-              lambda{|x| pr.call(PG_OBJECT_METHOD.call(x))}
-            else
-              PGArrayConverter.new(method(:convert_type_proc))
-            end
-          when Java::OrgPostgresqlUtil::PGobject
-            if pr = db.conversion_procs[ctn]
-              lambda{|x| pr.call(PG_OBJECT_METHOD.call(x))}
-            else
-              PG_OBJECT_METHOD
-            end
-          when String
-            if pr = db.conversion_procs[ctn]
+        # Literalize strings similar to the native postgres adapter
+        def literal_string_append(sql, v)
+          sql << APOS << db.synchronize(@opts[:server]){|c| c.escape_string(v)} << APOS
+        end
+
+        STRING_TYPE = Java::JavaSQL::Types::VARCHAR
+        ARRAY_TYPE = Java::JavaSQL::Types::ARRAY
+        PG_SPECIFIC_TYPES = [ARRAY_TYPE, Java::JavaSQL::Types::OTHER, Java::JavaSQL::Types::STRUCT]
+        HSTORE_TYPE = 'hstore'.freeze
+
+        def type_convertor(map, meta, type, i)
+          case type
+          when *PG_SPECIFIC_TYPES
+            oid = meta.field(i).oid
+            if pr = db.oid_convertor_proc(oid)
               pr
+            elsif type == ARRAY_TYPE
+              map[:RubyPGArray]
+            elsif oid == 2950 # UUID
+              map[STRING_TYPE]
+            elsif meta.getPGType(i) == HSTORE_TYPE
+              map[:RubyPGHstore]
             else
-              false
-            end
-          when JAVA_HASH_MAP
-            if Sequel.respond_to?(:hstore)
-              lambda{|x| Sequel.hstore(HASH_MAP_METHOD.call(x))}
-            else
-              HASH_MAP_METHOD
+              super
             end
           else
             super
           end
         end
-        
-        # The jdbc/postgresql adapter uses column type oids when determining
-        # conversion procs.
-        def convert_type_proc_uses_column_info?
-          true
-        end
-
-        # Use the column type oid as the database specific column info value.
-        def convert_type_proc_column_info(meta, i)
-          meta.field(i).oid
-        end
-      
-        # Literalize strings similar to the native postgres adapter
-        def literal_string_append(sql, v)
-          sql << APOS << db.synchronize(@opts[:server]){|c| c.escape_string(v)} << APOS
-        end
       end
     end
   end