sequel 3.46.0 → 3.47.0

data/lib/sequel/adapters/mock.rb

@@ -151,6 +151,8 @@ module Sequel
           if pr = SHARED_ADAPTER_SETUP[opts[:host]]
             pr.call(self)
           end
+        else
+          @shared_adapter = false
         end
         self.autoid = opts[:autoid]
         self.columns = opts[:columns]

data/lib/sequel/adapters/postgres.rb

@@ -96,6 +96,15 @@ module Sequel
       def bytea(s) ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s)) end
     end.new.method(:bytea)
 
+    @use_iso_date_format = true
+
+    class << self
+      # As an optimization, Sequel sets the date style to ISO, so that PostgreSQL provides
+      # the date in a known format that Sequel can parse faster.  This can be turned off
+      # if you require a date style other than ISO.
+      attr_accessor :use_iso_date_format
+    end
+
     # PGconn subclass for connection specific methods used with the
     # pg, postgres, or postgres-pr driver.
     class Adapter < ::PGconn
@@ -160,18 +169,20 @@ module Sequel
       
       set_adapter_scheme :postgres
 
-      # Whether infinite timestamps should be converted on retrieval.  By default, no
+      # Whether infinite timestamps/dates should be converted on retrieval.  By default, no
       # conversion is done, so an error is raised if you attempt to retrieve an infinite
-      # timestamp.  You can set this to :nil to convert to nil, :string to leave
+      # timestamp/date.  You can set this to :nil to convert to nil, :string to leave
       # as a string, or :float to convert to an infinite float.
       attr_reader :convert_infinite_timestamps
-      
+
       # Add the primary_keys and primary_key_sequences instance variables,
       # so we can get the correct return values for inserted rows.
       def initialize(*args)
         super
-        @convert_infinite_timestamps = false
+        @use_iso_date_format = typecast_value_boolean(@opts.fetch(:use_iso_date_format, Postgres.use_iso_date_format))
         initialize_postgres_adapter
+        conversion_procs[1082] = TYPE_TRANSLATOR.method(:date) if @use_iso_date_format
+        self.convert_infinite_timestamps = @opts[:convert_infinite_timestamps]
       end
 
       # Convert given argument so that it can be used directly by pg.  Currently, pg doesn't
@@ -233,16 +244,32 @@ module Sequel
         conn
       end
       
+      # Set whether to allow infinite timestamps/dates.  Make sure the
+      # conversion proc for date reflects that setting.
       def convert_infinite_timestamps=(v)
-        @convert_infinite_timestamps = v
-        pr = old_pr = Postgres.use_iso_date_format ? TYPE_TRANSLATOR.method(:date) : Sequel.method(:string_to_date)
+        @convert_infinite_timestamps = case v
+        when Symbol
+          v
+        when 'nil'
+          :nil
+        when 'string'
+          :string
+        when 'float'
+          :float
+        when String
+          typecast_value_boolean(v)
+        else
+          false
+        end
+
+        pr = old_pr = @use_iso_date_format ? TYPE_TRANSLATOR.method(:date) : Sequel.method(:string_to_date)
         if v
-          pr = lambda do |v|
-            case v
+          pr = lambda do |val|
+            case val
             when *INFINITE_TIMESTAMP_STRINGS
-              infinite_timestamp_value(v)
+              infinite_timestamp_value(val)
             else
-              old_pr.call(v)
+              old_pr.call(val)
             end
           end
         end
@@ -345,7 +372,7 @@ module Sequel
                   conn.put_copy_data(buf)
                 end
               else
-                data.each{|buf| conn.put_copy_data(buf)}
+                data.each{|buff| conn.put_copy_data(buff)}
               end
             rescue Exception => e
               conn.put_copy_end("ruby exception occurred while copying data into PostgreSQL")
@@ -385,7 +412,11 @@ module Sequel
             synchronize(opts[:server]) do |conn|
               begin
                 channels = Array(channels)
-                channels.each{|channel| conn.execute("LISTEN #{dataset.send(:table_ref, channel)}")}
+                channels.each do |channel|
+                  sql = "LISTEN "
+                  dataset.send(:identifier_append, sql, channel)
+                  conn.execute(sql)
+                end
                 opts[:after_listen].call(conn) if opts[:after_listen]
                 timeout = opts[:timeout] ? [opts[:timeout]] : []
                 if l = opts[:loop]
