sequel 3.44.0 → 3.45.0

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

@@ -10,6 +10,11 @@ module Sequel
 
         private
 
+        # JTDS exception handling with SQLState is less accurate than with regexps.
+        def database_exception_use_sqlstates?
+          false
+        end
+
         # 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))

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

@@ -20,6 +20,11 @@ module Sequel
           (m = /\/(.*)/.match(u.path)) && m[1]
         end
         
+        # MySQL exception handling with SQLState is less accurate than with regexps.
+        def database_exception_use_sqlstates?
+          false
+        end
+
         # Get the last inserted id using LAST_INSERT_ID().
         def last_insert_id(conn, opts={})
           if stmt = opts[:stmt]

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

@@ -21,6 +21,11 @@ module Sequel
         
         private
 
+        # Oracle exception handling with SQLState is less accurate than with regexps.
+        def database_exception_use_sqlstates?
+          false
+        end
+
         def last_insert_id(conn, opts)
           unless sequence = opts[:sequence]
             if t = opts[:table]
@@ -75,12 +80,13 @@ module Sequel
         private
 
         JAVA_BIG_DECIMAL = ::Sequel::JDBC::Dataset::JAVA_BIG_DECIMAL
+        JAVA_BIG_DECIMAL_CONSTRUCTOR = java.math.BigDecimal.java_class.constructor(Java::long).method(:new_instance)
 
         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))
+              if v.equals(JAVA_BIG_DECIMAL_CONSTRUCTOR.call(i))
                 i
               else
                 decimal(v)

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

@@ -30,7 +30,7 @@ module Sequel
 
         private
         
-        DATABASE_ERROR_REGEXPS = {/Abort due to constraint violation/ => ConstraintViolation}.freeze
+        DATABASE_ERROR_REGEXPS = Sequel::SQLite::DatabaseMethods::DATABASE_ERROR_REGEXPS.merge(/Abort due to constraint violation/ => ConstraintViolation).freeze
         def database_error_regexps
           DATABASE_ERROR_REGEXPS
         end

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

@@ -11,11 +11,33 @@ module Sequel
       # Check the JDBC DatabaseMetaData for savepoint support
       def supports_savepoints?
         return @supports_savepoints if defined?(@supports_savepoints)
-        @supports_savepoints = synchronize{|c| c.get_meta_data.supports_savepoints}
+        @supports_savepoints = synchronize{|c| c.getMetaData.supports_savepoints}
+      end
+
+      # Check the JDBC DatabaseMetaData for support for serializable isolation,
+      # since that's the value most people will use.
+      def supports_transaction_isolation_levels?
+        synchronize{|conn| conn.getMetaData.supportsTransactionIsolationLevel(JavaSQL::Connection::TRANSACTION_SERIALIZABLE)}
       end
 
       private
 
+      JDBC_TRANSACTION_ISOLATION_LEVELS = {:uncommitted=>JavaSQL::Connection::TRANSACTION_READ_UNCOMMITTED,
+        :committed=>JavaSQL::Connection::TRANSACTION_READ_COMMITTED,
+        :repeatable=>JavaSQL::Connection::TRANSACTION_REPEATABLE_READ,
+        :serializable=>JavaSQL::Connection::TRANSACTION_SERIALIZABLE}
+
+      # Set the transaction isolation level on the given connection using
+      # the JDBC API.
+      def set_transaction_isolation(conn, opts)
+        level = opts.fetch(:isolation, transaction_isolation_level)
+        if (jdbc_level = JDBC_TRANSACTION_ISOLATION_LEVELS[level]) &&
+            conn.getMetaData.supportsTransactionIsolationLevel(jdbc_level)
+          _trans(conn)[:original_jdbc_isolation_level] = conn.getTransactionIsolation
+          log_yield("Transaction.isolation_level = #{level}"){conn.setTransactionIsolation(jdbc_level)}
+        end
+      end
+
       # Most JDBC drivers that support savepoints support releasing them.
       def supports_releasing_savepoints?
         true
@@ -30,10 +52,12 @@ module Sequel
           else
             log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
             th[:savepoints] = []
+            set_transaction_isolation(conn, opts)
           end
           th[:savepoint_level] += 1
         else
           log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
+          set_transaction_isolation(conn, opts)
         end
       end
       
@@ -53,6 +77,9 @@ module Sequel
       
       # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
       def remove_transaction(conn, committed)
+        if jdbc_level = _trans(conn)[:original_jdbc_isolation_level]
+          conn.setTransactionIsolation(jdbc_level)
+        end
         if supports_savepoints?
           sps = _trans(conn)[:savepoints]
           conn.setAutoCommit(true) if sps.empty?

data/lib/sequel/adapters/mysql.rb

