sequel 4.26.0 → 5.37.0

data/lib/sequel/extensions/pg_range_ops.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The pg_range_ops extension adds support to Sequel's DSL to make
 # it easier to call PostgreSQL range functions and operators.
 #
@@ -17,7 +19,7 @@
 # Also, on most Sequel expression objects, you can call the pg_range
 # method:
 #
-#   r = Sequel.expr(:range).pg_range
+#   r = Sequel[:range].pg_range
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension
@@ -51,6 +53,8 @@
 # If you are also using the pg_range extension, you should load it before
 # loading this extension.  Doing so will allow you to use PGArray#op to get
 # an RangeOp, allowing you to perform range operations on range literals.
+#
+# Related module: Sequel::Postgres::RangeOp
 
 #
 module Sequel
@@ -71,13 +75,12 @@ module Sequel
         :starts_after => ["(".freeze, " &> ".freeze, ")".freeze].freeze,
         :adjacent_to => ["(".freeze, " -|- ".freeze, ")".freeze].freeze,
         :overlaps => ["(".freeze, " && ".freeze, ")".freeze].freeze,
-      }
-      FUNCTIONS = %w'lower upper isempty lower_inc upper_inc lower_inf upper_inf'
+      }.freeze
 
-      FUNCTIONS.each do |f|
+      %w'lower upper isempty lower_inc upper_inc lower_inf upper_inf'.each do |f|
         class_eval("def #{f}; function(:#{f}) end", __FILE__, __LINE__)
       end
-      OPERATORS.keys.each do |f|
+      OPERATORS.each_key do |f|
         class_eval("def #{f}(v); operator(:#{f}, v) end", __FILE__, __LINE__)
       end
 
@@ -113,7 +116,9 @@ module Sequel
       end
     end
 
+    # :nocov:
     if defined?(PGRange)
+    # :nocov:
       class PGRange
         # Wrap the PGRange instance in an RangeOp, allowing you to easily use
         # the PostgreSQL range functions and operators with literal ranges.

data/lib/sequel/extensions/pg_row.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The pg_row extension adds support for Sequel to handle
 # PostgreSQL's row-valued/composite types.
 #
@@ -5,7 +7,7 @@
 # that when composite fields are retrieved, they are parsed and returned
 # as instances of Sequel::Postgres::PGRow::(HashRow|ArrayRow), or
 # optionally a custom type.  HashRow and ArrayRow are DelegateClasses of
-# of Hash and Array, so they mostly act like a hash or array, but not
+# Hash and Array, so they mostly act like a hash or array, but not
 # completely (is_a?(Hash) and is_a?(Array) are false).  If you want the
 # actual hash for a HashRow, call HashRow#to_hash, and if you want the
 # actual array for an ArrayRow, call ArrayRow#to_a.  This is done so
@@ -16,11 +18,14 @@
 # for HashRow and ArrayRow using the standard Sequel literalization callbacks, so
 # they work with on all adapters.
 #
-# The first thing you are going to want to do is to load the extension into
-# your Database object.  Make sure you load the :pg_array extension first
-# if you plan to use composite types in bound variables:
+# To use this extension, first load it into the Database instance:
+#
+#   DB.extension :pg_row
+#
+# If you plan to use arrays of composite types, make sure you load the
+# pg_array extension first:
 # 
-#   DB.extension(:pg_array, :pg_row)
+#   DB.extension :pg_array, :pg_row
 #
 # You can create an anonymous row type by calling the Sequel.pg_row with
 # an array:
@@ -59,12 +64,12 @@
 #
 # You can also use a hash:
 #
-#   DB.row_type(:address, :street=>'123 Sesame St.', :city=>'Some City', :zip=>'12345')
+#   DB.row_type(:address, street: '123 Sesame St.', city: 'Some City', zip: '12345')
 #
 # So if you have a person table that has an address column, here's how you
 # could insert into the column:
 #
