sequel 5.22.0 → 5.27.0

data/lib/sequel/adapters/mysql2.rb

@@ -36,7 +36,6 @@ module Sequel
       # options such as :local_infile.
       def connect(server)
         opts = server_opts(server)
-        opts[:host] ||= 'localhost'
         opts[:username] ||= opts.delete(:user)
         opts[:flags] ||= 0
         opts[:flags] |= ::Mysql2::Client::FOUND_ROWS if ::Mysql2::Client.const_defined?(:FOUND_ROWS)

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

@@ -279,7 +279,7 @@ module Sequel
             end
           end
           sqls << "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{column_definition_sql(op)}"
-          sqls << alter_table_sql(table, op.merge(:op=>:set_column_default, :default=>default)) if default
+          sqls << alter_table_sql(table, op.merge(:op=>:set_column_default, :default=>default, :skip_drop_default=>true)) if default
           sqls
         when :set_column_null
           sch = schema(table).find{|k,v| k.to_s == op[:name].to_s}.last
@@ -290,7 +290,9 @@ module Sequel
           end
           "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(:type=>type)} #{'NOT ' unless op[:null]}NULL"
         when :set_column_default
-          "ALTER TABLE #{quote_schema_table(table)} ADD CONSTRAINT #{quote_identifier("sequel_#{table}_#{op[:name]}_def")} DEFAULT #{literal(op[:default])} FOR #{quote_identifier(op[:name])}"
+          sqls = []
+          add_drop_default_constraint_sql(sqls, table, op[:name]) unless op[:skip_drop_default]
+          sqls << "ALTER TABLE #{quote_schema_table(table)} ADD CONSTRAINT #{quote_identifier("sequel_#{table}_#{op[:name]}_def")} DEFAULT #{literal(op[:default])} FOR #{quote_identifier(op[:name])}"
         else
           super(table, op)
         end
@@ -427,20 +429,19 @@ module Sequel
         m = output_identifier_meth(opts[:dataset])
         m2 = input_identifier_meth(opts[:dataset])
         tn = m2.call(table_name.to_s)
-        table_id = get(Sequel.function(:object_id, tn))
         info_sch_sch = opts[:information_schema_schema]
         inf_sch_qual = lambda{|s| info_sch_sch ? Sequel.qualify(info_sch_sch, s) : Sequel[s]}
-        sys_qual = lambda{|s| info_sch_sch ? Sequel.qualify(info_sch_sch, Sequel.qualify(Sequel.lit(''), s)) : Sequel[s]}
+        table_id = metadata_dataset.from(inf_sch_qual.call(Sequel[:sys][:objects])).where(:name => tn).select_map(:object_id).first
 
-        identity_cols = metadata_dataset.from(Sequel.lit('[sys].[columns]')).
+        identity_cols = metadata_dataset.from(inf_sch_qual.call(Sequel[:sys][:columns])).
           where(:object_id=>table_id, :is_identity=>true).
           select_map(:name)
 
-        pk_index_id = metadata_dataset.from(sys_qual.call(Sequel.lit('sysindexes'))).
+        pk_index_id = metadata_dataset.from(inf_sch_qual.call(Sequel[:sys][:sysindexes])).
           where(:id=>table_id, :indid=>1..254){{(status & 2048)=>2048}}.
           get(:indid)
-        pk_cols = metadata_dataset.from(sys_qual.call(Sequel.lit('sysindexkeys')).as(:sik)).
-          join(sys_qual.call(Sequel.lit('syscolumns')).as(:sc), :id=>:id, :colid=>:colid).
+        pk_cols = metadata_dataset.from(inf_sch_qual.call(Sequel[:sys][:sysindexkeys]).as(:sik)).
+          join(inf_sch_qual.call(Sequel[:sys][:syscolumns]).as(:sc), :id=>:id, :colid=>:colid).
           where{{sik[:id]=>table_id, sik[:indid]=>pk_index_id}}.
           select_order_map{sc[:name]}
 

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?
@@ -1937,6 +1955,11 @@ module Sequel
         db.server_version(@opts[:server])
       end
 
+      # PostgreSQL 9.4+ supports the FILTER clause for aggregate functions.
+      def supports_filtered_aggregates?
+        server_version >= 90400
+      end
+
       # PostgreSQL supports quoted function names.
       def supports_quoted_function_names?
         true

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)
@@ -855,9 +869,9 @@ module Sequel
         end
       end
 
-      # SQLite does not natively support NULLS FIRST/LAST.
+      # SQLite supports NULLS FIRST/LAST natively in 3.30+.
       def requires_emulating_nulls_first?
-        true
+        db.sqlite_version < 33000
       end
 
       # SQLite does not support FOR UPDATE, but silently ignore it
@@ -883,6 +897,11 @@ module Sequel
         false
       end
 
+      # SQLite 3.30 supports the FILTER clause for aggregate functions.
+      def supports_filtered_aggregates?
+        db.sqlite_version >= 33000
+      end
+
       # SQLite supports quoted function names.
       def supports_quoted_function_names?
         true

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/dataset/features.rb

@@ -230,6 +230,12 @@ module Sequel
       supports_cte_in_subqueries?
     end
 
+    # Whether the dataset supports the FILTER clause for aggregate functions.
+    # If not, support is emulated using CASE.
+    def supports_filtered_aggregates?
+      false
+    end
+
     # Whether the database supports quoting function names.
     def supports_quoted_function_names?
       false

data/lib/sequel/dataset/sql.rb

@@ -492,11 +492,24 @@ module Sequel
       end
 
       sql << '('
+      if filter = opts[:filter]
+        filter = filter_expr(filter, &opts[:filter_block])
+      end
       if opts[:*]
-        sql << '*'
+        if filter && !supports_filtered_aggregates?
+          literal_append(sql, Sequel.case({filter=>1}, nil))
+          filter = nil
+        else
+          sql <<  '*'
+        end
       else
         sql << "DISTINCT " if opts[:distinct]
-        expression_list_append(sql, f.args)
+        if filter && !supports_filtered_aggregates?
+          expression_list_append(sql, f.args.map{|arg| Sequel.case({filter=>arg}, nil)})
+          filter = nil
+        else
+          expression_list_append(sql, f.args)
+        end
         if order = opts[:order]
           sql << " ORDER BY "
           expression_list_append(sql, order)
@@ -510,9 +523,9 @@ module Sequel
         sql << ')'
       end
 
-      if filter = opts[:filter]
+      if filter
         sql << " FILTER (WHERE "
-        literal_append(sql, filter_expr(filter, &opts[:filter_block]))
+        literal_append(sql, filter)
         sql << ')'
       end
 

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)