sequel 3.44.0 → 3.45.0

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

@@ -54,6 +54,11 @@ module Sequel
         true
       end
 
+      # DB2 supports transaction isolation levels.
+      def supports_transaction_isolation_levels?
+        true
+      end
+
       private
 
       # Handle Oracle specific ALTER TABLE SQL
@@ -141,6 +146,7 @@ module Sequel
         /integrity constraint .+ violated/ => ForeignKeyConstraintViolation,
         /check constraint .+ violated/ => CheckConstraintViolation,
         /cannot insert NULL into|cannot update .+ to NULL/ => NotNullConstraintViolation,
+        /can't serialize access for this transaction/ => SerializationFailure,
       }.freeze
       def database_error_regexps
         DATABASE_ERROR_REGEXPS
@@ -159,6 +165,16 @@ module Sequel
         super
       end
       
+      TRANSACTION_ISOLATION_LEVELS = {:uncommitted=>'READ COMMITTED'.freeze,
+        :committed=>'READ COMMITTED'.freeze,
+        :repeatable=>'SERIALIZABLE'.freeze,
+        :serializable=>'SERIALIZABLE'.freeze}
+      # Oracle doesn't support READ UNCOMMITTED OR REPEATABLE READ transaction
+      # isolation levels, so upgrade to the next highest level in those cases.
+      def set_transaction_isolation_sql(level)
+        "SET TRANSACTION ISOLATION LEVEL #{TRANSACTION_ISOLATION_LEVELS[level]}"
+      end
+    
       def sequence_for_table(table)
         return nil unless autosequence
         @primary_key_sequences.fetch(table) do |key|
@@ -217,12 +233,6 @@ module Sequel
       FROM = Dataset::FROM
       BITCOMP_OPEN = "((0 - ".freeze
       BITCOMP_CLOSE = ") - 1)".freeze
-      ILIKE_0 = "(UPPER(".freeze
-      ILIKE_1 = ") ".freeze
-      ILIKE_2 = ' UPPER('.freeze
-      ILIKE_3 = "))".freeze
-      LIKE = 'LIKE'.freeze
-      NOT_LIKE = 'NOT LIKE'.freeze
       TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S%N %z'".freeze
       TIMESTAMP_OFFSET_FORMAT = "%+03i:%02i".freeze
       BOOL_FALSE = "'N'".freeze
@@ -230,7 +240,6 @@ module Sequel
       HSTAR = "H*".freeze
       DUAL = ['DUAL'.freeze].freeze
 
-      # Oracle needs to emulate bitwise operators and ILIKE/NOT ILIKE operators.
       def complex_expression_sql_append(sql, op, args)
         case op
         when :&
@@ -249,14 +258,6 @@ module Sequel
           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 :ILIKE, :'NOT ILIKE'
-          sql << ILIKE_0
-          literal_append(sql, args.at(0))
-          sql << ILIKE_1
-          sql << (op == :ILIKE ? LIKE : NOT_LIKE)
-          sql<< ILIKE_2
-          literal_append(sql, args.at(1))
-          sql << ILIKE_3
         else
           super
         end

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

@@ -4,15 +4,16 @@ module Sequel
   # Top level module for holding all PostgreSQL-related modules and classes
   # for Sequel.  There are a few module level accessors that are added via
   # metaprogramming.  These are:
-  # * client_min_messages (only available when using the native adapter) -
-  #   Change the minimum level of messages that PostgreSQL will send to the
-  #   the client.  The PostgreSQL default is NOTICE, the Sequel default is
-  #   WARNING.  Set to nil to not change the server default.
-  # * force_standard_strings - Set to false to not force the use of
-  #   standard strings
-  # * use_iso_date_format (only available when using the native adapter) -
-  #   Set to false to not change the date format to
-  #   ISO.  This disables one of Sequel's optimizations.
+  #
+  # client_min_messages :: Change the minimum level of messages that PostgreSQL will send to the
+  #                        the client.  The PostgreSQL default is NOTICE, the Sequel default is
+  #                        WARNING.  Set to nil to not change the server default. Overridable on
+  #                        a per instance basis via the :client_min_messages option.
+  # force_standard_strings :: Set to false to not force the use of standard strings.  Overridable
+  #                           on a per instance basis via the :force_standard_strings option.
+  # use_iso_date_format :: (only available when using the native adapter)
+  #                        Set to false to not change the date format to
+  #                        ISO.  This disables one of Sequel's optimizations.
   #
   # Changes in these settings only affect future connections.  To make
   # sure that they are applied, they should generally be called right
