sequel-duckdb 0.3.1 → 0.4.1

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

@@ -3,6 +3,7 @@
 require_relative "../../../sequel/duckdb"
 require_relative "../../../sequel/duckdb/helpers/pathifier"
 require_relative "../../../sequel/duckdb/helpers/copier"
+require_relative "../../../sequel/duckdb/sql_time_tz"
 
 # Sequel is the database toolkit for Ruby
 module Sequel
@@ -102,10 +103,10 @@ module Sequel
 
         sql = if schema_ref.is_a?(Sequel::SQL::QualifiedIdentifier)
                 "SELECT table_name FROM information_schema.tables " \
-                  "WHERE table_catalog = '#{schema_ref.table}' AND table_schema = '#{schema_ref.column}' AND table_type = 'BASE TABLE'"
+                  "WHERE table_catalog = #{literal(schema_ref.table.to_s)} AND table_schema = #{literal(schema_ref.column.to_s)} AND table_type = 'BASE TABLE'"
         else
                 "SELECT table_name FROM information_schema.tables " \
-                  "WHERE table_schema = '#{schema_ref}' AND table_type = 'BASE TABLE'"
+                  "WHERE table_schema = #{literal(schema_ref.to_s)} AND table_type = 'BASE TABLE'"
         end
 
         tables = []
@@ -122,10 +123,7 @@ module Sequel
       # @param opts [Hash] Options for schema parsing
       # @return [Array<Array>] Array of [column_name, column_info] pairs
       def schema_parse_table(table_name, opts = {})
-        schema_name = opts[:schema] || "main"
-
-        # First check if table exists
-        raise Sequel::DatabaseError, "Table '#{table_name}' does not exist" unless table_exists?(table_name, opts)
+        resolved = resolve_table!(table_name, opts)
 
         # Use information_schema.columns for detailed column information
         sql = <<~SQL
@@ -139,7 +137,7 @@ module Sequel
             numeric_precision,
             numeric_scale
           FROM information_schema.columns
-          WHERE table_schema = '#{schema_name}' AND table_name = '#{table_name}'
+          WHERE #{resolved_table_filter(resolved, catalog: :table_catalog, schema: :table_schema, table: :table_name)}
           ORDER BY ordinal_position
         SQL
 
@@ -175,7 +173,7 @@ module Sequel
         end
 
         # Update primary key information
-        update_primary_key_info(table_name, columns, opts)
+        update_primary_key_info(resolved, columns)
 
         columns
       end
@@ -186,10 +184,7 @@ module Sequel
       # @param opts [Hash] Options for index parsing
       # @return [Hash] Hash of index_name => index_info
       def schema_parse_indexes(table_name, opts = {})
-        schema_name = opts[:schema] || "main"
-
-        # First check if table exists
-        raise Sequel::DatabaseError, "Table '#{table_name}' does not exist" unless table_exists?(table_name, opts)
+        resolved = resolve_table!(table_name, opts)
 
         # Use duckdb_indexes() function to get index information
         sql = <<~SQL
@@ -200,7 +195,7 @@ module Sequel
             expressions,
             sql
           FROM duckdb_indexes()
-          WHERE schema_name = '#{schema_name}' AND table_name = '#{table_name}'
+          WHERE #{resolved_table_filter(resolved, catalog: :database_name, schema: :schema_name, table: :table_name)}
         SQL
 
         indexes = {}
@@ -249,12 +244,10 @@ module Sequel
 
         # Format value appropriately for SQL
         formatted_value = case value
-        when String
-                            "'#{value.gsub("'", "''")}'" # Escape single quotes
         when TrueClass, FalseClass, Numeric
                             value.to_s
         else
-                            "'#{value}'"
+                            literal(value.to_s)
         end
 
         # Execute PRAGMA statement
@@ -299,28 +292,23 @@ module Sequel
 
       # Check if table exists
       #
-      # @param table_name [Symbol, String, Sequel::SQL::QualifiedIdentifier] Name of the table
-      # @param opts [Hash] Options
+      # DuckDB resolves the name itself, as it does for any query, so every Sequel
+      # identifier form, the search_path, temporary tables and views all work. The query
+      # reads no rows. A missing table is a catalog error. It must not abort an open
+      # transaction, and DuckDB has no savepoints, so see keep_transaction_on_bind_error.
+      #
+      # @param table_name [Symbol, String, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier] Name of the table
+      # @param opts [Hash] Options (:schema qualifies an unqualified name)
       # @return [Boolean] true if table exists
       def table_exists?(table_name, opts = {})