@@ -261,6 +261,10 @@ module Sequel
         [Mysql::Error]
       end
 
+      def database_exception_sqlstate(exception, opts)
+        exception.sqlstate
+      end
+
       # Raise a disconnect error if the exception message matches the list
       # of recognized exceptions.
       def disconnect_error?(e, opts)

data/lib/sequel/adapters/mysql2.rb

@@ -41,7 +41,7 @@ module Sequel
       def connect(server)
         opts = server_opts(server)
         opts[:host] ||= 'localhost'
-        opts[:username] ||= opts[:user]
+        opts[:username] ||= opts.delete(:user)
         opts[:flags] = ::Mysql2::Client::FOUND_ROWS if ::Mysql2::Client.const_defined?(:FOUND_ROWS)
         conn = ::Mysql2::Client.new(opts)
         conn.query_options.merge!(:symbolize_keys=>true, :cache_rows=>false)
@@ -105,6 +105,10 @@ module Sequel
         [::Mysql2::Error]
       end
 
+      def database_exception_sqlstate(exception, opts)
+        exception.sql_state
+      end
+
       # If a connection object is available, try pinging it.  Otherwise, if the
       # error is a Mysql2::Error, check the SQL state and exception message for
       # disconnects.

data/lib/sequel/adapters/oracle.rb

@@ -144,6 +144,23 @@ module Sequel
         [OCIException, RuntimeError]
       end
 
+      def database_specific_error_class(exception, opts)
+        case exception.code
+        when 1400, 1407
+          NotNullConstraintViolation
+        when 1
+          UniqueConstraintViolation
+        when 2291, 2292
+          ForeignKeyConstraintViolation
+        when 2290
+          CheckConstraintViolation
+        when 8177
+          SerializationFailure
+        else
+          super
+        end
+      end
+
       def execute_prepared_statement(conn, type, name, opts)
         ps = prepared_statement(name)
         sql = ps.prepared_sql
@@ -197,6 +214,7 @@ module Sequel
 
       def begin_transaction(conn, opts={})
         log_yield(TRANSACTION_BEGIN){conn.autocommit = false}
+        set_transaction_isolation(conn, opts)
       end
       
       def commit_transaction(conn, opts={})

data/lib/sequel/adapters/postgres.rb

@@ -20,7 +20,11 @@ rescue LoadError => e
         else
           # Raise an error if no valid string escaping method can be found.
           def escape_string(obj)
-            raise Sequel::Error, "string escaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
+            if Sequel::Postgres.force_standard_strings
+              str.gsub("'", "''")
+            else
+              raise Sequel::Error, "string escaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
+            end
           end
         end
       end
@@ -440,6 +444,12 @@ module Sequel
         [PGError]
       end
 
+      def database_exception_sqlstate(exception, opts)
+        if exception.respond_to?(:result) && (result = exception.result)
+          result.error_field(::PGresult::PG_DIAG_SQLSTATE)
+        end
+      end
+
       # Execute the prepared statement with the given name on an available
       # connection, using the given args.  If the connection has not prepared
       # a statement with the given name yet, prepare it.  If the connection

data/lib/sequel/adapters/shared/access.rb

@@ -94,6 +94,7 @@ module Sequel
       PAREN_OPEN = Dataset::PAREN_OPEN
       INTO = Dataset::INTO
       FROM = Dataset::FROM
+      SPACE = Dataset::SPACE
       NOT_EQUAL = ' <> '.freeze
       OPS = {:'%'=>' Mod '.freeze, :'||'=>' & '.freeze}
       BOOL_FALSE = '0'.freeze
@@ -125,9 +126,15 @@ module Sequel
       def complex_expression_sql_append(sql, op, args)
         case op
         when :ILIKE
-          super(sql, :LIKE, args)
+          complex_expression_sql_append(sql, :LIKE, args)
         when :'NOT ILIKE'
-          super(sql, :'NOT LIKE', args)
+          complex_expression_sql_append(sql, :'NOT LIKE', args)
+        when :LIKE, :'NOT LIKE'
+          sql << PAREN_OPEN
+          literal_append(sql, args.at(0))
+          sql << SPACE << op.to_s << SPACE
+          literal_append(sql, args.at(1))
+          sql << PAREN_CLOSE
         when :'!='
           sql << PAREN_OPEN
           literal_append(sql, args.at(0))
@@ -183,6 +190,11 @@ module Sequel
         end
       end
       