@@ -290,14 +291,13 @@ module Sequel
       # :name, :on_delete, :on_update, and :deferrable entries in the hashes.
       def foreign_key_list(table, opts={})
         m = output_identifier_meth
-        im = input_identifier_meth
-        schema, table = schema_and_table(table)
+        schema, _ = opts.fetch(:schema, schema_and_table(table))
         range = 0...32
 
         base_ds = metadata_dataset.
-          where(:cl__relkind=>'r', :co__contype=>'f', :cl__relname=>im.call(table)).
           from(:pg_constraint___co).
-          join(:pg_class___cl, :oid=>:conrelid)
+          join(:pg_class___cl, :oid=>:conrelid).
+          where(:cl__relkind=>'r', :co__contype=>'f', :cl__oid=>regclass_oid(table))
 
         # We split the parsing into two separate queries, which are merged manually later.
         # This is because PostgreSQL stores both the referencing and referenced columns in
@@ -320,8 +320,6 @@ module Sequel
         # If a schema is given, we only search in that schema, and the returned :table
         # entry is schema qualified as well.
         if schema
-          ds = ds.join(:pg_namespace___nsp, :oid=>:cl__relnamespace).
-            where(:nsp__nspname=>im.call(schema))
           ref_ds = ref_ds.join(:pg_namespace___nsp2, :oid=>:cl2__relnamespace).
             select_more(:nsp2__nspname___schema)
         end
@@ -347,21 +345,18 @@ module Sequel
       # Use the pg_* system tables to determine indexes on a table
       def indexes(table, opts={})
         m = output_identifier_meth
-        im = input_identifier_meth
-        schema, table = schema_and_table(table)
         range = 0...32
         attnums = server_version >= 80100 ? SQL::Function.new(:ANY, :ind__indkey) : range.map{|x| SQL::Subscript.new(:ind__indkey, [x])}
         ds = metadata_dataset.
           from(:pg_class___tab).
-          join(:pg_index___ind, :indrelid=>:oid, im.call(table)=>:relname).
+          join(:pg_index___ind, :indrelid=>:oid).
           join(:pg_class___indc, :oid=>:indexrelid).
           join(:pg_attribute___att, :attrelid=>:tab__oid, :attnum=>attnums).
           left_join(:pg_constraint___con, :conname=>:indc__relname).
-          filter(:indc__relkind=>'i', :ind__indisprimary=>false, :indexprs=>nil, :indpred=>nil, :indisvalid=>true).
+          filter(:indc__relkind=>'i', :ind__indisprimary=>false, :indexprs=>nil, :indpred=>nil, :indisvalid=>true, :tab__oid=>regclass_oid(table, opts)).
           order(:indc__relname, SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(:ind__indkey, [x]), x]}, 32, :att__attnum)).
           select(:indc__relname___name, :ind__indisunique___unique, :att__attname___column, :con__condeferrable___deferrable)
 
-        ds.join!(:pg_namespace___nsp, :oid=>:tab__relnamespace, :nspname=>schema.to_s) if schema
         ds.filter!(:indisready=>true, :indcheckxmin=>false) if server_version >= 80300
 
         indexes = {}
@@ -391,9 +386,7 @@ module Sequel
       def primary_key(table, opts={})
         quoted_table = quote_schema_table(table)
         Sequel.synchronize{return @primary_keys[quoted_table] if @primary_keys.has_key?(quoted_table)}
-        schema, table = schema_and_table(table)
-        sql = "#{SELECT_PK_SQL} AND pg_class.relname = #{literal(table)}"
-        sql << " AND pg_namespace.nspname = #{literal(schema)}" if schema
+        sql = "#{SELECT_PK_SQL} AND pg_class.oid = #{literal(regclass_oid(table, opts))}"
         value = fetch(sql).single_value
         Sequel.synchronize{@primary_keys[quoted_table] = value}
       end
@@ -402,16 +395,12 @@ module Sequel
       def primary_key_sequence(table, opts={})
         quoted_table = quote_schema_table(table)
         Sequel.synchronize{return @primary_key_sequences[quoted_table] if @primary_key_sequences.has_key?(quoted_table)}
-        schema, table = schema_and_table(table)
-        table = literal(table)
-        sql = "#{SELECT_SERIAL_SEQUENCE_SQL} AND t.relname = #{table}"
-        sql << " AND name.nspname = #{literal(schema)}" if schema
+        sql = "#{SELECT_SERIAL_SEQUENCE_SQL} AND t.oid = #{literal(regclass_oid(table, opts))}"
         if pks = fetch(sql).single_record
           value = literal(SQL::QualifiedIdentifier.new(pks[:schema], pks[:sequence]))
           Sequel.synchronize{@primary_key_sequences[quoted_table] = value}
         else
