torque-postgresql 4.1.0 → 4.1.1

data/sig/torque/postgresql/relation/inheritance.rbs

@@ -0,0 +1,48 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module Inheritance
+        RECORD_CLASS_TOKEN: Symbol
+
+        def expand_records_values: () -> Array[model]
+        def expand_records_values=: (Array[model] value) -> Array[model]
+        def expand_records_eager_load_value: () -> bool?
+        def expand_records_eager_load_value=: (bool? value) -> bool?
+        def expand_records_scoped_value: () -> Hash[model, Array[model]]
+        def expand_records_scoped_value=: (Hash[model, Array[model]] value) -> Hash[model, Array[model]]
+        def itself_only_value: () -> bool?
+        def itself_only_value=: (bool? value) -> bool?
+        def quote_table_name: (table_ref name) -> String
+        def quote_column_name: (column_ref name) -> String
+        def itself_only: () -> relation
+        def itself_only!: (*untyped) -> self
+        def expand_records: (*model types, ?eager_load: bool, ?filter: bool) -> relation
+        def expand_records!: (*model types, ?eager_load: bool, ?filter: bool) -> self
+        def select: (*untyped fields) ?{ (?) -> untyped } -> untyped
+
+        private
+
+        def raise_itself_only_conflict!: () -> bot
+        def build_arel: (*untyped) -> ::Arel::SelectManager
+        def inheritance_discriminated?: () -> bool
+        def build_record_class_marker: () -> ::Arel::Nodes::As
+        def build_inheritances: (::Arel::SelectManager arel) -> untyped
+        def build_inheritances_joins: (::Arel::SelectManager arel, Array[model] types) -> Hash[String, Array[::Arel::Nodes::TableAlias]]
+        def regclass: () -> Torque::PostgreSQL::Arel::Nodes::Cast
+
+        public
+
+        module Expansion
+          def preload_associations: (Array[record] records) -> untyped
+
+          private
+
+          def exec_queries: () ?{ (record) -> void } -> Array[record]
+          def preloaded_association_names: () -> Array[Symbol]
+          def warn_about_missing_record_class: (Array[record] records) -> untyped
+          def record_class_marker?: (arel_node | column_ref value) -> bool
+        end
+      end
+    end
+  end
+end

data/sig/torque/postgresql/relation/join_series.rbs

@@ -0,0 +1,28 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module JoinSeries
+        type step = Numeric | ActiveSupport::Duration | Symbol | String
+        type with = column_ref | Hash[column_ref, untyped] | arel_node
+
+        def self.build: (relation relation, untyped range, ?with: with?, ?as: column_ref, ?step: step?, ?time_zone: untyped, ?cast: column_ref?, ?mode: Symbol) ?{ (Torque::PostgreSQL::Arel::Nodes::Ref series, arel_table table) -> arel_node } -> ::Arel::Nodes::Join
+
+        private
+
+        def self.validate_build!: (untyped range, step? step) -> nil
+        def self.bind_value: (untyped value) -> arel_node
+        def self.arel_join: (Symbol | String mode) -> singleton(::Arel::Nodes::Join)
+        def self.build_join_on: (Torque::PostgreSQL::Arel::Nodes::Ref result, relation relation, with? with, column_ref? cast) ?{ (Torque::PostgreSQL::Arel::Nodes::Ref series, arel_table table) -> arel_node } -> arel_node
+
+        public
+
+        def join_series: (untyped range, ?with: with?, ?as: column_ref, ?step: step?, ?time_zone: untyped, ?cast: column_ref?, ?mode: Symbol) ?{ (Torque::PostgreSQL::Arel::Nodes::Ref series, arel_table table) -> arel_node } -> relation
+        def join_series!: (untyped range, ?with: with?, ?as: column_ref, ?step: step?, ?time_zone: untyped, ?cast: column_ref?, ?mode: Symbol) ?{ (Torque::PostgreSQL::Arel::Nodes::Ref series, arel_table table) -> arel_node } -> self
+      end
+    end
+  end
+end
+
+class ActiveRecord::Relation
+  include Torque::PostgreSQL::Relation::JoinSeries
+end

