sequel 4.42.1 → 4.43.0

data/lib/sequel/adapters/jdbc.rb

@@ -283,6 +283,12 @@ module Sequel
         execute(sql, opts)
       end
 
+      def freeze
+        @type_convertor_map.freeze
+        @basic_type_convertor_map.freeze
+        super
+      end
+
       # Use the JDBC metadata to get a list of foreign keys for the table.
       def foreign_key_list(table, opts=OPTS)
         m = output_identifier_meth

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

@@ -34,6 +34,11 @@ module Sequel
           :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}

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

@@ -26,6 +26,11 @@ module Sequel
           :hsqldb
         end
 
+        def freeze
+          db_version
+          super
+        end
+
         # HSQLDB uses an IDENTITY sequence as the default value for primary
         # key columns.
         def serial_primary_key_options
@@ -34,11 +39,10 @@ module Sequel
 
         # 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
+          return @db_version if defined?(@db_version)
+          v = get{DATABASE_VERSION(){}}
+          @db_version = if v =~ /(\d+)\.(\d+)\.(\d+)/
+            $1.to_i * 10000 + $2.to_i * 100 + $3.to_i
           end
         end
         

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

@@ -9,8 +9,8 @@ module Sequel
   module JDBC
     Sequel.synchronize do
       DATABASE_SETUP[:postgresql] = proc do |db|
-        db.extend(Sequel::JDBC::Postgres::DatabaseMethods)
         db.dataset_class = Sequel::JDBC::Postgres::Dataset
+        db.extend(Sequel::JDBC::Postgres::DatabaseMethods)
         org.postgresql.Driver
       end
     end

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

@@ -90,6 +90,11 @@ module Sequel
             end
           end
         end
+
+        # The result code for the exception, if the jdbc driver supports result codes for exceptions.
+        def sqlite_error_code(exception)
+          exception.resultCode.code if exception.respond_to?(:resultCode)
+        end
       end
     end
   end

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

@@ -10,6 +10,11 @@ module Sequel
       TRANSACTION_ROLLBACK_SP = 'Transaction.rollback_savepoint'.freeze
       TRANSACTION_SAVEPOINT= 'Transaction.savepoint'.freeze
 
+      def freeze
+        supports_savepoints?
+        super
+      end
+
       # Check the JDBC DatabaseMetaData for savepoint support
       def supports_savepoints?
         return @supports_savepoints if defined?(@supports_savepoints)

data/lib/sequel/adapters/mock.rb

@@ -48,7 +48,15 @@ module Sequel
       #         the value returned
       # Class :: Should be an Exception subclass, will create a new
       #          instance an raise it wrapped in a DatabaseError.
-      attr_writer :autoid
+      def autoid=(v)
+        @autoid = case v
+        when Integer
+          i = v - 1
+          proc{Sequel.synchronize{i+=1}}
+        else
+          v
+        end
+      end
 
       # Set the columns to set in the dataset when the dataset fetches
       # rows.  Argument types supported:
@@ -133,13 +141,8 @@ module Sequel
       private
 
       def _autoid(sql, v, ds=nil)
-        case v
-        when Integer
-          if ds
-            ds.send(:cache_set, :_autoid, ds.autoid + 1) if ds.autoid.is_a?(Integer)
-          else
-            @autoid += 1
-          end
+        if ds
+          ds.send(:cache_set, :_autoid, ds.autoid + 1) if ds.autoid.is_a?(Integer)
           v
         else
           _nextres(v, sql, nil)
@@ -192,7 +195,7 @@ module Sequel
           if f < Exception
             raise f
           else
-            raise Error, "Invalid @autoid/@numrows attribute: #{v.inspect}"
+            raise Error, "Invalid @fetch attribute: #{v.inspect}"
           end
         when nil
           # nothing

data/lib/sequel/adapters/mysql.rb

@@ -163,6 +163,12 @@ module Sequel
         execute(sql, opts){|c| return c.insert_id}
       end
 
+      def freeze
+        server_version
+        @conversion_procs.freeze
+        super
+      end
+
       # Return the version of the MySQL server two which we are connecting.
       def server_version(server=nil)
         @server_version ||= (synchronize(server){|conn| conn.server_version if conn.respond_to?(:server_version)} || super)

data/lib/sequel/adapters/mysql2.rb

@@ -47,7 +47,7 @@ module Sequel
         conn.query_options.merge!(:symbolize_keys=>true, :cache_rows=>false)
           
         if NativePreparedStatements
-          @default_query_options ||= conn.query_options.dup
+          conn.instance_variable_set(:@sequel_default_query_options, conn.query_options.dup)
         end
 
         sqls = mysql_connection_setting_sqls