-        # Handle qualified identifiers (e.g., Sequel[:schema][:table])
-        if table_name.is_a?(Sequel::SQL::QualifiedIdentifier)
-          schema_name = table_name.table.to_s
-          table_name = table_name.column.to_s
-        else
-          schema_name = opts[:schema] || "main"
-          table_name = table_name.to_s
+        keep_transaction_on_bind_error do
+          from(qualify_with_schema_option(table_name, opts)).where(false).select(Sequel::NULL).all
+          true
+        rescue Sequel::DatabaseConnectionError, Sequel::DatabaseDisconnectError
+          raise
+        rescue Sequel::DatabaseError
+          false
         end
-
-        sql = "SELECT 1 FROM information_schema.tables " \
-              "WHERE table_schema = '#{schema_name}' AND table_name = '#{table_name}' LIMIT 1"
-
-        result = nil
-        execute(sql) do |_row|
-          result = true
-        end
-
-        !!result
       end
 
       # Get list of tables
@@ -340,10 +328,10 @@ module Sequel
 
         sql = if schema_ref.is_a?(Sequel::SQL::QualifiedIdentifier)
                 "SELECT table_name FROM information_schema.tables " \
-                  "WHERE table_catalog = '#{schema_ref.table}' AND table_schema = '#{schema_ref.column}' AND table_type = 'VIEW'"
+                  "WHERE table_catalog = #{literal(schema_ref.table.to_s)} AND table_schema = #{literal(schema_ref.column.to_s)} AND table_type = 'VIEW'"
         else
                 "SELECT table_name FROM information_schema.tables " \
-                  "WHERE table_schema = '#{schema_ref}' AND table_type = 'VIEW'"
+                  "WHERE table_schema = #{literal(schema_ref.to_s)} AND table_type = 'VIEW'"
         end
 
         views = []
@@ -360,9 +348,9 @@ module Sequel
       # @param opts [Hash] Options
       # @return [Array<Array>] Schema information
       def schema(table_name, opts = {})
-        # Handle qualified identifiers (e.g., Sequel[:schema][:table])
+        # A qualified identifier (e.g., Sequel[:schema][:table]) is parsed as given
         if table_name.is_a?(Sequel::SQL::QualifiedIdentifier)
-          opts = opts.merge(schema: table_name.table.to_s)
+          parse_name = table_name
           actual_table_name = table_name.column.to_s.to_sym
         elsif table_name.is_a?(Sequel::Dataset)
           # Handle case where Sequel passes a Dataset object instead of table name
@@ -381,16 +369,7 @@ module Sequel
           actual_table_name = table_name
         end
 
-        # Cache schema information for type conversion
-        schema_info = schema_parse_table(actual_table_name, opts)
-        @schema_cache ||= {}
-        @schema_cache[actual_table_name] = {}
-
-        schema_info.each do |column_name, column_info|
-          @schema_cache[actual_table_name][column_name] = column_info
-        end
-
-        schema_info
+        schema_parse_table(parse_name || actual_table_name, opts)
       end
 
       # Get index information for a table
@@ -404,17 +383,37 @@ module Sequel
 
       private
 
+      # A value assigned to a TIMETZ model column becomes a SQLTimeTZ, which keeps the UTC
+      # offset. A string without an offset gets the local offset.
+      def typecast_value_time_timezone(value)
+        case value
+        when SQLTimeTZ
+          value
+        when Time
+          SQLTimeTZ.from_time(value)
+        when DateTime
+          SQLTimeTZ.from_time(value.to_time)
+        when String
+          SQLTimeTZ.from_time(Time.parse(typecast_check_string_length(value, 100)))
+        else
+          raise Sequel::InvalidValue, "invalid value for TIMETZ: #{value.inspect}"
+        end
+      end
+
       # Map DuckDB data types to Sequel types
       #
       # @param duckdb_type [String] DuckDB data type
       # @return [Symbol] Sequel type symbol