-#   DB[:table].insert(:address=>DB.row_type(:address, :street=>'123 Sesame St.', :city=>'Some City', :zip=>'12345'))
+#   DB[:table].insert(address: DB.row_type(:address, street: '123 Sesame St.', city: 'Some City', zip: '12345'))
 #
 # Note that registering row types without providing an explicit :converter option
 # creates anonymous classes.  This results in ruby being unable to Marshal such
@@ -74,25 +79,19 @@
 #   DB.conversion_procs.select{|k,v| v.is_a?(Sequel::Postgres::PGRow::Parser) && \
 #     v.converter && (v.converter.name.nil? || v.converter.name == '') }.map{|k,v| v}
 # 
-# If you are not using the native postgres or jdbc/postgresql adapters and are using composite types
-# types as model column values you probably should use the
-# pg_typecast_on_load plugin if the column values are returned as a string.
-#
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using row type columns in CREATE/ALTER TABLE statements.
 #
 # This extension requires both the strscan and delegate libraries.
+#
+# Related module: Sequel::Postgres::PGRow
 
 require 'delegate'
 require 'strscan'
-Sequel.require 'adapters/utils/pg_types'
 
 module Sequel
   module Postgres
     module PGRow
-      ROW = 'ROW'.freeze
-      CAST = '::'.freeze
-
       # Class for row-valued/composite types that are treated as arrays. By default,
       # this is only used for generic PostgreSQL record types, as registered
       # types use HashRow by default.
@@ -130,10 +129,10 @@ module Sequel
 
         # Append SQL fragment related to this object to the sql.
         def sql_literal_append(ds, sql)
-          sql << ROW
+          sql << 'ROW'
           ds.literal_append(sql, to_a)
           if db_type
-            sql << CAST
+            sql << '::'
             ds.quote_schema_table_append(sql, db_type)
           end
         end
@@ -202,16 +201,16 @@ module Sequel
         # Append SQL fragment related to this object to the sql.
         def sql_literal_append(ds, sql)
           check_columns!
-          sql << ROW
+          sql << 'ROW'
           ds.literal_append(sql, values_at(*columns))
           if db_type
-            sql << CAST
+            sql << '::'
             ds.quote_schema_table_append(sql, db_type)
           end
         end
       end
 
-      ROW_TYPE_CLASSES = [HashRow, ArrayRow]
+      ROW_TYPE_CLASSES = [HashRow, ArrayRow].freeze
 
       # This parser-like class splits the PostgreSQL
       # row-valued/composite type output string format
@@ -220,33 +219,24 @@ module Sequel
       # will accept, it only handles the output format that
       # PostgreSQL uses.
       class Splitter < StringScanner
