sequel 3.21.0 → 3.41.0

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

@@ -0,0 +1,189 @@
+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
+        PRIMARY_KEY_INDEX_RE = /\Asys_idx_sys_pk_/i.freeze
+
+        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
+
+        # HSQLDB requires parens around the SELECT, and the WITH DATA syntax.
+        def create_table_as_sql(name, sql, options)
+          "#{create_table_prefix_sql(name, options)} AS (#{sql}) WITH DATA"
+        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
+        
+        # Primary key indexes appear to start with sys_idx_sys_pk_ on HSQLDB
+        def primary_key_index_re
+          PRIMARY_KEY_INDEX_RE
+        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
+
+        # HSQLDB uses clob for text types.
+        def uses_clob_for_text?
+          true
+        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'select distinct columns from join where group having compounds order limit lock')
+        SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
+        APOS = Dataset::APOS
+        HSTAR = "H*".freeze
+        BLOB_OPEN = "X'".freeze
+        BITCOMP_OPEN = "((0 - ".freeze
+        BITCOMP_CLOSE = ") - 1)".freeze
+        DEFAULT_FROM = " FROM (VALUES (0))".freeze
+        TIME_FORMAT = "'%H:%M:%S'".freeze
+
+        # Handle HSQLDB specific case insensitive LIKE and bitwise operator support.
+        def complex_expression_sql_append(sql, op, args)
+          case op
+          when :ILIKE, :"NOT ILIKE"
+            super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), [SQL::Function.new(:ucase, args.at(0)), SQL::Function.new(:ucase, args.at(1)) ])
+          when :&, :|, :^
+            op = BITWISE_METHOD_MAP[op]
+            sql << complex_expression_arg_pairs(args){|a, b| literal(SQL::Function.new(op, a, b))}
+          when :<<
+            sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
+          when :>>
+            sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
+          when :%
+            sql << complex_expression_arg_pairs(args){|a, b| "MOD(#{literal(a)}, #{literal(b)})"}
+          when :'B~'
+            sql << BITCOMP_OPEN
+            literal_append(sql, args.at(0))
+            sql << BITCOMP_CLOSE
+          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_append(sql, v)
+          sql << BLOB_OPEN << v.unpack(HSTAR).first << APOS
+        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(TIME_FORMAT)
+        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 << 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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+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
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+Sequel.require 'adapters/jdbc/mssql'
+
+module Sequel
+  module JDBC
+    # Database and Dataset instance methods for JTDS specific
+    # support via JDBC.
+    module JTDS
+      module DatabaseMethods
+        include Sequel::JDBC::MSSQL::DatabaseMethods
+
+        private
+
+        # Handle nil values by using setNull with the correct parameter type.
+        def set_ps_arg_nil(cps, i)
+          cps.setNull(i, cps.getParameterMetaData.getParameterType(i))
+        end
+      end
+
+      # 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)
+          if v.is_a?(Java::NetSourceforgeJtdsJdbc::ClobImpl)
+            JTDS_CLOB_METHOD
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,20 +13,17 @@ module Sequel
       # Database instance methods for MSSQL databases accessed via JDBC.
       module DatabaseMethods
         PRIMARY_KEY_INDEX_RE = /\Apk__/i.freeze
+        ATAT_IDENTITY = 'SELECT @@IDENTITY'.freeze
+        SCOPE_IDENTITY = 'SELECT SCOPE_IDENTITY()'.freeze
         
         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().
         def last_insert_id(conn, opts={})
           statement(conn) do |stmt|
-            sql = opts[:prepared] ? 'SELECT @@IDENTITY' : 'SELECT SCOPE_IDENTITY()'
+            sql = opts[:prepared] ? ATAT_IDENTITY : SCOPE_IDENTITY
             rs = log_yield(sql){stmt.executeQuery(sql)}
             rs.next
             rs.getInt(1)
@@ -43,33 +40,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

@@ -8,11 +8,7 @@ module Sequel
       # Database instance methods for MySQL databases accessed via JDBC.
       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
+        LAST_INSERT_ID = 'SELECT LAST_INSERT_ID()'.freeze
         
         private
         
@@ -39,42 +35,34 @@ module Sequel
             end
           else
             statement(conn) do |stmt|