@@ -76,6 +76,11 @@ module Sequel
         execute(sql, opts){|c| return c.last_id}
       end
 
+      def freeze
+        server_version
+        super
+      end
+
       # Return the version of the MySQL server to which we are connecting.
       def server_version(server=nil)
         @server_version ||= (synchronize(server){|conn| conn.server_info[:id]} || super)
@@ -158,7 +163,7 @@ module Sequel
           raise_error(e)
         ensure
           if stmt
-            conn.query_options.replace(@default_query_options)
+            conn.query_options.replace(conn.instance_variable_get(:@sequel_default_query_options))
             stmt.close if close_stmt
           end
         end

data/lib/sequel/adapters/oracle.rb

@@ -71,6 +71,11 @@ module Sequel
         _execute(:insert, sql, opts)
       end
 
+      def freeze
+        @conversion_procs.freeze
+        super
+      end
+
       private
 
       def _execute(type, sql, opts=OPTS, &block)

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

@@ -26,11 +26,17 @@ module Sequel
       # Return the database version as a string.  Don't rely on this,
       # it may return an integer in the future.
       def db2_version
-        return @db2_version if @db2_version
+        return @db2_version if defined?(@db2_version)
         @db2_version = metadata_dataset.with_sql("select service_level from sysibmadm.env_inst_info").first[:service_level]
       end
       alias_method :server_version, :db2_version
 
+      def freeze
+        db2_version
+        offset_strategy
+        super
+      end
+
       # Use SYSIBM.SYSCOLUMNS to get the information on the tables.
       def schema_parse_table(table, opts = OPTS)
         m = output_identifier_meth(opts[:dataset])

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

@@ -173,6 +173,11 @@ module Sequel
         h.values
       end
 
+      def freeze
+        server_version
+        super
+      end
+
       # Use the system tables to get index information
       def indexes(table, opts=OPTS)
         m = output_identifier_meth

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

@@ -89,6 +89,12 @@ module Sequel
         h.values
       end
 
+      def freeze
+        server_version
+        supports_timestamp_usecs?
+        super
+      end
+
       # MySQL namespaces indexes per table.
       def global_index_namespace?
         false
@@ -155,7 +161,8 @@ module Sequel
       # automatic initialization of datetime values wasn't supported to 5.6.5+,
       # and this is related to that.
       def supports_timestamp_usecs?
-        @supports_timestamp_usecs ||= server_version >= 50605 && typecast_value_boolean(opts[:fractional_seconds])
+        return @supports_timestamp_usecs if defined?(@supports_timestamp_usecs)
+        @supports_timestamp_usecs = server_version >= 50605 && typecast_value_boolean(opts[:fractional_seconds])
       end
 
       # MySQL supports transaction isolation levels

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

@@ -74,6 +74,13 @@ module Sequel
         fks.values
       end
 
+      def freeze
+        current_user
+        server_version
+        @conversion_procs.freeze
+        super
+      end
+
       # Oracle namespaces indexes per table.
       def global_index_namespace?
         false
@@ -237,7 +244,7 @@ module Sequel
       end
 
       def remove_cached_schema(table)
-        @primary_key_sequences.delete(table)
+        Sequel.synchronize{@primary_key_sequences.delete(table)}
         super
       end
       
@@ -253,19 +260,20 @@ module Sequel
     
       def sequence_for_table(table)
         return nil unless autosequence
-        @primary_key_sequences.fetch(table) do |key|
-          begin
-            sch = schema(table)
-          rescue Sequel::Error
-            return nil
-          end
+        Sequel.synchronize{return @primary_key_sequences[table] if @primary_key_sequences.has_key?(table)}
 
-          pk = sch.select{|k, v| v[:primary_key]}
-          @primary_key_sequences[table] = if pk.length == 1
-            seq = "seq_#{table}_#{pk.first.first}"
-            seq.to_sym unless from(:user_sequences).where(:sequence_name=>input_identifier_meth.call(seq)).empty?
-          end
+        begin
+          sch = schema(table)
+        rescue Sequel::Error
+          return nil
+        end
+
+        pk = sch.select{|k, v| v[:primary_key]}
+        pks = if pk.length == 1
+          seq = "seq_#{table}_#{pk.first.first}"
+          seq.to_sym unless from(:user_sequences).where(:sequence_name=>input_identifier_meth.call(seq)).empty?
         end
+        Sequel.synchronize{@primary_key_sequences[table] = pks}
       end
 
       # Oracle supports CREATE OR REPLACE VIEW.

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