+      # information_schema.columns reports a REAL column as FLOAT, a TIMESTAMPTZ column as
+      # TIMESTAMP WITH TIME ZONE, and a VARINT column as BIGNUM. An unsigned type maps by
+      # the signed type that holds all its values.
       def map_duckdb_type_to_sequel(duckdb_type)
         case duckdb_type.upcase
-        when "INTEGER", "INT", "INT4", "SMALLINT", "INT2", "TINYINT", "INT1"
+        when "INTEGER", "INT", "INT4", "SMALLINT", "INT2", "TINYINT", "INT1", "USMALLINT", "UTINYINT"
           :integer
-        when "BIGINT", "INT8"
+        when "BIGINT", "INT8", "UINTEGER", "UBIGINT", "HUGEINT", "UHUGEINT", "BIGNUM", "VARINT"
           :bigint
-        when "REAL", "FLOAT4", "DOUBLE", "FLOAT8"
+        when "FLOAT", "REAL", "FLOAT4", "DOUBLE", "FLOAT8"
           :float
         when /^DECIMAL/, /^NUMERIC/
           :decimal
@@ -422,10 +421,15 @@ module Sequel
           :boolean
         when "DATE"
           :date
-        when "TIMESTAMP", "DATETIME"
+        when "TIMESTAMP", "DATETIME", "TIMESTAMP WITH TIME ZONE", "TIMESTAMPTZ",
+             "TIMESTAMP_S", "TIMESTAMP_MS", "TIMESTAMP_US", "TIMESTAMP_NS"
           :datetime
-        when "TIME"
+        when "TIME", "TIME_NS"
           :time
+        when "TIME WITH TIME ZONE", "TIMETZ"
+          :time_timezone
+        when "INTERVAL"
+          :interval
         when "BLOB", "BYTEA"
           :blob
         when "UUID"
@@ -460,25 +464,131 @@ module Sequel
         end
       end
 
