sequel 4.26.0 → 5.37.0

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

@@ -1,57 +1,45 @@
+# frozen-string-literal: true
+
 Sequel::JDBC.load_driver('com.ibm.db2.jcc.DB2Driver')
-Sequel.require 'adapters/shared/db2'
-Sequel.require 'adapters/jdbc/transactions'
+require_relative '../shared/db2'
+require_relative 'transactions'
 
 module Sequel
   module JDBC
     Sequel.synchronize do
       DATABASE_SETUP[:db2] = proc do |db|
-        db.extend(Sequel::JDBC::DB2::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::DB2::Dataset
-        com.ibm.db2.jcc.DB2Driver
-      end
-    end
+        db.singleton_class.class_eval do
+          alias jdbc_schema_parse_table schema_parse_table
+          alias jdbc_tables tables
+          alias jdbc_views views
+          alias jdbc_indexes indexes
 
-    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
+          include Sequel::JDBC::DB2::DatabaseMethods
+
+          alias schema_parse_table jdbc_schema_parse_table
+          alias tables jdbc_tables
+          alias views jdbc_views
+          alias indexes jdbc_indexes
+          %w'schema_parse_table tables views indexes'.each do |s|
+            remove_method(:"jdbc_#{s}")
+          end
         end
+        db.extend_datasets Sequel::DB2::DatasetMethods
+        com.ibm.db2.jcc.DB2Driver
       end
     end
 
-    class Database
-      # Alias the generic JDBC versions so they can be called directly later
-      alias jdbc_schema_parse_table schema_parse_table
-      alias jdbc_tables tables
-      alias jdbc_views views
-      alias jdbc_indexes indexes
-    end
-    
-    # Database and Dataset instance methods for DB2 specific
-    # support via JDBC.
     module DB2
-      # Database instance methods for DB2 databases accessed via JDBC.
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
-        PRIMARY_KEY_INDEX_RE = /\Asql\d+\z/i.freeze
-
         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__)
-        end
 
         private
 
         def set_ps_arg(cps, arg, i)
           case arg
           when Sequel::SQL::Blob
-            if ::Sequel::DB2.use_clob_as_blob
+            if use_clob_as_blob
               cps.setString(i, arg)
             else
               super
@@ -63,8 +51,8 @@ module Sequel
         
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
-            sql = IDENTITY_VAL_LOCAL
-            rs = log_yield(sql){stmt.executeQuery(sql)}
+            sql = "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1"
+            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
             rs.next
             rs.getLong(1)
           end
@@ -72,19 +60,23 @@ module Sequel
         
         # Primary key indexes appear to be named sqlNNNN on DB2
         def primary_key_index_re
-          PRIMARY_KEY_INDEX_RE
+          /\Asql\d+\z/i
         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)
+          map[types::NCLOB] = map[types::CLOB] = method(:convert_clob)
         end
-      end
 
-      class Dataset < JDBC::Dataset
-        include Sequel::DB2::DatasetMethods
+        def convert_clob(r, i)
+          if v = r.getClob(i)
+            v = v.getSubString(1, v.length)
+            v = Sequel::SQL::Blob.new(v) if use_clob_as_blob
+            v
+          end
+        end
       end
     end
   end

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

@@ -1,5 +1,7 @@
+# frozen-string-literal: true
+
 Sequel::JDBC.load_driver('org.apache.derby.jdbc.EmbeddedDriver', :Derby)
-Sequel.require 'adapters/jdbc/transactions'
+require_relative 'transactions'
 
 module Sequel
   module JDBC
@@ -11,13 +13,8 @@ module Sequel
       end
     end
 
-    # Database and Dataset support for Derby databases accessed via JDBC.
     module Derby
-      # Instance methods for Derby Database objects accessed via JDBC.
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
-        PRIMARY_KEY_INDEX_RE = /\Asql\d+\z/i.freeze
-
         include ::Sequel::JDBC::Transactions
 
         # Derby doesn't support casting integer to varchar, only integer to char,
@@ -28,14 +25,18 @@ module Sequel
           (type == String) ? 'CHAR(254)' : super
         end
 
-        # Derby uses the :derby database type.
         def database_type
           :derby
         end
 
