sequel 4.36.0 → 5.61.0

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

@@ -1,59 +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
+
+          include Sequel::JDBC::DB2::DatabaseMethods
 
-    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
+          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
@@ -65,7 +51,7 @@ module Sequel
         
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
-            sql = IDENTITY_VAL_LOCAL
+            sql = "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1"
             rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
             rs.next
             rs.getLong(1)
@@ -74,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,7 +1,8 @@
 # frozen-string-literal: true
 
 Sequel::JDBC.load_driver('org.apache.derby.jdbc.EmbeddedDriver', :Derby)
-Sequel.require 'adapters/jdbc/transactions'
+require_relative 'transactions'
+require_relative '../utils/columns_limit_1'
 
 module Sequel
   module JDBC
@@ -13,13 +14,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,
@@ -30,14 +26,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.
@@ -49,7 +49,7 @@ module Sequel
           end
         end
         
-        # Derby supports transaction DDL statements.
+        # Derby supports transactional DDL statements.
         def supports_transactional_ddl?
           true
         end
@@ -62,7 +62,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
@@ -82,9 +81,15 @@ 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.
@@ -149,7 +154,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.
@@ -172,35 +177,16 @@ 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}
+        include ::Sequel::Dataset::ColumnsLimit1
 
         # 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
@@ -210,9 +196,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
@@ -224,10 +210,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
@@ -243,6 +235,11 @@ module Sequel
           false
         end
 
+        # Derby 10.11+ supports MERGE.
+        def supports_merge?
+          db.svn_version >= 1616546
+        end
+
         # Derby does not support IN/NOT IN with multiple columns
         def supports_multiple_column_in?
           false
@@ -251,12 +248,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
@@ -265,47 +262,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

@@ -12,36 +12,36 @@ 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
+          version2?
+          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
@@ -58,6 +58,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)
@@ -68,17 +73,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)
@@ -126,18 +141,41 @@ module Sequel
           DATABASE_ERROR_REGEXPS
         end
 
-        # Use IDENTITY() to get the last inserted id.
+        def execute_statement_insert(stmt, sql)
+          stmt.executeUpdate(sql, JavaSQL::Statement::RETURN_GENERATED_KEYS)
+        end
+
+        def prepare_jdbc_statement(conn, sql, opts)
+          opts[:type] == :insert ? conn.prepareStatement(sql, JavaSQL::Statement::RETURN_GENERATED_KEYS) : super
+        end
+
+        # Get the last inserted id using getGeneratedKeys, scope_identity, or identity.
         def last_insert_id(conn, opts=OPTS)
-          statement(conn) do |stmt|
-            sql = 'SELECT IDENTITY();'
-            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
-            rs.next
-            rs.getLong(1)
+          if stmt = opts[:stmt]
+            rs = stmt.getGeneratedKeys
+            begin
+              if rs.next
+                begin
+                  rs.getLong(1)
+                rescue
+                  rs.getObject(1) rescue nil
+                end
+              end
+            ensure
+              rs.close
+            end
+          elsif !version2?
+            statement(conn) do |stmt|
+              sql = 'SELECT IDENTITY()'
+              rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
+              rs.next
+              rs.getLong(1)
+            end
           end
         end
         
         def primary_key_index_re
-          PRIMARY_KEY_INDEX_RE
+          /\Aprimary_key/i
         end
 
         # H2 does not support named column constraints.
@@ -145,26 +183,25 @@ module Sequel
           false
         end
 
-        # Use BIGINT IDENTITY for identity columns that use bigint, fixes
-        # the case where primary_key :column, :type=>:Bignum is used.
+        # Use BIGINT IDENTITY for identity columns that use :Bignum type
         def type_literal_generic_bignum_symbol(column)
-          column[:identity] ? 'BIGINT IDENTITY' : super
+          column[:identity] ? 'BIGINT AUTO_INCREMENT' : super
+        end
+
+        def version2?
+          return @version2 if defined?(@version2)
+          @version2 = h2_version.to_i >= 2
         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
@@ -192,6 +229,11 @@ module Sequel
           false
         end
         
+        # H2 supports MERGE
+        def supports_merge?
+          true
+        end
+
         # H2 doesn't support multiple columns in IN/NOT IN
         def supports_multiple_column_in?
           false
@@ -201,12 +243,24 @@ module Sequel
 
         # H2 expects hexadecimal strings for blob values
         def literal_blob_append(sql, v)
-          sql << APOS << v.unpack(HSTAR).first << APOS
+          if db.send(:version2?)
+            super
+          else
+            sql << "'" << v.unpack("H*").first << "'"
+          end
+        end
+
+        def literal_false
+          'FALSE'
         end
         
+        def literal_true
+          'TRUE'
+        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.
@@ -215,8 +269,12 @@ module Sequel
         end
 
         def select_only_offset_sql(sql)
-          sql << ONLY_OFFSET
-          literal_append(sql, @opts[:offset])
+          if db.send(:version2?)
+            super
+          else
+            sql << " LIMIT -1 OFFSET "
+            literal_append(sql, @opts[:offset])
+          end
         end
 
         # H2 supports quoted function names.