data/sig/torque/postgresql/relation/merger.rbs

@@ -0,0 +1,23 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module Merger
+        def merge: () -> relation
+
+        private
+
+        def merge_select_extra: () -> untyped
+        def merge_distinct_on: () -> untyped
+        def merge_auxiliary_statements: () -> untyped
+        def merge_inheritance: () -> untyped
+        def raise_eager_load_conflict!: () -> bot
+        def merge_buckets: () -> untyped
+        def merge_segments: () -> untyped
+      end
+    end
+  end
+end
+
+class ActiveRecord::Relation::Merger
+  prepend Torque::PostgreSQL::Relation::Merger
+end

data/sig/torque/postgresql/relation/segments.rbs

@@ -0,0 +1,27 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module Segments
+        type condition = relation | Symbol | Proc | Hash[untyped, untyped] | String | Array[untyped] | arel_node | nil
+
+        def segments_value: () -> Hash[Symbol, arel_node?]
+        def segments_value=: (Hash[Symbol, arel_node?] value) -> Hash[Symbol, arel_node?]
+        def segments: (**condition map) -> relation
+        def segments!: (**condition map) -> self
+
+        private
+
+        def execute_simple_calculation: (String operation, column_spec | arel_node | nil column_name, bool? distinct) -> untyped
+        def execute_grouped_calculation: (String operation, column_spec | arel_node | nil column_name, bool? distinct) -> untyped
+        def execute_segments_calculation: (String operation, column_spec | arel_node | nil column_name, bool? distinct) -> untyped
+        def segments_projections: (Array[arel_node] groups, arel_node aggregate, connection connection) -> Array[::Arel::Nodes::As]
+        def segments_result: (ActiveRecord::Result data, Array[arel_node] groups, arel_node column, String operation) -> (Hash[untyped, untyped] | nil)
+        def segment_predicate_for: (Symbol name, condition condition) -> arel_node?
+      end
+    end
+  end
+end
+
+class ActiveRecord::Relation
+  include Torque::PostgreSQL::Relation::Segments
+end

data/sig/torque/postgresql/relation.rbs

@@ -0,0 +1,48 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      extend ActiveSupport::Concern
+      include DistinctOn
+      include Inheritance
+
+      type column_spec = column_ref | Hash[column_ref, untyped] | Array[untyped]
+
+      SINGLE_VALUE_METHODS: Array[Symbol]
+      MULTI_VALUE_METHODS: Array[Symbol]
+      VALUE_METHODS: Array[Symbol]
+      FROZEN_EMPTY_ARRAY: Array[untyped]
+      ARColumn: singleton(ActiveRecord::ConnectionAdapters::PostgreSQL::Column)
+
+      def select_extra_values: () -> Array[arel_node]
+      def select_extra_values=: (Array[arel_node] value) -> Array[arel_node]
+      def calculate: (Symbol | String operation, column_spec | nil column_name) -> untyped
+      def resolve_column: (column_spec list, ?column_ref | false base) -> Array[arel_node]
+      def resolve_base_table: (column_ref | false relation) -> (model | PredicateTable | nil)
+      def cast_for_condition: (column_ref | column column, untyped value) -> untyped
+
+      private
+
+      def build_arel: (*untyped) -> ::Arel::SelectManager
+      def part_table_for: (ActiveRecord::TableMetadata table, String name) -> PredicateTable?
+
+      public
+
+      module ClassMethods
+        def _record_class_attribute: () -> Symbol
+        def _record_class_column_name: () -> String
+      end
+
+      module Initializer
+        def initialize: (model klass, *untyped, **untyped) -> void
+        def upsert_all: (Array[Hash[column_ref, untyped]] attributes, ?where: String | relation | nil, **untyped xargs) -> untyped
+      end
+    end
+  end
+end
+
+class ActiveRecord::Relation
+  include Torque::PostgreSQL::Relation
+  extend Torque::PostgreSQL::Relation::ClassMethods
+  prepend Torque::PostgreSQL::Relation::Initializer
+  prepend Torque::PostgreSQL::Relation::Inheritance::Expansion
+end

