torque-postgresql 4.0.1 → 4.1.1

data/lib/torque/postgresql/adapter/schema_definitions.rb

@@ -18,6 +18,26 @@ module Torque
           names.each { |name| column(name, :virtual, **options) }
         end
 
+        # Add a composite type column to the table
+        def composite(*names, composite_type:, **options)
+          raise ArgumentError, "Missing column name(s) for composite" if names.empty?
+          names.each { |name| column(name, :composite, composite_type: composite_type, **options) }
+        end
+
+        # Add a label tree column to the table. Tree operators are only indexed
+        # by GiST, as in +index: { using: :gist }+, whose default operator class
+        # is already the right one for both a path and an array of paths
+        def ltree(*names, **options)
+          raise ArgumentError, "Missing column name(s) for ltree" if names.empty?
+          names.each { |name| column(name, :ltree, **options) }
+        end
+
+        # Add a label tree pattern column to the table
+        def lquery(*names, **options)
+          raise ArgumentError, "Missing column name(s) for lquery" if names.empty?
+          names.each { |name| column(name, :lquery, **options) }
+        end
+
       end
 
       module TableDefinition
@@ -49,6 +69,32 @@ module Torque
           end
       end
 
+      # Composite types are defined with the same DSL as tables, where declaring
+      # a column adds one, plus the operations that +change_table+ provides
+      class CompositeTypeDefinition < ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition
+        attr_reader :changes, :removals, :renames
+
+        def initialize(*args, **xargs)
+          super
+
+          @changes = []
+          @removals = []
+          @renames = []
+        end
+
+        def change(name, type, **options)
+          @changes << new_column_definition(name, type, **options)
+        end
+
+        def remove(*names)
+          @removals.concat(names.map(&:to_s))
+        end
+
+        def rename(name, new_name)
+          @renames << [name.to_s, new_name.to_s]
+        end
+      end
+
       # Add exclusive support for versioned commands when importing from schema
       # dump. This ensures that such methods are not available in regular
       # migrations.
@@ -69,6 +115,11 @@ module Torque
           execute VersionedCommands.fetch_command(dir, :view, name, version)
         end
 
+        def create_trigger(name, version:, dir: pool.migrations_paths)
+          return super unless VersionedCommands.valid_type?(:trigger)
+          execute VersionedCommands.fetch_command(dir, :trigger, name, version)
+        end
+
       end
 
       ActiveRecord::ConnectionAdapters::PostgreSQL::Table.include ColumnMethods

data/lib/torque/postgresql/adapter/schema_dumper.rb

@@ -34,10 +34,35 @@ module Torque
           def types(stream) # :nodoc:
             super
 
+            composite_types(stream)
+
             versioned_commands(stream, :type)
             versioned_commands(stream, :function)
           end
 
+          # Dump user defined composite types, sorted by their dependencies
+          def composite_types(stream)
+            return unless PostgreSQL.config.composite.enabled
+
+            list = @connection.composite_types
+            list -= @versioned_commands.versions_of('type').map(&:first) \
+              if with_versioned_commands?
+            return if list.empty?
+
+            stream.puts "  # Custom composite types defined in this database."
+            list.each do |name|
+              stream.puts "  create_composite_type #{name.inspect}, force: :cascade do |t|"
+              @connection.columns(name).each do |column|
+                type, colspec = column_spec(column)
+                stream.print "    t.#{type} #{column.name.inspect}"
+                stream.print ", #{format_colspec(colspec)}" if colspec.present?
+                stream.puts
+              end
+              stream.puts "  end"
+              stream.puts
+            end
+          end
+
           def tables(stream) # :nodoc:
             around_tables(stream) { dump_tables(stream) }
           end
@@ -47,6 +72,7 @@ module Torque
 
             yield
             versioned_commands(stream, :view, true)
+            versioned_commands(stream, :trigger, true)
 
             functions(stream) if fx_functions_position == :end
             triggers(stream) if defined?(::Fx::SchemaDumper::Trigger)
@@ -126,6 +152,7 @@ module Torque
           def prepare_column_options(column)
             options = super
             parse_search_vector_options(column, options) if column.type == :tsvector
+            options[:composite_type] = column.sql_type.inspect if column.type == :composite
             options
           end
 

data/lib/torque/postgresql/adapter/schema_statements.rb

@@ -25,6 +25,100 @@ module Torque
           SQL
         end
 