-          sql = "#{SELECT_CUSTOM_SEQUENCE_SQL} AND t.relname = #{table}"
-          sql << " AND name.nspname = #{literal(schema)}" if schema
+          sql = "#{SELECT_CUSTOM_SEQUENCE_SQL} AND t.oid = #{literal(regclass_oid(table, opts))}"
           if pks = fetch(sql).single_record
             value = literal(SQL::QualifiedIdentifier.new(pks[:schema], LiteralString.new(pks[:sequence])))
             Sequel.synchronize{@primary_key_sequences[quoted_table] = value}
@@ -513,8 +502,10 @@ module Sequel
       # otherwise, an array of symbols of table names is returned.
       #
       # Options:
-      # * :schema - The schema to search (default_schema by default)
-      # * :server - The server to use
+      # :qualify :: Return the tables as Sequel::SQL::QualifiedIdentifier instances,
+      #             using the schema the table is located in as the qualifier.
+      # :schema :: The schema to search (default_schema by default)
+      # :server :: The server to use
       def tables(opts={}, &block)
         pg_class_relname('r', opts, &block)
       end
@@ -529,8 +520,10 @@ module Sequel
       # Array of symbols specifying view names in the current database.
       #
       # Options:
-      # * :schema - The schema to search (default_schema by default)
-      # * :server - The server to use
+      # :qualify :: Return the views as Sequel::SQL::QualifiedIdentifier instances,
+      #             using the schema the view is located in as the qualifier.
+      # :schema :: The schema to search (default_schema by default)
+      # :server :: The server to use
       def views(opts={})
         pg_class_relname('v', opts)
       end
@@ -606,8 +599,8 @@ module Sequel
       # The SQL queries to execute when starting a new connection.
       def connection_configuration_sqls
         sqls = []
-        sqls << "SET standard_conforming_strings = ON" if Postgres.force_standard_strings
-        if cmm = Postgres.client_min_messages
+        sqls << "SET standard_conforming_strings = ON" if typecast_value_boolean(@opts.fetch(:force_standard_strings, Postgres.force_standard_strings))
+        if (cmm = @opts.fetch(:client_min_messages, Postgres.client_min_messages)) && !cmm.to_s.empty?
           sqls << "SET client_min_messages = '#{cmm.to_s.upcase}'"
         end
         sqls
@@ -630,13 +623,26 @@ module Sequel
         end
       end
 
-      DATABASE_ERROR_REGEXPS = {
-        /duplicate key value violates unique constraint/ => UniqueConstraintViolation,
-        /violates foreign key constraint/ => ForeignKeyConstraintViolation,
-        /violates check constraint/ => CheckConstraintViolation,
-        /violates not-null constraint/ => NotNullConstraintViolation,
-        /conflicting key value violates exclusion constraint/ => ExclusionConstraintViolation,
-      }.freeze
+      EXCLUSION_CONSTRAINT_SQL_STATE = '23P01'.freeze
+      def database_specific_error_class_from_sqlstate(sqlstate)
+        if sqlstate == EXCLUSION_CONSTRAINT_SQL_STATE
+          ExclusionConstraintViolation
+        else
+          super
+        end
+      end
+
+      DATABASE_ERROR_REGEXPS = [
+        # Add this check first, since otherwise it's possible for users to control
+        # which exception class is generated.
+        [/invalid input syntax/, DatabaseError],
+        [/duplicate key value violates unique constraint/, UniqueConstraintViolation],
+        [/violates foreign key constraint/, ForeignKeyConstraintViolation],
+        [/violates check constraint/, CheckConstraintViolation],
+        [/violates not-null constraint/, NotNullConstraintViolation],
+        [/conflicting key value violates exclusion constraint/, ExclusionConstraintViolation],
+        [/could not serialize access/, SerializationFailure],
+      ].freeze
       def database_error_regexps
         DATABASE_ERROR_REGEXPS
       end
@@ -834,7 +840,13 @@ module Sequel
         ds = metadata_dataset.from(:pg_class).filter(:relkind=>type).select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace)
         ds = filter_schema(ds, opts)
         m = output_identifier_meth
