sequel 3.28.0 → 3.29.0

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

@@ -1,9 +1,13 @@
+Sequel.require 'adapters/jdbc/transactions'
+
 module Sequel
   module JDBC
     # Database and Dataset support for AS400 databases accessed via JDBC.
     module AS400
       # Instance methods for AS400 Database objects accessed via JDBC.
       module DatabaseMethods
+        include Sequel::JDBC::Transactions
+
         TRANSACTION_BEGIN = 'Transaction.begin'.freeze
         TRANSACTION_COMMIT = 'Transaction.commit'.freeze
         TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
@@ -13,11 +17,6 @@ module Sequel
           :as400
         end
 
-        # Return Sequel::JDBC::AS400::Dataset object with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::AS400::Dataset.new(self, opts)
-        end
-
         # TODO: Fix for AS400
         def last_insert_id(conn, opts={})
           nil
@@ -33,25 +32,7 @@ module Sequel
         # Use JDBC connection's setAutoCommit to false to start transactions
         def begin_transaction(conn, opts={})
           set_transaction_isolation(conn, opts)
-          log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
-          conn
-        end
-
-        # Use JDBC connection's commit method to commit transactions
-        def commit_transaction(conn, opts={})
-          log_yield(TRANSACTION_COMMIT){conn.commit}
-        end
-
-        # Use JDBC connection's setAutoCommit to true to enable default
-        # auto-commit mode
-        def remove_transaction(conn)
-          conn.setAutoCommit(true) if conn
-          @transactions.delete(Thread.current)
-        end
-
-        # Use JDBC connection's rollback method to rollback transactions
-        def rollback_transaction(conn, opts={})
-          log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+          super
         end
       end
       

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

@@ -19,11 +19,6 @@ module Sequel
         include Sequel::DB2::DatabaseMethods
         include Sequel::JDBC::Transactions
         
-        # Return instance of Sequel::JDBC::DB2::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::DB2::Dataset.new(self, opts)
-        end
-        
         %w'schema_parse_table tables views indexes'.each do |s|
           class_eval("def #{s}(*a) jdbc_#{s}(*a) end", __FILE__, __LINE__)
         end

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

@@ -18,11 +18,6 @@ module Sequel
             @primary_keys = {}
           end
         end
-        
-        # Return instance of Sequel::JDBC::Firebird::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::Firebird::Dataset.new(self, opts)
-        end
       end
       
       # Dataset class for Firebird datasets accessed via JDBC.

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)
@@ -53,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
@@ -95,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
@@ -111,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
@@ -119,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

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