+        # Creates a new composite type, with the columns being defined using
+        # the same DSL as +create_table+, although limited to the type itself,
+        # the size-related options, and no indexes or constraints
+        #
+        # Example:
+        #   create_composite_type :address do |t|
+        #     t.string  "street"
+        #     t.integer "number"
+        #   end
+        def create_composite_type(name, options = {})
+          td = create_composite_type_definition(name)
+          yield td if block_given?
+
+          validate_composite_type!(name, td)
+          drop_type(name, force: options[:force], check: true, schema: options[:schema]) \
+            if options[:force]
+
+          columns = td.columns.map { |column| composite_column_definition(name, column) }
+          type_name = sanitize_name_with_schema(name, options.dup)
+
+          internal_exec_query(<<~SQL.squish, 'SCHEMA').tap { reload_type_map }
+            CREATE TYPE #{quote_type_name(type_name)} AS (#{columns.join(', ')})
+          SQL
+        end
+
+        # Changes an existing composite type, using the same DSL as
+        # +change_table+, although limited to what a type supports
+        #
+        # Example:
+        #   change_composite_type :address do |t|
+        #     t.string 'zipcode'
+        #     t.change 'number', :bigint
+        #     t.remove 'city'
+        #     t.rename 'street', 'road'
+        #   end
+        def change_composite_type(name, options = {})
+          td = create_composite_type_definition(name)
+          yield td
+
+          validate_composite_type!(name, td)
+          type_name = quote_type_name(sanitize_name_with_schema(name, options.dup))
+          actions = composite_type_actions(name, td)
+
+          execute("ALTER TYPE #{type_name} #{actions.join(', ')}") if actions.any?
+
+          td.renames.each do |from, to|
+            execute <<~SQL.squish
+              ALTER TYPE #{type_name}
+              RENAME ATTRIBUTE #{quote_column_name(from)} TO #{quote_column_name(to)}
+            SQL
+          end
+
+          reset_composite_type(name)
+        end
+
+        # Adds a single column to an existing composite type
+        def add_composite_column(type_name, column_name, type, options = {})
+          options = options.dup
+          schema = options.delete(:schema)
+
+          td = create_composite_type_definition(type_name)
+          td.column(column_name, type, **options)
+
+          alter_composite_type(type_name, schema, composite_type_actions(type_name, td))
+        end
+
+        # Removes a single column of an existing composite type. The +type+ is
+        # only needed to make the migration reversible
+        def remove_composite_column(type_name, column_name, type = nil, options = {})
+          action = "DROP ATTRIBUTE #{quote_column_name(column_name)}"
+          alter_composite_type(type_name, options[:schema], [action])
+        end
+
+        # Changes the type of a single column of an existing composite type
+        def change_composite_column(type_name, column_name, type, options = {})
+          options = options.dup
+          schema = options.delete(:schema)
+
+          td = create_composite_type_definition(type_name)
+          td.change(column_name, type, **options)
+
+          alter_composite_type(type_name, schema, composite_type_actions(type_name, td))
+        end
+
+        # Renames a single column of an existing composite type
+        def rename_composite_column(type_name, column_name, new_name, options = {})
+          action = <<~SQL.squish
+            RENAME ATTRIBUTE #{quote_column_name(column_name)}
+            TO #{quote_column_name(new_name)}
+          SQL
+
+          alter_composite_type(type_name, options[:schema], [action])
+        end
+
         # Creates a column that stores the underlying language of the record so
         # that a search vector can be created dynamically based on it. It uses
         # a `regconfig` type, so string conversions are mandatory
@@ -92,6 +186,28 @@ module Torque
         end
 
 
+        # Spread the features of the parent tables into the one being created,
+        # since PostgreSQL only propagates columns and their check constraints
+        def create_table(table_name, **options, &block)
+          sync = options.delete(:sync)
+          result = super
+          return result if sync.blank?
+
+          parents = Array.wrap(options[:inherits]).flatten.compact.map(&:to_s)
+          return result if parents.empty?
+
+          sync_inheritance_into(table_name.to_s, parents, sync_inheritance_selection(sync), false)
+          result
+        end
+
+        # A primary key that came from a parent table is described by the +sync+
+        # option while dumping, otherwise the dumper would describe the inherited
+        # column all over again and the load would break on the duplicate
+        def primary_key(table_name)
+          return super unless @_dump_mode
+          sync_inheritance_parent_primary_key?(table_name) ? nil : super
+        end
+
         # Add the schema option when extracting table options
         def table_options(table_name)
           options = super
@@ -108,6 +224,7 @@ module Torque
 
             tables = inherited_table_names(table_name)
             options[:inherits] = tables.one? ? tables.first : tables
+            options[:sync] = { primary_key: true } if sync_inheritance_parent_primary_key?(table_name)
           end
 
           options
@@ -137,6 +254,25 @@ module Torque
           super + [:schema, :inherits]
         end
 
