torque-postgresql 4.1.0 → 4.1.1

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

@@ -4,173 +4,113 @@ module Torque
   module PostgreSQL
     module Attributes
       # A pattern that matches label paths, as described by the +lquery+ data
-      # type. It is only ever built from Ruby and never parsed back from its
-      # text form, so each entry of the given list becomes one item
+      # type. It holds the pure items of the pattern: labels as Strings, +:any+
+      # for a star, a Range for a quantified star and an Array for a group of
+      # alternatives
       class LQuery
+        include Enumerable
+
         MARKERS = /[*|!{}@%]/
-        QUANTIFIER = /\{(?:\d+|\d*,\d*)\}/
-        LABEL = /[[:alnum:]_-]+/
-        ALTERNATIVE = /#{LABEL}[@*%]{0,3}/
-        ITEM = /\A!?#{ALTERNATIVE}(?:\|#{ALTERNATIVE})*#{QUANTIFIER}?\z/
-        STAR_ITEM = /\A\*#{QUANTIFIER}?\z/
-
-        class << self
-          def [](*items)
-            new(items)
-          end
+        LEVEL = /\A(?<not>!)?(?<variants>.*?)(?:\{(?<min>\d*)(?<comma>,)?(?<max>\d*)\})?\z/
+        VARIANT = /\A(?<name>.*?)(?<modifiers>[*@%]*)\z/
 
-          # Values coming from the database are valid by construction
-          def load(value)
-            new(value, normalize: false)
-          end
+        attr_reader :items
 
-          # Whether the given value asks for a pattern instead of a plain path,
-          # which is what makes a condition use +~+ instead of +=+
-          def marker?(value)
-            Array.wrap(value).any? { |item| item_marker?(item) }
-          end
+        delegate :inspect, to: :to_s
+        delegate :each, :size, :empty?, :[], to: :items
+
+        def self.[](*items)
+          new(items)
+        end
 
-          private
+        def initialize(value = nil, sanitize: true)
+          @items = type.items_for(value, sanitize: sanitize).freeze
+        end
 
-            def item_marker?(item)
-              return marker?(LTree.compatible(item)) if LTree.compatible?(item)
+        def to_s
+          type.serialize(self)
+        end
 
-              case item
-              when ::Symbol then item == :any
-              when ::Range, ::Array, LQuery then true
-              when ::String then item.match?(MARKERS)
-              else false
-              end
-            end
+        def pattern?
+          items.any? { |item| !item.is_a?(::String) || item.match?(MARKERS) }
         end
 
-        attr_reader :items
+        def pattern
+          @pattern ||= compile
+        end
 
-        def initialize(items, normalize: true)
-          items = normalize ? expand(items) : Array.wrap(items)
-          @items = normalize ? items.map { |item| compile(item) } : items.map(&:to_s)
+        def match?(path)
+          path = LTree.new(path) unless path.is_a?(LTree)
+          pattern.match?(path.to_s)
         end
 
-        def to_s
-          items.join('.')
+        def =~(path)
+          path = LTree.new(path) unless path.is_a?(LTree)
+          pattern =~ path.to_s
         end
 
         def ==(other)
-          other.is_a?(LQuery) && to_s == other.to_s
+          other = other.items if other.is_a?(self.class)
+          other.is_a?(::Array) && items == other
         end
         alias eql? ==
 
         def hash
-          to_s.hash
+          items.hash
         end
 
         private
 
-          # An object that describes itself as a path contributes every one of
-          # its labels as an item, rather than a single one
-          def expand(value)
-            return expand(LTree.compatible(value)) if LTree.compatible?(value)
-
-            value = value.split('.') if value.is_a?(::String)
-            Array.wrap(value).flat_map { |item| expand_item(item) }
+          def type
+            Adapter::OID::Lquery.new
           end
 
-          def expand_item(item)
-            return expand(LTree.compatible(item)) if LTree.compatible?(item)
-
-            [item]
+          def compile
+            levels = to_s.split('.', -1).map { |level| compile_level(level) }
+            Regexp.new("\\A#{levels.join}\\z")
           end
 
