sequel 5.22.0 → 5.26.0

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

@@ -97,13 +97,17 @@ module Sequel
       # Add an exclusion constraint when creating the table. Elements should be
       # an array of 2 element arrays, with the first element being the column or
       # expression the exclusion constraint is applied to, and the second element
-      # being the operator to use for the column/expression to check for exclusion.
-      #
-      # Example:
+      # being the operator to use for the column/expression to check for exclusion:
       #
       #   exclude([[:col1, '&&'], [:col2, '=']])
       #   # EXCLUDE USING gist (col1 WITH &&, col2 WITH =)
       #
+      # To use a custom operator class, you need to use Sequel.lit with the expression
+      # and operator class:
+      #
+      #   exclude([[Sequel.lit('col1 inet_ops'), '&&'], [:col2, '=']])
+      #   # EXCLUDE USING gist (col1 inet_ops WITH &&, col2 WITH =)
+      #
       # Options supported:
       #
       # :name :: Name the constraint with the given name (useful if you may
@@ -836,10 +840,14 @@ module Sequel
       # default value is given.
       def column_definition_default_sql(sql, column)
         super
-        if !column[:serial] && !['serial', 'bigserial'].include?(column[:type].to_s) && !column[:default] && (identity = column[:identity])
-          sql << " GENERATED "
-          sql << (identity == :always ? "ALWAYS" : "BY DEFAULT")
-          sql << " AS IDENTITY"
+        if !column[:serial] && !['serial', 'bigserial'].include?(column[:type].to_s) && !column[:default]
+          if (identity = column[:identity])
+            sql << " GENERATED "
+            sql << (identity == :always ? "ALWAYS" : "BY DEFAULT")
+            sql << " AS IDENTITY"
+          elsif (generated = column[:generated_always_as])
+            sql << " GENERATED ALWAYS AS (#{literal(generated)}) STORED"
+          end
         end
       end
 
@@ -1798,6 +1806,16 @@ module Sequel
         end
       end
 
+      # Include aliases when inserting into a single table on PostgreSQL 9.5+.
+      def insert_into_sql(sql)
+        sql << " INTO "
+        if (f = @opts[:from]) && f.length == 1
+          identifier_append(sql, server_version >= 90500 ? f.first : unaliased_identifier(f.first))
+        else
+          source_list_append(sql, f)
+        end
+      end
+
       # Return the primary key to use for RETURNING in an INSERT statement
       def insert_pk
         if (f = opts[:from]) && !f.empty?

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

@@ -10,6 +10,10 @@ module Sequel
     def self.mock_adapter_setup(db)
       db.instance_exec do
         @sqlite_version = 30903
+
+        def schema_parse_table(*)
+          []
+        end
       end
     end
     
@@ -60,7 +64,7 @@ module Sequel
       def foreign_key_list(table, opts=OPTS)
         m = output_identifier_meth
         h = {}
-        metadata_dataset.with_sql("PRAGMA foreign_key_list(?)", input_identifier_meth.call(table)).each do |row|
+        _foreign_key_list_ds(table).each do |row|
           if r = h[row[:id]]
             r[:columns] << m.call(row[:from])
             r[:key] << m.call(row[:to]) if r[:key]
@@ -173,6 +177,16 @@ module Sequel
 
       private
 
+      # Dataset used for parsing foreign key lists
+      def _foreign_key_list_ds(table)
+        metadata_dataset.with_sql("PRAGMA foreign_key_list(?)", input_identifier_meth.call(table))
+      end
+
+      # Dataset used for parsing schema
+      def _parse_pragma_ds(table_name, opts)
+        metadata_dataset.with_sql("PRAGMA table_info(?)", input_identifier_meth(opts[:dataset]).call(table_name))
+      end
+
       # Run all alter_table commands in a transaction.  This is technically only
       # needed for drop column.
       def apply_alter_table(table, ops)
@@ -445,7 +459,7 @@ module Sequel
       # Parse the output of the table_info pragma
       def parse_pragma(table_name, opts)
         pks = 0
-        sch = metadata_dataset.with_sql("PRAGMA table_info(?)", input_identifier_meth(opts[:dataset]).call(table_name)).map do |row|
+        sch = _parse_pragma_ds(table_name, opts).map do |row|
           row.delete(:cid)
           row[:allow_null] = row.delete(:notnull).to_i == 0
           row[:default] = row.delete(:dflt_value)

data/lib/sequel/adapters/tinytds.rb

