sequel 5.43.0 → 5.47.0

data/doc/sql.rdoc

@@ -428,6 +428,18 @@ As you can see, these literalize with ANDs by default.  You can use the <tt>Sequ
 
   Sequel.or(column1: 1, column2: 2) # (("column1" = 1) OR ("column2" = 2))
 
+As you can see in the above examples, <tt>Sequel.|</tt> and <tt>Sequel.or</tt> work differently.
+<tt>Sequel.|</tt> is for combining an arbitrary number of expressions using OR. If you pass a single
+argument, <tt>Sequel.|</tt> will just convert it to a Sequel expression, similar to <tt>Sequel.expr</tt>.
+<tt>Sequel.or</tt> is for taking a single hash or array of two element arrays and combining the
+elements of that single argument using OR instead of AND:
+
+  Sequel.|(column1: 1, column2: 2) # (("column1" = 1) AND ("column2" = 2))
+  Sequel.or(column1: 1, column2: 2) # (("column1" = 1) OR ("column2" = 2))
+
+  Sequel.|({column1: 1}, {column2: 2}) # (("column1" = 1) OR ("column2" = 2))
+  Sequel.or({column1: 1}, {column2: 2}) # ArgumentError
+
 You've already seen the <tt>Sequel.negate</tt> method, which will use ANDs if multiple entries are used:
 
   Sequel.negate(column1: 1, column2: 2) # (("column1" != 1) AND ("column2" != 2))

data/doc/testing.rdoc

@@ -162,6 +162,7 @@ SEQUEL_ASYNC_THREAD_POOL_PREEMPT :: Use the async_thread_pool extension when run
 SEQUEL_COLUMNS_INTROSPECTION :: Use the columns_introspection extension when running the specs
 SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when running the specs
 SEQUEL_DUPLICATE_COLUMNS_HANDLER :: Use the duplicate columns handler extension with value given when running the specs
+SEQUEL_CONCURRENT_EAGER_LOADING :: Use the async_thread_pool extension and concurrent_eager_loading plugin when running the specs
 SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
 SEQUEL_INDEX_CACHING :: Use the index_caching extension when running the specs
 SEQUEL_FIBER_CONCURRENCY :: Use the fiber_concurrency extension when running the adapter and integration specs
@@ -174,6 +175,10 @@ SEQUEL_NO_CACHE_ASSOCIATIONS :: Don't cache association metadata when running th
 SEQUEL_CHECK_PENDING :: Try running all specs (note, can cause lockups for some adapters), and raise errors for skipped specs that don't fail
 SEQUEL_NO_PENDING :: Don't skip any specs, try running all specs (note, can cause lockups for some adapters)
 SEQUEL_PG_TIMESTAMPTZ :: Use the pg_timestamptz extension when running the postgres specs
+SEQUEL_QUERY_PER_ASSOCIATION_DB_0_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
+SEQUEL_QUERY_PER_ASSOCIATION_DB_1_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
+SEQUEL_QUERY_PER_ASSOCIATION_DB_2_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
+SEQUEL_QUERY_PER_ASSOCIATION_DB_3_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
 SEQUEL_SPLIT_SYMBOLS :: Turn on symbol splitting when running the adapter and integration specs
 SEQUEL_SYNCHRONIZE_SQL :: Use the synchronize_sql extension when running the specs
 SEQUEL_TZINFO_VERSION :: Force the given tzinfo version when running the specs (e.g. '>=2')

data/doc/virtual_rows.rdoc

@@ -54,7 +54,7 @@ methods in the surrounding scope. For example:
   
   # Regular block
   ds.where{|o| o.c > a - b + @d}
-  # WHERE (c > 100)
+  # WHERE (c > 110)
   
   # Instance-evaled block
   ds.where{c > a - b + @d}

data/lib/sequel/adapters/odbc.rb

@@ -94,7 +94,11 @@ module Sequel
           self.columns = columns
           s.each do |row|
             hash = {}
-            cols.each{|n,t,j| hash[n] = convert_odbc_value(row[j], t)}
+            cols.each do |n,t,j|
+              v = row[j]
+              # We can assume v is not false, so this shouldn't convert false to nil.
+              hash[n] = (convert_odbc_value(v, t) if v)
+            end
             yield hash
           end
         end

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

@@ -187,6 +187,15 @@ module Sequel
       def views(opts=OPTS)
         full_tables('VIEW', opts)
       end
