sequel 3.21.0 → 3.29.0

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

@@ -0,0 +1,217 @@
+Sequel.require 'adapters/jdbc/transactions'
+
+module Sequel
+  module JDBC
+    # Database and Dataset support for Derby databases accessed via JDBC.
+    module Derby
+      # Instance methods for Derby Database objects accessed via JDBC.
+      module DatabaseMethods
+        include ::Sequel::JDBC::Transactions
+
+        # Derby doesn't support casting integer to varchar, only integer to char,
+        # and char(254) appears to have the widest support (with char(255) failing).
+        # This does add a bunch of extra spaces at the end, but those will be trimmed
+        # elsewhere.
+        def cast_type_literal(type)
+          (type == String) ? 'CHAR(254)' : super
+        end
+
+        # Derby uses the :derby database type.
+        def database_type
+          :derby
+        end
+
+        # Derby uses an IDENTITY sequence for autoincrementing columns.
+        def serial_primary_key_options
+          {:primary_key => true, :type => :integer, :identity=>true, :start_with=>1}
+        end
+
+        # The SVN version of the database.
+        def svn_version
+          @svn_version ||= begin
+            v = synchronize{|c| c.get_meta_data.get_database_product_version}
+            v =~ /\((\d+)\)\z/
+            $1.to_i
+          end
+        end
+        
+        private
+        
+        # Derby-specific syntax for renaming columns and changing a columns type/nullity.
+        def alter_table_sql(table, op)
+          case op[:op]
+          when :rename_column
+            "RENAME COLUMN #{quote_schema_table(table)}.#{quote_identifier(op[:name])} TO #{quote_identifier(op[:new_name])}"
+          when :set_column_type
+            # Derby is very limited in changing a columns type, so adding a new column and then dropping the existing column is
+            # the best approach, as mentioned in the Derby documentation.
+            temp_name = :x_sequel_temp_column_x
+            [alter_table_sql(table, op.merge(:op=>:add_column, :name=>temp_name)),
+             from(table).update_sql(temp_name=>::Sequel::SQL::Cast.new(op[:name], op[:type])),
+             alter_table_sql(table, op.merge(:op=>:drop_column)),
+             alter_table_sql(table, op.merge(:op=>:rename_column, :name=>temp_name, :new_name=>op[:name]))]
+          when :set_column_null
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{op[:null] ? 'NULL' : 'NOT NULL'}"
+          else
+            super
+          end
+        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
+        end
+    
+        # Temporary table creation on Derby use DECLARE instead of CREATE.
+        def create_table_sql(name, generator, options)
+          if options[:temp]
+            "DECLARE GLOBAL TEMPORARY TABLE #{quote_identifier(name)} (#{column_list_sql(generator)}) NOT LOGGED"
+          else
+            super
+          end
+        end
+
+        # Use IDENTITY_VAL_LOCAL() to get the last inserted id.
+        def last_insert_id(conn, opts={})
+          statement(conn) do |stmt|
+            sql = 'SELECT IDENTITY_VAL_LOCAL() FROM sysibm.sysdummy1'
+            rs = log_yield(sql){stmt.executeQuery(sql)}
+            rs.next
+            rs.getInt(1)
+          end
+        end
+
+        # Derby uses RENAME TABLE syntax to rename tables.
+        def rename_table_sql(name, new_name)
+          "RENAME TABLE #{quote_schema_table(name)} TO #{quote_schema_table(new_name)}"
+        end
+
+        # If an :identity option is present in the column, add the necessary IDENTITY SQL.
+        def type_literal(column)
+          if column[:identity]
+            sql = "#{super} GENERATED BY DEFAULT AS IDENTITY"
+            if sw = column[:start_with]
+              sql << " (START WITH #{sw.to_i}"
+              sql << " INCREMENT BY #{column[:increment_by].to_i}" if column[:increment_by]
+              sql << ")"
+            end
+            sql
+          else
+            super
+          end
+        end
+      end
+      
+      # Dataset class for Derby datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        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')
+
+        # 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)
+          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))
+          else
+            super
+          end
+        end
+
+        # 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)
+          if type == String
+            "RTRIM(#{super})"
+          else
+            super
+          end
+        end
+
+        # Handle Derby specific LIKE, extract, and some bitwise compliment support.
+        def complex_expression_sql(op, args)
+          case op
+          when :ILIKE
+            super(: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)) ])
+          when :&, :|, :^, :<<, :>>
+            raise Error, "Derby doesn't support the #{op} operator"
+          when :'B~'
+            "((0 - #{literal(args.at(0))}) - 1)"
+          when :extract
+            "#{args.at(0)}(#{literal(args.at(1))})"
+          else
+            super
+          end
+        end
+
+        # Derby does not support IS TRUE.
+        def supports_is_true?
+          false
+        end
+
+        # Derby does not support IN/NOT IN with multiple columns
+        def supports_multiple_column_in?
+          false
+        end
+
+        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
+        end
+
+        # Derby needs the standard workaround to insert all default values into
+        # a table with more than one column.
+        def insert_supports_empty_values?
+          false
+        end
+
+        # Derby uses an expression yielding false for false values.
+        # Newer versions can use the FALSE literal, but the latest gem version cannot.
+        def literal_false
+          BOOL_FALSE
+        end
+
+        # Derby handles fractional seconds in timestamps, but not in times
+        def literal_sqltime(v)
+          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.
+        def literal_true
+          BOOL_TRUE
+        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 << " FROM sysibm.sysdummy1"
+          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]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+Sequel.require 'adapters/shared/firebird'
+Sequel.require 'adapters/jdbc/transactions'
+
+module Sequel
+  module JDBC
+    # Database and Dataset instance methods for Firebird specific
+    # support via JDBC.
+    module Firebird
+      # Database instance methods for Firebird databases accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::Firebird::DatabaseMethods
+        include Sequel::JDBC::Transactions
+        
+        # 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)
+          db.instance_eval do
+            @primary_keys = {}
+          end
+        end
+      end
+      
+      # Dataset class for Firebird datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::Firebird::DatasetMethods
+      end
+    end
+  end
+end

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