@@ -373,6 +373,13 @@ module Sequel
         h.values
       end
 
+      def freeze
+        server_version
+        supports_prepared_transactions?
+        @conversion_procs.freeze
+        super
+      end
+
       # Use the pg_* system tables to determine indexes on a table
       def indexes(table, opts=OPTS)
         m = output_identifier_meth
@@ -580,8 +587,9 @@ module Sequel
       # Check whether the given type name string/symbol (e.g. :hstore) is supported by
       # the database.
       def type_supported?(type)
-        @supported_types ||= {}
-        @supported_types.fetch(type){@supported_types[type] = (from(:pg_type).where(:typtype=>'b', :typname=>type.to_s).count > 0)}
+        Sequel.synchronize{return @supported_types[type] if @supported_types.has_key?(type)}
+        supported = from(:pg_type).where(:typtype=>'b', :typname=>type.to_s).count > 0
+        Sequel.synchronize{return @supported_types[type] = supported}
       end
 
       # Creates a dataset that uses the VALUES clause:
@@ -1032,6 +1040,7 @@ module Sequel
       def initialize_postgres_adapter
         @primary_keys = {}
         @primary_key_sequences = {}
+        @supported_types = {}
         @conversion_procs = PG_TYPES.dup
         reset_conversion_procs
       end

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

@@ -37,6 +37,12 @@ module Sequel
         :sqlanywhere
       end
 
+      def freeze
+        convert_smallint_to_bool
+        @conversion_procs.freeze
+        super
+      end
+
       def to_application_timestamp_sa(v)
         to_application_timestamp(v.to_s) if v
       end

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

@@ -101,6 +101,12 @@ module Sequel
         h.values
       end
 
+      def freeze
+        sqlite_version
+        use_timestamp_timezones?
+        super
+      end
+
       # Use the index_list and index_info PRAGMAs to determine the indexes on the table.
       def indexes(table, opts=OPTS)
         m = output_identifier_meth
@@ -359,6 +365,24 @@ module Sequel
         DATABASE_ERROR_REGEXPS
       end
 
+      # Recognize SQLite error codes if the exception provides access to them.
+      def database_specific_error_class(exception, opts)
+        case sqlite_error_code(exception)
+        when 1299
+          NotNullConstraintViolation
+        when 2067
+          UniqueConstraintViolation
+        when 787
+          ForeignKeyConstraintViolation
+        when 275
+          CheckConstraintViolation
+        when 19
+          ConstraintViolation
+        else
+          super
+        end
+      end
+
       # The array of column schema hashes for the current columns in the table
       def defined_columns_for(table)
         cols = parse_pragma(table, {})
@@ -497,6 +521,11 @@ module Sequel
         end
       end
       
+      # Don't support SQLite error codes for exceptions by default.
+      def sqlite_error_code(exception)
+        nil
+      end
+
       # Backbone of the tables and views support.
       def tables_and_views(filter, opts)
         m = output_identifier_meth

data/lib/sequel/adapters/sqlanywhere.rb

@@ -98,6 +98,11 @@ module Sequel
         end
       end
 
+      def freeze
+        @conversion_procs.freeze
+        super
+      end
+
       private
 
       LAST_INSERT_ID = 'SELECT @@IDENTITY'.freeze

data/lib/sequel/adapters/sqlite.rb

@@ -151,6 +151,11 @@ module Sequel
         _execute(:insert, sql, opts)
       end
       
+      def freeze
+        @conversion_procs.freeze
+        super
+      end
+
       # Handle Integer and Float arguments, since SQLite can store timestamps as integers and floats.
       def to_application_timestamp(s)
         case s
@@ -269,6 +274,14 @@ module Sequel
       def database_error_classes
         [SQLite3::Exception, ArgumentError]
       end
+
+      # Support SQLite exception codes if ruby-sqlite3 supports them.
+      # This is disabled by default because ruby-sqlite3 doesn't currently
+      # support them (returning nil), and even if it did, it doesn't support
+      # extended error codes, which would lead to worse behavior.
+      #def sqlite_error_code(exception)
+      #  exception.code if exception.respond_to?(:code)
+      #end
     end
     
     # Dataset class for SQLite datasets that use the ruby-sqlite3 driver.

data/lib/sequel/connection_pool/sharded_single.rb

@@ -43,6 +43,11 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   def disconnect(opts=OPTS)
     (opts[:server] ? Array(opts[:server]) : servers).each{|s| disconnect_server(s)}
   end
+
+  def freeze
+    @servers.freeze
+    super
+  end
   
   # Yields the connection to the supplied block for the given server.
   # This method simulates the ConnectionPool#hold API.