+        # Add composite_type as one of the valid options for column definition
+        def valid_column_definition_options
+          super + [:composite_type]
+        end
+
+        # Maps the composite type through its required option, mirroring how
+        # enums are handled
+        def type_to_sql(type, composite_type: nil, **options)
+          return super(type, **options) unless type.to_s == 'composite'
+
+          raise ArgumentError, <<~MSG.squish if composite_type.nil?
+            composite_type is required for composite columns
+          MSG
+
+          sql = composite_type.to_s
+          sql = "#{sql}[]" if options[:array]
+          sql
+        end
+
         # Add proper support for schema load when using versioned commands
         def assume_migrated_upto_version(version)
           return super unless PostgreSQL.config.versioned_commands.enabled
@@ -195,6 +331,77 @@ module Torque
             Quoting::Name.new(schema.to_s, name.to_s)
           end
 
+          # A composite type is defined with the same DSL as a table, but only
+          # its columns are taken into account
+          def create_composite_type_definition(name)
+            CompositeTypeDefinition.new(self, name)
+          end
+
+          # Runs a single set of changes over an existing composite type
+          def alter_composite_type(name, schema, actions)
+            type_name = quote_type_name(sanitize_name_with_schema(name, schema: schema))
+            execute("ALTER TYPE #{type_name} #{actions.join(', ')}")
+            reset_composite_type(name)
+          end
+
+          # Every addition, change, and removal that a composite type can batch
+          # into a single statement. Renames are left out because PostgreSQL
+          # does not allow them to be combined with other actions
+          def composite_type_actions(name, td)
+            adds = td.columns.map do |column|
+              "ADD ATTRIBUTE #{composite_column_definition(name, column)}"
+            end
+
+            changes = td.changes.map do |column|
+              quoted = quote_column_name(column.name)
+              "ALTER ATTRIBUTE #{quoted} TYPE #{composite_column_type(name, column)}"
+            end
+
+            drops = td.removals.map { |name| "DROP ATTRIBUTE #{quote_column_name(name)}" }
+
+            adds + changes + drops
+          end
+
+          # A composite type only holds columns, so anything else that the DSL
+          # can produce is rejected
+          def validate_composite_type!(name, td)
+            raise ArgumentError, <<~MSG.squish if td.indexes.present?
+              Unable to define the composite type "#{name}" because it does
+              not support indexes.
+            MSG
+          end
+
+          # Build a single column of a composite type
+          def composite_column_definition(name, column)
+            "#{quote_column_name(column.name)} #{composite_column_type(name, column)}"
+          end
+
+          # Resolve the type of a column, making sure that only supported
+          # options were provided
+          def composite_column_type(name, column)
+            supported = %i[limit precision scale array enum_type composite_type]
+            options = column.options.dup
+            options.delete(:primary_key) unless options[:primary_key]
+
+            unsupported = options.keys - supported
+            raise ArgumentError, <<~MSG.squish if unsupported.present?
+              Unable to define the composite type "#{name}" because the
+              column "#{column.name}" contains unsupported options:
+              #{unsupported.map(&:inspect).join(', ')}.
+            MSG
+
+            type_to_sql(column.type, **options.slice(*supported))
+          end
+
+          # Members loaded by the class that handles the type are no longer
+          # valid once the type itself has changed
+          def reset_composite_type(name)
+            reload_type_map
+            return unless PostgreSQL.config.composite.enabled
+
+            Attributes::Composite.lookup(name.to_s.split('.').last).reset_columns!
+          end
+
           def quote_enum_values(name, values, options)
             prefix = options[:prefix]
             prefix = name if prefix === true

data/lib/torque/postgresql/adapter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'adapter/database_statements'
+require_relative 'adapter/inheritance_statements'
 require_relative 'adapter/oid'
 require_relative 'adapter/quoting'
 require_relative 'adapter/schema_creation'
@@ -13,6 +14,7 @@ module Torque
     module Adapter
       include Quoting
       include DatabaseStatements
+      include InheritanceStatements
       include SchemaStatements
 
       # :nodoc:
@@ -31,11 +33,6 @@ module Torque
         )
       end
 
-      # Add `inherits` and `schema` to the list of extracted table options
-      def extract_table_options!(options)
-        super.merge(options.extract!(:inherits, :schema))
-      end
-
       # Allow filtered bulk insert by adding the where clause. This method is
       # only used by +InsertAll+, so it somewhat safe to override it
       def build_insert_sql(insert)

data/lib/torque/postgresql/arel/nodes.rb

@@ -13,12 +13,125 @@ module Torque
           include ::Arel::Math
 
           def initialize(left, right, array = false)
