sequel 5.56.0 → 5.59.0

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

@@ -414,6 +414,7 @@ module Sequel
       #                  2 :: argument name
       #                  3 :: argument mode (e.g. in, out, inout)
       #         :behavior :: Should be IMMUTABLE, STABLE, or VOLATILE.  PostgreSQL assumes VOLATILE by default.
+      #         :parallel :: The thread safety attribute of the function. Should be SAFE, UNSAFE, RESTRICTED. PostgreSQL assumes UNSAFE by default.
       #         :cost :: The estimated cost of the function, used by the query planner.
       #         :language :: The language the function uses.  SQL is the default.
       #         :link_symbol :: For a dynamically loaded see function, the function's link symbol if different from the definition argument.
@@ -1117,6 +1118,7 @@ module Sequel
         #{opts[:behavior].to_s.upcase if opts[:behavior]}
         #{'STRICT' if opts[:strict]}
         #{'SECURITY DEFINER' if opts[:security_definer]}
+        #{"PARALLEL #{opts[:parallel].to_s.upcase}" if opts[:parallel]}
         #{"COST #{opts[:cost]}" if opts[:cost]}
         #{"ROWS #{opts[:rows]}" if opts[:rows]}
         #{opts[:set].map{|k,v| " SET #{k} = #{v}"}.join("\n") if opts[:set]}
@@ -1245,6 +1247,10 @@ module Sequel
       def create_view_prefix_sql(name, options)
         sql = create_view_sql_append_columns("CREATE #{'OR REPLACE 'if options[:replace]}#{'TEMPORARY 'if options[:temp]}#{'RECURSIVE ' if options[:recursive]}#{'MATERIALIZED ' if options[:materialized]}VIEW #{quote_schema_table(name)}", options[:columns] || options[:recursive])
 
+        if options[:security_invoker]
+          sql += " WITH (security_invoker)"
+        end
+
         if tablespace = options[:tablespace]
           sql += " TABLESPACE #{quote_identifier(tablespace)}"
         end
@@ -1302,16 +1308,20 @@ module Sequel
       def index_definition_sql(table_name, index)
         cols = index[:columns]
         index_name = index[:name] || default_index_name(table_name, cols)
+
         expr = if o = index[:opclass]
           "(#{Array(cols).map{|c| "#{literal(c)} #{o}"}.join(', ')})"
         else
           literal(Array(cols))
         end
+
         if_not_exists = " IF NOT EXISTS" if index[:if_not_exists]
         unique = "UNIQUE " if index[:unique]
         index_type = index[:type]
         filter = index[:where] || index[:filter]
         filter = " WHERE #{filter_expr(filter)}" if filter
+        nulls_distinct = " NULLS#{' NOT' if index[:nulls_distinct] == false} DISTINCT" unless index[:nulls_distinct].nil?
+
         case index_type
         when :full_text
           expr = "(to_tsvector(#{literal(index[:language] || 'simple')}::regconfig, #{literal(dataset.send(:full_text_string_join, cols))}))"
@@ -1319,7 +1329,8 @@ module Sequel
         when :spatial
           index_type = :gist
         end
-        "CREATE #{unique}INDEX#{' CONCURRENTLY' if index[:concurrently]}#{if_not_exists} #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{"USING #{index_type} " if index_type}#{expr}#{" INCLUDE #{literal(Array(index[:include]))}" if index[:include]}#{" TABLESPACE #{quote_identifier(index[:tablespace])}" if index[:tablespace]}#{filter}"
+
+        "CREATE #{unique}INDEX#{' CONCURRENTLY' if index[:concurrently]}#{if_not_exists} #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{"USING #{index_type} " if index_type}#{expr}#{" INCLUDE #{literal(Array(index[:include]))}" if index[:include]}#{nulls_distinct}#{" TABLESPACE #{quote_identifier(index[:tablespace])}" if index[:tablespace]}#{filter}"
       end
 
       # Setup datastructures shared by all postgres adapters.
@@ -1525,7 +1536,7 @@ module Sequel
       LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each(&:freeze).freeze
 
       Dataset.def_sql_method(self, :delete, [['if server_version >= 90100', %w'with delete from using where returning'], ['else', %w'delete from using where returning']])