@@ -16,6 +16,18 @@ module Sequel
         c = TinyTds::Client.new(opts)
         c.query_options.merge!(:cache_rows=>false)
 
+        if opts[:ansi]
+          sql = %w(
+            ANSI_NULLS
+            ANSI_PADDING
+            ANSI_WARNINGS
+            ANSI_NULL_DFLT_ON
+            QUOTED_IDENTIFIER
+            CONCAT_NULL_YIELDS_NULL
+          ).map{|v| "SET #{v} ON"}.join(";")
+          log_connection_yield(sql, c){c.execute(sql)}
+        end
+
         if (ts = opts[:textsize])
           sql = "SET TEXTSIZE #{typecast_value_integer(ts)}"
           log_connection_yield(sql, c){c.execute(sql)}

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

@@ -55,7 +55,7 @@ module Sequel
             NotNullConstraintViolation
           when 1062
             UniqueConstraintViolation
-          when 1451, 1452
+          when 1451, 1452, 1216, 1217
             ForeignKeyConstraintViolation
           when 4025
             CheckConstraintViolation

data/lib/sequel/database/logging.rb

@@ -35,7 +35,7 @@ module Sequel
     # Yield to the block, logging any errors at error level to all loggers,
     # and all other queries with the duration at warn or info level.
     def log_connection_yield(sql, conn, args=nil)
-      return yield if @loggers.empty?
+      return yield if skip_logging?
       sql = "#{connection_info(conn) if conn && log_connection_info}#{sql}#{"; #{args.inspect}" if args}"
       timer = Sequel.start_timer
 
@@ -58,6 +58,12 @@ module Sequel
 
     private
 
+    # Determine if logging should be skipped. Defaults to true if no loggers
+    # have been specified.
+    def skip_logging?
+      @loggers.empty?
+    end
+
     # String including information about the connection, for use when logging
     # connection info.
     def connection_info(conn)

data/lib/sequel/database/schema_generator.rb

@@ -110,6 +110,9 @@ module Sequel
       #                yet exist on referenced table (but will exist before the transaction commits).
       #                Basically it adds DEFERRABLE INITIALLY DEFERRED on key creation.
       #                If you use :immediate as the value, uses DEFERRABLE INITIALLY IMMEDIATE.
+      # :generated_always_as :: Specify a GENERATED ALWAYS AS column expression,
+      #                         if generated columns are supported (PostgreSQL 12+, MariaDB 5.2.0+,
+      #                         and MySQL 5.7.6+).
       # :index :: Create an index on this column.  If given a hash, use the hash as the
       #           options for the index.
       # :key :: For foreign key columns, the column in the associated table
@@ -126,15 +129,21 @@ module Sequel
       #                 be used if you have a single, nonautoincrementing primary key column
       #                 (use the primary_key method in that case).
       # :primary_key_constraint_name :: The name to give the primary key constraint
+      # :primary_key_deferrable :: Similar to :deferrable, but for the primary key constraint
+      #                            if :primary_key is used.
       # :type :: Overrides the type given as the argument.  Generally not used by column
       #          itself, but can be passed as an option to other methods that call column.
       # :unique :: Mark the column as unique, generally has the same effect as
       #            creating a unique index on the column.
       # :unique_constraint_name :: The name to give the unique key constraint
+      # :unique_deferrable :: Similar to :deferrable, but for the unique constraint if :unique
+      #                       is used.
+      #
+      # PostgreSQL specific options:
+      #
+      # :identity :: Create an identity column.
       #
       # MySQL specific options:
-      # :generated_always_as :: Specify a GENERATED ALWAYS AS column expression,
-      #                         if generated columns are supported.
       # :generated_type :: Set the type of column when using :generated_always_as,
       #                    should be :virtual or :stored to force a type.
       def column(name, type, opts = OPTS)

data/lib/sequel/database/schema_methods.rb

@@ -586,6 +586,7 @@ module Sequel
           sql << " CONSTRAINT #{quote_identifier(name)}"
         end
         sql << ' PRIMARY KEY'
+        constraint_deferrable_sql_append(sql, column[:primary_key_deferrable])
       end
     end
     
@@ -606,6 +607,7 @@ module Sequel
           sql << " CONSTRAINT #{quote_identifier(name)}"
         end
         sql << ' UNIQUE'
+        constraint_deferrable_sql_append(sql, column[:unique_deferrable])
       end
     end
     

data/lib/sequel/dataset/actions.rb

@@ -333,6 +333,7 @@ module Sequel
     #                  after every 50 records.
     # :return :: When this is set to :primary_key, returns an array of
     #            autoincremented primary key values for the rows inserted.
