sequel 5.23.0 → 5.28.0

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

@@ -869,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
@@ -897,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/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/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/query.rb

@@ -1237,6 +1237,20 @@ module Sequel
       self
     end
 
+    # If invert is true, invert the condition.
+    def _invert_filter(cond, invert)
+      if invert
+        SQL::BooleanExpression.invert(cond)
+      else
+        cond
+      end
+    end
+
+    # Add the given filter condition. Arguments:
+    # clause :: Symbol or which SQL clause to effect, should be :where or :having
+    # cond :: The filter condition to add
+    # invert :: Whether the condition should be inverted (true or false)
+    # combine :: How to combine the condition with an existing condition, should be :AND or :OR
     def add_filter(clause, cond, invert=false, combine=:AND, &block)
       if cond == EMPTY_ARRAY && !block
         raise Error, "must provide an argument to a filtering method if not passing a block"
@@ -1256,8 +1270,7 @@ module Sequel
           cond = nil
         end
 
-        cond = filter_expr(cond, &block)
-        cond = SQL::BooleanExpression.invert(cond) if invert
+        cond = _invert_filter(filter_expr(cond, &block), invert)
         cond = SQL::BooleanExpression.new(combine, @opts[clause], cond) if @opts[clause]
 
         if cond.nil?

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/any_not_empty.rb

@@ -0,0 +1,45 @@
+# frozen-string-literal: true
+#
+# The any_not_empty extension changes the behavior of Dataset#any?
+# if called without a block.  By default, this method uses the
+# standard Enumerable behavior of enumerating results and seeing
+# if any result is not false or nil.  With this extension, it
+# just checks whether the dataset is empty.  This approach can
+# be much faster if the dataset is currently large.
+#
+#   DB[:table].any?
+#   # SELECT * FROM table
+#
+#   DB[:table].extension(:any_not_empty).any?
+#   # SELECT 1 as one FROM table LIMIT 1
+#   
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:any_not_empty)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:any_not_empty)
+#
+# Note that this can result in any? returning a different result if
+# the dataset has a row_proc that can return false or nil.
+#
+# Related module: Sequel::AnyNotEmpty
+
+#
+module Sequel
+  module AnyNotEmpty
+    # If a block is not given, return whether the dataset is not empty.
+    def any?
+      if block_given?
+        super
+      else
+        !empty?
+      end
+    end
+  end
+
+  Dataset.register_extension(:any_not_empty, AnyNotEmpty)
+end

data/lib/sequel/extensions/exclude_or_null.rb

@@ -0,0 +1,68 @@
+# frozen-string-literal: true
+#
+# The exclude_or_null extension adds Dataset#exclude_or_null and
+# Dataset#exclude_or_null_having.  These methods are similar to
+# Dataset#exclude and Dataset#exclude_having, except that they
+# will also exclude rows where the condition IS NULL.
+#
+#   DB[:table].exclude_or_null(foo: 1)
+#   # SELECT * FROM table WHERE NOT coalesce((foo = 1), false)
+#   
+#   DB[:table].exclude_or_null{foo(bar) =~ 1}
+#   # SELECT * FROM table HAVING NOT coalesce((foo(bar) = 1), false))
+#   
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:exclude_or_null)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:exclude_or_null)
+#
+# Note, this extension works correctly on PostgreSQL, SQLite, MySQL,
+# H2, and HSQLDB.  However, it does not work correctly on Microsoft SQL Server,
+# Oracle, DB2, SQLAnywhere, or Derby.
+#
+# Related module: Sequel::ExcludeOrNull
+
+#
+module Sequel
+  module ExcludeOrNull
+    # Performs the inverse of Dataset#where, but also excludes rows where the given
+    # condition IS NULL.
+    #
+    #   DB[:items].exclude_or_null(category: 'software')
+    #   # SELECT * FROM items WHERE NOT coalesce((category = 'software'), false)
+    #   
+    #   DB[:items].exclude_or_null(category: 'software', id: 3)
+    #   # SELECT * FROM items WHERE NOT coalesce(((category = 'software') AND (id = 3)), false)
+    def exclude_or_null(*cond, &block)
+      add_filter(:where, cond, :or_null, &block)
+    end
+
+    # The same as exclude_or_null, but affecting the HAVING clause instead of the
+    # WHERE clause.
+    #
+    #   DB[:items].select_group(:name).exclude_or_null_having{count(name) < 2}
+    #   # SELECT name FROM items GROUP BY name HAVING NOT coalesce((count(name) < 2), true)
+    def exclude_or_null_having(*cond, &block)
+      add_filter(:having, cond, :or_null, &block)
+    end
+
+    private
+
+    # Recognize :or_null value for invert, returning an expression for
+    # the invert of the condition or the condition being null.
+    def _invert_filter(cond, invert)
+      if invert == :or_null
+        ~SQL::Function.new(:coalesce, cond, SQL::Constants::SQLFALSE)
+      else
+        super
+      end
+    end
+  end
+
+  Dataset.register_extension(:exclude_or_null, ExcludeOrNull)
+end