@@ -452,7 +483,7 @@ module Sequel
       # Set the DateStyle to ISO if configured, for faster date parsing.
       def connection_configuration_sqls
         sqls = super
-        sqls << "SET DateStyle = 'ISO'" if Postgres.use_iso_date_format
+        sqls << "SET DateStyle = 'ISO'" if @use_iso_date_format
         sqls
       end
 

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

@@ -1,4 +1,4 @@
-Sequel.require %w'emulate_offset_with_row_number split_alter_table', 'adapters/utils/'
+Sequel.require %w'emulate_offset_with_row_number split_alter_table', 'adapters/utils'
 
 module Sequel
   Dataset::NON_SQL_OPTIONS << :disable_insert_output

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

@@ -203,7 +203,7 @@ module Sequel
           opts.delete(:auto_increment) if op[:auto_increment] == false
           "CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(opts)}"
         when :drop_constraint
-          type = case op[:type]
+          case op[:type]
           when :primary_key
             "DROP PRIMARY KEY"
           when :foreign_key
@@ -881,7 +881,7 @@ module Sequel
       def limit_sql(sql)
         if l = @opts[:limit]
           sql << LIMIT
-          literal_append(sql, @opts[:limit])
+          literal_append(sql, l)
         end
       end
       alias delete_limit_sql limit_sql

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

@@ -11,25 +11,17 @@ module Sequel
   #                        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
-  # after the Database object is instantiated and before a connection
-  # is actually made. For example, to use whatever the server defaults are:
+  # It is not recommened you use these module-level accessors.  Instead,
+  # use the database option to make the setting per-Database.
   #
-  #   DB = Sequel.postgres(...)
-  #   Sequel::Postgres.client_min_messages = nil
-  #   Sequel::Postgres.force_standard_strings = false
-  #   Sequel::Postgres.use_iso_date_format = false
-  #   # A connection to the server is not made until here
-  #   DB[:t].all
+  # All adapters that connect to PostgreSQL support the following option in
+  # addition to those mentioned above:
   #
-  # The reason they can't be done earlier is that the Sequel::Postgres
-  # module is not loaded until a Database object which uses PostgreSQL
-  # is created.
+  # :search_path :: Set the schema search_path for this Database's connections.
+  #                 Allows to to set which schemas do not need explicit
+  #                 qualification, and in which order to check the schemas when
+  #                 an unqualified object is referenced.
   module Postgres
     # Array of exceptions that need to be converted.  JDBC
     # uses NativeExceptions, the native adapter uses PGError.
@@ -155,9 +147,6 @@ module Sequel
       end_sql
       ).strip.gsub(/\s+/, ' ').freeze
 
-      # The Sequel extensions that require reseting of the conversion procs.
-      RESET_PROCS_EXTENSIONS = [:pg_array, :pg_hstore, :pg_inet, :pg_interval, :pg_json, :pg_range].freeze
-
       # A hash of conversion procs, keyed by type integer (oid) and
       # having callable values for the conversion proc for that type.
       attr_reader :conversion_procs
@@ -276,17 +265,6 @@ module Sequel
         self << drop_trigger_sql(table, name, opts)
       end
 
-      # If any of the extensions that require reseting the conversion procs
-      # is loaded, reset them.  This is done here so that if you load
-      # multiple pg_* extensions in the same call, the conversion procs are
-      # only reset once instead of once for every extension.
-      def extension(*exts)
-        super
-        unless (RESET_PROCS_EXTENSIONS & exts).empty?
-          reset_conversion_procs
-        end
-      end
-
       # Return full foreign key information using the pg system tables, including
       # :name, :on_delete, :on_update, and :deferrable entries in the hashes.
       def foreign_key_list(table, opts={})
@@ -379,7 +357,13 @@ module Sequel
       # :server :: The server to which to send the NOTIFY statement, if the sharding support
       #            is being used.
       def notify(channel, opts={})