+    #            This does not have an effect if +values+ is a Dataset.
     # :server :: Set the server/shard to use for the transaction and insert
     #            queries.
     # :slice :: Same as :commit_every, :commit_every takes precedence.
@@ -1069,7 +1070,7 @@ module Sequel
 
     # Set the server to use to :default unless it is already set in the passed opts
     def default_server_opts(opts)
-      if @db.sharded?
+      if @db.sharded? && !opts.has_key?(:server)
         opts = Hash[opts]
         opts[:server] = @opts[:server] || :default
       end
@@ -1080,7 +1081,7 @@ module Sequel
     # :read_only server unless a specific server is set.
     def execute(sql, opts=OPTS, &block)
       db = @db
-      if db.sharded?
+      if db.sharded? && !opts.has_key?(:server)
         opts = Hash[opts]
         opts[:server] = @opts[:server] || (@opts[:lock] ? :default : :read_only)
         opts

data/lib/sequel/extensions/named_timezones.rb

@@ -2,18 +2,21 @@
 #
 # Allows the use of named timezones via TZInfo (requires tzinfo).
 # Forces the use of DateTime as Sequel's datetime_class, since
-# ruby's Time class doesn't support timezones other than local
-# and UTC.
+# historically, Ruby's Time class doesn't support timezones other
+# than local and UTC. To continue using Ruby's Time class when using
+# the named_timezones extension:
+#
+#   # Load the extension
+#   Sequel.extension :named_timezones
+#
+#   # Set Sequel.datetime_class back to Time
+#   Sequel.datetime_class = Time
 #
 # This allows you to either pass strings or TZInfo::Timezone
 # instance to Sequel.database_timezone=, application_timezone=, and
 # typecast_timezone=.  If a string is passed, it is converted to a
 # TZInfo::Timezone using TZInfo::Timezone.get.
 #
-# To load the extension:
-#
-#   Sequel.extension :named_timezones
-#
 # Let's say you have the database server in New York and the
 # application server in Los Angeles.  For historical reasons, data
 # is stored in local New York time, but the application server only
@@ -37,7 +40,8 @@
 # Note that typecasting from the database timezone to the application
 # timezone when fetching rows is dependent on the database adapter,
 # and only works on adapters where Sequel itself does the conversion.
-# It should work on mysql, postgres, sqlite, ibmdb, and jdbc.
+# It should work with the mysql, postgres, sqlite, ibmdb, and jdbc
+# adapters.
 #
 # Related module: Sequel::NamedTimezones
 
@@ -63,10 +67,48 @@ module Sequel
 
     private 
     
-    # Handle both TZInfo 1 and TZInfo 2
-    if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
+    if RUBY_VERSION >= '2.6'
+      # Convert the given input Time (which must be in UTC) to the given input timezone,
+      # which should be a TZInfo::Timezone instance.
+      def convert_input_time_other(v, input_timezone)
+        Time.new(v.year, v.mon, v.day, v.hour, v.min, (v.sec + Rational(v.nsec, 1000000000)), input_timezone)
+      rescue TZInfo::AmbiguousTime
+        raise unless disamb = tzinfo_disambiguator_for(v)
+        period = input_timezone.period_for_local(v, &disamb)
+        offset = period.utc_total_offset
+        Time.at(v.to_i - offset, :in => input_timezone)
+      end
+
+      # Convert the given input Time to the given output timezone,
+      # which should be a TZInfo::Timezone instance.
+      def convert_output_time_other(v, output_timezone)
+        Time.at(v.to_i, :in => output_timezone)
+      end
+    else
       # :nodoc:
       # :nocov:
+      def convert_input_time_other(v, input_timezone)
+        local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+        Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
+      end
+
+      if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
+        def convert_output_time_other(v, output_timezone)
+          v = output_timezone.utc_to_local(v.getutc)
+          local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i + local_offset
+        end
+      else
+        def convert_output_time_other(v, output_timezone)
+          v = output_timezone.utc_to_local(v.getutc)
+          local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
+        end
+      end
+    end
+
+    # Handle both TZInfo 1 and TZInfo 2
+    if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
       def convert_input_datetime_other(v, input_timezone)
         local_offset = Rational(input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset, 86400)
         (v - local_offset).new_offset(local_offset)

data/lib/sequel/extensions/pg_array.rb