data/sig/torque/postgresql/schema_cache/bound_schema_reflection.rbs

@@ -0,0 +1,14 @@
+module Torque
+  module PostgreSQL
+    module BoundSchemaReflection
+      def add_model_name: (String table_name, model model) -> model?
+      def dependencies: (String table_name) -> Array[String]?
+      def associations: (String table_name) -> Array[String]?
+      def lookup_model: (String table_name, ?String | model scoped_class) -> model
+    end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::BoundSchemaReflection
+  prepend Torque::PostgreSQL::BoundSchemaReflection
+end

data/sig/torque/postgresql/schema_cache/inheritance.rbs

@@ -0,0 +1,12 @@
+module Torque
+  module PostgreSQL
+    module SchemaCache
+      module Inheritance
+        def lookup_model: (String table_name, ?String | model scoped_class, source_to_model: Hash[String, model]) -> model
+        def find_model: (String | Array[String] max_name, String table_name, ?Module scope) -> model?
+        def generate_associations: (Hash[String, Array[String]] inheritance_dependencies) -> Hash[String, Array[String]]
+        def prepare_irregular_models: (Array[String] data_sources) -> Hash[String, model]
+      end
+    end
+  end
+end

data/sig/torque/postgresql/schema_cache/schema_reflection.rbs

@@ -0,0 +1,14 @@
+module Torque
+  module PostgreSQL
+    module SchemaReflection
+      def add_model_name: (SchemaCache::source source, String table_name, model model) -> model?
+      def dependencies: (SchemaCache::source source, String table_name) -> Array[String]?
+      def associations: (SchemaCache::source source, String table_name) -> Array[String]?
+      def lookup_model: (SchemaCache::source source, String table_name, String | model scoped_class) -> model
+    end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::SchemaReflection
+  prepend Torque::PostgreSQL::SchemaReflection
+end

data/sig/torque/postgresql/schema_cache.rbs

@@ -0,0 +1,43 @@
+module Torque
+  module PostgreSQL
+    class LookupError < ArgumentError
+    end
+
+    # initialize is not declared: schema_cache/inheritance.rb reopens this
+    # module before it is defined, and the runtime checker hooks it eagerly
+    module SchemaCache
+      include SchemaCache::Inheritance
+
+      type source = connection | pool
+
+      @data_sources_model_names: Hash[String, model]
+      @inheritance_dependencies: Hash[String, Array[String]]
+      @inheritance_associations: Hash[String, Array[String]]
+      @inheritance_loaded: bool
+
+      def initialize_dup: (*untyped) -> untyped
+      def encode_with: (untyped coder) -> untyped
+      def init_with: (untyped coder) -> untyped
+      def add: (source | String connection_or_table_name, ?String table_name, *untyped) -> untyped
+      def clear!: () -> untyped
+      def size: () -> Integer
+      def clear_data_source_cache!: (source | String connection_or_name, ?String name) -> untyped
+      def marshal_dump: () -> Array[untyped]
+      def marshal_load: (Array[untyped] array) -> untyped
+      def add_model_name: (*untyped args) -> model?
+      def dependencies: (source | String source, ?String table_name) -> Array[String]?
+      def associations: (source | String source, ?String table_name) -> Array[String]?
+      def lookup_model: (String table_name, ?String | model scoped_class) -> model
+
+      private
+
+      def reload_inheritance_data!: (source source) -> untyped
+      def generate_associations: () -> Hash[String, Array[String]]
+      def add_all: (?source? source) -> untyped
+    end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::SchemaCache
+  prepend Torque::PostgreSQL::SchemaCache
+end

data/sig/torque/postgresql/table_name.rbs

@@ -0,0 +1,20 @@
+module Torque
+  module PostgreSQL
+    class TableName < Delegator
+      @klass: model
+      @table_name: String
+      @schema: String?
+
+      def initialize: (model klass, String table_name) -> void
+      def schema: () -> String?
+      def to_s: () -> String
+      alias __getobj__ to_s
+      def ==: (untyped other) -> Integer?
+      def __setobj__: (String value) -> String
+
+      private
+
+      def search_path_schemes: () -> Array[String]
+    end
+  end
+end