-      Dataset.def_sql_method(self, :insert, [['if server_version >= 90500', %w'with insert into columns values conflict returning'], ['elsif server_version >= 90100', %w'with insert into columns values returning'], ['else', %w'insert into columns values returning']])
+      Dataset.def_sql_method(self, :insert, [['if server_version >= 90500', %w'with insert into columns override values conflict returning'], ['elsif server_version >= 90100', %w'with insert into columns values returning'], ['else', %w'insert into columns values returning']])
       Dataset.def_sql_method(self, :select, [['if opts[:values]', %w'values order limit'], ['elsif server_version >= 80400', %w'with select distinct columns from join where group having window compounds order limit lock'], ['else', %w'select distinct columns from join where group having compounds order limit lock']])
       Dataset.def_sql_method(self, :update, [['if server_version >= 90100', %w'with update table set from where returning'], ['else', %w'update table set from where returning']])
 
@@ -1758,6 +1769,41 @@ module Sequel
         nil
       end
 
+      # Return a dataset with a WHEN MATCHED THEN DO NOTHING clause added to the
+      # MERGE statement.  If a block is passed, treat it as a virtual row and
+      # use it as additional conditions for the match.
+      #
+      #   merge_do_nothing_when_matched
+      #   # WHEN MATCHED THEN DO NOTHING
+      #
+      #   merge_do_nothing_when_matched{a > 30}
+      #   # WHEN MATCHED AND (a > 30) THEN DO NOTHING
+      def merge_do_nothing_when_matched(&block)
+        _merge_when(:type=>:matched, &block)
+      end
+
+      # Return a dataset with a WHEN NOT MATCHED THEN DO NOTHING clause added to the
+      # MERGE statement.  If a block is passed, treat it as a virtual row and
+      # use it as additional conditions for the match.
+      #
+      #   merge_do_nothing_when_not_matched
+      #   # WHEN NOT MATCHED THEN DO NOTHING
+      #
+      #   merge_do_nothing_when_not_matched{a > 30}
+      #   # WHEN NOT MATCHED AND (a > 30) THEN DO NOTHING
+      def merge_do_nothing_when_not_matched(&block)
+        _merge_when(:type=>:not_matched, &block)
+      end
+
+      # Support OVERRIDING USER|SYSTEM VALUE for MERGE INSERT.
+      def merge_insert(*values, &block)
+        h = {:type=>:insert, :values=>values}
+        if override = @opts[:override]
+          h[:override] = insert_override_sql(String.new)
+        end
+        _merge_when(h, &block)
+      end
+    
       # Use OVERRIDING USER VALUE for INSERT statements, so that identity columns
       # always use the user supplied value, and an error is not raised for identity
       # columns that are GENERATED ALWAYS.
@@ -1825,6 +1871,11 @@ module Sequel
         true
       end
 
+      # PostgreSQL 15+ supports MERGE.
+      def supports_merge?
+        server_version >= 150000
+      end
+
       # PostgreSQL supports NOWAIT.
       def supports_nowait?
         true
@@ -1935,6 +1986,22 @@ module Sequel
 
       private
 
+      # Append the INSERT sql used in a MERGE
+      def _merge_insert_sql(sql, data)
+        sql << " THEN INSERT "
+        columns, values = _parse_insert_sql_args(data[:values])
+        _insert_columns_sql(sql, columns)
+        if override = data[:override]
+          sql << override
+        end
+        _insert_values_sql(sql, values)
+      end
+
+      def _merge_matched_sql(sql, data)
+        sql << " THEN DO NOTHING"
+      end
+      alias _merge_not_matched_sql _merge_matched_sql
+
       # Format TRUNCATE statement with PostgreSQL specific options.
       def _truncate_sql(table)
         to = @opts[:truncate_opts] || OPTS
@@ -2011,14 +2078,13 @@ module Sequel
       end
 
       # Support OVERRIDING SYSTEM|USER VALUE in insert statements
-      def insert_values_sql(sql)
+      def insert_override_sql(sql)
         case opts[:override]
         when :system
           sql << " OVERRIDING SYSTEM VALUE"
         when :user
           sql << " OVERRIDING USER VALUE"
         end
-        super
       end
 
       # For multiple table support, PostgreSQL requires at least

data/lib/sequel/database/schema_generator.rb

@@ -146,6 +146,9 @@ module Sequel
       #
       # :generated_type :: Set the type of column when using :generated_always_as,
       #                    should be :virtual or :stored to force a type.
+      # :on_update_current_timestamp :: Use ON UPDATE CURRENT TIMESTAMP when defining the column,
+      #                                 which will update the column value to CURRENT_TIMESTAMP
+      #                                 on every UPDATE.
       #
       # Microsoft SQL Server specific options:
       #