@@ -340,14 +340,18 @@ module Sequel
             raise Sequel::Error, "invalid array, empty string" if eos?
             raise Sequel::Error, "invalid array, doesn't start with {" unless scan(/((\[\d+:\d+\])+=)?\{/)
 
+            # :nocov:
             while !eos?
+            # :nocov:
               char = scan(/[{}",]|[^{}",]+/)
               if char == ','
                 # Comma outside quoted string indicates end of current entry
                 new_entry
               elsif char == '"'
                 raise Sequel::Error, "invalid array, opening quote with existing recorded data" unless @recorded.empty?
+                # :nocov:
                 while true
+                # :nocov:
                   char = scan(/["\\]|[^"\\]+/)
                   if char == '\\'
                     @recorded << getch

data/lib/sequel/extensions/pg_json.rb

@@ -12,7 +12,7 @@
 #
 # Note that wrapping JSON primitives changes the behavior for
 # JSON false and null values.  Because only +false+ and +nil+
-# in Ruby are considered falesy, wrapping these objects results
+# in Ruby are considered falsey, wrapping these objects results
 # in unexpected behavior if you use the values directly in
 # conditionals:
 #
@@ -208,11 +208,19 @@ module Sequel
     JSONB_PRIMITIVE_WRAPPER_MAPPING.freeze
 
     JSON_COMBINED_WRAPPER_MAPPING =JSON_WRAPPER_MAPPING.merge(JSON_PRIMITIVE_WRAPPER_MAPPING).freeze
-    JSON_WRAP_CLASSES = JSON_COMBINED_WRAPPER_MAPPING.keys.freeze
-
     JSONB_COMBINED_WRAPPER_MAPPING =JSONB_WRAPPER_MAPPING.merge(JSONB_PRIMITIVE_WRAPPER_MAPPING).freeze
     JSONB_WRAP_CLASSES = JSONB_COMBINED_WRAPPER_MAPPING.keys.freeze
 
+    Sequel::Deprecation.deprecate_constant(self, :JSON_WRAPPER_MAPPING)
+    Sequel::Deprecation.deprecate_constant(self, :JSONB_WRAPPER_MAPPING)
+    Sequel::Deprecation.deprecate_constant(self, :JSON_PRIMITIVE_WRAPPER_MAPPING)
+    Sequel::Deprecation.deprecate_constant(self, :JSONB_PRIMITIVE_WRAPPER_MAPPING)
+    Sequel::Deprecation.deprecate_constant(self, :JSON_COMBINED_WRAPPER_MAPPING)
+    Sequel::Deprecation.deprecate_constant(self, :JSONB_COMBINED_WRAPPER_MAPPING)
+    Sequel::Deprecation.deprecate_constant(self, :JSONB_WRAP_CLASSES)
+
+    JSON_WRAP_CLASSES = [Hash, Array, String, Integer, Float, NilClass, TrueClass, FalseClass].freeze
+
     # Methods enabling Database object integration with the json type.
     module JSONDatabaseMethods
       def self.extended(db)
@@ -228,6 +236,69 @@ module Sequel
         end
       end
 
+      # Return the wrapper class for the json type if value is Hash or Array.
+      def self.json_wrapper(value)
+        case value
+        when ::Hash
+          JSONHash
+        when ::Array
+          JSONArray
+        end
+      end
+
+      # Return the wrapper class for the jsonb type if value is Hash or Array.
+      def self.jsonb_wrapper(value)
+        case value
+        when ::Hash
+          JSONBHash
+        when ::Array
+          JSONBArray
+        end
+      end
+
+      # Return the wrapper class for the json type if value is a supported type.
+      def self.json_primitive_wrapper(value)
+        case value
+        when ::Hash
+          JSONHash
+        when ::Array
+          JSONArray
+        when ::String
+          JSONString
+        when ::Integer
+          JSONInteger
+        when ::Float
+          JSONFloat
+        when ::NilClass
+          JSONNull
+        when ::TrueClass
+          JSONTrue
+        when ::FalseClass
+          JSONFalse
+        end
+      end
+
+      # Return the wrapper class for the jsonb type if value is a supported type.
+      def self.jsonb_primitive_wrapper(value)
+        case value
+        when ::Hash
+          JSONBHash
+        when ::Array
+          JSONBArray
+        when ::String
+          JSONBString
+        when ::Integer
+          JSONBInteger
+        when ::Float
+          JSONBFloat
+        when ::NilClass
+          JSONBNull
+        when ::TrueClass
+          JSONBTrue
+        when ::FalseClass
+          JSONBFalse
+        end
+      end
 
       # Deprecated
       def self.db_parse_json(s)
@@ -326,9 +397,9 @@ module Sequel
       # Wrap the parsed JSON value in the appropriate JSON wrapper class.
       # Only wrap primitive values if wrap_json_primitives is set.
       def _wrap_json(value)
-        if klass = JSON_WRAPPER_MAPPING[value.class]
+        if klass = JSONDatabaseMethods.json_wrapper(value)
           klass.new(value)
-        elsif klass = JSON_PRIMITIVE_WRAPPER_MAPPING[value.class]
+        elsif klass = JSONDatabaseMethods.json_primitive_wrapper(value)
           if wrap_json_primitives
             klass.new(value)
           else
@@ -342,9 +413,9 @@ module Sequel
       # Wrap the parsed JSON value in the appropriate JSONB wrapper class.
       # Only wrap primitive values if wrap_json_primitives is set.
       def _wrap_jsonb(value)
-        if klass = JSONB_WRAPPER_MAPPING[value.class]
+        if klass = JSONDatabaseMethods.jsonb_wrapper(value)
           klass.new(value)
-        elsif klass = JSONB_PRIMITIVE_WRAPPER_MAPPING[value.class]
+        elsif klass = JSONDatabaseMethods.jsonb_primitive_wrapper(value)
           if wrap_json_primitives
             klass.new(value)
           else
@@ -413,10 +484,10 @@ module Sequel
             _wrap_json(_parse_json(value))
           end
         when *JSON_WRAP_CLASSES
-          JSON_COMBINED_WRAPPER_MAPPING[value.class].new(value)
+          JSONDatabaseMethods.json_primitive_wrapper(value).new(value)
         when JSONBObject
           value = value.__getobj__
-          JSON_COMBINED_WRAPPER_MAPPING[value.class].new(value)
+          JSONDatabaseMethods.json_primitive_wrapper(value).new(value)
         else
           raise Sequel::InvalidValue, "invalid value for json: #{value.inspect}"
         end
@@ -433,11 +504,11 @@ module Sequel
           else
             _wrap_jsonb(_parse_json(value))
           end
-        when *JSONB_WRAP_CLASSES
-          JSONB_COMBINED_WRAPPER_MAPPING[value.class].new(value)
+        when *JSON_WRAP_CLASSES
+          JSONDatabaseMethods.jsonb_primitive_wrapper(value).new(value)
         when JSONObject
           value = value.__getobj__
-          JSONB_COMBINED_WRAPPER_MAPPING[value.class].new(value)
+          JSONDatabaseMethods.jsonb_primitive_wrapper(value).new(value)
         else
           raise Sequel::InvalidValue, "invalid value for jsonb: #{value.inspect}"
         end
@@ -460,7 +531,7 @@ module Sequel
         Postgres::JSONHash.new(v)
       when Postgres::JSONBObject
         v = v.__getobj__
-        Postgres::JSON_COMBINED_WRAPPER_MAPPING[v.class].new(v)
+        Postgres::JSONDatabaseMethods.json_primitive_wrapper(v).new(v)
       else
         Sequel.pg_json_op(v)
       end
@@ -472,7 +543,7 @@ module Sequel
     def pg_json_wrap(v)
       case v
       when *Postgres::JSON_WRAP_CLASSES
-        Postgres::JSON_COMBINED_WRAPPER_MAPPING[v.class].new(v)
+        Postgres::JSONDatabaseMethods.json_primitive_wrapper(v).new(v)
       else
         raise Error, "invalid value passed to Sequel.pg_json_wrap: #{v.inspect}"
       end
@@ -492,7 +563,7 @@ module Sequel
         Postgres::JSONBHash.new(v)
       when Postgres::JSONObject
         v = v.__getobj__
-        Postgres::JSONB_COMBINED_WRAPPER_MAPPING[v.class].new(v)
+        Postgres::JSONDatabaseMethods.jsonb_primitive_wrapper(v).new(v)
       else
         Sequel.pg_jsonb_op(v)
       end
@@ -503,8 +574,8 @@ module Sequel
     # other types.
     def pg_jsonb_wrap(v)
       case v
-      when *Postgres::JSONB_WRAP_CLASSES
-        Postgres::JSONB_COMBINED_WRAPPER_MAPPING[v.class].new(v)
+      when *Postgres::JSON_WRAP_CLASSES
+        Postgres::JSONDatabaseMethods.jsonb_primitive_wrapper(v).new(v)
       else
         raise Error, "invalid value passed to Sequel.pg_jsonb_wrap: #{v.inspect}"
       end