-        execute_ddl("NOTIFY #{dataset.send(:table_ref, channel)}#{", #{literal(opts[:payload].to_s)}" if opts[:payload]}", opts)
+        sql = "NOTIFY "
+        dataset.send(:identifier_append, sql, channel)
+        if payload = opts[:payload]
+          sql << ", "
+          dataset.literal_append(sql, payload.to_s)
+        end
+        execute_ddl(sql, opts)
       end
 
       # Return primary key for the given table.
@@ -530,6 +514,16 @@ module Sequel
 
       private
 
+      # Do a type name-to-oid lookup using the database and update the procs
+      # with the related proc if the database supports the type.
+      def add_named_conversion_procs(procs, named_procs)
+        unless (named_procs).empty?
+          convert_named_procs_to_procs(named_procs).each do |oid, pr|
+            procs[oid] ||= pr
+          end
+        end
+      end
+
       # Use a PostgreSQL-specific alter table generator
       def alter_table_generator_class
         Postgres::AlterTableGenerator
@@ -596,13 +590,29 @@ module Sequel
         (super || op[:op] == :validate_constraint) && op[:op] != :rename_column
       end
 
+      VALID_CLIENT_MIN_MESSAGES = %w'DEBUG5 DEBUG4 DEBUG3 DEBUG2 DEBUG1 LOG NOTICE WARNING ERROR FATAL PANIC'.freeze
       # The SQL queries to execute when starting a new connection.
       def connection_configuration_sqls
         sqls = []
+
         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
+
+        if search_path = @opts[:search_path]
+          case search_path
+          when String
+            search_path = search_path.split(",").map{|s| s.strip}
+          when Array
+            # nil
+          else
+            raise Error, "unrecognized value for :search_path option: #{search_path.inspect}"
+          end
+          sqls << "SET search_path = #{search_path.map{|s| "\"#{s.gsub('"', '""')}\""}.join(',')}"
+        end
+
         sqls
       end
 
@@ -623,6 +633,24 @@ module Sequel
         end
       end
 
+      # Convert the hash of named conversion procs into a hash a oid conversion procs. 
+      def convert_named_procs_to_procs(named_procs)
+        h = {}
+        from(:pg_type).where(:typtype=>'b', :typname=>named_procs.keys.map{|t| t.to_s}).select_map([:oid, :typname]).each do |oid, name|
+          h[oid.to_i] = named_procs[name.untaint.to_sym]
+        end
+        h
+      end
+
+      # Copy the conversion procs related to the given oids from PG_TYPES into
+      # the conversion procs for this instance.
+      def copy_conversion_procs(oids)
+        procs = conversion_procs
+        oids.each do |oid|
+          procs[oid] = PG_TYPES[oid]
+        end
+      end
+
       EXCLUSION_CONSTRAINT_SQL_STATE = '23P01'.freeze
       def database_specific_error_class_from_sqlstate(sqlstate)
         if sqlstate == EXCLUSION_CONSTRAINT_SQL_STATE
@@ -665,23 +693,23 @@ module Sequel
 
       # SQL for doing fast table output to stdout.
       def copy_table_sql(table, opts)
-         if table.is_a?(String)
-           return table
-         else
-           if opts[:options] || opts[:format]
-             options = " ("
-             options << "FORMAT #{opts[:format]}" if opts[:format]
-             options << "#{', ' if opts[:format]}#{opts[:options]}" if opts[:options]
-             options << ')'
-           end
-           table = if table.is_a?(::Sequel::Dataset)
-             "(#{table.sql})"
-           else
-             literal(table)
-           end
-          return "COPY #{table} TO STDOUT#{options}"
-         end
-       end
+        if table.is_a?(String)
+          table
+        else
+          if opts[:options] || opts[:format]
+            options = " ("
+            options << "FORMAT #{opts[:format]}" if opts[:format]
+            options << "#{', ' if opts[:format]}#{opts[:options]}" if opts[:options]
+            options << ')'
+          end
+          table = if table.is_a?(::Sequel::Dataset)
+            "(#{table.sql})"
+          else
+            literal(table)
+          end
+          "COPY #{table} TO STDOUT#{options}"
+        end
+      end
 
       # SQL statement to create database function.
       def create_function_sql(name, definition, opts={})
@@ -786,11 +814,7 @@ module Sequel
       def get_conversion_procs
         procs = PG_TYPES.dup
         procs[1184] = procs[1114] = method(:to_application_timestamp)
-        unless (pgnt = PG_NAMED_TYPES).empty?
-          from(:pg_type).where(:typtype=>'b', :typname=>pgnt.keys.map{|t| t.to_s}).select_map([:oid, :typname]).each do |oid, name|
-            procs[oid.to_i] ||= pgnt[name.untaint.to_sym]
-          end
-        end
+        add_named_conversion_procs(procs, PG_NAMED_TYPES)
         procs
       end
 
@@ -915,6 +939,8 @@ module Sequel
         m = output_identifier_meth(opts[:dataset])
         ds = metadata_dataset.select(:pg_attribute__attname___name,
             SQL::Cast.new(:pg_attribute__atttypid, :integer).as(:oid),
+            SQL::Cast.new(:basetype__oid, :integer).as(:base_oid),
+            SQL::Function.new(:format_type, :basetype__oid, :pg_type__typtypmod).as(:db_base_type),
             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),
@@ -922,6 +948,7 @@ module Sequel
           from(:pg_class).
           join(:pg_attribute, :attrelid=>:oid).
           join(:pg_type, :oid=>:atttypid).
+          left_outer_join(:pg_type___basetype, :oid=>:typbasetype).
           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).