+      # Access uses [] to escape metacharacters, instead of backslashes.
+      def escape_like(string)
+        string.gsub(/[\\*#?\[]/){|m| "[#{m}]"}
+      end
+   
       # Specify a table for a SELECT ... INTO query.
       def into(table)
         clone(:into => table)

data/lib/sequel/adapters/shared/cubrid.rb

@@ -130,6 +130,7 @@ module Sequel
         /Operation would have caused one or more unique constraint violations/ => UniqueConstraintViolation,
         /The constraint of the foreign key .+ is invalid|Update\/Delete operations are restricted by the foreign key/ => ForeignKeyConstraintViolation,
         /cannot be made NULL/ => NotNullConstraintViolation,
+        /Your transaction .+ has been unilaterally aborted by the system/ => SerializationFailure,
       }.freeze
       def database_error_regexps
         DATABASE_ERROR_REGEXPS
@@ -163,17 +164,6 @@ module Sequel
       BOOL_FALSE = '0'.freeze
       BOOL_TRUE = '1'.freeze
 
-      def complex_expression_sql_append(sql, op, args)
-        case op
-        when :ILIKE
-          super(sql, :LIKE, [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1))])
-        when :"NOT ILIKE"
-          super(sql, :"NOT LIKE", [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1))])
-        else
-          super
-        end
-      end
-
       def supports_join_using?
         false
       end

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

@@ -72,6 +72,11 @@ module Sequel
         indexes
       end
 
+      # DB2 supports transaction isolation levels.
+      def supports_transaction_isolation_levels?
+        true
+      end
+
       private
 
       # Handle DB2 specific alter table operations.
@@ -159,6 +164,7 @@ module Sequel
         /DB2 SQL Error: (SQLCODE=-530, SQLSTATE=23503|SQLCODE=-532, SQLSTATE=23504)|The insert or update value of the FOREIGN KEY .+ is not equal to any value of the parent key of the parent table|A parent row cannot be deleted because the relationship .+ restricts the deletion/ => ForeignKeyConstraintViolation,
         /DB2 SQL Error: SQLCODE=-545, SQLSTATE=23513|The requested operation is not allowed because a row does not satisfy the check constraint/ => CheckConstraintViolation,
         /DB2 SQL Error: SQLCODE=-407, SQLSTATE=23502|Assignment of a NULL value to a NOT NULL column/ => NotNullConstraintViolation,
+        /DB2 SQL Error: SQLCODE=-911, SQLSTATE=40001|The current transaction has been rolled back because of a deadlock or timeout/ => SerializationFailure,
       }.freeze
       def database_error_regexps
         DATABASE_ERROR_REGEXPS
@@ -191,6 +197,11 @@ module Sequel
         (::Sequel::DB2::use_clob_as_blob && db_type.downcase == 'clob') ? :blob : super
       end
 
+      # SQL to set the transaction isolation level
+      def set_transaction_isolation_sql(level)
+        "SET CURRENT ISOLATION #{Database::TRANSACTION_ISOLATION_LEVELS[level]}"
+      end
+
       # We uses the clob type by default for Files.
       # Note: if user select to use blob, then insert statement should use 
       # use this for blob value:
@@ -241,14 +252,8 @@ module Sequel
         end
       end
 
-      # Handle DB2 specific LIKE and bitwise operator support, and
-      # emulate the extract method, which DB2 doesn't natively support.
       def complex_expression_sql_append(sql, op, args)
         case op
-        when :ILIKE
-          super(sql, :LIKE, [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1)) ])
-        when :"NOT ILIKE"
-          super(sql, :"NOT LIKE", [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1)) ])
         when :&, :|, :^
           # works with db2 v9.5 and after
           op = BITWISE_METHOD_MAP[op]

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

@@ -243,6 +243,7 @@ module Sequel
         /conflicted with the (FOREIGN KEY.*|REFERENCE) constraint/ => ForeignKeyConstraintViolation,
         /conflicted with the CHECK constraint/ => CheckConstraintViolation,
         /column does not allow nulls/ => NotNullConstraintViolation,
+        /was deadlocked on lock resources with another process and has been chosen as the deadlock victim/ => SerializationFailure,
       }.freeze
       def database_error_regexps
         DATABASE_ERROR_REGEXPS
@@ -309,8 +310,10 @@ module Sequel
       # The closest MSSQL equivalent of a boolean datatype is the bit type.
       def schema_column_type(db_type)
         case db_type
-        when /\A(bit)\z/io
+        when /\A(?:bit)\z/io
           :boolean
+        when /\A(?:(?:small)?money)\z/io
+          :decimal
         else
           super
         end
@@ -432,6 +435,8 @@ module Sequel
       DEFAULT_TIMESTAMP_FORMAT = "'%Y-%m-%dT%H:%M:%S%N%z'".freeze
       FORMAT_DATE = "'%Y%m%d'".freeze
 
+      Sequel::Dataset.def_mutation_method(:disable_insert_output, :output, :module=>self)
+
       # Allow overriding of the mssql_unicode_strings option at the dataset level.
       attr_accessor :mssql_unicode_strings
 