@@ -17,11 +17,6 @@ module Sequel
           :h2
         end
 
-        # Return Sequel::JDBC::H2::Dataset object with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::H2::Dataset.new(self, opts)
-        end
-        
         # Rollback an existing prepared transaction with the given transaction
         # identifier string.
         def rollback_prepared_transaction(transaction_id)
@@ -33,6 +28,11 @@ module Sequel
           {:primary_key => true, :type => :identity}
         end
 
+        # H2 supports CREATE TABLE IF NOT EXISTS syntax.
+        def supports_create_table_if_not_exists?
+          true
+        end
+      
         # H2 supports prepared transactions
         def supports_prepared_transactions?
           true
@@ -48,8 +48,8 @@ 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={})
-          if opts[:prepare] && Thread.current[:sequel_transaction_depth] <= 1
-            log_connection_execute(conn, "PREPARE COMMIT #{opts[:prepare]}")
+          if (s = opts[:prepare]) && @transactions[conn][:savepoint_level] <= 1
+            log_connection_execute(conn, "PREPARE COMMIT #{s}")
           else
             super
           end
@@ -90,7 +90,8 @@ module Sequel
         # Use IDENTITY() to get the last inserted id.
         def last_insert_id(conn, opts={})
           statement(conn) do |stmt|
-            rs = stmt.executeQuery('SELECT IDENTITY();')
+            sql = 'SELECT IDENTITY();'
+            rs = log_yield(sql){stmt.executeQuery(sql)}
             rs.next
             rs.getInt(1)
           end
@@ -106,7 +107,7 @@ module Sequel
         SELECT_CLAUSE_METHODS = clause_methods(:select, %w'distinct columns from join where group having compounds order limit')
         BITWISE_METHOD_MAP = {:& =>:BITAND, :| => :BITOR, :^ => :BITXOR}
         
-        # Work around H2's lack of a case insensitive LIKE operator
+        # Emulate the case insensitive LIKE operator and the bitwise operators.
         def complex_expression_sql(op, args)
           case op
           when :ILIKE
@@ -114,11 +115,13 @@ module Sequel
           when :"NOT ILIKE"
             super(:"NOT LIKE", [SQL::PlaceholderLiteralString.new("CAST(? AS VARCHAR_IGNORECASE)", [args.at(0)]), args.at(1)])
           when :&, :|, :^
-            literal(SQL::Function.new(BITWISE_METHOD_MAP[op], *args))
+            complex_expression_arg_pairs(args){|a, b| literal(SQL::Function.new(BITWISE_METHOD_MAP[op], a, b))}
           when :<<
-            "(#{literal(args[0])} * POWER(2, #{literal(args[1])}))"
+            complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
           when :>>