+        def freeze
+          svn_version
+          super
+        end
+
         # Derby uses an IDENTITY sequence for autoincrementing columns.
         def serial_primary_key_options
-          {:primary_key => true, :type => :integer, :identity=>true, :start_with=>1}
+          {:primary_key => true, :type => Integer, :identity=>true, :start_with=>1}
         end
 
         # The SVN version of the database.
@@ -47,7 +48,7 @@ module Sequel
           end
         end
         
-        # Derby supports transaction DDL statements.
+        # Derby supports transactional DDL statements.
         def supports_transactional_ddl?
           true
         end
@@ -60,7 +61,6 @@ module Sequel
           ds.first
         end
     
-        # Derby-specific syntax for renaming columns and changing a columns type/nullity.
         def alter_table_sql(table, op)
           case op[:op]
           when :rename_column
@@ -80,15 +80,21 @@ module Sequel
           end
         end
 
+        # Derby does not allow adding primary key constraints to NULLable columns.
+        def can_add_primary_key_constraint_on_nullable_columns?
+          false
+        end
+
         # Derby doesn't allow specifying NULL for columns, only NOT NULL.
         def column_definition_null_sql(sql, column)
-          sql << " NOT NULL" if column.fetch(:null, column[:allow_null]) == false
+          null = column.fetch(:null, column[:allow_null])
+          sql << " NOT NULL" if null == false || (null.nil? && column[:primary_key])
         end
     
         # Add NOT LOGGED for temporary tables to improve performance.
         def create_table_sql(name, generator, options)
           s = super
-          s << ' NOT LOGGED' if options[:temp]
+          s += ' NOT LOGGED' if options[:temp]
           s
         end
 
@@ -129,7 +135,7 @@ module Sequel
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
             sql = 'SELECT IDENTITY_VAL_LOCAL() FROM sysibm.sysdummy1'
-            rs = log_yield(sql){stmt.executeQuery(sql)}
+            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
             rs.next
             rs.getLong(1)
           end
@@ -147,7 +153,7 @@ module Sequel
 
         # Primary key indexes appear to be named sqlNNNN on Derby
         def primary_key_index_re
-          PRIMARY_KEY_INDEX_RE
+          /\Asql\d+\z/i
         end
 
         # If an :identity option is present in the column, add the necessary IDENTITY SQL.
@@ -155,7 +161,7 @@ module Sequel
           if column[:identity]
             sql = "#{super} GENERATED BY DEFAULT AS IDENTITY"
             if sw = column[:start_with]
-              sql << " (START WITH #{sw.to_i}"
+              sql += " (START WITH #{sw.to_i}"
               sql << " INCREMENT BY #{column[:increment_by].to_i}" if column[:increment_by]
               sql << ")"
             end
@@ -170,35 +176,14 @@ module Sequel
           true
         end
 
-        # The SQL query to issue to check if a connection is valid.
         def valid_connection_sql
           @valid_connection_sql ||= select(1).sql
         end
       end
       
-      # 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
-        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_OLD = '(1 = 1)'.freeze
-        BOOL_FALSE_OLD = '(1 = 0)'.freeze
-        BOOL_TRUE = 'TRUE'.freeze
-        BOOL_FALSE = 'FALSE'.freeze
-        EMULATED_FUNCTION_MAP = {:char_length=>'length'.freeze}
-
         # Derby doesn't support an expression between CASE and WHEN,
-        # so remove 
-        # conditions.
+        # so remove conditions.
         def case_expression_sql_append(sql, ce)
           super(sql, ce.with_merged_expression)
         end
@@ -208,9 +193,9 @@ module Sequel
         # a string and the ending whitespace is important.
         def cast_sql_append(sql, expr, type)
           if type == String
-            sql << CAST_STRING_OPEN
+            sql << "RTRIM("
             super
-            sql << PAREN_CLOSE
+            sql << ')'
           else
             super
           end
@@ -222,10 +207,16 @@ module Sequel
             complex_expression_emulate_append(sql, op, args)
           when :&, :|, :^, :<<, :>>
             raise Error, "Derby doesn't support the #{op} operator"
+          when :**
+            sql << 'exp('
+            literal_append(sql, args[1])
+            sql << ' * ln('
+            literal_append(sql, args[0])
+            sql << "))"
           when :extract