-              rs = stmt.executeQuery('SELECT LAST_INSERT_ID()')
+              rs = stmt.executeQuery(LAST_INSERT_ID)
               rs.next
               rs.getInt(1)
             end
           end
         end
 
-        # MySQL 5.1.12 JDBC adapter requires this to be true,
+        # MySQL 5.1.12 JDBC adapter requires generated keys
         # and previous versions don't mind.
-        def requires_return_generated_keys?
-          true
+        def execute_statement_insert(stmt, sql)
+          stmt.executeUpdate(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS)
         end
-      
+
+        # Return generated keys for insert statements.
+        def prepare_jdbc_statement(conn, sql, opts)
+          opts[:type] == :insert ? conn.prepareStatement(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS) : super
+        end
+
         # Convert tinyint(1) type to boolean
         def schema_column_type(db_type)
           db_type == 'tinyint(1)' ? :boolean : super
         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))
-        end
-        
-        # MySQL on JDBC does provides an accurate number of rows matched.
-        def provides_accurate_rows_matched?
-          true
+        # Run the default connection setting SQL statements.
+        # Apply the connectiong setting SQLs for every new connection.
+        def setup_connection(conn)
+          mysql_connection_setting_sqls.each{|sql| statement(conn){|s| log_yield(sql){s.execute(sql)}}}
+          super
         end
       end
     end

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

@@ -1,4 +1,5 @@
 Sequel.require 'adapters/shared/oracle'
+Sequel.require 'adapters/jdbc/transactions'
 
 module Sequel
   module JDBC
@@ -6,44 +7,106 @@ module Sequel
     module Oracle
       # Instance methods for Oracle Database objects accessed via JDBC.
       module DatabaseMethods
+        PRIMARY_KEY_INDEX_RE = /\Asys_/i.freeze
+
         include Sequel::Oracle::DatabaseMethods
-        TRANSACTION_BEGIN = 'Transaction.begin'.freeze
-        TRANSACTION_COMMIT = 'Transaction.commit'.freeze
-        TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
-        
-        # Return Sequel::JDBC::Oracle::Dataset object with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::Oracle::Dataset.new(self, opts)
+        include Sequel::JDBC::Transactions
+
+        def self.extended(db)
+          db.instance_eval do
+            @autosequence = opts[:autosequence]
+            @primary_key_sequences = {}
+          end
         end
         
         private
-        
-        # Use JDBC connection's setAutoCommit to false to start transactions
-        def begin_transaction(conn, opts={})
-          log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
-          conn
+
+        def last_insert_id(conn, opts)
+          unless sequence = opts[:sequence]
+            if t = opts[:table]
+              sequence = sequence_for_table(t)
+            end
+          end
+          if sequence
+            sql = "SELECT #{literal(sequence)}.currval FROM dual"
+            statement(conn) do |stmt|
+              begin
+                rs = log_yield(sql){stmt.executeQuery(sql)}
+                rs.next
+                rs.getInt(1)
+              rescue java.sql.SQLException
+                nil
+              end
+            end
+          end
         end
-        
-        # Use JDBC connection's commit method to commit transactions
-        def commit_transaction(conn, opts={})
-          log_yield(TRANSACTION_COMMIT){conn.commit}
+
+        # Primary key indexes appear to start with sys_ on Oracle
+        def primary_key_index_re
+          PRIMARY_KEY_INDEX_RE
         end
-        
-        # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
-        def remove_transaction(conn)
-          conn.setAutoCommit(true) if conn
-          @transactions.delete(Thread.current)
+
+        def schema_parse_table(*)
+          sch = super
+          sch.each do |c, s|
+            if s[:type] == :decimal && s[:scale] == -127
+              s[:type] = :integer
+            elsif s[:db_type] == 'DATE'
+              s[:type] = :datetime
+            end
+          end
+          sch
         end
-        
-        # Use JDBC connection's rollback method to rollback transactions
-        def rollback_transaction(conn, opts={})
-          log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+
+        def schema_parse_table_skip?(h, schema)
+          super || (h[:table_schem] != current_user unless schema)
+        end
+
+        # As of Oracle 9.2, releasing savepoints is no longer supported.
+        def supports_releasing_savepoints?
+          false
         end
       end
       
       # Dataset class for Oracle datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::Oracle::DatasetMethods