+      # Find the table or view that a name refers to, as DuckDB resolves it in a query.
+      # The information_schema and duckdb_indexes() queries need the exact catalog, schema
+      # and table, and DuckDB has no function that returns them. So the candidates are the
+      # tables and views with that name, and the one whose EXPLAIN plan equals the plan for
+      # the name is the match. Two candidates have equal plans only when a view is
+      # SELECT * FROM the other candidate. DuckDB's search order then decides.
+      #
+      # @param table_name [Symbol, String, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier] Name of the table
+      # @param opts [Hash] Options (:schema qualifies an unqualified name)
+      # @return [Hash, nil] :catalog, :schema and :table, or nil if the name does not resolve
+      def resolve_table(table_name, opts = {})
+        table_name = qualify_with_schema_option(table_name, opts)
+        keep_transaction_on_bind_error do
+          target = explain_plan(table_name)
+          next unless target
+
+          candidates = fetch("SELECT table_catalog, table_schema, table_name FROM information_schema.tables " \
+                             "WHERE lower(table_name) = lower(?)", bare_table_name(table_name)).all
+          matches = candidates.select do |c|
+            explain_plan(qualified_name(c[:table_catalog], c[:table_schema], c[:table_name])) == target
+          end
+          match = matches.size > 1 ? first_in_search_order(matches) : matches.first
+          match && { catalog: match[:table_catalog], schema: match[:table_schema], table: match[:table_name] }
+        end
+      end
+
+      # resolve_table, but a name that does not resolve raises.
+      def resolve_table!(table_name, opts = {})
+        resolve_table(table_name, opts) ||
+          raise(Sequel::DatabaseError, "Table #{literal(qualify_with_schema_option(table_name, opts))} does not exist")
+      end
+
+      def qualify_with_schema_option(table_name, opts)
+        return table_name unless opts[:schema] && !table_name.is_a?(Sequel::SQL::QualifiedIdentifier)
+
+        Sequel.qualify(opts[:schema], table_name)
+      end
+
+      def bare_table_name(table_name)
+        case table_name
+        when Sequel::SQL::QualifiedIdentifier then bare_table_name(table_name.column)
+        when Sequel::SQL::Identifier then table_name.value.to_s
+        else table_name.to_s
+        end
+      end
+
+      def qualified_name(catalog, schema, table)
+        Sequel::SQL::QualifiedIdentifier.new(
+          Sequel::SQL::QualifiedIdentifier.new(Sequel.identifier(catalog), Sequel.identifier(schema)),
+          Sequel.identifier(table)
+        )
+      end
+
+      # The EXPLAIN plan of SELECT * FROM the name, or nil if DuckDB cannot bind the name.
+      # Call it inside keep_transaction_on_bind_error.
+      def explain_plan(table_name)
+        plan = []
+        execute("EXPLAIN (FORMAT JSON) #{from(table_name).sql}") { |row| plan << row }
+        plan
+      rescue Sequel::DatabaseConnectionError, Sequel::DatabaseDisconnectError
+        raise
+      rescue Sequel::DatabaseError
+        nil
+      end
+
+      # Runs the block so that a binder or catalog error in it, such as a missing table,
+      # does not abort an open transaction.
+      #
+      # DuckDB 1.x never aborts a transaction on those errors. DuckDB 2.x aborts it by
+      # default, and its current_transaction_invalidation_policy setting turns that off
+      # for the open transaction only. DuckDB 1.x does not know the value, and a failed
+      # SET aborts the transaction, so the setting is used only where
+      # bind_errors_abort_transactions? is true. The block must handle its own errors:
+      # if it raises, the policy is not restored, and the transaction ends anyway.
+      def keep_transaction_on_bind_error
+        return yield unless bind_errors_abort_transactions? && in_transaction?
+
+        setting = "current_transaction_invalidation_policy"
+        previous = get(Sequel.function(:current_setting, setting))
+        run("SET #{setting} = 'SYNTACTIC_ERRORS_DO_NOT_INVALIDATE'")
+        result = yield
+        run("SET #{setting} = #{literal(previous)}")
+        result
+      end
+
+      # True when a binder or catalog error aborts an open transaction. The native adapter
+      # answers from the loaded DuckDB library. Other adapters run no queries, so false.
+      def bind_errors_abort_transactions?
+        false
+      end
+
+      # DuckDB looks in the temp catalog first, then in the search_path schemas, then in the
+      # default catalog.
+      def first_in_search_order(candidates)
+        schemas = get(Sequel.function(:current_schemas, false))
+        database = get(Sequel.function(:current_database))
+        candidates.min_by do |c|
+          [ c[:table_catalog] == "temp" ? 0 : 1,
+            schemas.index(c[:table_schema]) || schemas.size,
+            c[:table_catalog] == database ? 0 : 1 ]
+        end
+      end
+
+      # The SQL condition that selects the resolved table in a catalog query, given the
+      # names of that query's catalog, schema and table columns.
+      def resolved_table_filter(resolved, catalog:, schema:, table:)
+        literal(Sequel.&({ catalog => resolved[:catalog] }, { schema => resolved[:schema] }, { table => resolved[:table] }))
+      end
+
       # Update primary key information in column schema
       #
-      # @param table_name [Symbol, String] Table name
+      # @param resolved [Hash] The table, from resolve_table
       # @param columns [Array] Array of column information
-      # @param opts [Hash] Options
-      def update_primary_key_info(table_name, columns, opts = {})
-        schema_name = opts[:schema] || "main"
-
+      def update_primary_key_info(resolved, columns)
         # Query for primary key constraints
         sql = <<~SQL
           SELECT column_name
           FROM information_schema.table_constraints tc
           JOIN information_schema.key_column_usage kcu
             ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_catalog = kcu.table_catalog
             AND tc.table_schema = kcu.table_schema
             AND tc.table_name = kcu.table_name
           WHERE tc.constraint_type = 'PRIMARY KEY'
-            AND tc.table_schema = '#{schema_name}'
-            AND tc.table_name = '#{table_name}'
+            AND #{resolved_table_filter(resolved, catalog: Sequel[:tc][:table_catalog], schema: Sequel[:tc][:table_schema], table: Sequel[:tc][:table_name])}
         SQL
 
         primary_key_columns = []
@@ -523,6 +633,16 @@ module Sequel
         true
       end
 
