torque-postgresql 4.0.0 → 4.1.0

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,74 @@ 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
+
         class Ref < ::Arel::Nodes::Unary
           attr_reader :reference
           alias to_s expr

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

@@ -16,19 +16,30 @@ 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
+
         # Allow casting any node
         def visit_Torque_PostgreSQL_Arel_Nodes_Cast(o, collector)
           visit(o.left, collector) << '::' << o.right

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)

data/lib/torque/postgresql/attributes/base.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'simple_enum'
+
+module Torque
+  module PostgreSQL
+    module Attributes
+      # The common ground between the classes that back a column with a set of
+      # typed properties, like structs and composite types. It carries enough of
+      # the ActiveRecord attribute surface for its own features, and for the
+      # ActiveRecord concerns that build on top of it, to work
+      class Base
+        include ActiveModel::Model
+        include ActiveModel::Attributes
+        include ActiveModel::Serialization
+        include ActiveModel::Serializers::JSON
+        include ActiveModel::Dirty
+        include ActiveModel::Validations::Callbacks
+
+        include SimpleEnum
+        include ActiveRecord::Store
+        # Rails 8.1 moved normalization to Active Model, which is where these
+        # classes belong anyway
+        include(AR810 ? ActiveModel::Attributes::Normalization : ActiveRecord::Normalization)
+        include ActiveRecord::Encryption::EncryptableRecord
+
+        class << self
+          # These classes are not backed by a table, so nothing here has the
+          # extra information that a column would provide
+          def columns_hash
+            {}
+          end
+
+          # Encrypt individual attributes, so their values are stored encrypted
+          # inside the column that holds them
+          def encrypts(*names, **options)
+            names.each do |name|
+              raise ArgumentError, <<~MSG.squish unless attribute_names.include?(name.to_s)
+                Unable to encrypt "#{name}" because it is not a declared
+                attribute of #{self.name}.
+              MSG
+            end
+
+            super
+          end
+        end
+
+        # Plain access to any property, declared or not
+        def [](key)
+          key = key.to_s
+          @attributes.key?(key) ? @attributes.fetch_value(key) : nil
+        end
+
+        def []=(key, value)
+          assign_attributes(key => value)
+        end
+
+        def ==(other)
+          other.class == self.class && other.attributes == attributes
+        end
+        alias eql? ==
+
+        def empty?
+          @attributes.keys.empty?
+        end
+
+        def hash
+          [self.class, attributes].hash
+        end
+
+        def to_h
+          attributes.symbolize_keys
+        end
+
+        def inspect
+          entries = attributes.map { |key, value| "#{key}: #{value.inspect}" }
+          "#<#{self.class.name} #{entries.join(', ')}>"
+        end
+
+        def type_for_attribute(name, &block)
+          self.class.type_for_attribute(name, &block)
+        end
+
+        def read_attribute_before_type_cast(name)
+          @attributes[name.to_s].value_before_type_cast
+        end
+
+        def read_attribute_for_database(name)
+          @attributes[name.to_s].value_for_database
+        end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/attributes/composite.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Torque
+  module PostgreSQL
+    module Attributes
+      class Composite < Base
+        class << self
+          attr_writer :type_name
+
+          # Find or create the class that will handle the composite type. It
+          # first checks the irregular types mapping, then the namespace
+          def lookup(name)
+            name = name.to_s.underscore
+            mapping = PostgreSQL.config.composite.irregular_types
+            return resolve(mapping[name].constantize, name) if mapping.key?(name)
+
+            const     = name.camelize
+            namespace = PostgreSQL.config.composite.namespace
+
+            return resolve(namespace.const_get(const), name) if namespace.const_defined?(const)
+            resolve(namespace.const_set(const, Class.new(Composite)), name)
+          end
+
+          def inherited(subclass)
+            super
+            subclass.instance_variable_set(:@load_columns_monitor, ::Monitor.new)
+          end
+
+          # The name of the composite type on the database
+          def type_name
+            @type_name ||= name.demodulize.underscore
+          end
+
+          # The ordered list of columns of the composite type, as a hash of
+          # name and type, loaded in a lazy way
+          def columns
+            load_columns
+            @columns
+          end
+
+          # Load the columns from the database and define any attribute that
+          # was not manually declared
+          def load_columns
+            return if self == Composite || defined?(@columns)
+
+            @load_columns_monitor.synchronize do
+              next if defined?(@columns)
+
+              columns = connection.composite_column_types(type_name)
+              columns.each do |attr_name, attr_type|
+                attribute(attr_name, attr_type) unless attribute_names.include?(attr_name)
+              end
+
+              @columns = columns
+            end
+          end
+
+          # Drop the loaded columns, so that they are collected again on the
+          # next use, which happens after the type is changed
+          def reset_columns!
+            @load_columns_monitor.synchronize do
+              remove_instance_variable(:@columns) if defined?(@columns)
+            end
+          end
+
+          def new(*args, **xargs, &block)
+            load_columns
+            super
+          end
+
+          # Columns have to be in place before any of them can be decorated
+          def encrypts(*names, **options)
+            load_columns
+            super
+          end
+
+          def enum(*args, **xargs)
+            load_columns
+            super
+          end
+
+          private
+
+            # Make sure that the class knows the name of the type it handles,
+            # since it can be resolved from an irregular mapping
+            def resolve(klass, name)
+              klass.type_name = name
+              klass
+            end
+
+            def connection
+              ActiveRecord::Base.connection
+            end
+        end
+      end
+    end
+
+    Composite = Attributes::Composite
+  end
+end

data/lib/torque/postgresql/attributes/enum.rb

@@ -39,11 +39,22 @@ module Torque
             super
           end
 
+          def inherited(subclass)
+            super
+            subclass.instance_variable_set(:@load_values_monitor, ::Monitor.new)
+          end
+
           # Load the list of values in a lazy way
           def values
-            @values ||= self == Enum ? nil : begin
-              connection.enum_values(type_name).freeze
+            return if self == Enum
+            return @values if defined?(@values)
+
+            @load_values_monitor.synchronize do
+              next if defined?(@values)
+              @values = connection.enum_values(type_name).freeze
             end
+
+            @values
           end
 
           # List of values as symbols