sequel 3.39.0 → 3.40.0

data/lib/sequel/database/query.rb

@@ -22,7 +22,7 @@ module Sequel
       :serializable=>'SERIALIZABLE'.freeze}
     
     STRING_DEFAULT_RE = /\A'(.*)'\z/
-    CURRENT_TIMESTAMP_RE = /now|CURRENT|getdate/io
+    CURRENT_TIMESTAMP_RE = /now|CURRENT|getdate|\ADate\(\)\z/io
     COLUMN_SCHEMA_DATETIME_TYPES = [:date, :datetime]
     COLUMN_SCHEMA_STRING_TYPES = [:string, :blob, :date, :datetime, :time, :enum, :set, :interval]
 
@@ -195,7 +195,9 @@ module Sequel
       opts[:schema] = sch if sch && !opts.include?(:schema)
 
       Sequel.synchronize{@schemas.delete(quoted_name)} if opts[:reload]
-      return Sequel.synchronize{@schemas[quoted_name]} if @schemas[quoted_name]
+      if v = Sequel.synchronize{@schemas[quoted_name]}
+        return v
+      end
 
       cols = schema_parse_table(table_name, opts)
       raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.nil? || cols.empty?
@@ -234,6 +236,14 @@ module Sequel
     #
     # The following general options are respected:
     #
+    # :disconnect :: Can be set to :retry to automatically retry the transaction with
+    #                a new connection object if it detects a disconnect on the connection.
+    #                Note that this should not be used unless the entire transaction
+    #                block is idempotent, as otherwise it can cause non-idempotent
+    #                behavior to execute multiple times.  This does no checking for
+    #                infinite loops, so if your transaction will repeatedly raise a
+    #                disconnection error, this will cause the transaction block to loop
+    #                indefinitely.
     # :isolation :: The transaction isolation level to use for this transaction,
     #               should be :uncommitted, :committed, :repeatable, or :serializable,
     #               used if given and the database/adapter supports customizable
@@ -258,9 +268,22 @@ module Sequel
     #                 appropriately.  Valid values true, :on, false, :off, :local (9.1+),
     #                 and :remote_write (9.2+).
     def transaction(opts={}, &block)
-      synchronize(opts[:server]) do |conn|
-        return yield(conn) if already_in_transaction?(conn, opts)
-        _transaction(conn, opts, &block)
+      if opts[:disconnect] == :retry
+        begin
+          transaction(opts.merge(:disconnect=>:disallow), &block)
+        rescue Sequel::DatabaseDisconnectError
+          retry
+        end
+      else
+        synchronize(opts[:server]) do |conn|
+          if already_in_transaction?(conn, opts)
+            if opts[:disconnect] == :disallow
+              raise Sequel::Error, "cannot set :disconnect=>:retry if you are already inside a transaction"
+            end
+            return yield(conn)
+          end
+          _transaction(conn, opts, &block)
+        end
       end
     end
     
@@ -440,7 +463,7 @@ module Sequel
     # Convert the given default, which should be a database specific string, into
     # a ruby object.
     def column_schema_to_ruby_default(default, type)
-      return if default.nil?
+      return default unless default.is_a?(String)
       if COLUMN_SCHEMA_DATETIME_TYPES.include?(type)
         if CURRENT_TIMESTAMP_RE.match(default)
           if type == :date
@@ -582,7 +605,7 @@ module Sequel
     # such as :integer or :string.
     def schema_column_type(db_type)
       case db_type
-      when /\A(character( varying)?|n?(var)?char|n?text)/io
+      when /\A(character( varying)?|n?(var)?char|n?text|string)/io
         :string
       when /\A(int(eger)?|(big|small|tiny)int)/io
         :integer

data/lib/sequel/database/schema_methods.rb

@@ -354,7 +354,7 @@ module Sequel
     # SQL fragment for given alter table operation.
     def alter_table_op_sql(table, op)
       quoted_name = quote_identifier(op[:name]) if op[:name]
-      alter_table_op = case op[:op]
+      case op[:op]
       when :add_column
         "ADD COLUMN #{column_definition_sql(op)}"
       when :drop_column
@@ -783,7 +783,7 @@ module Sequel
     # :text option is used, Sequel uses the :text type.
     def type_literal_generic_string(column)
       if column[:text]
-        :text
+        uses_clob_for_text? ? :clob : :text
       elsif column[:fixed]
         "char(#{column[:size]||255})"
       else
@@ -811,5 +811,10 @@ module Sequel
       elements = column[:size] || column[:elements]
       "#{type}#{literal(Array(elements)) if elements}#{UNSIGNED if column[:unsigned]}"
     end