@@ -259,6 +262,7 @@ module Sequel
       #                  operations on the table while the index is being
       #                  built.
       # :if_not_exists :: Only create the index if an index of the same name doesn't already exist.
+      # :nulls_distinct :: Set whether separate NULLs should be considered distinct values in unique indexes.
       # :opclass :: Set an opclass to use for all columns (per-column opclasses require
       #             custom SQL).
       # :tablespace :: Specify tablespace for index.

data/lib/sequel/database/schema_methods.rb

@@ -295,6 +295,9 @@ module Sequel
     #               in a subquery, if you are providing a Dataset as the source
     #               argument, if should probably call the union method with the
     #               all: true and from_self: false options.
+    # :security_invoker :: Set the security_invoker property on the view, making
+    #                      the access to the view use the current user's permissions,
+    #                      instead of the view owner's permissions.
     # :tablespace :: The tablespace to use for materialized views.
     def create_view(name, source, options = OPTS)
       execute_ddl(create_view_sql(name, source, options))

data/lib/sequel/dataset/actions.rb

@@ -457,6 +457,55 @@ module Sequel
       _aggregate(:max, arg)
     end
 
+    # Execute a MERGE statement, which allows for INSERT, UPDATE, and DELETE
+    # behavior in a single query, based on whether rows from a source table
+    # match rows in the current table, based on the join conditions.
+    #
+    # Unless the dataset uses static SQL, to use #merge, you must first have
+    # called #merge_using to specify the merge source and join conditions.
+    # You will then likely to call one or more of the following methods
+    # to specify MERGE behavior by adding WHEN [NOT] MATCHED clauses:
+    #
+    # * #merge_insert
+    # * #merge_update
+    # * #merge_delete
+    # 
+    # The WHEN [NOT] MATCHED clauses are added to the SQL in the order these
+    # methods were called on the dataset.  If none of these methods are
+    # called, an error is raised.
+    #
+    # Example:
+    #
+    #   DB[:m1]
+    #     merge_using(:m2, i1: :i2).
+    #     merge_insert(i1: :i2, a: Sequel[:b]+11).
+    #     merge_delete{a > 30}.
+    #     merge_update(i1: Sequel[:i1]+:i2+10, a: Sequel[:a]+:b+20).
+    #     merge
+    #
+    # SQL:
+    #
+    #   MERGE INTO m1 USING m2 ON (i1 = i2)
+    #   WHEN NOT MATCHED THEN INSERT (i1, a) VALUES (i2, (b + 11))
+    #   WHEN MATCHED AND (a > 30) THEN DELETE
+    #   WHEN MATCHED THEN UPDATE SET i1 = (i1 + i2 + 10), a = (a + b + 20)
+    #
+    # On PostgreSQL, two additional merge methods are supported, for the
+    # PostgreSQL-specific DO NOTHING syntax.
+    #
+    # * #merge_do_nothing_when_matched
+    # * #merge_do_nothing_when_not_matched
+    #
+    # This method is supported on Oracle, but Oracle's MERGE support is
+    # non-standard, and has the following issues:
+    #
+    # * DELETE clause requires UPDATE clause
+    # * DELETE clause requires a condition
+    # * DELETE clause only affects rows updated by UPDATE clause
+    def merge
+      execute_ddl(merge_sql)
+    end
+
     # Returns the minimum value for the given column/expression.
     # Uses a virtual row block if no argument is given.
     #

data/lib/sequel/dataset/features.rb

@@ -125,6 +125,11 @@ module Sequel
       false
     end
 
+    # Whether the MERGE statement is supported, false by default.
+    def supports_merge?
+      false
+    end
+
     # Whether modifying joined datasets is supported, false by default.
     def supports_modifying_joins?
       false

data/lib/sequel/dataset/query.rb

@@ -678,6 +678,56 @@ module Sequel
       clone(:lock => style)
     end
     