-            "(#{literal(args[0])} / POWER(2, #{literal(args[1])}))"
+            complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
+          when :'B~'
+            "((0 - #{literal(args.at(0))}) - 1)"
           else
             super(op, args)
           end
@@ -146,11 +149,7 @@ module Sequel
 
         private
       
-        # H2 expects hexadecimal strings for blob values
-        def literal_blob(v)
-          literal_string v.unpack("H*").first
-        end
-        
+        # Handle H2 specific clobs as strings.
         def convert_type(v)
           case v
           when Java::OrgH2Jdbc::JdbcClob
@@ -160,6 +159,16 @@ module Sequel
           end
         end
         
+        # H2 expects hexadecimal strings for blob values
+        def literal_blob(v)
+          literal_string v.unpack("H*").first
+        end
+        
+        # H2 handles fractional seconds in timestamps, but not in times
+        def literal_sqltime(v)
+          v.strftime("'%H:%M:%S'")
+        end
+
         def select_clause_methods
           SELECT_CLAUSE_METHODS
         end

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

@@ -0,0 +1,166 @@
+Sequel.require 'adapters/jdbc/transactions'
+
+module Sequel
+  module JDBC
+    # Database and Dataset support for HSQLDB databases accessed via JDBC.
+    module HSQLDB
+      # Instance methods for HSQLDB Database objects accessed via JDBC.
+      module DatabaseMethods
+        include ::Sequel::JDBC::Transactions
+
+        # HSQLDB uses the :hsqldb database type.
+        def database_type
+          :hsqldb
+        end
+
+        # HSQLDB uses an IDENTITY sequence as the default value for primary
+        # key columns.
+        def serial_primary_key_options
+          {:primary_key => true, :type => :integer, :identity=>true, :start_with=>1}
+        end
+
+        # The version of the database, as an integer (e.g 2.2.5 -> 20205)
+        def db_version
+          @db_version ||= begin
+            v = get{DATABASE_VERSION(){}}
+            if v =~ /(\d+)\.(\d+)\.(\d+)/
+              $1.to_i * 10000 + $2.to_i * 100 + $3.to_i
+            end
+          end
+        end
+        
+        private
+        
+        # HSQLDB specific SQL for renaming columns, and changing column types and/or nullity.
+        def alter_table_sql(table, op)
+          case op[:op]
+          when :rename_column
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} RENAME TO #{quote_identifier(op[:new_name])}"
+          when :set_column_type
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} SET DATA TYPE #{type_literal(op)}"
+          when :set_column_null
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} SET #{op[:null] ? 'NULL' : 'NOT NULL'}"
+          else
+            super
+          end
+        end
+
+        # Use IDENTITY() to get the last inserted id.
+        def last_insert_id(conn, opts={})
+          statement(conn) do |stmt|
+            sql = 'CALL IDENTITY()'
+            rs = log_yield(sql){stmt.executeQuery(sql)}
+            rs.next
+            rs.getInt(1)
+          end
+        end
+
+        # If an :identity option is present in the column, add the necessary IDENTITY SQL.
+        # It's possible to use an IDENTITY type, but that defaults the sequence to start
+        # at 0 instead of 1, and we don't want that.
+        def type_literal(column)
+          if column[:identity]
+            sql = "#{super} GENERATED BY DEFAULT AS IDENTITY"
+            if sw = column[:start_with]
+              sql << " (START WITH #{sw.to_i}"
+              sql << " INCREMENT BY #{column[:increment_by].to_i}" if column[:increment_by]
+              sql << ")"
+            end
+            sql
+          else
+            super
+          end
+        end
+      end
+      
+      # Dataset class for HSQLDB datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        BITWISE_METHOD_MAP = {:& =>:BITAND, :| => :BITOR, :^ => :BITXOR}
+        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'distinct columns from join where group having compounds order limit lock')
+        SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
+
+        # Handle HSQLDB specific case insensitive LIKE and bitwise operator support.
+        def complex_expression_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 :&, :|, :^
+            op = BITWISE_METHOD_MAP[op]
+            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)}))"}
+          when :>>
+            complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
+          when :'B~'
+            "((0 - #{literal(args.at(0))}) - 1)"
+          else
+            super
+          end
+        end
+
+        # HSQLDB requires recursive CTEs to have column aliases.
+        def recursive_cte_requires_column_aliases?
+          true
+        end
+
+        # HSQLDB does not support IS TRUE.
+        def supports_is_true?
+          false
+        end
+
+        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
+        end
+
+        # HSQLDB uses FALSE for false values.
+        def literal_false
+          BOOL_FALSE
+        end
+
+        # HSQLDB handles fractional seconds in timestamps, but not in times
+        def literal_sqltime(v)
+          v.strftime("'%H:%M:%S'")
+        end
+
+        # HSQLDB uses TRUE for true values.
+        def literal_true
+          BOOL_TRUE
+        end
+
+        # HSQLDB does not support CTEs well enough for Sequel to enable support for them.
+        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 << " FROM (VALUES (0))"
+          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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+Sequel.require 'adapters/shared/informix'
+
+module Sequel
+  module JDBC
+    # Database and Dataset instance methods for Informix specific
+    # support via JDBC.
+    module Informix
+      # Database instance methods for Informix databases accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::Informix::DatabaseMethods
+        
+        private
+        
+        # TODO: implement
+        def last_insert_id(conn, opts={})
+          nil
+        end
+      end
+      
+      # Dataset class for Informix datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::Informix::DatasetMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+Sequel.require 'adapters/jdbc/mssql'
+
+module Sequel
+  module JDBC
+    # Database and Dataset instance methods for JTDS specific
+    # support via JDBC.
+    module JTDS
+      # Database instance methods for JTDS databases accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::JDBC::MSSQL::DatabaseMethods
+      end
+      
+      # Dataset class for JTDS datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::MSSQL::DatasetMethods
+
+        # Handle CLOB types retrieved via JTDS.
+        def convert_type(v)
+          case v
+          when Java::NetSourceforgeJtdsJdbc::ClobImpl
+            convert_type(v.getSubString(1, v.length))
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,11 +16,6 @@ module Sequel
         
         include Sequel::MSSQL::DatabaseMethods
         