data/sig/torque/postgresql/validations.rbs

@@ -0,0 +1,13 @@
+module Torque
+  module PostgreSQL
+    module Validations
+      class NestedValidator < ActiveModel::EachValidator
+        def validate_each: (ActiveModel::Validations record, column_ref attribute, untyped value) -> untyped
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  include Torque::PostgreSQL::Validations
+end

data/sig/torque/postgresql/version.rbs

@@ -0,0 +1,5 @@
+module Torque
+  module PostgreSQL
+    VERSION: String
+  end
+end

data/sig/torque/postgresql/versioned_commands/command_migration.rbs

@@ -0,0 +1,54 @@
+module Torque
+  module PostgreSQL
+    module VersionedCommands
+      module Migration
+        @command: CommandMigration
+        @description: [String, String]
+        @connection: connection?
+        @execution_strategy: untyped
+
+        def initialize: (*untyped args) -> void
+        def migrate: (:up | :down direction) -> untyped
+        def exec_migration: (connection conn, :up | :down direction) -> untyped
+        def announce: (String message) -> untyped
+        def description_for: (:up | :down direction) -> [String, String]
+        def execute: (String command) -> untyped
+      end
+
+      class CommandMigration < ::Struct[untyped]
+        @migration: ActiveRecord::Migration?
+
+        def filename: () -> String
+        def filename=: (String value) -> String
+        def version: () -> Integer
+        def version=: (Integer value) -> Integer
+        def op: () -> String
+        def op=: (String value) -> String
+        def type: () -> String
+        def type=: (String value) -> String
+        def object_name: () -> String
+        def object_name=: (String value) -> String
+        def op_version: () -> Integer
+        def op_version=: (Integer value) -> Integer
+        def scope: () -> String?
+        def scope=: (String? value) -> String?
+
+        def execute: (String command) -> untyped
+        def initialize: (String filename, *untyped args) -> void
+        def name: () -> String
+        def disable_ddl_transaction: () -> false
+        def migrate: (:up | :down direction) -> untyped
+        def up: () -> untyped
+        def down: () -> untyped
+        def drop: () -> untyped
+
+        private
+
+        def drop_function: () -> untyped
+        def drop_type: () -> untyped
+        def drop_trigger: () -> untyped
+        def drop_view: () -> untyped
+      end
+    end
+  end
+end

data/sig/torque/postgresql/versioned_commands/generator.rbs

@@ -0,0 +1,17 @@
+module Torque
+  module PostgreSQL
+    module VersionedCommands
+      module Generator
+        TEMPLATES_PATH: String
+
+        attr_reader file_name: String?
+
+        def self.included: (singleton(Rails::Generators::Base) base) -> untyped
+        def type: () -> String
+        def create_migration_file: () -> untyped
+        def count_object_entries: () -> Integer
+        def validate_file_name!: () -> nil
+      end
+    end
+  end
+end

data/sig/torque/postgresql/versioned_commands/migration_context.rbs