-          def compile(item)
-            case item
-            when ::Range then compile_range(item)
-            when ::Array then compile_alternatives(item)
-            when ::Symbol then item == :any ? '*' : compile_item(item)
-            when ::String, ::Numeric, ::ActiveRecord::Base then compile_item(item)
-            else
-              raise ArgumentError, <<~MSG.squish
-                Unable to use #{item.inspect} as an lquery item. Items are labels,
-                a Range for a quantified star, or an Array of alternatives.
-              MSG
-            end
+          def compile_level(text)
+            match = text.match(LEVEL)
+            variants = match[:variants]
+            label = variants == '*' ? '[^.]+' : compile_variants(variants.split('|'))
+            label = "(?!#{label}(?:\\.|\\z))[^.]+" if match[:not]
+            "(?:(?:\\A|\\.)#{label})#{quantifier(match)}"
           end
 
-          # A Range is always a quantifier over the star, since a star on its own
-          # already means any number of labels
-          def compile_range(range)
-            min = range.begin
-            max = range.end
-            max -= 1 if max && range.exclude_end?
-
-            invalid = min&.negative? || max&.negative? || (min && max && max < min)
-            raise ArgumentError, <<~MSG.squish if invalid
-              #{range.inspect} is not a valid quantifier for an lquery star.
-            MSG
-
-            return '*' if min.nil? && max.nil?
-            return "*{#{min}}" if min == max
-            return "*{#{min},}" if max.nil?
-            return "*{,#{max}}" if min.nil?
-            "*{#{min},#{max}}"
+          def compile_variants(variants)
+            sources = variants.map { |variant| compile_variant(variant) }
+            "(?:#{sources.join('|')})"
           end
 
-          def compile_alternatives(list)
-            raise ArgumentError, <<~MSG.squish if list.empty?
-              An lquery alternation needs at least one label.
-            MSG
+          def compile_variant(text)
+            match = text.match(VARIANT)
+            modifiers = match[:modifiers]
+            prefix = modifiers.include?('*')
+            name = match[:name]
 
-            alternatives = list.map { |entry| compile_alternative(entry) }
-            alternatives.join('|')
+            source = modifiers.include?('%') ? words(name, prefix) : label(name, prefix)
+            modifiers.include?('@') ? "(?i:#{source})" : source
           end
 