data/lib/sequel/extensions/pg_array_ops.rb

@@ -51,8 +51,8 @@
 #   ia.length(2)       # array_length(int_array_column, 2)
 #   ia.lower           # array_lower(int_array_column, 1)
 #   ia.lower(2)        # array_lower(int_array_column, 2)
-#   ia.join            # array_to_string(int_array_column, '', NULL)
-#   ia.join(':')       # array_to_string(int_array_column, ':', NULL)
+#   ia.join            # array_to_string(int_array_column, '')
+#   ia.join(':')       # array_to_string(int_array_column, ':')
 #   ia.join(':', ' ')  # array_to_string(int_array_column, ':', ' ')
 #   ia.unnest          # unnest(int_array_column)
 #   ia.unnest(:b)      # unnest(int_array_column, b)
@@ -217,12 +217,16 @@ module Sequel
 
       # Call the array_to_string method:
       #
-      #   array_op.join           # array_to_string(array, '', NULL)
-      #   array_op.to_string      # array_to_string(array, '', NULL)
-      #   array_op.join(":")      # array_to_string(array, ':', NULL)
+      #   array_op.join           # array_to_string(array, '')
+      #   array_op.to_string      # array_to_string(array, '')
+      #   array_op.join(":")      # array_to_string(array, ':')
       #   array_op.join(":", "*") # array_to_string(array, ':', '*')
       def to_string(joiner="", null=nil)
-        function(:array_to_string, joiner, null)
+        if null.nil?
+          function(:array_to_string, joiner)
+        else
+          function(:array_to_string, joiner, null)
+        end
       end
       alias join to_string
       

data/lib/sequel/extensions/pg_enum.rb

@@ -133,8 +133,11 @@ module Sequel
       # the pg_type table to get names and array oids for
       # enums.
       def parse_enum_labels
+        order = [:enumtypid]
+        order << :enumsortorder if server_version >= 90100
+
         enum_labels = metadata_dataset.from(:pg_enum).
-          order(:enumtypid, :enumsortorder).
+          order(*order).
           select_hash_groups(Sequel.cast(:enumtypid, Integer).as(:v), :enumlabel).freeze
         enum_labels.each_value(&:freeze)
 

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:
 #

data/lib/sequel/extensions/pg_json_ops.rb

@@ -73,6 +73,23 @@
 #   j.pretty                  # jsonb_pretty(jsonb_column)
 #   j.set(%w'0 a', :h)        # jsonb_set(jsonb_column, ARRAY['0','a'], h, true)
 #
+# On PostgreSQL 12+ SQL/JSON functions and operators are supported:
+#
+#   j.path_exists('$.foo')      # (jsonb_column @? '$.foo')
+#   j.path_match('$.foo')       # (jsonb_column @@ '$.foo')
+#
+#   j.path_exists!('$.foo')     # jsonb_path_exists(jsonb_column, '$.foo')
+#   j.path_match!('$.foo')      # jsonb_path_match(jsonb_column, '$.foo')
+#   j.path_query('$.foo')       # jsonb_path_query(jsonb_column, '$.foo')
+#   j.path_query_array('$.foo') # jsonb_path_query_array(jsonb_column, '$.foo')
+#   j.path_query_first('$.foo') # jsonb_path_query_first(jsonb_column, '$.foo')
+#
+# For the PostgreSQL 12+ SQL/JSON functions, one argument is required (+path+) and
+# two more arguments are optional (+vars+ and +silent+).  +path+ specifies the JSON path.
+# +vars+ specifies a hash or a string in JSON format of named variables to be
+# substituted in +path+. +silent+ specifies whether errors are suppressed. By default,
+# errors are not suppressed.
+#
 # If you are also using the pg_json extension, you should load it before
 # loading this extension.  Doing so will allow you to use the #op method on
 # JSONHash, JSONHarray, JSONBHash, and JSONBArray, allowing you to perform json/jsonb operations
@@ -292,6 +309,8 @@ module Sequel
       CONTAINED_BY = ["(".freeze, " <@ ".freeze, ")".freeze].freeze
       DELETE_PATH = ["(".freeze, " #- ".freeze, ")".freeze].freeze
       HAS_KEY = ["(".freeze, " ? ".freeze, ")".freeze].freeze
+      PATH_EXISTS = ["(".freeze, " @? ".freeze, ")".freeze].freeze
+      PATH_MATCH = ["(".freeze, " @@ ".freeze, ")".freeze].freeze
 
       # jsonb expression for deletion of the given argument from the
       # current jsonb.
@@ -362,6 +381,95 @@ module Sequel
         self.class.new(function(:insert, wrap_input_array(path), wrap_input_jsonb(other), insert_after))
       end
 