-            sql << args.at(0).to_s << PAREN_OPEN
-            literal_append(sql, args.at(1))
-            sql << PAREN_CLOSE
+            sql << args[0].to_s << '('
+            literal_append(sql, args[1])
+            sql << ')'
           else
             super
           end
@@ -249,12 +240,12 @@ module Sequel
         private
 
         def empty_from_sql
-          DEFAULT_FROM
+          " FROM sysibm.sysdummy1"
         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
+          sql << "CAST(X'" << v.unpack("H*").first << "' AS BLOB)"
         end
 
         # Derby needs the standard workaround to insert all default values into
@@ -263,47 +254,54 @@ module Sequel
           false
         end
 
-        # Derby uses an expression yielding false for false values.
-        # Newer versions can use the FALSE literal, but the latest gem version cannot.
+        # Newer Derby versions can use the FALSE literal, but older versions need an always false expression.
         def literal_false
           if db.svn_version >= 1040133
-            BOOL_FALSE
+            'FALSE'
           else
-            BOOL_FALSE_OLD
+            '(1 = 0)'
           end
         end
 
         # Derby handles fractional seconds in timestamps, but not in times
         def literal_sqltime(v)
-          v.strftime(TIME_FORMAT)
+          v.strftime("'%H:%M:%S'")
         end
 
-        # Derby uses an expression yielding true for true values.
-        # Newer versions can use the TRUE literal, but the latest gem version cannot.
+        # Newer Derby versions can use the TRUE literal, but older versions need an always false expression.
         def literal_true
           if db.svn_version >= 1040133
-            BOOL_TRUE
+            'TRUE'
           else
-            BOOL_TRUE_OLD
+            '(1 = 1)'
           end
         end
 
-        # Derby supports multiple rows in INSERT.
+        # Derby supports multiple rows for VALUES in INSERT.
         def multi_insert_sql_strategy
           :values
         end
 
+        # Emulate the char_length function with length
+        def native_function_name(emulated_function)
+          if emulated_function == :char_length
+            'length'
+          else
+            super
+          end
+        end
+
         # Offset comes before limit in Derby
         def select_limit_sql(sql)
           if o = @opts[:offset]
-            sql << OFFSET
+            sql << " OFFSET "
             literal_append(sql, o)
-            sql << ROWS
+            sql << " ROWS"
           end
           if l = @opts[:limit]
-            sql << FETCH_FIRST
+            sql << " FETCH FIRST "
             literal_append(sql, l)
-            sql << ROWS_ONLY
+            sql << " ROWS ONLY"
           end
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 Sequel::JDBC.load_driver('org.h2.Driver', :H2)
 
 module Sequel
@@ -10,36 +12,35 @@ module Sequel
       end
     end
 
-    # Database and Dataset support for H2 databases accessed via JDBC.
     module H2
-      # Instance methods for H2 Database objects accessed via JDBC.
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
-        PRIMARY_KEY_INDEX_RE = /\Aprimary_key/i.freeze
-      
-        # Commit an existing prepared transaction with the given transaction
-        # identifier string.
         def commit_prepared_transaction(transaction_id, opts=OPTS)
           run("COMMIT TRANSACTION #{transaction_id}", opts)
         end
 
-        # H2 uses the :h2 database type.
         def database_type
           :h2
         end
 
-        # Rollback an existing prepared transaction with the given transaction
-        # identifier string.
+        def freeze
+          h2_version
+          super
+        end
+
+        def h2_version
+          @h2_version ||= get(Sequel.function(:H2VERSION))
+        end
+
         def rollback_prepared_transaction(transaction_id, opts=OPTS)
           run("ROLLBACK TRANSACTION #{transaction_id}", opts)
         end
 
-        # H2 uses an IDENTITY type
+        # H2 uses an IDENTITY type for primary keys
         def serial_primary_key_options
           {:primary_key => true, :type => :identity, :identity=>true}
         end
 
-        # H2 supports CREATE TABLE IF NOT EXISTS syntax.
+        # H2 supports CREATE TABLE IF NOT EXISTS syntax
         def supports_create_table_if_not_exists?
           true
         end