-        OPEN_PAREN = /\(/.freeze
-        CLOSE_PAREN = /\)/.freeze
-        UNQUOTED_RE = /[^,)]*/.freeze
-        SEP_RE = /[,)]/.freeze
-        QUOTE_RE = /"/.freeze
-        QUOTE_SEP_RE = /"[,)]/.freeze
-        QUOTED_RE = /(\\.|""|[^"])*/.freeze
-        REPLACE_RE = /\\(.)|"(")/.freeze
-        REPLACE_WITH = '\1\2'.freeze
-
         # Split the stored string into an array of strings, handling
         # the different types of quoting.
         def parse
-          return @result if @result
           values = []
-          skip(OPEN_PAREN)
-          if skip(CLOSE_PAREN)
+          skip(/\(/)
+          if skip(/\)/)
             values << nil
           else
+            # :nocov:
             until eos?
-              if skip(QUOTE_RE)
-                values << scan(QUOTED_RE).gsub(REPLACE_RE, REPLACE_WITH)
-                skip(QUOTE_SEP_RE)
+            # :nocov:
+              if skip(/"/)
+                values << scan(/(\\.|""|[^"])*/).gsub(/\\(.)|"(")/, '\1\2')
+                skip(/"[,)]/)
               else
-                v = scan(UNQUOTED_RE)
+                v = scan(/[^,)]*/)
                 values << (v unless v.empty?)
-                skip(SEP_RE)
+                skip(/[,)]/)
               end
             end
           end
@@ -373,10 +363,6 @@ module Sequel
       end
 
       module DatabaseMethods
-        ESCAPE_RE = /("|\\)/.freeze
-        ESCAPE_REPLACEMENT = '\\\\\1'.freeze
-        COMMA = ','.freeze
-
         # A hash mapping row type keys (usually symbols), to option
         # hashes.  At the least, the values will contain the :parser
         # option for the Parser instance that the type will use.
@@ -384,17 +370,14 @@ module Sequel
 
         # Do some setup for the data structures the module uses.
         def self.extended(db)
-          # Return right away if row_types has already been set. This
-          # makes things not break if a user extends the database with
-          # this module more than once (since extended is called every
-          # time).
-          return if db.row_types
-
-          db.instance_eval do
+          db.instance_exec do
             @row_types = {}
             @row_schema_types = {}
             extend(@row_type_method_module = Module.new)
-            copy_conversion_procs([2249, 2287])
+            add_conversion_proc(2249, PGRow::Parser.new(:converter=>PGRow::ArrayRow))
+            if respond_to?(:register_array_type)
+              register_array_type('record', :oid=>2287, :scalar_oid=>2249)
+            end
           end
         end
 
@@ -402,15 +385,23 @@ module Sequel
         def bound_variable_arg(arg, conn)
           case arg
           when ArrayRow
-            "(#{arg.map{|v| bound_variable_array(v) if v}.join(COMMA)})"
+            "(#{arg.map{|v| bound_variable_array(v) if v}.join(',')})"
           when HashRow
             arg.check_columns!
-            "(#{arg.values_at(*arg.columns).map{|v| bound_variable_array(v) if v}.join(COMMA)})"
+            "(#{arg.values_at(*arg.columns).map{|v| bound_variable_array(v) if v}.join(',')})"
           else
             super
           end
         end
 
+        # Freeze the row types and row schema types to prevent adding new ones.
+        def freeze
+          @row_types.freeze
+          @row_schema_types.freeze
+          @row_type_method_module.freeze
+          super
+        end
+
         # Register a new row type for the Database instance. db_type should be the type
         # symbol.  This parses the PostgreSQL system tables to get information the
         # composite type, and by default has the type return instances of a subclass
@@ -432,7 +423,7 @@ module Sequel
 
           # Get basic oid information for the composite type.
           ds = from(:pg_type).
-            select(:pg_type__oid, :typrelid, :typarray).
+            select{[pg_type[:oid], :typrelid, :typarray]}.
             where([[:typtype, 'c'], [:typname, type_name.to_s]])
           if type_schema
             ds = ds.join(:pg_namespace, [[:oid, :typnamespace], [:nspname, type_schema.to_s]])
@@ -454,7 +445,7 @@ module Sequel
             where{attnum > 0}.
             exclude(:attisdropped).
             order(:attnum).
-            select_map([:attname, Sequel.case({0=>:atttypid}, :pg_type__typbasetype, :pg_type__typbasetype).as(:atttypid)])
+            select_map{[:attname, Sequel.case({0=>:atttypid}, pg_type[:typbasetype], pg_type[:typbasetype]).as(:atttypid)]}
           if res.empty?
             raise Error, "no columns for row type #{db_type.inspect} in database"
           end
@@ -463,13 +454,7 @@ module Sequel
 
           # Using the conversion_procs, lookup converters for each member of the composite type
           parser_opts[:column_converters] = parser_opts[:column_oids].map do |oid|
-            if pr = procs[oid]
-              pr
-            elsif !Sequel::Postgres::STRING_TYPES.include?(oid)
-              # It's not a string type, and it's possible a conversion proc for this
-              # oid will be added later, so do a runtime check for it.
-              lambda{|s| (pr = procs[oid]) ? pr.call(s) : s}
-            end
+            procs[oid]
           end
 
           # Setup the converter and typecaster
@@ -477,18 +462,18 @@ module Sequel
           parser_opts[:typecaster] = opts.fetch(:typecaster, parser_opts[:converter])
 
           parser = Parser.new(parser_opts)
-          @conversion_procs[parser.oid] = parser
+          add_conversion_proc(parser.oid, parser)
 
-          if defined?(PGArray) && PGArray.respond_to?(:register) && array_oid && array_oid > 0
+          if respond_to?(:register_array_type) && array_oid && array_oid > 0
             array_type_name = if type_schema
               "#{type_schema}.#{type_name}"
             else
               type_name
             end
-            PGArray.register(array_type_name, :oid=>array_oid, :converter=>parser, :type_procs=>@conversion_procs, :scalar_typecast=>schema_type_symbol)
+            register_array_type(array_type_name, :oid=>array_oid, :converter=>parser, :scalar_typecast=>schema_type_symbol)
           end
 
-          @row_types[db_type] = opts.merge(:parser=>parser)
+          @row_types[literal(db_type)] = opts.merge(:parser=>parser, :type=>db_type)
           @row_schema_types[schema_type_string] = schema_type_symbol 
           @schema_type_classes[schema_type_symbol] = ROW_TYPE_CLASSES
           @row_type_method_module.class_eval do
@@ -499,27 +484,14 @@ module Sequel
             private meth
           end
 
-          conversion_procs_updated
           nil
         end
 
-        # When reseting conversion procs, reregister all the row types so that
-        # the system tables are introspected again, picking up database changes.
-        def reset_conversion_procs
-          procs = super
-
-          row_types.each do |db_type, opts|
-            register_row_type(db_type, opts)
-          end
-
-          procs
-        end
-
         # Handle typecasting of the given object to the given database type.
         # In general, the given database type should already be registered,
         # but if obj is an array, this will handled unregistered types.
         def row_type(db_type, obj)
-          (type_hash = @row_types[db_type]) &&
+          (type_hash = @row_types[literal(db_type)]) &&
             (parser = type_hash[:parser])
 
           case obj
@@ -550,10 +522,10 @@ module Sequel
         def bound_variable_array(arg)
           case arg
           when ArrayRow
-            "\"(#{arg.map{|v| bound_variable_array(v) if v}.join(COMMA).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)})\""
+            "\"(#{arg.map{|v| bound_variable_array(v) if v}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
           when HashRow
             arg.check_columns!
-            "\"(#{arg.values_at(*arg.columns).map{|v| bound_variable_array(v) if v}.join(COMMA).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)})\""
+            "\"(#{arg.values_at(*arg.columns).map{|v| bound_variable_array(v) if v}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
           else
             super
           end
@@ -569,12 +541,6 @@ module Sequel
         end
       end
     end
-
-    # Register the default anonymous record type
-    PG_TYPES[2249] = PGRow::Parser.new(:converter=>PGRow::ArrayRow)
-    if defined?(PGArray) && PGArray.respond_to?(:register)
-      PGArray.register('record', :oid=>2287, :scalar_oid=>2249)
-    end
   end
 
   module SQL::Builders

data/lib/sequel/extensions/pg_row_ops.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The pg_row_ops extension adds support to Sequel's DSL to make
 # it easier to deal with PostgreSQL row-valued/composite types.
 #
@@ -17,7 +19,7 @@
 # Also, on most Sequel expression objects, you can call the pg_row
 # method:
 #
-#   r = Sequel.expr(:row_column).pg_row
+#   r = Sequel[:row_column].pg_row
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension
@@ -68,31 +70,28 @@
 #
 # By casting the expression, you can get a composite type returned:
 #
-#   DB[:a].select(a.splat).first # SELECT (a.*)::a FROM a
+#   DB[:a].select(a.splat(:a)).first # SELECT (a.*)::a FROM a
 #   # => {:a=>"(1,2)"} # or {:a=>{:a=>1, :b=>2}} if the "a" type has been registered
 #                      # with the pg_row extension
 #
 # This feature is mostly useful for a different way to graph tables:
 #
-#   DB[:a].join(:b, :id=>:b_id).select(Sequel.pg_row_op(:a).splat(:a),
-#                                      Sequel.pg_row_op(:b).splat(:b))
+#   DB[:a].join(:b, id: :b_id).select(Sequel.pg_row_op(:a).splat(:a),
+#                                     Sequel.pg_row_op(:b).splat(:b))
 #   # SELECT (a.*)::a, (b.*)::b FROM a INNER JOIN b ON (b.id = a.b_id)
 #   # => {:a=>{:id=>1, :b_id=>2}, :b=>{:id=>2}}
+#
+# Related module: Sequel::Postgres::PGRowOp
 
 #
 module Sequel
   module Postgres
     # This class represents a composite type expression reference.
     class PGRowOp < SQL::PlaceholderLiteralString
-      OPEN = '('.freeze
-      CLOSE_DOT = ').'.freeze
-      CLOSE_STAR = '.*)'.freeze
-      CLOSE_STAR_CAST = '.*)::'.freeze
-      EMPTY = "".freeze
-      ROW = [OPEN, CLOSE_STAR].freeze
-      ROW_CAST = [OPEN, CLOSE_STAR_CAST].freeze
-      QUALIFY = [OPEN, CLOSE_DOT].freeze
-      WRAP = [EMPTY].freeze
+      ROW = ['(', '.*)'].freeze.each(&:freeze)
+      ROW_CAST = ['(', '.*)::'].freeze.each(&:freeze)
+      QUALIFY = ['(', ').'].freeze.each(&:freeze)
+      WRAP = [""].freeze.each(&:freeze)
 
       # Wrap the expression in a PGRowOp, without changing the
       # SQL it would use.
@@ -159,6 +158,30 @@ module Sequel
         end
       end
     end
+
+    # :nocov:
+    if defined?(PGRow::ArrayRow)
+    # :nocov:
+      class PGRow::ArrayRow
+        # Wrap the PGRow::ArrayRow instance in an PGRowOp, allowing you to easily use
+        # the PostgreSQL row functions and operators with literal rows.
+        def op
+          Sequel.pg_row_op(self)
+        end
+      end
+    end
+
+    # :nocov:
+    if defined?(PGRow::HashRow)
+    # :nocov:
+      class PGRow::HashRow
+        # Wrap the PGRow::ArrayRow instance in an PGRowOp, allowing you to easily use
+        # the PostgreSQL row functions and operators with literal rows.
+        def op
+          Sequel.pg_row_op(self)
+        end
+      end
+    end
   end
 
   module SQL::Builders

data/lib/sequel/extensions/pg_static_cache_updater.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The pg_static_cache_updater extension is designed to
 # automatically update the caches in the models using the
 # static_cache plugin when changes to the underlying tables
@@ -61,6 +63,8 @@
 #   with the pg driver (the model classes do not have to
 #   use the same Database).
 # * Must be using a thread-safe connection pool (the default).
+#
+# Related module: Sequel::Postgres::StaticCacheUpdater
 
 #
 module Sequel
@@ -117,7 +121,7 @@ SQL
 
         oid_map = {}
         models.each do |model|
-          raise Error, "#{model.inspect} does not use the static_cache plugin" unless model.respond_to?(:load_cache, true)
+          raise Error, "#{model.inspect} does not use the static_cache plugin" unless model.respond_to?(:load_cache)
           oid_map[get(regclass_oid(model.dataset.first_source_table))] = model
         end
 
@@ -125,7 +129,7 @@ SQL
           begin
             listen(opts[:channel_name]||default_static_cache_update_name, {:loop=>true}.merge!(opts)) do |_, _, oid|
               if model = oid_map[oid.to_i]
-                model.send(:load_cache)
+                model.load_cache
               end
             end
           ensure