@@ -0,0 +1,30 @@
+module Torque
+  module PostgreSQL
+    class IllegalCommandTypeError < ActiveRecord::MigrationError
+      def initialize: (String file) -> void
+    end
+
+    module VersionedCommands
+      module MigrationContext
+        type status = [String, String, String]
+
+        InvalidMigrationTimestampError: untyped
+        PGAdapter: singleton(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+
+        def migrations: () -> Array[untyped]
+        def migrations_status: () -> Array[status]
+        def migration_commands: () -> Array[CommandMigration]
+
+        private
+
+        def running_for_pg?: () -> bool
+        def command_files: () -> Array[String]
+        def parse_command_filename: (String filename) -> Array[String?]?
+      end
+    end
+  end
+end
+
+class ActiveRecord::MigrationContext
+  prepend Torque::PostgreSQL::VersionedCommands::MigrationContext
+end

data/sig/torque/postgresql/versioned_commands/migrator.rbs

@@ -0,0 +1,19 @@
+module Torque
+  module PostgreSQL
+    module VersionedCommands
+      module Migrator
+        @versioned_command: CommandMigration | false
+        @versioned_table: SchemaTable
+        @versioned_counter: Integer
+
+        def execute_migration_in_transaction: (untyped migration) -> untyped
+        def record_version_state_after_migrating: (Integer version) -> untyped
+        def versioned_command?: (untyped migration) -> bool
+      end
+    end
+  end
+end
+
+class ActiveRecord::Migrator
+  prepend Torque::PostgreSQL::VersionedCommands::Migrator
+end

data/sig/torque/postgresql/versioned_commands/schema_table.rbs

@@ -0,0 +1,23 @@
+module Torque
+  module PostgreSQL
+    module VersionedCommands
+      class SchemaTable
+        attr_reader arel_table: arel_table
+
+        @pool: pool
+
+        def initialize: (pool pool) -> void
+        def create_version: (CommandMigration command) -> untyped
+        def delete_version: (CommandMigration command) -> Integer
+        def primary_key: () -> String
+        def name: () -> String
+        def table_name: () -> String
+        def create_table: () -> untyped
+        def drop_table: () -> untyped
+        def count: () -> Integer
+        def table_exists?: () -> bool
+        def versions_of: (Symbol | String type) -> Array[[String, Integer]]
+      end
+    end
+  end
+end

data/sig/torque/postgresql/versioned_commands.rbs

@@ -0,0 +1,25 @@
+module Torque
+  module PostgreSQL
+    module VersionedCommands
+      type command_type = :function | :type | :view | :trigger
+      type dirs = String | Array[String]
+
+      RAILS_APP: untyped
+      NAME_MATCH: String
+
+      @filename_regexp: Regexp
+
+      def self.valid_type?: (Symbol | String type) -> bool
+      def self.validate!: (Symbol | String type, String content, String name) -> nil
+      def self.fetch_command: (dirs dirs, Symbol | String type, String name, Integer | String version) -> String
+      def self.filename_regexp: () -> Regexp
+
+      private
+
+      def self.validate_function!: (String content, String name) -> nil
+      def self.validate_type!: (String content, String name) -> nil
+      def self.validate_trigger!: (String content, String name) -> nil
+      def self.validate_view!: (String content, String name) -> nil
+    end
+  end
+end

data/sig/torque/postgresql.rbs

@@ -0,0 +1,26 @@
+module Torque
+  module PostgreSQL
+    type model = singleton(ActiveRecord::Base)
+    type record = ActiveRecord::Base
+    type relation = ActiveRecord::Relation
+    type connection = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+    type pool = ActiveRecord::ConnectionAdapters::ConnectionPool
+    type reflection = ActiveRecord::Reflection::AssociationReflection
+    type any_reflection = ActiveRecord::Reflection::AbstractReflection
+    type column = ActiveRecord::ConnectionAdapters::PostgreSQL::Column
+    type type_caster = ActiveModel::Type::Value
+    type column_ref = String | Symbol
+    type table_ref = String | Symbol | ActiveRecord::ConnectionAdapters::PostgreSQL::Name
+    type arel_table = ::Arel::Table
+    type arel_attribute = ::Arel::Attributes::Attribute
+    type arel_node = ::Arel::Nodes::Node | ::Arel::Nodes::SqlLiteral | arel_attribute
+    type collector = ::Arel::Collectors::SQLString | ::Arel::Collectors::Composite | ::Arel::Collectors::Bind | ::Arel::Collectors::SubstituteBinds
+    type stream = IO | StringIO
+    type table_node = arel_table | ::Arel::Nodes::TableAlias
+    type path_key = column_ref | Integer
+
+    interface _Callable
+      def call: (*untyped) -> untyped
+    end
+  end
+end

data/skills/torque-postgresql/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: torque-postgresql
+description: PostgreSQL features in Rails through the torque-postgresql gem. Use when writing models, migrations, or queries in an app whose Gemfile has torque-postgresql, or when a task needs a PostgreSQL type (enum, enum set, jsonb document, composite, ltree, range, interval, geometry) or query feature (CTE, DISTINCT ON, FILTER aggregates, width_bucket, generate_series, full-text search, array associations, table inheritance).
+---
+
+# torque-postgresql
+
+The gem exposes PostgreSQL features through the regular Rails DSL: migration methods that dump
+to `schema.rb`, model macros, and relation methods. Reach for it before raw SQL.
+
+## Steps
+
+1. Locate the installed gem with `bundle info torque-postgresql`. Done when you know its version
+   and path.
+2. Read the app's `Torque::PostgreSQL.configure` block (search `config/` for it). Done when you
+   know which features are off and which macros are renamed: every `base_method` key renames a
+   macro, and `versioned_commands` and `cross_join` stay off unless enabled there.
+3. Pick the feature from the table below and read its docs page before writing code. Done when
+   the migration, the model macro, and the query you plan all appear on that page.
+4. Check exact signatures in `<gem path>/sig/`, when the installed release ships one. Methods
+   generated per attribute (`admin?`, period scopes, `full_text_search`) are named on the docs
+   page, never in `sig/`.
+5. Write the migration with the gem's DSL, run it, and confirm `db/schema.rb` dumps it.
+
+## Features
+
+Docs live at `https://torque.dev/postgresql/<page>/`. The index is
+`https://torque.dev/postgresql/llms.txt`, and every page in one file is
+`https://torque.dev/postgresql/llms-full.txt`.
+
+| Need | Migration | Model or query | Page |
+|---|---|---|---|
+| Fixed list of values | `create_enum`, `t.enum enum_type:` | `torque_enum :role`, `Enum::Roles` | `data-types/enum` |
+| Several values of one enum | `t.enum enum_type:, array: true` | `torque_enum_set :perms` | `data-types/enum-set` |
+| Typed jsonb document | `t.jsonb` | `struct_for :settings, Klass` | `data-types/struct` |
+| Database composite type | `create_composite_type`, `t.composite composite_type:` | `Composite::Address` | `data-types/composite` |
+| Tree paths | `enable_extension 'ltree'`, `t.ltree`, `t.lquery` | `where(path: ...)` | `data-types/ltree` |
+| Time windows | `t.tsrange`, `t.daterange` | `period_for :period` | `data-types/date-time-range` |
+| Durations | `t.interval` | `ActiveSupport::Duration` values | `data-types/interval` |
+| Geometry | `t.box`, `t.circle`, `t.line`, `t.segment` | value objects | `data-types/box` and siblings |
+| Array of foreign keys | `t.bigint :tag_ids, array: true` | `belongs_to_many :tags`, `has_many :videos, array: true` | `modeling/belongs-to-many`, `modeling/has-many` |
+| Table inheritance | `create_table :child, inherits: :parent` | `expand_records` | `modeling/inherited-tables` |
+| Value computed on demand | | `dynamic_attribute(:name) { }` | `modeling/dynamic-attributes` |
+| Conditional upsert | | `upsert_all(rows, where: ...)` | `modeling/insert-all` |
+| CTE | | `auxiliary_statement :name`, `.with(:name)` | `querying/auxiliary-statements` |
+| First row per group | | `distinct_on(:col)` | `querying/distinct-on` |
+| Histogram | | `buckets(:col, range_or_list)` | `querying/buckets` |
+| Several filtered aggregates | | `segments(name: condition).count` | `querying/segments` |
+| Report rows with no data | | `join_series(range, with: :col)` | `querying/join-series` |
+| Full-text search | `t.search_vector columns:` | `torque_search_for :col`, `.full_text_search` | `querying/full-text-search` |
+| Regexp and array conditions | | `where(title: /x/)` | `querying/predicate-builder` |
+| SQL functions and operators | | `FN.*`, Arel infix methods | `querying/arel` |
+| Several schemas | `create_schema` | `self.schema =` | `experimental/multiple-schemas` |
+| Versioned views, functions, triggers, types | `rails g torque:view` and siblings | | `experimental/versioned-commands` |
+| Join a function, subquery, or row list | | `cross_join(source, as:)` | `experimental/cross-join` |
+
+## Rules
+
+- **Enum types** come from Rails' own `create_enum`. Adding values with `add_enum_values` may
+  need `disable_ddl_transaction!` in that migration.
+- **Struct classes** subclass `Torque::PostgreSQL::Struct` and are strict by default. Only `jsonb`
+  columns can be queried by property. Encrypt properties, never the whole column.
+- **Inherited records** reached through an association come back partial and read-only. Load
+  them with `expand_records` before writing to them.
+- **ltree labels** accept dashes only on PostgreSQL 16+. The `ltree.sanitize` setting rewrites
+  them, which matters for UUID labels.
+- **`FN`** is `Torque::PostgreSQL::FN`. The app may expose it under a shorter name through
+  `arel.expose_function_helper_on`, which the docs write as `PG::Fn`.
+- **Array conditions** use `ANY` and overlaps only when `predicate_builder.handle_array_attributes`
+  is on. It is off by default.

data/spec/fixtures/migrations/20250101000008_create_trigger_audit_users_v1.sql

@@ -0,0 +1,3 @@
+CREATE OR REPLACE TRIGGER audit_users
+  BEFORE INSERT ON users
+  FOR EACH ROW EXECUTE FUNCTION count_users();

data/spec/initialize.rb

@@ -22,10 +22,14 @@ require_relative '../lib/torque/postgresql/attributes/enum_set'
 require_relative '../lib/torque/postgresql/attributes/period'
 require_relative '../lib/torque/postgresql/attributes/struct'
 require_relative '../lib/torque/postgresql/attributes/full_text_search'
+require_relative '../lib/torque/postgresql/attributes/ltree'
+require_relative '../lib/torque/postgresql/attributes/lquery'
 
 require_relative '../lib/torque/postgresql/relation/auxiliary_statement'
 require_relative '../lib/torque/postgresql/relation/join_series'
 require_relative '../lib/torque/postgresql/relation/buckets'
+require_relative '../lib/torque/postgresql/relation/segments'
+require_relative '../lib/torque/postgresql/relation/cross_join'
 
 require_relative '../lib/torque/postgresql/versioned_commands'
 
@@ -42,6 +46,11 @@ module Torque
     Relation.include(Relation::AuxiliaryStatement)
     Relation.include(Relation::JoinSeries)
     Relation.include(Relation::Buckets)
+    Relation.include(Relation::Segments)
+    Relation.include(Relation::CrossJoin)
+
+    config.cross_join.enabled = true
+    ActiveRecord::Base.singleton_class.delegate(:cross_join, to: :all)
 
     config.versioned_commands.enabled = true
     ActiveRecord::Schema::Definition.include(Adapter::Definition)

data/spec/mocks/cache_query.rb

@@ -32,7 +32,7 @@ module Mocks
 
       original_method = ActiveRecord::Base.connection.method(:raw_execute)
       original_method.receiver.define_singleton_method(:raw_execute) do |*args, **xargs, &block|
-        result ||= [args.first, args.third]
+        result ||= [args.first, args.third] unless %w[SCHEMA TRANSACTION].include?(args.second)
         super(*args, **xargs, &block)
       end
 

data/spec/rbs_helper.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+ENV['RBS_TEST_TARGET'] ||= 'Torque::PostgreSQL::*,Torque::Generators::*'
+ENV['RBS_TEST_SKIP'] ||= '::Torque::PostgreSQL::Attributes::Lazy,::Torque::PostgreSQL::Adapter::OID::Range::Comparison'
+ENV['RBS_TEST_OPT'] ||= '-I sig'
+ENV['RBS_TEST_LOGLEVEL'] ||= 'warn'
+
+require 'rbs/test/setup'

data/spec/schema.rb

@@ -102,6 +102,8 @@ ActiveRecord::Schema.define do
     t.integer  "parent_id"
     t.string   "title"
     t.ltree    "path", index: { using: :gist }
+    t.lquery   "pattern"
+    t.lquery   "patterns", array: true
   end
 
   create_table "texts", force: :cascade do |t|

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+require_relative 'rbs_helper' if ENV['RBS_TEST']
 require 'torque-postgresql'
 require 'database_cleaner'
 require 'factory_bot'