-            right = +right.to_s
+            right = right.to_s.dup
             right << '[]' if array
             super left, right
           end
         end
 
+        # Accessing a single column of a composite value, which behaves like an
+        # attribute of the composite type it belongs to
+        class Column < ::Arel::Nodes::Binary
+          include ::Arel::Expressions
+          include ::Arel::Predications
+          include ::Arel::AliasPredication
+          include ::Arel::OrderPredications
+          include ::Arel::Math
+
+          attr_reader :type_caster
+          alias name right
+
+          def initialize(source, name, type_caster)
+            @type_caster = type_caster
+            super(source, name.to_s)
+          end
+
+          def able_to_type_cast?
+            true
+          end
+
+          def type_cast_for_database(value)
+            type_caster.serialize(value)
+          end
+        end
+
+        # Accessing a single property of a document, at any depth, casted to
+        # the type that the class declares for it
+        class Property < ::Arel::Nodes::Binary
+          include ::Arel::Expressions
+          include ::Arel::Predications
+          include ::Arel::AliasPredication
+          include ::Arel::OrderPredications
+          include ::Arel::Math
+
+          attr_reader :type_caster, :cast
+
+          alias path right
+
+          # Reaching a property of another one simply adds up to the path, so
+          # that a single node always holds the whole way to it
+          def initialize(source, key, type_caster, cast = nil)
+            @type_caster = type_caster
+            @cast = cast
+
+            return super(source.left, source.path + [key.to_s]) if source.is_a?(Property)
+            super(source, [key.to_s])
+          end
+
+          def name
+            right.last
+          end
+
+          def able_to_type_cast?
+            true
+          end
+
+          def type_cast_for_database(value)
+            type_caster.serialize(value)
+          end
+        end
+
+        # A cross join, which PostgreSQL needs spelled out because an inner
+        # join without a condition is a syntax error
+        class CrossJoin < ::Arel::Nodes::Join
+          def initialize(left, right = nil)
+            super
+          end
+        end
+
+        # An aliased FROM item. +definitions+ maps a column name to the SQL
+        # type a function has to be told to return, +columns+ are the plain
+        # names the alias exposes, +ordinality+ names the appended counter,
+        # and +lateral+ is only needed when the source is a subquery
+        class FromItem < ::Arel::Nodes::Binary
+          attr_reader :columns, :definitions, :ordinality, :lateral
+
+          alias name right
+
+          def initialize(source, name, columns: nil, definitions: nil, ordinality: nil, lateral: false)
+            @columns = Array.wrap(columns).presence&.freeze
+            @definitions = definitions.presence&.freeze
+            @ordinality = ordinality&.to_s
+            @lateral = lateral
+
+            super(source, name.to_s)
+          end
+
+          # The definitions can only be moved into the source when the counter
+          # forces the +ROWS FROM+ form, since PostgreSQL refuses a column
+          # definition list next to +WITH ORDINALITY+
+          def rows_from?
+            ordinality.present? && definitions.present?
+          end
+
+          # What the alias exposes, as name => type, where a +nil+ type means
+          # the name stands on its own. Types are only spelled out here when
+          # they have not been moved into the +ROWS FROM+ source.
+          #
+          # The list is all or nothing, because PostgreSQL matches it
+          # positionally: a partial list silently renames the columns it does
+          # reach instead of naming the ones it does not
+          def alias_columns
+            return {} if columns.nil? && definitions.nil?
+
+            plain = rows_from? ? definitions.keys : columns
+            result = plain.nil? ? definitions : plain.to_h { |name| [name.to_s, nil] }
+
+            return result if ordinality.blank?
+            result.merge(ordinality => nil)
+          end
+        end
+
         class Ref < ::Arel::Nodes::Unary
           attr_reader :reference
           alias to_s expr

data/lib/torque/postgresql/arel/visitors.rb

@@ -16,19 +16,57 @@ module Torque
           quote_array(o.expr, collector)
         end
 
-        # Allow quoted arrays to get here
-        def visit_Arel_Nodes_Casted(o, collector)
-          value = o.value_for_database
-          klass = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array::Data
-          return super unless value.is_a?(klass)
-          quote_array(value.values, collector)
-        end
-
         ## TORQUE VISITORS
         def visit_Torque_PostgreSQL_Arel_Nodes_Ref(o, collector)
           collector << quote_table_name(o.expr)
         end
 