@@ -930,6 +957,15 @@ module Sequel
           order(:pg_attribute__attnum)
         ds.map do |row|
           row[:default] = nil if blank_object?(row[:default])
+          if row[:base_oid]
+            row[:domain_oid] = row[:oid]
+            row[:oid] = row.delete(:base_oid)
+            row[:db_domain_type] = row[:db_type]
+            row[:db_type] = row.delete(:db_base_type)
+          else
+            row.delete(:base_oid)
+            row.delete(:db_base_type)
+          end
           row[:type] = schema_column_type(row[:db_type])
           [m.call(row.delete(:name)), row]
         end
@@ -1009,7 +1045,6 @@ module Sequel
       FOR_SHARE = ' FOR SHARE'.freeze
       INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'insert into columns values returning')
       INSERT_CLAUSE_METHODS_91 = Dataset.clause_methods(:insert, %w'with insert into columns values returning')
-      LOCK = 'LOCK TABLE %s IN %s MODE'.freeze
       NULL = LiteralString.new('NULL').freeze
       PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
       QUERY_PLAN = 'QUERY PLAN'.to_sym
@@ -1039,6 +1074,7 @@ module Sequel
       BLOB_RE = /[\000-\037\047\134\177-\377]/n.freeze
       WINDOW = " WINDOW ".freeze
       EMPTY_STRING = ''.freeze
+      LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each{|s| s.freeze}
 
       # Shared methods for prepared statements when used with PostgreSQL databases.
       module PreparedStatementMethods
@@ -1140,7 +1176,10 @@ module Sequel
         if block_given? # perform locking inside a transaction and yield to block
           @db.transaction(opts){lock(mode, opts); yield}
         else
-          @db.execute(LOCK % [source_list(@opts[:from]), mode], opts) # lock without a transaction
+          sql = 'LOCK TABLE '
+          source_list_append(sql, @opts[:from])
+          sql << " IN #{mode} MODE"
+          @db.execute(sql, opts) # lock without a transaction
         end
         nil
       end

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

@@ -661,7 +661,9 @@ module Sequel
         SELECT_CLAUSE_METHODS
       end
       
-      # Support FOR SHARE locking when using the :share lock style.
+      # SQLite does not support FOR UPDATE, but silently ignore it
+      # instead of raising an error for compatibility with other
+      # databases.
       def select_lock_sql(sql)
         super unless @opts[:lock] == :update
       end

data/lib/sequel/adapters/sqlite.rb

@@ -356,8 +356,8 @@ module Sequel
           @columns = cols.map{|c| c.first}
           result.each do |values|
             row = {}
-            cols.each do |name,i,type_proc|
-              v = values[i]
+            cols.each do |name,id,type_proc|
+              v = values[id]
               if type_proc && v
                 v = type_proc.call(v)
               end

data/lib/sequel/adapters/utils/pg_types.rb

@@ -59,23 +59,10 @@ module Sequel
       [700, 701] => tt.method(:float),
       [1700] => ::BigDecimal.method(:new),
       [1083, 1266] => ::Sequel.method(:string_to_time),
+      [1082] => ::Sequel.method(:string_to_date),
       [1184, 1114] => ::Sequel.method(:database_to_application_timestamp),
     }.each do |k,v|
       k.each{|n| PG_TYPES[n] = v}
     end
-    
-    class << self
-      # As an optimization, Sequel sets the date style to ISO, so that PostgreSQL provides
-      # the date in a known format that Sequel can parse faster.  This can be turned off
-      # if you require a date style other than ISO.
-      attr_reader :use_iso_date_format
-    end
-
-    # Modify the type translator for the date type depending on the value given.
-    def self.use_iso_date_format=(v)
-      PG_TYPES[1082] = v ? TYPE_TRANSLATOR.method(:date) : Sequel.method(:string_to_date)
-      @use_iso_date_format = v
-    end
-    self.use_iso_date_format = true
   end
 end