+
+    # Whether clob should be used for String :text=>true columns.
+    def uses_clob_for_text?
+      false
+    end
   end
 end

data/lib/sequel/dataset/query.rb

@@ -974,17 +974,16 @@ module Sequel
     # :args :: Specify the arguments/columns for the CTE, should be an array of symbols.
     # :union_all :: Set to false to use UNION instead of UNION ALL combining the nonrecursive and recursive parts.
     #
-    #   DB[:t].select(:i___id, :pi___parent_id).
-    #    with_recursive(:t,
-    #                   DB[:i1].filter(:parent_id=>nil),
-    #                   DB[:t].join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id),
-    #                   :args=>[:i, :pi])
-    #   # WITH RECURSIVE t(i, pi) AS (
-    #   #   SELECT * FROM i1 WHERE (parent_id IS NULL)
+    #   DB[:t].with_recursive(:t,
+    #     DB[:i1].select(:id, :parent_id).filter(:parent_id=>nil),
+    #     DB[:i1].join(:t, :id=>:parent_id).select(:i1__id, :i1__parent_id),
+    #     :args=>[:id, :parent_id])
+    #   
+    #   # WITH RECURSIVE "t"("id", "parent_id") AS (
+    #   #   SELECT "id", "parent_id" FROM "i1" WHERE ("parent_id" IS NULL)
     #   #   UNION ALL
-    #   #   SELECT i1.id, i1.parent_id FROM t INNER JOIN t ON (t.i = t.parent_id)
-    #   # )
-    #   # SELECT i AS id, pi AS parent_id FROM t
+    #   #   SELECT "i1"."id", "i1"."parent_id" FROM "i1" INNER JOIN "t" ON ("t"."id" = "i1"."parent_id")
+    #   # ) SELECT * FROM "t"
     def with_recursive(name, nonrecursive, recursive, opts={})
       raise(Error, 'This datatset does not support common table expressions') unless supports_cte?
       if hoist_cte?(nonrecursive)

data/lib/sequel/dataset/sql.rb

@@ -306,7 +306,6 @@ module Sequel
       window_function_sql
     END
     PRIVATE_APPEND_METHODS = (<<-END).split.map{|x| x.to_sym}
-      argument_list
       as_sql
       column_list
       compound_dataset_sql
@@ -783,16 +782,6 @@ module Sequel
       options_overlap(COUNT_FROM_SELF_OPTS) ? from_self : unordered
     end
 
-    def argument_list_append(sql, args)
-      c = false
-      comma = COMMA
-      args.each do |a|
-        sql << comma if c
-        sql << a.to_s
-        c ||= true
-      end
-    end
-
     # SQL fragment for specifying an alias.  expression should already be literalized.
     def as_sql_append(sql, aliaz)
       sql << AS
@@ -940,6 +929,17 @@ module Sequel
     end
     alias table_ref_append identifier_append 
     
+    # Append all identifiers in args interspersed by commas.
+    def identifier_list_append(sql, args)
+      c = false
+      comma = COMMA
+      args.each do |a|
+        sql << comma if c
+        identifier_append(sql, a)
+        c ||= true
+      end
+    end
+
     # Modify the identifier returned from the database based on the
     # identifier_output_method.
     def input_identifier(v)
@@ -962,13 +962,7 @@ module Sequel
       columns = opts[:columns]
       if columns && !columns.empty?
         sql << PAREN_SPACE_OPEN
-        c = false
-        co = COMMA
-        columns.each do |col|
-          sql << co if c
-          identifier_append(sql, col)
-          c ||= true
-        end
+        identifier_list_append(sql, columns)
         sql << PAREN_CLOSE
       end 
     end
@@ -1311,7 +1305,7 @@ module Sequel
         quote_identifier_append(sql, w[:name])
         if args = w[:args]
          sql << PAREN_OPEN
-         argument_list_append(sql, args)
+         identifier_list_append(sql, args)
          sql << PAREN_CLOSE
         end
         sql << AS
@@ -1332,13 +1326,7 @@ module Sequel
     # Converts an array of source names into into a comma separated list.
     def source_list_append(sql, sources)
       raise(Error, 'No source specified for query') if sources.nil? || sources == []
-      c = false
-      co = COMMA
-      sources.each do |s|
-        sql << co if c
-        identifier_append(sql, s)
-        c ||= true
-      end
+      identifier_list_append(sql, sources)
     end
     
     # Delegate to Sequel.split_symbol.

data/lib/sequel/extensions/pg_hstore.rb

@@ -182,6 +182,20 @@ module Sequel
       ESCAPE_REPLACE = '\\\\\1'.freeze
       HSTORE_CAST = '::hstore'.freeze
 