+
+      # Renames multiple tables in a single call.
+      #
+      #   DB.rename_tables [:items, :old_items], [:other_items, :old_other_items]
+      #   # RENAME TABLE items TO old_items, other_items TO old_other_items
+      def rename_tables(*renames)
+        execute_ddl(rename_tables_sql(renames))
+        renames.each{|from,| remove_cached_schema(from)}
+      end
       
       private
       
@@ -473,6 +482,14 @@ module Sequel
         schema(table).select{|a| a[1][:primary_key]}.map{|a| a[0]}
       end
 
+      # SQL statement for renaming multiple tables.
+      def rename_tables_sql(renames)
+        rename_tos = renames.map do |from, to|
+            "#{quote_schema_table(from)} TO #{quote_schema_table(to)}"
+        end.join(', ')
+        "RENAME TABLE #{rename_tos}"
+      end
+
       # Rollback the currently open XA transaction
       def rollback_transaction(conn, opts=OPTS)
         if (s = opts[:prepare]) && savepoint_level(conn) <= 1

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

@@ -2141,18 +2141,6 @@ module Sequel
         opts[:with].any?{|w| w[:recursive]} ? "WITH RECURSIVE " : super
       end
 
-      # Support WITH AS [NOT] MATERIALIZED if :materialized option is used.
-      def select_with_sql_prefix(sql, w)
-        super
-
-        case w[:materialized]
-        when true
-          sql << "MATERIALIZED "
-        when false
-          sql << "NOT MATERIALIZED "
-        end
-      end
-
       # The version of the database server
       def server_version
         db.server_version(@opts[:server])

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

@@ -239,8 +239,12 @@ module Sequel
             super
           end
         when :drop_column
-          ocp = lambda{|oc| oc.delete_if{|c| c.to_s == op[:name].to_s}}
-          duplicate_table(table, :old_columns_proc=>ocp){|columns| columns.delete_if{|s| s[:name].to_s == op[:name].to_s}}
+          if sqlite_version >= 33500
+            super
+          else
+            ocp = lambda{|oc| oc.delete_if{|c| c.to_s == op[:name].to_s}}
+            duplicate_table(table, :old_columns_proc=>ocp){|columns| columns.delete_if{|s| s[:name].to_s == op[:name].to_s}}
+          end
         when :rename_column
           if sqlite_version >= 32500
             super
@@ -424,10 +428,10 @@ module Sequel
         skip_indexes = []
         indexes(table, :only_autocreated=>true).each do |name, h|
           skip_indexes << name
-          if h[:unique]
+          if h[:unique] && !opts[:no_unique]
             if h[:columns].length == 1
               unique_columns.concat(h[:columns])
-            elsif h[:columns].map(&:to_s) != pks && !opts[:no_unique]
+            elsif h[:columns].map(&:to_s) != pks
               constraints << {:type=>:unique, :columns=>h[:columns]}
             end
           end
@@ -558,10 +562,10 @@ module Sequel
       EXTRACT_MAP = {:year=>"'%Y'", :month=>"'%m'", :day=>"'%d'", :hour=>"'%H'", :minute=>"'%M'", :second=>"'%f'"}.freeze
       EXTRACT_MAP.each_value(&:freeze)
 
-      Dataset.def_sql_method(self, :delete, [['if db.sqlite_version >= 30803', %w'with delete from where'], ["else", %w'delete from where']])
-      Dataset.def_sql_method(self, :insert, [['if db.sqlite_version >= 30803', %w'with insert conflict into columns values on_conflict'], ["else", %w'insert conflict into columns values']])
+      Dataset.def_sql_method(self, :delete, [['if db.sqlite_version >= 33500', %w'with delete from where returning'], ['elsif db.sqlite_version >= 30803', %w'with delete from where'], ["else", %w'delete from where']])
+      Dataset.def_sql_method(self, :insert, [['if db.sqlite_version >= 33500', %w'with insert conflict into columns values on_conflict returning'], ['elsif db.sqlite_version >= 30803', %w'with insert conflict into columns values on_conflict'], ["else", %w'insert conflict into columns values']])
       Dataset.def_sql_method(self, :select, [['if opts[:values]', %w'with values compounds'], ['else', %w'with select distinct columns from join where group having window compounds order limit lock']])
-      Dataset.def_sql_method(self, :update, [['if db.sqlite_version >= 33300', %w'with update table set from where'], ['elsif db.sqlite_version >= 30803', %w'with update table set where'], ["else", %w'update table set where']])
+      Dataset.def_sql_method(self, :update, [['if db.sqlite_version >= 33500', %w'with update table set from where returning'], ['elsif db.sqlite_version >= 33300', %w'with update table set from where'], ['elsif db.sqlite_version >= 30803', %w'with update table set where'], ["else", %w'update table set where']])
 
       def cast_sql_append(sql, expr, type)
         if type == Time or type == DateTime