+
+        private
+
+        JAVA_BIG_DECIMAL = ::Sequel::JDBC::Dataset::JAVA_BIG_DECIMAL
+
+        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
+          def oracle_decimal(v)
+            if v.scale == 0
+              i = v.long_value
+              if v.equals(JAVA_BIG_DECIMAL.new(i))
+                i
+              else
+                decimal(v)
+              end
+            else
+              decimal(v)
+            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_proc(v)
+          case v
+          when JAVA_BIG_DECIMAL
+            ORACLE_DECIMAL_METHOD
+          when Java::OracleSql::TIMESTAMP
+            method(:convert_type_oracle_timestamp)
+          else
+            super
+          end
+        end
       end
     end
   end

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

@@ -7,32 +7,6 @@ module Sequel
     # Adapter, Database, and Dataset support for accessing a PostgreSQL
     # database via JDBC.
     module Postgres
-      # Methods to add to the JDBC adapter/connection to allow it to work
-      # with the shared PostgreSQL code.
-      module AdapterMethods
-        include Sequel::Postgres::AdapterMethods
-        
-        # Give the JDBC adapter a direct execute method, which creates
-        # a statement with the given sql and executes it.
-        def execute(sql, args=nil)
-          method = block_given? ? :executeQuery : :execute
-          @db.send(:statement, self) do |stmt|
-            rows = @db.log_yield(sql){stmt.send(method, sql)}
-            yield(rows) if block_given?
-          end
-        end
-        
-        private
-        
-        # JDBC specific method of getting specific values from a result set.
-        def single_value(r)
-          unless r.nil?
-            r.next
-            r.getString(1) unless r.getRow == 0
-          end
-        end
-      end
-    
       # Methods to add to Database instances that access PostgreSQL via
       # JDBC.
       module DatabaseMethods
@@ -41,54 +15,105 @@ module Sequel
         # 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 = {}
-            @primary_key_sequences = {}
-          end
-        end
-        
-        # Return instance of Sequel::JDBC::Postgres::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::Postgres::Dataset.new(self, opts)
-        end
-        
-        # Run the INSERT sql on the database and return the primary key
-        # for the record.
-        def execute_insert(sql, opts={})
-          super(sql, {:type=>:insert}.merge(opts))
+          db.send(:initialize_postgres_adapter)
         end
         
         private
         
-        # Extend the adapter with the JDBC PostgreSQL AdapterMethods
+        # Use setNull for nil arguments as the default behavior of setString
+        # with nil doesn't appear to work correctly on PostgreSQL.
+        def set_ps_arg_nil(cps, i)
+          cps.setNull(i, JavaSQL::Types::NULL)
+        end
+
+        # Execute the connection configuration SQL queries on the connection.
         def setup_connection(conn)
           conn = super(conn)
-          conn.extend(Sequel::JDBC::Postgres::AdapterMethods)
-          conn.db = self
-          conn.apply_connection_settings
+          statement(conn) do |stmt|
+            connection_configuration_sqls.each{|sql| log_yield(sql){stmt.execute(sql)}}
+          end
           conn
         end
-        
-        # Call insert_result with the table and values specified in the opts.
-        def last_insert_id(conn, opts)
-          insert_result(conn, opts[:table], opts[:values])
-        end
       end
       
       # Dataset subclass used for datasets that connect to PostgreSQL via JDBC.
       class Dataset < JDBC::Dataset
         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(*args)
           ps = super
           ps.extend(::Sequel::Postgres::DatasetMethods::PreparedStatementMethods)
           ps
         end
+
+        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)
+          case v
+          when Java::OrgPostgresqlJdbc4::Jdbc4Array
+            PGArrayConverter.new(method(:convert_type_proc))
+          when Java::OrgPostgresqlUtil::PGobject
+            PG_OBJECT_METHOD
+          else
+            super
+          end
+        end
         
         # Literalize strings similar to the native postgres adapter
-        def literal_string(v)
-          db.synchronize{|c| "'#{c.escape_string(v)}'"}
+        def literal_string_append(sql, v)
+          sql << APOS << db.synchronize{|c| c.escape_string(v)} << APOS
         end
       end
     end