+      # create_table? and drop_table? emit IF NOT EXISTS / IF EXISTS instead of
+      # querying information_schema first.
+      def supports_create_table_if_not_exists?
+        true
+      end
+
+      def supports_drop_table_if_exists?
+        true
+      end
+
       # DuckDB-specific schema generation methods
 
       # Generate SQL for primary key column
@@ -667,14 +787,12 @@ module Sequel
 
       # Remove all cached schema information
       #
-      # Called after schema modifications to ensure cache consistency
+      # Called after schema modifications to ensure cache consistency. It empties the
+      # cache in place, because a frozen Database cannot replace it.
       #
       # @return [void]
       def remove_all_cached_schemas
-        @schema_cache = {}
-        @schemas = {}
-        @primary_keys = {}
-        @primary_key_sequences = {}
+        Sequel.synchronize { @schemas&.clear }
       end
 
       # List all schemas in the database
@@ -685,7 +803,7 @@ module Sequel
       #
       def schemas(opts = OPTS)
         sql = "SELECT schema_name FROM information_schema.schemata"
-        sql += " WHERE catalog_name = '#{opts[:catalog]}'" if opts[:catalog]
+        sql += " WHERE catalog_name = #{literal(opts[:catalog].to_s)}" if opts[:catalog]
 
         schemas = []
         execute(sql) do |row|
@@ -702,7 +820,7 @@ module Sequel
       # @return [Boolean] true if schema exists
       #
       def schema_exists?(name, _opts = OPTS)
-        sql = "SELECT 1 FROM information_schema.schemata WHERE schema_name = '#{name}' LIMIT 1"
+        sql = "SELECT 1 FROM information_schema.schemata WHERE schema_name = #{literal(name.to_s)} LIMIT 1"
 
         result = nil
         execute(sql) do |_row|
@@ -772,64 +890,57 @@ module Sequel
         sql
       end
 
-      def copy_to(source, path, options = Sequel::OPTS)
-        Sequel::DuckDB::Helpers::Copier.new(source, path, options).then do |copier|
-          run(copier.to_sql)
-        end
+      # Runs a DuckDB ATTACH, which opens the database file at +path+ as the catalog
+      # +as+. The catalog is part of the DuckDB database, so every pool connection sees
+      # it. It lasts until Database#disconnect closes the last connection; attach again
+      # after that. See attach_sql for the options.
+      def attach(path, as:, **options)
+        run(attach_sql(path, as:, **options))
       end
 
-      private
+      # The ATTACH statement that #attach runs. The alias +as+ is required: an alias
+      # that DuckDB derives from the file name can equal a schema name in the file,
+      # which makes schema.table ambiguous.
+      #
+      # @param path [String] The database file; a string literal in the SQL
+      # @param as [Symbol, String] The catalog name
+      # @param if_not_exists [Boolean] Do nothing if the catalog is already attached
+      # @param options [Hash] DuckDB ATTACH options, for example read_only: true or
+      #   type: :sqlite. A true value renders the bare keyword (READ_ONLY).
+      # @return [String]
+      def attach_sql(path, as:, if_not_exists: false, **options)
+        sql = +"ATTACH "
+        sql << "IF NOT EXISTS " if if_not_exists
+        sql << "#{literal(path.to_s)} AS #{Sequel::DuckDB::Helpers::SqlOptions.quoted_identifier(as)}"
+        list = Sequel::DuckDB::Helpers::SqlOptions.list(options)
+        sql << " #{list}" unless list.empty?
+        sql
+      end
 
-      def read_something_sql(paths, options = OPTS)
-        Sequel::DuckDB::Helpers::Pathifier.new(paths, options).to_sql
+      # Runs a DuckDB DETACH of the catalog +name+.
+      def detach(name, if_exists: false)
+        run(detach_sql(name, if_exists:))
       end
 
-      # Type conversion methods for DuckDB-specific handling
+      # The DETACH statement that #detach runs.
+      def detach_sql(name, if_exists: false)
+        "DETACH DATABASE #{"IF EXISTS " if if_exists}#{Sequel::DuckDB::Helpers::SqlOptions.quoted_identifier(name)}"
+      end
 