-        block_given? ? yield(ds) : ds.map{|r| m.call(r[:relname])}
+        if block_given?
+          yield(ds)
+        elsif opts[:qualify]
+          ds.select_append(:pg_namespace__nspname).map{|r| Sequel.qualify(m.call(r[:nspname]), m.call(r[:relname]))}
+        else
+          ds.map{|r| m.call(r[:relname])}
+        end
       end
 
       # Use a dollar sign instead of question mark for the argument
@@ -843,6 +855,28 @@ module Sequel
         PREPARED_ARG_PLACEHOLDER
       end
 
+      # Return an expression the oid for the table expr.  Used by the metadata parsing
+      # code to disambiguate unqualified tables.
+      def regclass_oid(expr, opts={})
+        if expr.is_a?(String) && !expr.is_a?(LiteralString)
+          expr = Sequel.identifier(expr)
+        end
+
+        sch, table = schema_and_table(expr)
+        sch ||= opts[:schema]
+        if sch
+          expr = Sequel.qualify(sch, table)
+        end
+        
+        expr = if ds = opts[:dataset]
+          ds.literal(expr)
+        else
+          literal(expr)
+        end
+
+        Sequel.cast(expr.to_s,:regclass).cast(:oid)
+      end
+
       # Remove the cached entries for primary keys and sequences when a table is
       # changed.
       def remove_cached_schema(table)
@@ -879,35 +913,22 @@ module Sequel
       # The dataset used for parsing table schemas, using the pg_* system catalogs.
       def schema_parse_table(table_name, opts)
         m = output_identifier_meth(opts[:dataset])
-        m2 = input_identifier_meth(opts[:dataset])
         ds = metadata_dataset.select(:pg_attribute__attname___name,
             SQL::Cast.new(:pg_attribute__atttypid, :integer).as(:oid),
             SQL::Function.new(:format_type, :pg_type__oid, :pg_attribute__atttypmod).as(:db_type),
             SQL::Function.new(:pg_get_expr, :pg_attrdef__adbin, :pg_class__oid).as(:default),
             SQL::BooleanExpression.new(:NOT, :pg_attribute__attnotnull).as(:allow_null),
-            SQL::Function.new(:COALESCE, SQL::BooleanExpression.from_value_pairs(:pg_attribute__attnum => SQL::Function.new(:ANY, :pg_index__indkey)), false).as(:primary_key),
-            :pg_namespace__nspname).
+            SQL::Function.new(:COALESCE, SQL::BooleanExpression.from_value_pairs(:pg_attribute__attnum => SQL::Function.new(:ANY, :pg_index__indkey)), false).as(:primary_key)).
           from(:pg_class).
           join(:pg_attribute, :attrelid=>:oid).
           join(:pg_type, :oid=>:atttypid).
-          join(:pg_namespace, :oid=>:pg_class__relnamespace).
           left_outer_join(:pg_attrdef, :adrelid=>:pg_class__oid, :adnum=>:pg_attribute__attnum).
           left_outer_join(:pg_index, :indrelid=>:pg_class__oid, :indisprimary=>true).
           filter(:pg_attribute__attisdropped=>false).
           filter{|o| o.pg_attribute__attnum > 0}.
-          filter(:pg_class__relname=>m2.call(table_name)).
+          filter(:pg_class__oid=>regclass_oid(table_name, opts)).
           order(:pg_attribute__attnum)
-        ds = filter_schema(ds, opts)
-        current_schema = nil
         ds.map do |row|
-          sch = row.delete(:nspname)
-          if current_schema
-            if sch != current_schema
-              raise Error, "columns from tables in two separate schema were returned (please specify a schema): #{current_schema.inspect}, #{sch.inspect}"
-            end
-          else
-            current_schema = sch
-          end
           row[:default] = nil if blank_object?(row[:default])
           row[:type] = schema_column_type(row[:db_type])
           [m.call(row.delete(:name)), row]
@@ -1010,6 +1031,8 @@ module Sequel
       PAREN_OPEN = Dataset::PAREN_OPEN
       PAREN_CLOSE = Dataset::PAREN_CLOSE
       COMMA = Dataset::COMMA
+      ESCAPE = Dataset::ESCAPE
+      BACKSLASH = Dataset::BACKSLASH
       AS = Dataset::AS
       XOR_OP = ' # '.freeze
       CRLF = "\r\n".freeze
@@ -1042,7 +1065,8 @@ module Sequel
       end
 
       # Handle converting the ruby xor operator (^) into the
-      # PostgreSQL xor operator (#).
+      # PostgreSQL xor operator (#), and use the ILIKE and NOT ILIKE
+      # operators.
       def complex_expression_sql_append(sql, op, args)
         case op
         when :^