+    # Return a dataset with a WHEN MATCHED THEN DELETE clause added to the
+    # MERGE statement.  If a block is passed, treat it as a virtual row and
+    # use it as additional conditions for the match.
+    #
+    #   merge_delete
+    #   # WHEN MATCHED THEN DELETE
+    #
+    #   merge_delete{a > 30}
+    #   # WHEN MATCHED AND (a > 30) THEN DELETE
+    def merge_delete(&block)
+      _merge_when(:type=>:delete, &block)
+    end
+
+    # Return a dataset with a WHEN NOT MATCHED THEN INSERT clause added to the
+    # MERGE statement.  If a block is passed, treat it as a virtual row and
+    # use it as additional conditions for the match.
+    #
+    # The arguments provided can be any arguments that would be accepted by
+    # #insert.
+    #
+    #   merge_insert(i1: :i2, a: Sequel[:b]+11)
+    #   # WHEN NOT MATCHED THEN INSERT (i1, a) VALUES (i2, (b + 11))
+    #
+    #   merge_insert(:i2, Sequel[:b]+11){a > 30}
+    #   # WHEN NOT MATCHED AND (a > 30) THEN INSERT VALUES (i2, (b + 11))
+    def merge_insert(*values, &block)
+      _merge_when(:type=>:insert, :values=>values, &block)
+    end
+    
+    # Return a dataset with a WHEN MATCHED THEN UPDATE clause added to the
+    # MERGE statement.  If a block is passed, treat it as a virtual row and
+    # use it as additional conditions for the match.
+    #
+    #   merge_update(i1: Sequel[:i1]+:i2+10, a: Sequel[:a]+:b+20)
+    #   # WHEN MATCHED THEN UPDATE SET i1 = (i1 + i2 + 10), a = (a + b + 20)
+    #
+    #   merge_update(i1: :i2){a > 30}
+    #   # WHEN MATCHED AND (a > 30) THEN UPDATE SET i1 = i2
+    def merge_update(values, &block)
+      _merge_when(:type=>:update, :values=>values, &block)
+    end
+
+    # Return a dataset with the source and join condition to use for the MERGE statement.
+    #
+    #   merge_using(:m2, i1: :i2)
+    #   # USING m2 ON (i1 = i2)
+    def merge_using(source, join_condition)
+      clone(:merge_using => [source, join_condition].freeze)
+    end
+
     # Returns a cloned dataset without a row_proc.
     #
     #   ds = DB[:items].with_row_proc(:invert.to_proc)
@@ -1287,6 +1337,18 @@ module Sequel
       end
     end
 
+    # Append to the current MERGE WHEN clauses.
+    # Mutates the hash to add the conditions, if a virtual row block is passed.
+    def _merge_when(hash, &block)
+      hash[:conditions] = Sequel.virtual_row(&block) if block
+
+      if merge_when = @opts[:merge_when]
+        clone(:merge_when => (merge_when.dup << hash.freeze).freeze)
+      else
+        clone(:merge_when => [hash.freeze].freeze)
+      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

data/lib/sequel/dataset/sql.rb

@@ -24,29 +24,7 @@ module Sequel
 
       check_insert_allowed!
 
-      columns = []
-
-      case values.size
-      when 0
-        return insert_sql(OPTS)
-      when 1
-        case vals = values[0]
-        when Hash
-          values = []
-          vals.each do |k,v| 
-            columns << k
-            values << v
-          end
-        when Dataset, Array, LiteralString
-          values = vals
-        end
-      when 2
-        if (v0 = values[0]).is_a?(Array) && ((v1 = values[1]).is_a?(Array) || v1.is_a?(Dataset) || v1.is_a?(LiteralString))
-          columns, values = v0, v1
-          raise(Error, "Different number of values and columns given to insert_sql") if values.is_a?(Array) and columns.length != values.length
-        end
-      end
-
+      columns, values = _parse_insert_sql_args(values)
       if values.is_a?(Array) && values.empty? && !insert_supports_empty_values? 
         columns, values = insert_empty_columns_values
       elsif values.is_a?(Dataset) && hoist_cte?(values) && supports_cte?(:insert)
@@ -112,6 +90,31 @@ module Sequel
       end
     end
     
+    # The SQL to use for the MERGE statement.
+    def merge_sql
+      raise Error, "This database doesn't support MERGE" unless supports_merge?
+      if sql = opts[:sql]
+        return static_sql(sql)
+      end
+      if sql = cache_get(:_merge_sql)
+        return sql
+      end
+      source, join_condition = @opts[:merge_using]
+      raise Error, "No USING clause for MERGE" unless source
+      sql = @opts[:append_sql] || sql_string_origin
+
+      select_with_sql(sql)
+      sql << "MERGE INTO "
+      source_list_append(sql, @opts[:from])
+      sql << " USING "
+      identifier_append(sql, source)
+      sql << " ON "
+      literal_append(sql, join_condition)
+      _merge_when_sql(sql)
+      cache_set(:_merge_sql, sql) if cache_sql?
+      sql
+    end
+
     # Returns an array of insert statements for inserting multiple records.
     # This method is used by +multi_insert+ to format insert statements and
     # expects a keys array and and an array of value arrays.