+      if RUBY_VERSION >= '1.9'
+        # Undef 1.9 marshal_{dump,load} methods in the delegate class,
+        # so that ruby 1.9 uses the old style _dump/_load methods defined
+        # in the delegate class, instead of the marshal_{dump,load} methods
+        # in the Hash class.
+        undef_method :marshal_load
+        undef_method :marshal_dump
+      end
+
+      # Use custom marshal loading, since underlying hash uses a default proc.
+      def self._load(args)
+        new(Hash[Marshal.load(args)])
+      end
+
       # Parse the given string into an HStore, assuming the str is in PostgreSQL
       # hstore output format.
       def self.parse(str)
@@ -209,6 +223,11 @@ module Sequel
         class_eval("def #{m}(h, &block) super(convert_hash(h), &block) end", __FILE__, __LINE__)
       end
 
+      # Use custom marshal dumping, since underlying hash uses a default proc.
+      def _dump(*)
+        Marshal.dump(to_a)
+      end
+
       # Override to force the key argument to a string.
       def fetch(key, *args, &block)
         super(key.to_s, *args, &block)

data/lib/sequel/extensions/pg_row.rb

@@ -321,7 +321,7 @@ module Sequel
         # ruby objects, one for each converter.
         def convert_columns(arr)
           if ccs = @column_converters
-            arr.zip(ccs).map{|v, pr| pr ? pr.call(v) : v}
+            arr.zip(ccs).map{|v, pr| (v && pr) ? pr.call(v) : v}
           else
             arr 
           end
@@ -379,10 +379,10 @@ module Sequel
         def bound_variable_arg(arg, conn)
           case arg
           when ArrayRow
-            "(#{arg.map{|v| bound_variable_array(v)}.join(COMMA)})"
+            "(#{arg.map{|v| bound_variable_array(v) if v}.join(COMMA)})"
           when HashRow
             arg.check_columns!
-            "(#{arg.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA)})"
+            "(#{arg.values_at(*arg.columns).map{|v| bound_variable_array(v) if v}.join(COMMA)})"
           else
             super
           end
@@ -528,10 +528,10 @@ module Sequel
         def bound_variable_array(arg)
           case arg
           when ArrayRow
-            "\"(#{arg.map{|v| bound_variable_array(v)}.join(COMMA).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)})\""
+            "\"(#{arg.map{|v| bound_variable_array(v) if v}.join(COMMA).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)})\""
           when HashRow
             arg.check_columns!
-            "\"(#{arg.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)})\""
+            "\"(#{arg.values_at(*arg.columns).map{|v| bound_variable_array(v) if v}.join(COMMA).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)})\""
           else
             super
           end

data/lib/sequel/plugins/association_pks.rb

@@ -21,9 +21,6 @@ module Sequel
     # not call any callbacks.  If you have any association callbacks,
     # you probably should not use the setter methods.
     #
-    # This plugin only works with singular primary keys, it does not work
-    # with composite primary keys.
-    # 
     # Usage:
     #
     #   # Make all model subclass *_to_many associations have association_pks
@@ -52,16 +49,85 @@ module Sequel
         # a setter that deletes from or inserts into the join table.
         def def_many_to_many(opts)
           super