@@ -1053,6 +1077,14 @@ module Sequel
             literal_append(sql, a)
             c ||= true
           end
+        when :ILIKE, :'NOT ILIKE'
+          sql << PAREN_OPEN
+          literal_append(sql, args.at(0))
+          sql << SPACE << op.to_s << SPACE
+          literal_append(sql, args.at(1))
+          sql << ESCAPE
+          literal_append(sql, BACKSLASH)
+          sql << PAREN_CLOSE
         else
           super
         end

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

@@ -496,13 +496,10 @@ module Sequel
         end
       end
 
-      # SQLite is case insensitive (depending on pragma), so use LIKE for ILIKE.
-      # It also doesn't support a NOT LIKE b, you need to use NOT (a LIKE b).
+      # SQLite doesn't support a NOT LIKE b, you need to use NOT (a LIKE b).
       # It doesn't support xor or the extract function natively, so those have to be emulated.
       def complex_expression_sql_append(sql, op, args)
         case op
-        when :ILIKE
-          super(sql, :LIKE, args.map{|a| SQL::Function.new(:upper, a)})
         when :"NOT LIKE", :"NOT ILIKE"
           sql << NOT_SPACE
           complex_expression_sql_append(sql, (op == :"NOT ILIKE" ? :ILIKE : :LIKE), args)

data/lib/sequel/adapters/tinytds.rb

@@ -109,6 +109,21 @@ module Sequel
         [TinyTds::Error]
       end
 
+      # Stupid MSSQL maps foreign key and check constraint violations
+      # to the same error code, and doesn't expose the sqlstate.  Use
+      # database error numbers if present and unambiguous, otherwise
+      # fallback to the regexp mapping.
+      def database_specific_error_class(exception, opts)
+        case exception.db_error_number
+        when 515
+          NotNullConstraintViolation
+        when 2627
+          UniqueConstraintViolation
+        else
+          super
+        end
+      end
+
       # Return true if the :conn argument is present and not active.
       def disconnect_error?(e, opts)
         super || (opts[:conn] && !opts[:conn].active?)

data/lib/sequel/connection_pool/threaded.rb

@@ -30,7 +30,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     @connection_handling = opts[:connection_handling]
     @available_connections = []
     @allocated = {}
-    @timeout = Integer(opts[:pool_timeout] || 5)
+    @timeout = Float(opts[:pool_timeout] || 5)
     @sleep_time = Float(opts[:pool_sleep_time] || 0.001)
   end
   

data/lib/sequel/core.rb

@@ -208,6 +208,12 @@ module Sequel
   def self.identifier_output_method=(value)
     Database.identifier_output_method = value
   end
+
+  # Parse the string as JSON and return the result.
+  # This is solely for internal use, it should not be used externally.
+  def self.parse_json(json) # :nodoc:
+    JSON.parse(json, :create_additions=>false)
+  end
   
   # Set whether to quote identifiers for all databases by default. By default,
   # Sequel quotes identifiers in all SQL strings, so to turn that off:
@@ -312,6 +318,7 @@ module Sequel
   end
 
   if defined?(RUBY_ENGINE) && RUBY_ENGINE != 'ruby'
+  # :nocov:
     # Mutex used to protect mutable data structures
     @data_mutex = Mutex.new
 
@@ -321,6 +328,7 @@ module Sequel
     def self.synchronize(&block)
       @single_threaded ? yield : @data_mutex.synchronize(&block)
     end
+  # :nocov:
   else
     # Yield directly to the block.  You don't need to synchronize
     # access on MRI because the GVL makes certain methods atomic.
@@ -424,7 +432,9 @@ module Sequel
   
   require(%w"sql connection_pool exceptions dataset database timezones ast_transformer version")
   if !defined?(::SEQUEL_NO_CORE_EXTENSIONS) && !ENV.has_key?('SEQUEL_NO_CORE_EXTENSIONS')
+  # :nocov:
     extension(:core_extensions)
+  # :nocov:
   end
 
   # Add the database adapter class methods to Sequel via metaprogramming

data/lib/sequel/database/connecting.rb

@@ -236,9 +236,11 @@ module Sequel
         @pool.hold(server || :default){|conn| yield conn}
       end
     else
+    # :nocov:
       def synchronize(server=nil, &block)
         @pool.hold(server || :default, &block)
       end
+    # :nocov:
     end
     
     # Attempts to acquire a database connection.  Returns true if successful.