@@ -850,6 +853,83 @@ module Sequel
     
     private
 
+    # Append the INSERT sql used in a MERGE
+    def _merge_insert_sql(sql, data)
+      sql << " THEN INSERT"
+      columns, values = _parse_insert_sql_args(data[:values])
+      _insert_columns_sql(sql, columns)
+      _insert_values_sql(sql, values)
+    end
+
+    def _merge_update_sql(sql, data)
+      sql << " THEN UPDATE SET "
+      update_sql_values_hash(sql, data[:values])
+    end
+
+    def _merge_delete_sql(sql, data)
+      sql << " THEN DELETE"
+    end
+
+    # Mapping of merge types to related SQL
+    MERGE_TYPE_SQL = {
+      :insert => ' WHEN NOT MATCHED',
+      :delete => ' WHEN MATCHED',
+      :update => ' WHEN MATCHED',
+      :matched => ' WHEN MATCHED',
+      :not_matched => ' WHEN NOT MATCHED',
+    }.freeze
+    private_constant :MERGE_TYPE_SQL
+
+    # Add the WHEN clauses to the MERGE SQL
+    def _merge_when_sql(sql)
+      raise Error, "no WHEN [NOT] MATCHED clauses provided for MERGE" unless merge_when = @opts[:merge_when]
+      merge_when.each do |data|
+        type = data[:type]
+        sql << MERGE_TYPE_SQL[type]
+        _merge_when_conditions_sql(sql, data)
+        send(:"_merge_#{type}_sql", sql, data)
+      end
+    end
+
+    # Append MERGE WHEN conditions, if there are conditions provided.
+    def _merge_when_conditions_sql(sql, data)
+      if data.has_key?(:conditions)
+        sql << " AND "
+        literal_append(sql, data[:conditions])
+      end
+    end
+
+    # Parse the values passed to insert_sql, returning columns and values
+    # to use for the INSERT.  Returned columns is always an array, but can be empty
+    # for an INSERT without explicit column references. Returned values can be an
+    # array, dataset, or literal string.
+    def _parse_insert_sql_args(values)
+      columns = []
+
+      case values.size
+      when 0
+        values = []
+      when 1
+        case vals = values[0]
+        when Hash
+          values = []
+          vals.each do |k,v| 
+            columns << k
+            values << v
+          end
+        when Dataset, Array, LiteralString
+          values = vals
+        end
+      when 2
+        if (v0 = values[0]).is_a?(Array) && ((v1 = values[1]).is_a?(Array) || v1.is_a?(Dataset) || v1.is_a?(LiteralString))
+          columns, values = v0, v1
+          raise(Error, "Different number of values and columns given to insert_sql") if values.is_a?(Array) and columns.length != values.length
+        end
+      end
+
+      [columns, values]
+    end
+
     # Formats the truncate statement.  Assumes the table given has already been
     # literalized.
     def _truncate_sql(table)
@@ -1165,7 +1245,10 @@ module Sequel
     end
 
     def insert_columns_sql(sql)
-      columns = opts[:columns]
+      _insert_columns_sql(sql, opts[:columns])
+    end
+
+    def _insert_columns_sql(sql, columns)
       if columns && !columns.empty?
         sql << ' ('
         identifier_list_append(sql, columns)
@@ -1184,7 +1267,11 @@ module Sequel
     end
 
     def insert_values_sql(sql)
-      case values = opts[:values]
+      _insert_values_sql(sql, opts[:values])
+    end
+    
+    def _insert_values_sql(sql, values)
+      case values
       when Array
         if values.empty?
           sql << " DEFAULT VALUES"

data/lib/sequel/extensions/is_distinct_from.rb