@@ -635,8 +639,8 @@ module Sequel
       # SQLite performs a TRUNCATE style DELETE if no filter is specified.
       # Since we want to always return the count of records, add a condition
       # that is always true and then delete.
-      def delete
-        @opts[:where] ? super : where(1=>1).delete
+      def delete(&block)
+        @opts[:where] ? super : where(1=>1).delete(&block)
       end
       
       # Return an array of strings specifying a query explanation for a SELECT of the
@@ -657,6 +661,21 @@ module Sequel
         super
       end
       
+      # Support insert select for associations, so that the model code can use
+      # returning instead of a separate query.
+      def insert_select(*values)
+        return unless supports_insert_select?
+        # Handle case where query does not return a row
+        server?(:default).with_sql_first(insert_select_sql(*values)) || false
+      end
+
+      # The SQL to use for an insert_select, adds a RETURNING clause to the insert
+      # unless the RETURNING clause is already present.
+      def insert_select_sql(*values)
+        ds = opts[:returning] ? self : returning
+        ds.insert_sql(*values)
+      end
+
       # SQLite uses the nonstandard ` (backtick) for quoting identifiers.
       def quoted_identifier_append(sql, c)
         sql << '`' << c.to_s.gsub('`', '``') << '`'
@@ -738,6 +757,13 @@ module Sequel
         insert_conflict(:ignore)
       end
 
+      # Automatically add aliases to RETURNING values to work around SQLite bug.
+      def returning(*values)
+        return super if values.empty?
+        raise Error, "RETURNING is not supported on #{db.database_type}" unless supports_returning?(:insert)
+        clone(:returning=>_returning_values(values).freeze)
+      end
+
       # SQLite 3.8.3+ supports common table expressions.
       def supports_cte?(type=:select)
         db.sqlite_version >= 30803
@@ -778,6 +804,11 @@ module Sequel
         false
       end
       
+      # SQLite 3.35.0 supports RETURNING on INSERT/UPDATE/DELETE.
+      def supports_returning?(_)
+        db.sqlite_version >= 33500
+      end
+
       # SQLite supports timezones in literal timestamps, since it stores them
       # as text.  But using timezones in timestamps breaks SQLite datetime
       # functions, so we allow the user to override the default per database.
@@ -810,6 +841,21 @@ module Sequel
 
       private
       
+      # Add aliases to symbols and identifiers to work around SQLite bug.
+      def _returning_values(values)
+        values.map do |v|
+          case v
+          when Symbol
+            _, c, a = split_symbol(v)
+            a ? v : Sequel.as(v, c)
+          when SQL::Identifier, SQL::QualifiedIdentifier
+            Sequel.as(v, unqualified_column_for(v))
+          else
+            v
+          end
+        end
+      end
+
       # SQLite uses string literals instead of identifiers in AS clauses.
       def as_sql_append(sql, aliaz, column_aliases=nil)
         raise Error, "sqlite does not support derived column lists" if column_aliases

data/lib/sequel/core.rb

@@ -176,6 +176,17 @@ module Sequel
       JSON.parse(json, :create_additions=>false)
     end
 
+    # If a mutex is given, synchronize access using it.  If nil is given, just
+    # yield to the block.  This is designed for cases where a mutex may or may
+    # not be provided.
+    def synchronize_with(mutex)
+      if mutex
+        mutex.synchronize{yield}
+      else
+        yield
+      end
+    end
+
     # Convert each item in the array to the correct type, handling multi-dimensional
     # arrays.  For each element in the array or subarrays, call the converter,
     # unless the value is nil.

data/lib/sequel/database/schema_generator.rb

@@ -214,14 +214,12 @@ module Sequel
       end
 
       # Add a full text index on the given columns.
+      # See #index for additional options.
       #
       # PostgreSQL specific options:
       # :index_type :: Can be set to :gist to use a GIST index instead of the
       #                default GIN index.
       # :language :: Set a language to use for the index (default: simple).
-      #
-      # Microsoft SQL Server specific options:
-      # :key_index :: The KEY INDEX to use for the full text index.
       def full_text_index(columns, opts = OPTS)
         index(columns, opts.merge(:type => :full_text))
       end
@@ -231,35 +229,43 @@ module Sequel
         columns.any?{|c| c[:name] == name}
       end
       