@@ -484,11 +489,11 @@ module Sequel
         clone(:disable_insert_output=>true)
       end
 
-      # Disable the use of INSERT OUTPUT, modifying the receiver
-      def disable_insert_output!
-        mutation_method(:disable_insert_output)
+      # MSSQL treats [] as a metacharacter in LIKE expresions.
+      def escape_like(string)
+        string.gsub(/[\\%_\[\]]/){|m| "\\#{m}"}
       end
-
+   
       # There is no function on Microsoft SQL Server that does character length
       # and respects trailing spaces (datalength respects trailing spaces, but
       # counts bytes instead of characters).  Use a hack to work around the
@@ -565,11 +570,6 @@ module Sequel
         clone({:output => output})
       end
 
-      # An output method that modifies the receiver.
-      def output!(into, values)
-        mutation_method(:output, into, values)
-      end
-
       # MSSQL uses [] to quote identifiers.  MSSQL does not support
       # escaping of ], so you cannot use that character in an identifier.
       def quoted_identifier_append(sql, name)

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

@@ -64,7 +64,7 @@ module Sequel
         im = input_identifier_meth
         ds = metadata_dataset.
           from(:INFORMATION_SCHEMA__KEY_COLUMN_USAGE).
-          where(:TABLE_NAME=>im.call(table)).
+          where(:TABLE_NAME=>im.call(table), :TABLE_SCHEMA=>Sequel.function(:DATABASE)).
           exclude(:CONSTRAINT_NAME=>'PRIMARY').
           exclude(:REFERENCED_TABLE_NAME=>nil).
           select(:CONSTRAINT_NAME___name, :COLUMN_NAME___column, :REFERENCED_TABLE_NAME___table, :REFERENCED_COLUMN_NAME___key)
@@ -196,6 +196,9 @@ module Sequel
           opts[:default] = o == :set_column_default ? op[:default] : opts[:ruby_default]
           opts.delete(:default) if opts[:default] == nil
           opts.delete(:primary_key)
+          unless op[:type] || opts[:type]
+            raise Error, "cannot determine database type to use for CHANGE COLUMN operation"
+          end
           "CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(op.merge(opts))}"
         when :drop_constraint
           type = case op[:type]
@@ -354,6 +357,7 @@ module Sequel
         /Duplicate entry .+ for key/ => UniqueConstraintViolation,
         /foreign key constraint fails/ => ForeignKeyConstraintViolation,
         /cannot be null/ => NotNullConstraintViolation,
+        /Deadlock found when trying to get lock; try restarting transaction/ => SerializationFailure,
       }.freeze
       def database_error_regexps
         DATABASE_ERROR_REGEXPS
@@ -505,6 +509,8 @@ module Sequel
       COMMA = Dataset::COMMA
       LIMIT = Dataset::LIMIT
       GROUP_BY = Dataset::GROUP_BY
+      ESCAPE = Dataset::ESCAPE
+      BACKSLASH = Dataset::BACKSLASH
       REGEXP = 'REGEXP'.freeze
       LIKE = 'LIKE'.freeze
       BINARY = 'BINARY '.freeze
@@ -551,6 +557,10 @@ module Sequel
           sql << SPACE
           sql << BINARY if [:~, :'!~', :LIKE, :'NOT LIKE'].include?(op)
           literal_append(sql, args.at(1))
+          if [:LIKE, :'NOT LIKE', :ILIKE, :'NOT ILIKE'].include?(op)
+            sql << ESCAPE
+            literal_append(sql, BACKSLASH)
+          end
           sql << PAREN_CLOSE
         when :'||'
           if args.length > 1

data/lib/sequel/adapters/shared/mysql_prepared_statements.rb

@@ -44,6 +44,22 @@ module Sequel
           conn.prepared_statements = {}
         end
 
+        # Stupid MySQL doesn't use SQLState error codes correctly, mapping
+        # all constraint violations to 23000 even though it recognizes
+        # different types.
+        def database_specific_error_class(exception, opts)
+          case exception.errno
+          when 1048
+            NotNullConstraintViolation
+          when 1062
+            UniqueConstraintViolation
+          when 1451, 1452
+            ForeignKeyConstraintViolation
+          else
+            super
+          end
+        end
+
         # Executes a prepared statement on an available connection.  If the
         # prepared statement already exists for the connection and has the same
         # SQL, reuse it, otherwise, prepare the new statement.  Because of the
@@ -65,8 +81,8 @@ module Sequel
             _execute(conn, "EXECUTE #{ps_name}#{" USING #{(1..i).map{|j| "@sequel_arg_#{j}"}.join(', ')}" unless i == 0}", opts, &block)
           end
         end
-        
       end
+
       module DatasetMethods
         include Sequel::Dataset::StoredProcedures