+      # Returns whether the JSON path returns any item for the json object.
+      #
+      #   json_op.path_exists("$.foo") # (json @? '$.foo')
+      def path_exists(path)
+        bool_op(PATH_EXISTS, path)
+      end
+
+      # Returns whether the JSON path returns any item for the json object.
+      #
+      #   json_op.path_exists!("$.foo")
+      #   # jsonb_path_exists(json, '$.foo')
+      #
+      #   json_op.path_exists!("$.foo ? ($ > $x)", x: 2)
+      #   # jsonb_path_exists(json, '$.foo ? ($ > $x)', '{"x":2}')
+      #
+      #   json_op.path_exists!("$.foo ? ($ > $x)", {x: 2}, true)
+      #   # jsonb_path_exists(json, '$.foo ? ($ > $x)', '{"x":2}', true)
+      def path_exists!(path, vars=nil, silent=nil)
+        Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_exists, path, vars, silent))
+      end
+
+      # Returns the first item of the result of JSON path predicate check for the json object.
+      # Returns nil if the first item is not true or false.
+      #
+      #   json_op.path_match("$.foo") # (json @@ '$.foo')
+      def path_match(path)
+        bool_op(PATH_MATCH, path)
+      end
+
+      # Returns the first item of the result of JSON path predicate check for the json object.
+      # Returns nil if the first item is not true or false and silent is true.
+      #
+      #   json_op.path_match!("$.foo")
+      #   # jsonb_path_match(json, '$.foo')
+      #
+      #   json_op.path_match!("$.foo ? ($ > $x)", x: 2)
+      #   # jsonb_path_match(json, '$.foo ? ($ > $x)', '{"x":2}')
+      #
+      #   json_op.path_match!("$.foo ? ($ > $x)", {x: 2}, true)
+      #   # jsonb_path_match(json, '$.foo ? ($ > $x)', '{"x":2}', true)
+      def path_match!(path, vars=nil, silent=nil)
+        Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_match, path, vars, silent))
+      end
+
+      # Returns a set of all jsonb values specified by the JSON path
+      # for the json object.
+      #
+      #   json_op.path_query("$.foo")
+      #   # jsonb_path_query(json, '$.foo')
+      #
+      #   json_op.path_query("$.foo ? ($ > $x)", x: 2)
+      #   # jsonb_path_query(json, '$.foo ? ($ > $x)', '{"x":2}')
+      #
+      #   json_op.path_query("$.foo ? ($ > $x)", {x: 2}, true)
+      #   # jsonb_path_query(json, '$.foo ? ($ > $x)', '{"x":2}', true)
+      def path_query(path, vars=nil, silent=nil)
+        _path_function(:jsonb_path_query, path, vars, silent)
+      end
+
+      # Returns a jsonb array of all values specified by the JSON path
+      # for the json object.
+      #
+      #   json_op.path_query_array("$.foo")
+      #   # jsonb_path_query_array(json, '$.foo')
+      #
+      #   json_op.path_query_array("$.foo ? ($ > $x)", x: 2)
+      #   # jsonb_path_query_array(json, '$.foo ? ($ > $x)', '{"x":2}')
+      #
+      #   json_op.path_query_array("$.foo ? ($ > $x)", {x: 2}, true)
+      #   # jsonb_path_query_array(json, '$.foo ? ($ > $x)', '{"x":2}', true)
+      def path_query_array(path, vars=nil, silent=nil)
+        JSONBOp.new(_path_function(:jsonb_path_query_array, path, vars, silent))
+      end
+
+      # Returns the first item of the result specified by the JSON path
+      # for the json object.
+      #
+      #   json_op.path_query_first("$.foo")
+      #   # jsonb_path_query_first(json, '$.foo')
+      #
+      #   json_op.path_query_first("$.foo ? ($ > $x)", x: 2)
+      #   # jsonb_path_query_first(json, '$.foo ? ($ > $x)', '{"x":2}')
+      #
+      #   json_op.path_query_first("$.foo ? ($ > $x)", {x: 2}, true)
+      #   # jsonb_path_query_first(json, '$.foo ? ($ > $x)', '{"x":2}', true)
+      def path_query_first(path, vars=nil, silent=nil)
+        JSONBOp.new(_path_function(:jsonb_path_query_first, path, vars, silent))
+      end
+
       # Return the receiver, since it is already a JSONBOp.
       def pg_jsonb
         self
@@ -386,6 +494,22 @@ module Sequel
 
       private
 
+      # Internals of the jsonb SQL/JSON path functions.
+      def _path_function(func, path, vars, silent)
+        args = []
+        if vars
+          if vars.is_a?(Hash)
+            vars = vars.to_json
+          end
+          args << vars
+
+          unless silent.nil?
+            args << silent
+          end
+        end
+        SQL::Function.new(func, self, path, *args)
+      end
+
       # Return a placeholder literal with the given str and args, wrapped
       # in a boolean expression, used by operators that return booleans.
       def bool_op(str, other)