sequel 4.36.0 → 5.61.0

data/lib/sequel/extensions/pg_row.rb

@@ -7,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
@@ -18,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:
@@ -61,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
@@ -85,14 +88,10 @@
 
 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,15 +462,15 @@ 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[literal(db_type)] = opts.merge(:parser=>parser, :type=>db_type)
@@ -497,24 +482,12 @@ module Sequel
               row_type(db_type, v)
             end
             private meth
+            alias_method(meth, 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.values.each do |opts|
-            register_row_type(opts[: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.
@@ -550,10 +523,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 +542,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

@@ -19,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
@@ -70,14 +70,14 @@
 #
 # 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}}
 #
@@ -88,15 +88,10 @@ 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.
@@ -163,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
@@ -191,7 +210,7 @@ end
 if defined?(Sequel::CoreRefinements)
   module Sequel::CoreRefinements
     refine Symbol do
-      include Sequel::Postgres::PGRowOp::ExpressionMethods
+      send INCLUDE_METH, Sequel::Postgres::PGRowOp::ExpressionMethods
     end
   end
 end

data/lib/sequel/extensions/pg_static_cache_updater.rb

@@ -121,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
 
@@ -129,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

data/lib/sequel/extensions/pg_timestamptz.rb

@@ -0,0 +1,28 @@
+# frozen-string-literal: true
+#
+# The pg_timestamptz extension changes the default timestamp
+# type for the database to be +timestamptz+ (+timestamp with time zone+)
+# instead of +timestamp+ (+timestamp without time zone+).  This is
+# recommended if you are dealing with multiple timezones in your application.
+# 
+# To load the extension into the database:
+#
+#   DB.extension :pg_timestamptz
+#
+# Related module: Sequel::Postgres::Timestamptz
+
+#
+module Sequel
+  module Postgres
+    module Timestamptz
+      private
+
+      # Use timestamptz by default for generic timestamp value.
+      def type_literal_generic_datetime(column)
+        :timestamptz
+      end
+    end
+  end
+
+  Database.register_extension(:pg_timestamptz, Postgres::Timestamptz)
+end

data/lib/sequel/extensions/query.rb

@@ -6,7 +6,7 @@
 #
 #   dataset = DB[:items].query do
 #     select :x, :y, :z
-#     filter{(x > 1) & (y > 2)}
+#     where{(x > 1) & (y > 2)}
 #     reverse :z
 #   end
 #
@@ -37,24 +37,22 @@ module Sequel
   end
 
   module DatasetQuery
-    Dataset.def_mutation_method(:query, :module=>self)
-
     # Translates a query block into a dataset. Query blocks are an
     # alternative to Sequel's usual method chaining, by using
-    # instance_eval with a proxy object:
+    # instance_exec with a proxy object:
     #
     #   dataset = DB[:items].query do
     #     select :x, :y, :z
-    #     filter{(x > 1) & (y > 2)}
+    #     where{(x > 1) & (y > 2)}
     #     reverse :z
     #   end
     #
     # Which is the same as:
     #
-    #  dataset = DB[:items].select(:x, :y, :z).filter{(x > 1) & (y > 2)}.reverse(:z)
+    #  dataset = DB[:items].select(:x, :y, :z).where{(x > 1) & (y > 2)}.reverse(:z)
     def query(&block)
       query = Dataset::Query.new(self)
-      query.instance_eval(&block)
+      query.instance_exec(&block)
       query.dataset
     end
   end
@@ -71,10 +69,14 @@ module Sequel
 
       # Replace the query's dataset with dataset returned by the method call.
       def method_missing(method, *args, &block)
+        # Allow calling private methods, so things like raise works
         @dataset = @dataset.send(method, *args, &block)
         raise(Sequel::Error, "method #{method.inspect} did not return a dataset") unless @dataset.is_a?(Dataset)
         self
       end
+      # :nocov:
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+      # :nocov:
     end
   end
 

data/lib/sequel/extensions/round_timestamps.rb

@@ -25,12 +25,6 @@
 #
 # Related module: Sequel::Dataset::RoundTimestamps
 
-unless RUBY_VERSION >= '1.9'
-  # :nocov:
-  raise LoadError, 'the round_timestamps extension only works on ruby 1.9+'
-  # :nocov:
-end
-
 module Sequel
   class Dataset
     module RoundTimestamps

data/lib/sequel/extensions/run_transaction_hooks.rb

@@ -0,0 +1,72 @@
+# frozen-string-literal: true
+#
+# The run_transaction_hooks extension allows for running after_commit or
+# after_rollback extensions before commit or rollback.  It then removes
+# the hook after running it, so it will not be run twice.
+#
+# This extension should only be used in transactional tests where the
+# transaction always rolls back, to test the behavior of the after_commit
+# and after_rollback hooks.  Any other usage is probably a bad idea.
+#
+# Example:
+#
+#   DB.extension :run_transaction_hooks
+#   x = 1
+#   DB.transaction(rollback: :always) do
+#     DB.after_rollback{x = 3}
+#     DB.after_commit{x = 2}
+#
+#     x # => 1
+#     DB.run_after_rollback_hooks
+#     x # => 3
+#     DB.run_after_commit_hooks
+#     x # => 2
+#   end
+#   x # => 2
+
+#
+class Sequel::Database
+  module RunTransactionHooks
+    # Run all savepoint and transaction after_commit hooks for the current transaction,
+    # and remove the hooks after running them.
+    # Options:
+    # :server :: The server/shard to use.
+    def run_after_commit_hooks(opts=OPTS)
+      _run_transaction_hooks(:after_commit, opts)
+    end
+
+    # Run all savepoint and transaction after_rollback hooks for the current transaction,
+    # and remove the hooks after running them.
+    # Options:
+    # :server :: The server/shard to use.
+    def run_after_rollback_hooks(opts=OPTS)
+      _run_transaction_hooks(:after_rollback, opts)
+    end
+
+    private
+
+    def _run_transaction_hooks(type, opts)
+      synchronize(opts[:server]) do |conn|
+        unless h = _trans(conn)
+          raise Sequel::Error, "Cannot call run_#{type}_hooks outside of a transaction"
+        end
+
+        if hooks = h[type]
+          hooks.each(&:call)
+          hooks.clear
+        end
+
+        if (savepoints = h[:savepoints])
+          savepoints.each do |savepoint|
+            if hooks = savepoint[type]
+              hooks.each(&:call)
+              hooks.clear
+            end
+          end
+        end
+      end
+    end
+  end
+
+  register_extension(:run_transaction_hooks, RunTransactionHooks)
+end

data/lib/sequel/extensions/s.rb

@@ -0,0 +1,60 @@
+# frozen-string-literal: true
+#
+# The s extension adds Sequel::S, a module containing a private #S
+# method that calls Sequel.expr.  It's designed as a shortcut so
+# that instead of:
+#
+#   Sequel.expr(:column) + 1
+#   # or
+#   Sequel.expr{column + 1}
+#
+# you can just write:
+#
+#   S(:column) + 1
+#   # or
+#   S{column + 1}
+#
+# To load the extension:
+#
+#   Sequel.extension :s
+#
+# Then you can include the Sequel::S module into whatever classes or
+# objects you care about:
+#
+#   Sequel::Model.send(:include, Sequel::S)   # available in model instance methods
+#   Sequel::Model.extend(Sequel::S)           # available in model class methods
+#   Sequel::Dataset.send(:include, Sequel::S) # available in dataset methods
+#
+# or just into Object if you want it available everywhere:
+#
+#   Object.send(:include, Sequel::S)
+#
+# If you are using Ruby 2+, and you would like to use refinements, you
+# can use Sequel::S as a refinement, in which case the private #S method
+# will be available on all objects while the refinement is active.
+#
+#   using Sequel::S
+#
+#   S(:column) + 1
+#
+# Related module: Sequel::S
+
+
+# 
+module Sequel::S
+  private
+
+  # Delegate to Sequel.expr
+  def S(*a, &block)
+    Sequel.expr(*a, &block)
+  end
+
+  # :nocov:
+  if RUBY_VERSION >= '2.0.0'
+    include_meth = RUBY_VERSION >= '3.1' ? :import_methods : :include
+  # :nocov:
+    refine Object do
+      send include_meth, Sequel::S
+    end
+  end
+end

data/lib/sequel/extensions/schema_caching.rb

@@ -51,7 +51,15 @@ module Sequel
   module SchemaCaching
     # Dump the cached schema to the filename given in Marshal format.
     def dump_schema_cache(file)
-      File.open(file, 'wb'){|f| f.write(Marshal.dump(@schemas))}
+      sch = {}
+      @schemas.each do |k,v|
+        sch[k] = v.map do |c, h|
+          h = Hash[h]
+          h.delete(:callable_default)
+          [c, h]
+        end
+      end
+      File.open(file, 'wb'){|f| f.write(Marshal.dump(sch))}
       nil
     end
 
@@ -65,6 +73,7 @@ module Sequel
     # should be in Marshal format.
     def load_schema_cache(file)
       @schemas = Marshal.load(File.read(file))
+      @schemas.each_value{|v| schema_post_process(v)}
       nil
     end