-      # Convert DuckDB TIME values to Ruby time-only objects
-      # DuckDB TIME columns should only contain time-of-day information
-      def typecast_value_time(value)
-        case value
-        when Time
-          # Extract only the time portion, discarding date information
-          # Create a new Time object with today's date but the original time
-          Time.local(1970, 1, 1, value.hour, value.min, value.sec, value.usec)
-        when String
-          # Parse time string and create time-only object
-          if value =~ /\A(\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))?\z/
-            hour = ::Regexp.last_match(1).to_i
-            min = ::Regexp.last_match(2).to_i
-            sec = ::Regexp.last_match(3).to_i
-            usec = (::Regexp.last_match(4) || "0").ljust(6, "0").to_i
-            Time.local(1970, 1, 1, hour, min, sec, usec)
-          else
-            # Fallback: parse as time and extract time portion
-            parsed = Time.parse(value.to_s)
-            Time.local(1970, 1, 1, parsed.hour, parsed.min, parsed.sec, parsed.usec)
-          end
+      # Runs a DuckDB COPY that writes +source+ (a Dataset or a SQL string) to
+      # +path+. For a Dataset this is the SQL from Dataset#copy_to_sql.
+      def copy_to(source, path, options = Sequel::OPTS)
+        if source.is_a?(Sequel::Dataset)
+          run(source.copy_to_sql(path, **options))
         else
-          value
+          run(Sequel::DuckDB::Helpers::Copier.new(source, path, options).to_sql)
         end
       end
 
-      # Override the default type conversion to use our custom TIME handling
-      # This method needs to be public for Sequel models to access it
-      public
-
-      def typecast_value(column, value)
-        return value if value.nil?
-
-        # Get column schema information to determine the correct type
-        if @schema_cache && @schema_cache[column]
-          column_type = @schema_cache[column][:type]
-          case column_type
-          when :time
-            return typecast_value_time(value)
-          end
-        end
+      private
 
-        # Fall back to default Sequel type conversion
-        super
+      def read_something_sql(paths, options = OPTS)
+        Sequel::DuckDB::Helpers::Pathifier.new(paths, options).to_sql
       end
     end
 
@@ -862,8 +973,24 @@ module Sequel
         seconds: "SECOND"
       }.freeze
 
-      # Override select SQL clause order to support VALUES
-      Dataset.def_sql_method(self, :select, [ [ "if opts[:values]", %w[values compounds order limit] ], [ "else", %w[with select distinct columns from join where group having compounds order limit lock] ] ])
+      # Units that date_add_sql_append emits as a subtraction, and units it emits with the
+      # interval first (see the comment there)
+      MONTH_BASED_UNITS = %w[YEAR MONTH].freeze
+      TIME_BASED_UNITS = %w[HOUR MINUTE SECOND].freeze
+
+      # Clause order of each statement. A SELECT can be a VALUES list, and every
+      # statement can start with a WITH clause.
+      Dataset.def_sql_method(self, :select, [ [ "if opts[:values]", %w[values compounds order limit] ], [ "else", %w[with select distinct columns from join where group having window compounds order limit lock] ] ])
+      Dataset.def_sql_method(self, :insert, %w[with insert into columns values])
+      Dataset.def_sql_method(self, :update, %w[with update table set where])
+      Dataset.def_sql_method(self, :delete, %w[with delete from where])
+
+      # Returns the DuckDB COPY statement that writes this dataset to +path+,
+      # without running it. Options are DuckDB COPY options, for example
+      # format: :parquet, partition_by: [:a, :b], compression: :zstd.
+      def copy_to_sql(path, **options)
+        Sequel::DuckDB::Helpers::Copier.new(self, path, options).to_sql
+      end
 
       private
 
@@ -904,7 +1031,21 @@ module Sequel
         true
       end
 
-      def supports_cte?
+      # DuckDB supports the FILTER clause for aggregate functions natively.
+      # Without this, Sequel emulates FILTER with CASE, which gives wrong
+      # results for order-sensitive aggregates such as first(x ORDER BY ...).
+      def supports_filtered_aggregates?
+        true
+      end
+
+      # DuckDB supports IS DISTINCT FROM natively. Sequel's is_distinct_from
+      # extension uses this flag; without it the extension emits a CASE.
+      def supports_is_distinct_from?
+        true
+      end
+
+      # DuckDB runs a WITH clause before SELECT, INSERT, UPDATE and DELETE.
+      def supports_cte?(_type = :select)
         true
       end
 