-          def compile_alternative(entry)
-            alternative = sanitize_labels(assert_plain!(entry))
-
-            raise ArgumentError, <<~MSG.squish unless alternative.match?(/\A#{ALTERNATIVE}\z/)
-              #{entry.inspect} is not a valid lquery alternative. Alternatives are
-              single labels, optionally followed by the #{'@*%'.inspect} modifiers.
-            MSG
-
-            alternative
+          def label(name, prefix)
+            "#{Regexp.escape(name)}#{'[^.]*' if prefix}"
           end
 
-          def compile_item(entry)
-            text = assert_plain!(entry)
-            return text if text.match?(STAR_ITEM)
-
-            head, quantifier = split_quantifier(text)
-            item = sanitize_labels(head) + quantifier
-
-            raise ArgumentError, <<~MSG.squish unless item.match?(ITEM)
-              #{entry.inspect} is not a valid lquery item. An item is a label with
-              the optional #{'@*%'.inspect} modifiers, optionally negated with "!",
-              alternated with "|" and quantified with "{n,m}".
-            MSG
-
-            item
-          end
-
-          def assert_plain!(entry)
-            entry = LTree.resolve_record(entry)
-            plain = entry.is_a?(::String) || entry.is_a?(::Symbol) || entry.is_a?(::Numeric)
-            raise ArgumentError, <<~MSG.squish unless plain
-              Unable to use #{entry.inspect} as part of an lquery item.
-            MSG
-
-            entry.to_s
-          end
+          def words(name, prefix)
+            lookaheads = name.split('_').reject(&:empty?).map do |word|
+              "(?=(?:[^.]*_)?#{Regexp.escape(word)}#{'[^._]*' if prefix}(?:[_.]|\\z))"
+            end
 
-          # Only the labels are normalized, so that a replacement never rewrites
-          # the structure of the pattern nor the digits of a quantifier
-          def sanitize_labels(text)
-            text.gsub(LABEL) { |label| LTree.sanitize(label) }
+            "#{lookaheads.join}[^.]+"
           end
 
-          def split_quantifier(text)
-            match = text.match(/#{QUANTIFIER}\z/)
-            return [text, ''] if match.nil?
+          def quantifier(match)
+            return match[:variants] == '*' ? '*' : '' if match[:min].nil?
 
-            [match.pre_match, match[0]]
+            min = match[:min].presence || 0
+            max = match[:comma] ? match[:max] : min
+            "{#{min},#{max}}"
           end
       end
     end

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

@@ -3,23 +3,21 @@
 module Torque
   module PostgreSQL
     module Attributes
-      # A label path, as stored by the +ltree+ data type. It is an Array of
-      # labels, so it flows through Ruby like any other list, which also means
-      # that an +ltree[]+ column simply becomes an Array of these
-      class LTree < Array
-        LABEL = /\A[[:alnum:]_-]+\z/
+      # A label path, as stored by the +ltree+ data type. It holds the plain
+      # list of labels, so it enumerates like any other list, and an +ltree[]+
+      # column simply becomes an Array of these
+      class LTree
+        include Enumerable
 
+        attr_reader :items
+
+        delegate :inspect, to: :to_s
+        delegate :each, :size, :empty?, :[], to: :items
         alias depth size
 
         class << self
-          def [](*labels)
-            new(labels)
-          end
-
-          # Values coming from the database are valid by construction, so they
-          # skip both the normalization and the validation
-          def load(value)
-            new(value.to_s.split('.'), normalize: false)
+          def [](*items)
+            new(items)
           end
 
           # Whether the object knows how to describe itself as a path, which is
@@ -34,44 +32,24 @@ module Torque
             method = PostgreSQL.config.ltree.compatible_method
             value.public_send(method) if compatible?(value)
           end
+        end
 
-          # A record stands for its primary key, which is what makes a path
-          # built out of other records work the same way as one built out of
-          # labels
-          def resolve_record(value)
-            return value unless value.is_a?(::ActiveRecord::Base)
-
-            id = value.id
-            raise ArgumentError, <<~MSG.squish if id.nil?
-              Unable to use #{value.class.name} as a label because its
-              #{value.class.primary_key} is still empty.
-            MSG
-
-            raise ArgumentError, <<~MSG.squish if id.is_a?(::Array)
-              Unable to use #{value.class.name} as a label because it has a
-              composite primary key, which cannot be a single label.
-            MSG
-
-            id
-          end
-
-          # Apply the configured replacements, so callers can feed a source that
-          # does not satisfy PostgreSQL's rules for a label on its own
-          def sanitize(value)
-            replacements = PostgreSQL.config.ltree.sanitize
-            return value if replacements.blank?
+        def initialize(value = nil, sanitize: true)
+          @items = type.items_for(value, sanitize: sanitize).freeze
+        end
 
-            value.gsub(Regexp.union(replacements.keys), replacements)
-          end
+        def to_s
+          type.serialize(self)
         end
 
-        def initialize(labels = nil, normalize: true)
-          super()
-          concat(normalize ? normalized(labels) : Array.wrap(labels))
+        def ==(other)
+          other = other.items if other.is_a?(self.class)
+          other.is_a?(::Array) && items == other
         end
+        alias eql? ==
 
-        def to_s
-          join('.')
+        def hash
+          items.hash
         end
 
         def root?
@@ -79,24 +57,23 @@ module Torque
         end
 
         def root
-          self.class.new(first, normalize: false)
+          self.class.new(items.first(1), sanitize: false)
         end
 
-        # A path with a single label has no parent, and neither does an empty one
         def parent
-          self.class.new(self[0..-2], normalize: false) unless root?
+          self.class.new(items[0..-2], sanitize: false) unless root?
         end
 
         def /(other)
-          self.class.new(to_a + self.class.new(other), normalize: false)
+          self.class.new(items + self.class.new(other).items, sanitize: false)
         end
 
         alias_method :+, :/
 
         # Same as the +@>+ operator, which includes the path itself
         def ancestor_of?(other)
-          other = self.class.new(other)
-          size <= other.size && other.first(size) == to_a
+          other = self.class.new(other).items
+          size <= other.size && other.first(size) == items
         end
         alias covers? ancestor_of?
 
@@ -109,51 +86,26 @@ module Torque
         # The longest common ancestor, which never includes the last label of
         # any of the paths, exactly like PostgreSQL's own +lca+
         def lca(*others)
-          paths = [self, *others].map { |path| self.class.new(path)[0..-2].to_a }
-          result = paths.shift || []
+          paths = [self, *others].map { |path| self.class.new(path).items[0..-2] }
+          result = paths.shift
           paths.each { |path| result = common_prefix(result, path) }
-          self.class.new(result, normalize: false)
+          self.class.new(result, sanitize: false)
         end
 
-        # The position where the given subpath starts, or -1 when it is not
-        # present. Named apart from +index+ so that Array's own contract, of
-        # returning +nil+ when the element is missing, stays intact
         def index_of(subpath, offset = 0)
-          subpath = self.class.new(subpath)
+          subpath = self.class.new(subpath).items
           offset += size if offset.negative?
           return -1 if subpath.empty? || offset.negative?
 
           range = offset..(size - subpath.size)
-          position = range.find { |i| self[i, subpath.size] == subpath.to_a }
+          position = range.find { |i| items[i, subpath.size] == subpath }
           position || -1
         end
 
         private
 
-          def normalized(labels)
-            entries = Array.wrap(labels).flat_map { |value| split_labels(value) }
-            entries.each { |label| assert_valid_label!(label) }
-          end
-
-          def split_labels(value)
-            return normalized(self.class.compatible(value)) if self.class.compatible?(value)
-
-            value = self.class.resolve_record(value)
-            plain = value.is_a?(::String) || value.is_a?(::Symbol) || value.is_a?(::Numeric)
-            raise ArgumentError, <<~MSG.squish unless plain
-              Unable to use #{value.inspect} as part of an ltree path. A path is a
-              plain sequence of labels, so it accepts neither the alternatives nor
-              the quantifiers that only make sense on an lquery.
-            MSG
-
-            self.class.sanitize(value.to_s).split('.')
-          end
-
-          def assert_valid_label!(label)
-            raise ArgumentError, <<~MSG.squish unless label.match?(LABEL)
-              #{label.inspect} is not a valid ltree label. Labels are limited to
-              letters, numbers, underscores and dashes.
-            MSG
+          def type
+            Adapter::OID::Ltree.new
           end
 
           def common_prefix(one, other)

data/lib/torque/postgresql/base.rb

@@ -18,7 +18,15 @@ module Torque
 
       class_methods do
         delegate :distinct_on, :with, :itself_only, :expand_records, :join_series,
-          :buckets, to: :all
+          :buckets, :segments, to: :all
+
+        # The Arel node for a path into a document column, typed by the struct
+        # class that backs the column when there is one
+        def arel_property_of(column, *path)
+          type = Adapter::OID.unwrap(attribute_types[column.to_s])
+          handler = PredicateBuilder::StructHandler.new(predicate_builder)
+          handler.property_for(arel_table[column], type, path)
+        end
 
         # Composite values are objects that can be invalid on their own, so the
         # attributes backed by one are validated alongside the record

data/lib/torque/postgresql/config.rb

@@ -38,6 +38,9 @@ module Torque
     # Add support for querying and calculating histogram buckets
     config.buckets = true
 
+    # Add support for segmenting calculations by named conditions
+    config.segments = true
+
     # Set a list of irregular model name when associated with table names
     config.irregular_models = {}
     def config.irregular_models=(hash)
@@ -309,8 +312,8 @@ module Torque
       ltree.enabled = true
 
       # A hash of replacements applied to every label provided by the
-      # application before it gets validated, so that a source that does not
-      # satisfy PostgreSQL's rules on its own can still be used. Dashes, for
+      # application before it is sent to the database, so that a source that
+      # does not satisfy PostgreSQL's rules on its own can still be used. Dashes, for
       # example, are only accepted as of PostgreSQL 16
       #   { '-' => '_' } turns dashes into underscores
       #   { '-' => '' }  drops dashes
@@ -411,7 +414,7 @@ module Torque
 
       # Define the list of commands that are going to be versioned by this
       # method
-      vs.types = %i[function type view]
+      vs.types = %i[function type view trigger]
 
       # The name of the table that will inherit from +schema_migrations+ and
       # store the list of versioned commands that have been executed
@@ -419,5 +422,20 @@ module Torque
 
     end
 
+    # Configure cross join features
+    config.nested(:cross_join) do |cross_join|
+
+      # This is an experimental feature that developers must explicitly opt-in.
+      # TODO: hook into how conditions and columns are resolved, so that the
+      # name of a joined set can shadow a real column
+      cross_join.enabled = false
+
+      # The name of the column added by +with_ordinality+ when it is given
+      # +true+ instead of a name. It matches what PostgreSQL calls the column
+      # when it is not named at all
+      cross_join.ordinality_column = :ordinality
+
+    end
+
   end
 end

data/lib/torque/postgresql/geometry_builder.rb

@@ -24,8 +24,7 @@ module Torque
         case value
         when ::String
           return if value.blank?
-          value.gsub!(DESTRUCTOR, '')
-          build_klass(*value.split(','))
+          build_klass(*value.gsub(DESTRUCTOR, '').split(','))
         when ::Hash
           build_klass(*value.symbolize_keys.slice(*pieces).values)
         when ::Array
@@ -49,8 +48,8 @@ module Torque
         parts = parts&.compact&.flatten
         return if parts.blank?
 
-        raise 'Invalid format' if parts.size < pieces.size
-        format(formation, *parts.first(pieces.size).map(&number_serializer))
+        parts = ::Array.new(pieces.size) { |index| parts[index] }
+        format(formation, *parts.map(&number_serializer))
       end
 
       def deserialize(value)
@@ -81,13 +80,8 @@ module Torque
 
         def build_klass(*args)
           return nil if args.empty?
-          check_invalid_format!(args)
 
-          config_class.new(*args.try(:first, pieces.size)&.map(&:to_f))
-        end
-
-        def check_invalid_format!(args)
-          raise 'Invalid format' if args.size < pieces.size
+          config_class.new(*args.first(pieces.size).map(&:to_f))
         end
     end
   end

data/lib/torque/postgresql/inheritance.rb

@@ -45,7 +45,7 @@ module Torque
         # Check if the model's table depends on any inheritance
         def physically_inherited?
           inheritance_cache(:@physically_inherited) do
-            connection.schema_cache.dependencies(
+            connection_pool.schema_cache.dependencies(
               defined?(@table_name) ? @table_name : decorated_table_name,
             ).present?
           end
@@ -56,7 +56,7 @@ module Torque
         # Get the list of all tables directly or indirectly dependent of the
         # current one
         def inheritance_dependents
-          connection.schema_cache.associations(table_name) || []
+          connection_pool.schema_cache.associations(table_name) || []
         end
 
         # Check whether the model's table has directly or indirectly dependents
@@ -100,7 +100,7 @@ module Torque
         def casted_dependents
           inheritance_cache(:@casted_dependents) do
             inheritance_dependents.map do |table_name|
-              [table_name, connection.schema_cache.lookup_model(table_name)]
+              [table_name, connection_pool.schema_cache.lookup_model(table_name)]
             end.to_h.freeze
           end
         end
@@ -121,8 +121,8 @@ module Torque
           table = super
 
           adapter = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-          if Torque::PostgreSQL.config.eager_load && connection.is_a?(adapter)
-            connection.schema_cache.add_model_name(table, self)
+          if Torque::PostgreSQL.config.eager_load && connection_pool.db_config.adapter_class <= adapter
+            connection_pool.schema_cache.add_model_name(table, self)
           end
 
           table

data/lib/torque/postgresql/predicate_builder/arel_attribute_handler.rb

@@ -25,7 +25,7 @@ module Torque
         private
 
           def array_typed?(attribute)
-            attribute.able_to_type_cast? && attribute.type_caster.is_a?(ARRAY_OID)
+            attribute.able_to_type_cast? && Adapter::OID.unwrap(attribute.type_caster).is_a?(ARRAY_OID)
           end
       end
     end

data/lib/torque/postgresql/predicate_builder/array_handler.rb

@@ -12,13 +12,17 @@ module Torque
         end
 
         def call_for_array(attribute, value)
-          if !value.is_a?(::Array)
-            call_with_value(attribute, value)
-          elsif value.any?
-            call_with_array(attribute, value)
-          else
-            call_with_empty(attribute)
-          end
+          return attribute.eq(nil) if value.nil?
+
+          value = value.to_a if value.is_a?(::Set)
+          return call_with_value(attribute, value) unless value.is_a?(::Array)
+          return call_with_empty(attribute) if value.empty?
+
+          nils, values = value.map { |entry| id_of(entry) }.partition(&:nil?)
+          return attribute.eq(nil) if values.empty?
+
+          condition = call_with_array(attribute, values)
+          nils.empty? ? condition : condition.or(attribute.eq(nil))
         end
 
         private
@@ -35,8 +39,12 @@ module Torque
             FN.cardinality(attribute).eq(0)
           end
 
+          def id_of(entry)
+            entry.is_a?(::ActiveRecord::Base) ? entry.id : entry
+          end
+
           def array_attribute?(attribute)
-            attribute.type_caster.is_a?(ARRAY_OID)
+            Adapter::OID.unwrap(attribute.type_caster).is_a?(ARRAY_OID)
           end
       end
 

data/lib/torque/postgresql/predicate_builder/composite_handler.rb

@@ -8,14 +8,15 @@ module Torque
       # whole +where+ vocabulary works inside a composite
       class CompositeHandler
         class << self
-          # Values that this handler knows how to deal with, checked before the
-          # attribute itself because it is way cheaper
-          def candidate?(value, type)
+          # Values that this handler knows how to deal with. Without a value,
+          # only a single composite has parts that can be reached on their own
+          def candidate?(type, value = nil)
             return false unless Adapter::OID::Composite.from(type)
+            return !type.is_a?(ARRAY_OID) if value.nil?
 
             case value
             when ::Hash, Attributes::Composite then true
-            when ::Array then value.any? { |entry| candidate?(entry, type) }
+            when ::Array then value.compact.any? { |entry| candidate?(type, entry) }
             else false
             end
           end
@@ -41,6 +42,13 @@ module Torque
           conditions_for(attribute, value)
         end
 
+        # The columns of the composite value as the columns of a table, so that
+        # any of them can be resolved by name
+        def table_for(source, type)
+          @composite = Adapter::OID::Composite.from(type)
+          PredicateTable.new(self, source, Arel::Nodes::Column)
+        end
+
         # The type of a single column of the composite type
         def type_of(name)
           columns = @composite.columns
@@ -65,6 +73,11 @@ module Torque
             name = attribute.name
             cast = composite.name
 
+            if !array && value.is_a?(::Array)
+              records = value.map { |entry| FN.bind(name, entry, composite).pg_cast(cast) }
+              return attribute.in(records)
+            end
+
             return attribute.eq(FN.bind(name, value, composite).pg_cast(cast)) unless array
 
             if value.is_a?(::Array)
@@ -99,7 +112,7 @@ module Torque
 
           def group_for(source, entry)
             entry = entry.to_h unless entry.is_a?(::Hash)
-            table = PredicateTable.new(self, source, Arel::Nodes::Column)
+            table = table_for(source, composite)
             nodes = predicate_builder.with(table).build_from_hash(entry.stringify_keys)
             ::Arel::Nodes::Grouping.new(nodes.reduce(:and))
           end