-        # Return instance of Sequel::JDBC::MSSQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::MSSQL::Dataset.new(self, opts)
-        end
-        
         private
         
         # Get the last inserted id using SCOPE_IDENTITY().
@@ -43,33 +38,6 @@ module Sequel
         def primary_key_index_re
           PRIMARY_KEY_INDEX_RE
         end
-
-        def metadata_dataset
-          ds = super
-          # Work around a bug in SQL Server JDBC Driver 3.0, where the metadata
-          # for the getColumns result set specifies an incorrect type for the
-          # IS_AUTOINCREMENT column. The column is a string, but the type is
-          # specified as a short. This causes getObject() to throw a
-          # com.microsoft.sqlserver.jdbc.SQLServerException: "The conversion
-          # from char to SMALLINT is unsupported." Using getString() rather
-          # than getObject() for this column avoids the problem.
-          # Reference: http://social.msdn.microsoft.com/Forums/en/sqldataaccess/thread/20df12f3-d1bf-4526-9daa-239a83a8e435
-          def ds.result_set_object_getter
-            lambda do |result, n, i|
-              if n == :is_autoincrement
-                @convert_types ? convert_type(result.getString(i)) : result.getString(i)
-              else
-                @convert_types ? convert_type(result.getObject(i)) : result.getObject(i)
-              end
-            end
-          end
-          ds
-        end
-      end
-      
-      # Dataset class for MSSQL datasets accessed via JDBC.
-      class Dataset < JDBC::Dataset
-        include Sequel::MSSQL::DatasetMethods
       end
     end
   end

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

@@ -9,11 +9,6 @@ module Sequel
       module DatabaseMethods
         include Sequel::MySQL::DatabaseMethods
         
-        # Return instance of Sequel::JDBC::MySQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::MySQL::Dataset.new(self, opts)
-        end
-        
         private
         
         # The database name for the given database.  Need to parse it out
@@ -56,17 +51,21 @@ module Sequel
         def schema_column_type(db_type)
           db_type == 'tinyint(1)' ? :boolean : super
         end
+      
+        # By default, MySQL 'where id is null' selects the last inserted id.
+        # Turn that off unless explicitly enabled.
+        def setup_connection(conn)
+          super
+          sql = "SET SQL_AUTO_IS_NULL=0"
+          statement(conn){|s| log_yield(sql){s.execute(sql)}} unless opts[:auto_is_null]
+          conn
+        end
       end
       
       # Dataset class for MySQL datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::MySQL::DatasetMethods
         
-        # Use execute_insert to execute the insert_sql.
-        def insert(*values)
-          execute_insert(insert_sql(*values))
-        end
-        
         # Use execute_insert to execute the replace_sql.
         def replace(*args)
           execute_insert(replace_sql(*args))