@@ -56,6 +57,11 @@ module Sequel
         
         private
         
+        # H2 does not allow adding primary key constraints to NULLable columns.
+        def can_add_primary_key_constraint_on_nullable_columns?
+          false
+        end
+
         # 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)
@@ -66,17 +72,27 @@ module Sequel
           end
         end
 
-        # H2 needs to add a primary key column as a constraint
         def alter_table_sql(table, op)
           case op[:op]
           when :add_column
             if (pk = op.delete(:primary_key)) || (ref = op.delete(:table))
+              if pk
+                op[:null] = false
+              end
+
               sqls = [super(table, op)]
-              sqls << "ALTER TABLE #{quote_schema_table(table)} ADD PRIMARY KEY (#{quote_identifier(op[:name])})" if pk && op[:type] != :identity
+
+              if pk && (h2_version >= '1.4' || op[:type] != :identity)
+                # H2 needs to add a primary key column as a constraint in this case
+                sqls << "ALTER TABLE #{quote_schema_table(table)} ADD PRIMARY KEY (#{quote_identifier(op[:name])})"
+              end
+
               if ref
                 op[:table] = ref
-                sqls << "ALTER TABLE #{quote_schema_table(table)} ADD FOREIGN KEY (#{quote_identifier(op[:name])}) #{column_references_sql(op)}"
+                constraint_name = op[:foreign_key_constraint_name]
+                sqls << "ALTER TABLE #{quote_schema_table(table)} ADD#{" CONSTRAINT #{quote_identifier(constraint_name)}" if constraint_name} FOREIGN KEY (#{quote_identifier(op[:name])}) #{column_references_sql(op)}"
               end
+
               sqls
             else
               super(table, op)
@@ -93,7 +109,7 @@ module Sequel
                 op = cs.merge!(op)
               end
             end
-            sql = "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}"
+            sql = "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}".dup
             column_definition_order.each{|m| send(:"column_definition_#{m}_sql", sql, op)}
             sql
           when :drop_constraint
@@ -128,14 +144,14 @@ module Sequel
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
             sql = 'SELECT IDENTITY();'
-            rs = log_yield(sql){stmt.executeQuery(sql)}
+            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
             rs.next
             rs.getLong(1)
           end
         end
         
         def primary_key_index_re
-          PRIMARY_KEY_INDEX_RE
+          /\Aprimary_key/i
         end
 
         # H2 does not support named column constraints.
@@ -143,26 +159,20 @@ module Sequel
           false
         end
 
-        # Use BIGINT IDENTITY for identity columns that use bigint, fixes
-        # the case where primary_key :column, :type=>Bignum is used.
-        def type_literal_generic_bignum(column)
+        # Use BIGINT IDENTITY for identity columns that use :Bignum type
+        def type_literal_generic_bignum_symbol(column)
           column[:identity] ? 'BIGINT IDENTITY' : super
         end
       end
       
-      # Dataset class for H2 datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
-        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
           when :ILIKE, :"NOT ILIKE"
-            super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), [SQL::PlaceholderLiteralString.new(ILIKE_PLACEHOLDER, [args.at(0)]), args.at(1)])
+            super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), [SQL::PlaceholderLiteralString.new(ILIKE_PLACEHOLDER, [args[0]]), args[1]])
           when :&, :|, :^, :<<, :>>, :'B~'
             complex_expression_emulate_append(sql, op, args)
           else
@@ -199,12 +209,12 @@ module Sequel
 
         # H2 expects hexadecimal strings for blob values
         def literal_blob_append(sql, v)
-          sql << APOS << v.unpack(HSTAR).first << APOS
+          sql << "'" << v.unpack("H*").first << "'"
         end
         
         # H2 handles fractional seconds in timestamps, but not in times
         def literal_sqltime(v)
-          v.strftime(TIME_FORMAT)
+          v.strftime("'%H:%M:%S'")
         end
 
         # H2 supports multiple rows in INSERT.
@@ -213,7 +223,7 @@ module Sequel
         end
 
         def select_only_offset_sql(sql)
-          sql << ONLY_OFFSET
+          sql << " LIMIT -1 OFFSET "
           literal_append(sql, @opts[:offset])
         end