@@ -0,0 +1,139 @@
+# frozen-string-literal: true
+#
+# The is_distinct_from extension adds the ability to use the
+# SQL standard IS DISTINCT FROM operator, which is similar to the
+# not equals operator, except that NULL values are considered
+# equal.  Only PostgreSQL and H2 currently support this operator.  On 
+# other databases, support is emulated.
+#
+# First, you need to load the extension into the database:
+#
+#   DB.extension :is_distinct_from
+#
+# Then you can use the Sequel.is_distinct_from to create the expression
+# objects:  
+#
+#   expr = Sequel.is_distinct_from(:column_a, :column_b)
+#   # (column_a IS DISTINCT FROM column_b)
+#
+# You can also use the +is_distinct_from+ method on most Sequel expressions:
+#
+#   expr = Sequel[:column_a].is_distinct_from(:column_b)
+#   # (column_a IS DISTINCT FROM column_b)
+#   
+# These expressions can be used in your datasets, or anywhere else that
+# Sequel expressions are allowed:
+#
+#   DB[:table].where(expr)
+#
+# Related module: Sequel::SQL::IsDistinctFrom
+
+#
+module Sequel
+  module SQL
+    module Builders
+      # Return a IsDistinctFrom expression object, using the IS DISTINCT FROM operator
+      # with the given left hand side and right hand side.
+      def is_distinct_from(lhs, rhs)
+        BooleanExpression.new(:NOOP, IsDistinctFrom.new(lhs, rhs))
+      end
+    end
+
+    # Represents an SQL expression using the IS DISTINCT FROM operator.
+    class IsDistinctFrom < GenericExpression
+      # These methods are added to expressions, allowing them to return IS DISTINCT
+      # FROM expressions based on the receiving expression.
+      module Methods
+        # Return a IsDistinctFrom expression, using the IS DISTINCT FROM operator,
+        # with the receiver as the left hand side and the argument as the right hand side.
+        def is_distinct_from(rhs)
+          BooleanExpression.new(:NOOP, IsDistinctFrom.new(self, rhs))
+        end
+      end
+
+      # These methods are added to datasets using the is_distinct_from extension
+      # extension, for the purposes of correctly literalizing IsDistinctFrom
+      # expressions for the appropriate database type.
+      module DatasetMethods
+        # Append the SQL fragment for the IS DISTINCT FROM expression to the SQL query.
+        def is_distinct_from_sql_append(sql, idf)
+          lhs = idf.lhs
+          rhs = idf.rhs
+
+          if supports_is_distinct_from?
+            sql << "("
+            literal_append(sql, lhs)
+            sql << " IS DISTINCT FROM "
+            literal_append(sql, rhs)
+            sql << ")"
+          elsif db.database_type == :derby && (lhs == nil || rhs == nil)
+            if lhs == nil && rhs == nil
+              sql << literal_false
+            elsif lhs == nil
+              literal_append(sql, ~Sequel.expr(rhs=>nil))
+            else
+              literal_append(sql, ~Sequel.expr(lhs=>nil))
+            end
+          else
+            literal_append(sql, Sequel.case({(Sequel.expr(lhs=>rhs) | [[lhs, nil], [rhs, nil]]) => 0}, 1) => 1)
+          end
+        end
+
+        private
+
+        # Whether the database supports IS DISTINCT FROM.
+        def supports_is_distinct_from?
+          if defined?(super)
+            return super
+          end
+        
+          case db.database_type
+          when :postgres, :h2
+            true
+          else
+            false
+          end
+        end
+      end
+
+      # The left hand side of the IS DISTINCT FROM expression.
+      attr_reader :lhs
+
+      # The right hand side of the IS DISTINCT FROM expression.
+      attr_reader :rhs
+
+      def initialize(lhs, rhs)
+        @lhs = lhs
+        @rhs = rhs
+      end
+
+      to_s_method :is_distinct_from_sql
+    end
+  end
+
+  class SQL::GenericExpression
+    include SQL::IsDistinctFrom::Methods
+  end
+
+  class LiteralString
+    include SQL::IsDistinctFrom::Methods
+  end
+
+  Dataset.register_extension(:is_distinct_from, SQL::IsDistinctFrom::DatasetMethods)
+end
+
+# :nocov:
+if Sequel.core_extensions?
+  class Symbol
+    include Sequel::SQL::IsDistinctFrom::Methods
+  end
+end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      send INCLUDE_METH, Sequel::SQL::IsDistinctFrom::Methods
+    end
+  end
+end
+# :nocov:

data/lib/sequel/extensions/pg_hstore.rb

@@ -76,7 +76,7 @@
 #
 # This extension integrates with the pg_array extension.  If you plan
 # to use arrays of hstore types, load the pg_array extension before the
-# pg_interval extension:
+# pg_hstore extension:
 #
 #   DB.extension :pg_array, :pg_hstore
 #