-          def_association_pks_getter(opts) do
-            _join_table_dataset(opts).filter(opts[:left_key]=>send(opts[:left_primary_key])).select_map(opts[:right_key])
-          end
-          def_association_pks_setter(opts) do |pks|
-            pks = convert_pk_array(opts, pks)
-            checked_transaction do
-              ds = _join_table_dataset(opts).filter(opts[:left_key]=>send(opts[:left_primary_key]))
-              ds.exclude(opts[:right_key]=>pks).delete
-              pks -= ds.select_map(opts[:right_key])
-              pks.each{|pk| ds.insert(opts[:left_key]=>send(opts[:left_primary_key]), opts[:right_key]=>pk)}
+          # Grab values from the reflection so that the hash lookup only needs to be
+          # done once instead of inside ever method call.
+          lk, lpk, rk = opts.values_at(:left_key, :left_primary_key, :right_key)
+
+          # Add 2 separate implementations of the getter method optimized for the
+          # composite and singular left key cases, and 4 separate implementations of the setter
+          # method optimized for each combination of composite and singular keys for both
+          # the left and right keys.
+          if lpk.is_a?(Array)
+            def_association_pks_getter(opts) do
+              h = {}
+              lk.zip(lpk).each{|k, pk| h[k] = send(pk)}
+              _join_table_dataset(opts).filter(h).select_map(rk)
+            end
+
+            if rk.is_a?(Array)
+              def_association_pks_setter(opts) do |pks|
+                pks = convert_cpk_array(opts, pks)
+                checked_transaction do
+                  lpkv = lpk.map{|k| send(k)}
+                  ds = _join_table_dataset(opts).filter(lk.zip(lpkv))
+                  ds.exclude(rk=>pks).delete
+                  pks -= ds.select_map(rk)
+                  h = {}
+                  lk.zip(lpkv).each{|k, v| h[k] = v}
+                  pks.each do |pk|
+                    ih = h.dup
+                    rk.zip(pk).each{|k, v| ih[k] = v}
+                    ds.insert(ih)
+                  end
+                end
+              end
+            else
+              def_association_pks_setter(opts) do |pks|
+                pks = convert_pk_array(opts, pks)
+                checked_transaction do
+                  lpkv = lpk.map{|k| send(k)}
+                  ds = _join_table_dataset(opts).filter(lk.zip(lpkv))
+                  ds.exclude(rk=>pks).delete
+                  pks -= ds.select_map(rk)
+                  h = {}
+                  lk.zip(lpkv).each{|k, v| h[k] = v}
+                  pks.each do |pk|
+                    ds.insert(h.merge(rk=>pk))
+                  end
+                end
+              end
+            end
+          else
+            def_association_pks_getter(opts) do
+              _join_table_dataset(opts).filter(lk=>send(lpk)).select_map(rk)
+            end
+
+            if rk.is_a?(Array)
+              def_association_pks_setter(opts) do |pks|
+                pks = convert_cpk_array(opts, pks)
+                checked_transaction do
+                  lpkv = send(lpk)
+                  ds = _join_table_dataset(opts).filter(lk=>lpkv)
+                  ds.exclude(rk=>pks).delete
+                  pks -= ds.select_map(rk)
+                  pks.each do |pk|
+                    h = {lk=>lpkv}
+                    rk.zip(pk).each{|k, v| h[k] = v}
+                    ds.insert(h)
+                  end
+                end
+              end
+            else
+              def_association_pks_setter(opts) do |pks|
+                pks = convert_pk_array(opts, pks)
+                checked_transaction do
+                  lpkv = send(lpk)
+                  ds = _join_table_dataset(opts).filter(lk=>lpkv)
+                  ds.exclude(rk=>pks).delete
+                  pks -= ds.select_map(rk)
+                  pks.each{|pk| ds.insert(lk=>lpkv, rk=>pk)}
+                end
+              end
             end
           end
         end
@@ -71,17 +137,40 @@ module Sequel
         def def_one_to_many(opts)
           super
           return if opts[:type] == :one_to_one
+
+          key = opts[:key]
+
           def_association_pks_getter(opts) do
             send(opts.dataset_method).select_map(opts.associated_class.primary_key)
           end
+
           def_association_pks_setter(opts) do |pks|
-            pks = convert_pk_array(opts, pks)
+            primary_key = opts.associated_class.primary_key
+
+            pks = if primary_key.is_a?(Array)
+              convert_cpk_array(opts, pks)
+            else
+              convert_pk_array(opts, pks)
+            end
+
+            pkh = {primary_key=>pks}
+
+            if key.is_a?(Array)
+              h = {}
+              nh = {}
+              key.zip(pk).each do|k, v|
+                h[k] = v
+                nh[k] = nil
+              end
+            else
+              h = {key=>pk}
+              nh = {key=>nil}
+            end
+
             checked_transaction do
               ds = send(opts.dataset_method)
-              primary_key = opts.associated_class.primary_key
-              key = opts[:key]
-              ds.unfiltered.filter(primary_key=>pks).update(key=>pk)
-              ds.exclude(primary_key=>pks).update(key=>nil)
+              ds.unfiltered.filter(pkh).update(h)
+              ds.exclude(pkh).update(nh)
             end
           end
         end
@@ -90,6 +179,20 @@ module Sequel
       module InstanceMethods
         private
 
+        # If any of associated class's composite primary key column types is integer,
+        # typecast the appropriate values to integer before using them.
+        def convert_cpk_array(opts, cpks)
+          if klass = opts.associated_class and sch = klass.db_schema and (cols = sch.values_at(*klass.primary_key)).all? and (convs = cols.map{|c| c[:type] == :integer}).any?
+            cpks.map do |cpk|
+              cpk.zip(convs).map do |pk, conv|
+                conv ? model.db.typecast_value(:integer, pk) : pk
+              end
+            end
+          else
+            cpks
+          end
+        end
+
         # If the associated class's primary key column type is integer,
         # typecast all provided values to integer before using them.
         def convert_pk_array(opts, pks)