+        # Access a single column of a composite value
+        def visit_Torque_PostgreSQL_Arel_Nodes_Column(o, collector)
+          collector << '('
+          visit(o.left, collector)
+          collector << ').' << quote_column_name(o.right)
+        end
+
+        # Access a single property of a document, as text, so that it can then
+        # be casted to whatever the property is supposed to be
+        def visit_Torque_PostgreSQL_Arel_Nodes_Property(o, collector)
+          collector << '('
+          visit(o.left, collector)
+          collector << ' #>> '
+          visit(::Arel.array(o.path), collector)
+          collector << ')'
+          collector << '::' << o.cast if o.cast
+          collector
+        end
+
+        # A cross join only ever carries its source
+        def visit_Torque_PostgreSQL_Arel_Nodes_CrossJoin(o, collector)
+          collector << 'CROSS JOIN '
+          visit(o.left, collector)
+        end
+
+        # Every part here is written only when it is actually needed, since
+        # LATERAL is a noise word on functions and ROWS FROM is only forced
+        # by the counter
+        def visit_Torque_PostgreSQL_Arel_Nodes_FromItem(o, collector)
+          collector << 'LATERAL ' if o.lateral
+
+          collector << 'ROWS FROM (' if o.rows_from?
+          visit(o.left, collector)
+          collector = visit_definitions(o.definitions, collector) << ')' if o.rows_from?
+
+          collector << ' WITH ORDINALITY' if o.ordinality.present?
+          collector << ' ' << quote_table_name(o.name)
+
+          columns = o.alias_columns
+          return collector if columns.blank?
+
+          collector << '('
+          visit_alias_columns(columns, collector)
+          collector << ')'
+        end
+
         # Allow casting any node
         def visit_Torque_PostgreSQL_Arel_Nodes_Cast(o, collector)
           visit(o.left, collector) << '::' << o.right
@@ -36,6 +74,25 @@ module Torque
 
         private
 
+          # The column definition list a function has to be told to return
+          def visit_definitions(definitions, collector)
+            collector << ' AS ('
+            visit_alias_columns(definitions, collector)
+            collector << ')'
+          end
+
+          # A name on its own when it has no type, otherwise the name and the
+          # type it is being given
+          def visit_alias_columns(columns, collector)
+            columns.each_with_index do |(name, type), index|
+              collector << ', ' unless index.zero?
+              collector << quote_column_name(name)
+              collector << ' ' << type if type.present?
+            end
+
+            collector
+          end
+
           def quote_array(value, collector)
             value = value.map(&::Arel::Nodes.method(:build_quoted))
 

data/lib/torque/postgresql/associations/join_dependency.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Associations
+      module JoinDependency
+        def apply_column_aliases(relation)
+          result = super
+          return result unless relation.from_clause.empty?
+
+          relation._select!(root_record_class_marker) if cast_join_root?(relation)
+          relation._select!(-> { joined_record_class_markers })
+          result
+        end
+
+        private
+
+          def cast_join_root?(relation)
+            return false if relation.itself_only_value === true
+            return false unless join_root_alias
+
+            join_root.base_klass.physically_inheritances?
+          end
+
+          def root_record_class_marker
+            table = join_root.base_klass.arel_table
+            table['tableoid'].pg_cast(:regclass).as(record_class_column_name)
+          end
+
+          # The root is projected under its own name and picked up by the
+          # column sweep in #instantiate, which only ever feeds the root. Every
+          # other join part has to carry the marker inside its own set of
+          # aliases, since that is all #extract_record ever reads
+          def joined_record_class_markers
+            markers = join_root.each_with_index.map do |join_part, index|
+              next if index.zero? || !join_part.base_klass.physically_inheritances?
+              next if (columns = aliases.column_aliases(join_part)).blank?
+
+              column_alias = "#{columns.first.alias[/\At\d+/]}_r#{columns.size}"
+              columns << ::ActiveRecord::Associations::JoinDependency::Aliases::Column
+                .new(record_class_column_name, column_alias)
+
+              join_part.table['tableoid'].pg_cast(:regclass).as(column_alias)
+            end
+
+            markers.compact
+          end
+
+          def record_class_column_name
+            ::ActiveRecord::Relation._record_class_column_name
+          end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/associations.rb

@@ -4,7 +4,10 @@ require_relative 'associations/foreign_association'
 
 require_relative 'associations/builder'
 require_relative 'associations/preloader'
+require_relative 'associations/join_dependency'
 
 association_mod = Torque::PostgreSQL::Associations::ForeignAssociation
 ::ActiveRecord::Associations::HasManyAssociation.prepend(association_mod)
 ::ActiveRecord::Associations::BelongsToManyAssociation.prepend(association_mod)
+
+::ActiveRecord::Associations::JoinDependency.prepend(Torque::PostgreSQL::Associations::JoinDependency)