@@ -926,6 +1067,48 @@ module Sequel
         true
       end
 
+      # Features that Sequel refuses, or leaves out of the SQL, without these flags.
+      # test/capability_flags_test.rb runs each one against a real DuckDB.
+      # supports_cte_in_subqueries? is left undeclared on purpose: declaring it stops
+      # Sequel from moving a subquery's CTE to the outer query, which changes the SQL
+      # that existing callers get.
+      def supports_distinct_on?
+        true
+      end
+
+      def supports_ordered_distinct_on?
+        true
+      end
+
+      def supports_group_rollup?
+        true
+      end
+
+      def supports_group_cube?
+        true
+      end
+
+      def supports_grouping_sets?
+        true
+      end
+
+      def supports_lateral_subqueries?
+        true
+      end
+
+      def supports_merge?
+        true
+      end
+
+      def supports_window_clause?
+        true
+      end
+
+      # complex_expression_sql_append writes all four regexp operators.
+      def supports_regexp?
+        true
+      end
+
       # DuckDB requires WITH RECURSIVE if any CTE is recursive
       # This follows the same pattern as PostgreSQL
       def select_with_sql_base
@@ -995,6 +1178,10 @@ module Sequel
           sql << ", "
           literal_append(sql, args.last)
           sql << ", 'i'))"
+        when :"!~", :"!~*"
+          # Not Sequel's default: DuckDB's !~ is a full match, so !~ 'bc' is true for 'abc'.
+          sql << "NOT "
+          complex_expression_sql_append(sql, operator == :"!~" ? :~ : :"~*", args)
         else
           super
         end
@@ -1045,16 +1232,12 @@ module Sequel
       # Only handles cases that differ from Sequel's default behavior
       def literal_append(sql, value)
         case value
-        when Time
-          # Special handling for time-only values (year 1970 indicates time-only)
-          if value.year == 1970 && value.month == 1 && value.day == 1
-            # This is a time-only value, use TIME format
-            sql << "'#{value.strftime("%H:%M:%S")}'"
-          else
-            # Use our custom datetime formatting for consistency
-            literal_datetime_append(sql, value)
-          end
-        when DateTime
+        when SQLTimeTZ
+          sql << "'#{value.strftime("%H:%M:%S.%6N%:z")}'"
+        when Sequel::SQLTime
+          # A time of day: Sequel writes it as 'HH:MM:SS.ffffff'
+          super
+        when Time, DateTime
           # Use our custom datetime formatting for consistency
           literal_datetime_append(sql, value)
         when String
@@ -1100,9 +1283,22 @@ module Sequel
           sql_unit = DUCKDB_DURATION_UNITS[unit]
           next unless sql_unit
 
-          # Create interval addition
+          # DuckDB judges INTERVAL 1 MONTH, INTERVAL 30 DAY and INTERVAL 720 HOUR equal, and
+          # its optimizer then merges d + INTERVAL 30 DAY with d + INTERVAL 1 MONTH (or 1 DAY
+          # with 24 HOUR) into one expression, so both return the same value. Each kind of
+          # unit gets its own expression form, so two kinds never compare equal:
+          #   month-based: d - INTERVAL (-n) MONTH
+          #   days:        d + INTERVAL n DAY
+          #   time-based:  INTERVAL n HOUR + d
+          # A subtraction for time units would merge them with months.
           interval = build_interval_literal(value, sql_unit)
-          result = Sequel.+(result, interval)
+          result = if MONTH_BASED_UNITS.include?(sql_unit)
+            Sequel.-(result, build_interval_literal(negate_interval_value(value), sql_unit))
+          elsif TIME_BASED_UNITS.include?(sql_unit)
+            Sequel.+(interval, result)
+          else
+            Sequel.+(result, interval)
+          end
         end
 
         # Apply cast if specified or default to Time (TIMESTAMP)
@@ -1114,6 +1310,10 @@ module Sequel
 
       private
 
+      def negate_interval_value(value)
+        value.is_a?(Numeric) ? -value : Sequel.*(value, -1)
+      end
+
       def build_interval_literal(value, unit)
         # If value is numeric, use direct syntax
         # If value is expression, wrap in parentheses