-      # Add an index on the given column(s) with the given options.
+      # Add an index on the given column(s) with the given options. Examples:
+      #
+      #   index :name
+      #   # CREATE INDEX table_name_index ON table (name)
+      #
+      #   index [:artist_id, :name]
+      #   # CREATE INDEX table_artist_id_name_index ON table (artist_id, name)
+      #
+      #   index [:artist_id, :name], name: :foo
+      #   # CREATE INDEX foo ON table (artist_id, name)
+      #
       # General options:
       #
+      # :include :: Include additional column values in the index, without
+      #             actually indexing on those values (only supported by
+      #             some databases).
       # :name :: The name to use for the index. If not given, a default name
       #          based on the table and columns is used.
-      # :type :: The type of index to use (only supported by some databases)
+      # :type :: The type of index to use (only supported by some databases,
+      #          :full_text and :spatial values are handled specially).
       # :unique :: Make the index unique, so duplicate values are not allowed.
-      # :where :: Create a partial index (only supported by some databases)
+      # :where :: A filter expression, used to create a partial index (only
+      #           supported by some databases).
       #
       # PostgreSQL specific options:
       #
       # :concurrently :: Create the index concurrently, so it doesn't block
       #                  operations on the table while the index is being
       #                  built.
-      # :opclass :: Use a specific operator class in the index.
-      # :include :: Include additional column values in the index, without
-      #             actually indexing on those values (PostgreSQL 11+).
+      # :if_not_exists :: Only create the index if an index of the same name doesn't already exist.
+      # :opclass :: Set an opclass to use for all columns (per-column opclasses require
+      #             custom SQL).
       # :tablespace :: Specify tablespace for index.
       #
       # Microsoft SQL Server specific options:
       #
-      # :include :: Include additional column values in the index, without
-      #             actually indexing on those values.
-      #
-      #   index :name
-      #   # CREATE INDEX table_name_index ON table (name)
-      #
-      #   index [:artist_id, :name]
-      #   # CREATE INDEX table_artist_id_name_index ON table (artist_id, name)
+      # :key_index :: Sets the KEY INDEX to the given value.
       def index(columns, opts = OPTS)
         indexes << {:columns => Array(columns)}.merge!(opts)
         nil
@@ -325,6 +331,7 @@ module Sequel
       end
       
       # Add a spatial index on the given columns.
+      # See #index for additional options.
       def spatial_index(columns, opts = OPTS)
         index(columns, opts.merge(:type => :spatial))
       end
@@ -451,7 +458,7 @@ module Sequel
       end
       
       # Add a full text index on the given columns.
-      # See CreateTableGenerator#index for available options.
+      # See CreateTableGenerator#full_text_index for available options.
       def add_full_text_index(columns, opts = OPTS)
         add_index(columns, {:type=>:full_text}.merge!(opts))
       end
@@ -460,34 +467,6 @@ module Sequel
       # CreateTableGenerator#index for available options.
       #
       #   add_index(:artist_id) # CREATE INDEX table_artist_id_index ON table (artist_id)
-      #
-      # Options:
-      #
-      # :name :: Give a specific name for the index. Highly recommended if you plan on
-      #          dropping the index later.
-      # :where :: A filter expression, used to setup a partial index (if supported).
-      # :unique :: Create a unique index.
-      #
-      # PostgreSQL specific options:
-      #
-      # :concurrently :: Create the index concurrently, so it doesn't require an exclusive lock
-      #                  on the table.
-      # :index_type :: The underlying index type to use for a full_text index, gin by default).
-      # :language :: The language to use for a full text index (simple by default).
-      # :opclass :: Set an opclass to use for all columns (per-column opclasses require
-      #             custom SQL).
-      # :type :: Set the index type (e.g. full_text, spatial, hash, gin, gist, btree).
-      # :if_not_exists :: Only create the index if an index of the same name doesn't already exists
-      #
-      # MySQL specific options:
-      #
-      # :type :: Set the index type, with full_text and spatial indexes handled specially.
-      #
-      # Microsoft SQL Server specific options:
-      #
-      # :include :: Includes additional columns in the index.
-      # :key_index :: Sets the KEY INDEX to the given value.
-      # :type :: clustered uses a clustered index, full_text uses a full text index.
       def add_index(columns, opts = OPTS)
         @operations << {:op => :add_index, :columns => Array(columns)}.merge!(opts)
         nil

data/lib/sequel/database/schema_methods.rb

@@ -63,7 +63,7 @@ module Sequel
     # definitions using <tt>create_table</tt>, and +add_index+ accepts all the options
     # available for index definition.
     #
-    # See <tt>Schema::AlterTableGenerator</tt> and the {"Migrations and Schema Modification" guide}[rdoc-ref:doc/migration.rdoc].
+    # See <tt>Schema::AlterTableGenerator</tt> and the {Migrations guide}[rdoc-ref:doc/migration.rdoc].
     def alter_table(name, &block)
       generator = alter_table_generator(&block)
       remove_cached_schema(name)

data/lib/sequel/dataset/query.rb

@@ -699,7 +699,7 @@ module Sequel
     end
 
     # Returns a copy of the dataset with a specified order. Can be safely combined with limit.
-    # If you call limit with an offset, it will override override the offset if you've called
+    # If you call limit with an offset, it will override the offset if you've called
     # offset first.
     #
     #   DB[:items].offset(10) # SELECT * FROM items OFFSET 10
@@ -1062,10 +1062,8 @@ module Sequel
     # Options:
     # :args :: Specify the arguments/columns for the CTE, should be an array of symbols.
     # :recursive :: Specify that this is a recursive CTE
-    #
-    # PostgreSQL Specific Options:
     # :materialized :: Set to false to force inlining of the CTE, or true to force not inlining
-    #                  the CTE (PostgreSQL 12+).
+    #                  the CTE (PostgreSQL 12+/SQLite 3.35+).
     #
     #   DB[:items].with(:items, DB[:syx].where(Sequel[:name].like('A%')))
     #   # WITH items AS (SELECT * FROM syx WHERE (name LIKE 'A%' ESCAPE '\')) SELECT * FROM items

data/lib/sequel/dataset/sql.rb

@@ -1567,6 +1567,13 @@ module Sequel
        sql << ')'
       end
       sql << ' AS '
+
+      case w[:materialized]
+      when true
+        sql << "MATERIALIZED "
+      when false
+        sql << "NOT MATERIALIZED "
+      end
     end
 
     # Whether the symbol cache should be skipped when literalizing the dataset

data/lib/sequel/extensions/date_arithmetic.rb

@@ -8,9 +8,10 @@
 #   DB.extension :date_arithmetic
 #
 # Then you can use the Sequel.date_add and Sequel.date_sub methods
-# to return Sequel expressions:
+# to return Sequel expressions (this example shows the only supported
+# keys for the second argument):
 #
-#   add = Sequel.date_add(:date_column, years: 1, months: 2, days: 3)
+#   add = Sequel.date_add(:date_column, years: 1, months: 2, weeks: 2, days: 1)
 #   sub = Sequel.date_sub(:date_column, hours: 1, minutes: 2, seconds: 3)
 #
 # In addition to specifying the interval as a hash, there is also
@@ -184,22 +185,35 @@ module Sequel
       # ActiveSupport::Duration :: Converted to a hash using the interval's parts.
       def initialize(expr, interval, opts=OPTS)
         @expr = expr
-        @interval = if interval.is_a?(Hash)
-          interval.each_value do |v|
-             # Attempt to prevent SQL injection by users who pass untrusted strings
-             # as interval values. 
-             if v.is_a?(String) && !v.is_a?(LiteralString)
-               raise Sequel::InvalidValue, "cannot provide String value as interval part: #{v.inspect}"
-             end
+
+        h = Hash.new(0)
+        interval = interval.parts unless interval.is_a?(Hash)
+        interval.each do |unit, value|
+          # skip nil values
+          next unless value
+
+          # Convert weeks to days, as ActiveSupport::Duration can use weeks,
+          # but the database-specific literalizers only support days.
+          if unit == :weeks
+            unit = :days
+            value *= 7
+          end
+
+          unless DatasetMethods::DURATION_UNITS.include?(unit)
+            raise Sequel::Error, "Invalid key used in DateAdd interval hash: #{unit.inspect}"
           end
-          Hash[interval]
-        else
-          h = Hash.new(0)
-          interval.parts.each{|unit, value| h[unit] += value}
-          Hash[h]
+
+          # Attempt to prevent SQL injection by users who pass untrusted strings
+          # as interval values. It doesn't make sense to support literal strings,
+          # due to the numeric adding below.
+          if value.is_a?(String)
+            raise Sequel::InvalidValue, "cannot provide String value as interval part: #{value.inspect}"
+          end
+
+          h[unit] += value
         end
 
-        @interval.freeze
+        @interval = Hash[h].freeze
         @cast_type = opts[:cast] if opts[:cast]
         freeze
       end