sequel 3.37.0 → 3.38.0

data/lib/sequel/adapters/utils/pg_types.rb

@@ -39,6 +39,11 @@ module Sequel
       end
     end.new
 
+    # Type OIDs for string types used by PostgreSQL.  These types don't
+    # have conversion procs associated with them (since the data is
+    # already in the form of a string).
+    STRING_TYPES = [18, 19, 25, 1042, 1043]
+
     # Hash with type name strings/symbols and callable values for converting PostgreSQL types.
     # Non-builtin types that don't have fixed numbers should use this to register
     # conversion procs.

data/lib/sequel/core.rb

@@ -147,23 +147,11 @@ module Sequel
     Database.connect(*args, &block)
   end
 
-  if !defined?(::SEQUEL_NO_CORE_EXTENSIONS) && !ENV.has_key?('SEQUEL_NO_CORE_EXTENSIONS')
-    # Whether the core extensions are enabled.  The core extensions are enabled by
-    # default for backwards compatibility, but can be disabled using the SEQUEL_NO_CORE_EXTENSIONS
-    # constant or environment variable.
-    def self.core_extensions?
-      # We override this method to return true inside the core_extensions.rb file,
-      # but we also set it here because that file is not loaded until most of Sequel
-      # is finished loading, and parts of Sequel check whether the core extensions
-      # are loaded.
-      true
-    end
-  else
-    def self.core_extensions?
-      false
-    end
+  # Assume the core extensions are not loaded by default, if the core_extensions
+  # extension is loaded, this will be overridden.
+  def self.core_extensions?
+    false
   end
-
   
   # Convert the +exception+ to the given class.  The given class should be
   # <tt>Sequel::Error</tt> or a subclass.  Returns an instance of +klass+ with
@@ -262,6 +250,28 @@ module Sequel
     Database.single_threaded = value
   end
 
+  COLUMN_REF_RE1 = /\A((?:(?!__).)+)__((?:(?!___).)+)___(.+)\z/.freeze
+  COLUMN_REF_RE2 = /\A((?:(?!___).)+)___(.+)\z/.freeze
+  COLUMN_REF_RE3 = /\A((?:(?!__).)+)__(.+)\z/.freeze
+
+  # Splits the symbol into three parts.  Each part will
+  # either be a string or nil.
+  #
+  # For columns, these parts are the table, column, and alias.
+  # For tables, these parts are the schema, table, and alias.
+  def self.split_symbol(sym)
+    case s = sym.to_s
+    when COLUMN_REF_RE1
+      [$1, $2, $3]
+    when COLUMN_REF_RE2
+      [nil, $1, $2]
+    when COLUMN_REF_RE3
+      [$1, $2, nil]
+    else
+      [nil, s, nil]
+    end
+  end
+
   # Converts the given +string+ into a +Date+ object.
   #
   #   Sequel.string_to_date('2010-09-10') # Date.civil(2010, 09, 10)
@@ -413,7 +423,9 @@ module Sequel
   private_class_method :adapter_method, :def_adapter_method
   
   require(%w"metaprogramming sql connection_pool exceptions dataset database timezones ast_transformer version")
-  extension(:core_extensions) if Sequel.core_extensions?
+  if !defined?(::SEQUEL_NO_CORE_EXTENSIONS) && !ENV.has_key?('SEQUEL_NO_CORE_EXTENSIONS')
+    extension(:core_extensions)
+  end
 
   # Add the database adapter class methods to Sequel via metaprogramming
   def_adapter_method(*Database::ADAPTERS)

data/lib/sequel/database/query.rb

@@ -582,7 +582,7 @@ module Sequel
         :time
       when /\A(bool(ean)?)\z/io
         :boolean
-      when /\A(real|float|double( precision)?)\z/io
+      when /\A(real|float|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
         :float
       when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(\d+|false|true)\))?)|(?:small)?money)\z/io
         $1 && ['0', 'false'].include?($1) ? :integer : :decimal

data/lib/sequel/database/schema_generator.rb

@@ -98,6 +98,8 @@ module Sequel
       #               (:restrict, :cascade, :set_null, :set_default, :no_action).
       # :primary_key :: Make the column as a single primary key column.  This should only
       #                 be used if you have a single, nonautoincrementing primary key column.
+      # :type :: Overrides the type given as the argument.  Generally not used by column
+      #          itself, but can be passed as an option to other methods that call column.
       # :unique :: Mark the column as unique, generally has the same effect as
       #            creating a unique index on the column.
       def column(name, type, opts = {})
@@ -122,6 +124,7 @@ module Sequel
       #   foreign_key(:artist_id) # artist_id INTEGER
       #   foreign_key(:artist_id, :artists) # artist_id INTEGER REFERENCES artists
       #   foreign_key(:artist_id, :artists, :key=>:id) # artist_id INTEGER REFERENCES artists(id)
+      #   foreign_key(:artist_id, :artists, :type=>String) # artist_id varchar(255) REFERENCES artists(id)
       #
       # If you want a foreign key constraint without adding a column (usually because it is a
       # composite foreign key), you can provide an array of columns as the first argument, and

data/lib/sequel/dataset/actions.rb

@@ -340,7 +340,7 @@ module Sequel
     #   DB[:table].order(:id).last # SELECT * FROM table ORDER BY id DESC LIMIT 1
     #   # => {:id=>10}
     #
-    #   DB[:table].order(:id.desc).last(2) # SELECT * FROM table ORDER BY id ASC LIMIT 2
+    #   DB[:table].order(Sequel.desc(:id)).last(2) # SELECT * FROM table ORDER BY id ASC LIMIT 2
     #   # => [{:id=>1}, {:id=>2}]
     def last(*args, &block)
       raise(Error, 'No order specified') unless @opts[:order]
@@ -768,7 +768,7 @@ module Sequel
       when Symbol
         _, c, a = split_symbol(s)
         (a || c).to_sym
-      when SQL::Identifier
+      when SQL::Identifier, SQL::Wrapper
         hash_key_symbol(s.value)
       when SQL::QualifiedIdentifier
         hash_key_symbol(s.column)
@@ -820,10 +820,9 @@ module Sequel
       when SQL::AliasedExpression
         c.expression
       when SQL::OrderedExpression
-        expr = c.expression
-        if expr.is_a?(Symbol)
-          expr = unaliased_identifier(expr)
-          SQL::OrderedExpression.new(unaliased_identifier(c.expression), c.descending, :nulls=>c.nulls)
+        case expr = c.expression
+        when Symbol, SQL::AliasedExpression
+          SQL::OrderedExpression.new(unaliased_identifier(expr), c.descending, :nulls=>c.nulls)
         else
           c
         end

data/lib/sequel/dataset/query.rb

@@ -500,7 +500,7 @@ module Sequel
     #   # SELECT * FROM a LEFT JOIN b AS c USING (d)
     #
     #   DB[:a].natural_join(:b).join_table(:inner, :c) do |ta, jta, js|
-    #     (:d.qualify(ta) > :e.qualify(jta)) & {:f.qualify(ta)=>DB.from(js.first.table).select(:g)}
+    #     (Sequel.qualify(ta, :d) > Sequel.qualify(jta, :e)) & {Sequel.qualify(ta, :f)=>DB.from(js.first.table).select(:g)}
     #   end
     #   # SELECT * FROM a NATURAL JOIN b INNER JOIN c
     #   #   ON ((c.d > b.e) AND (c.f IN (SELECT g FROM b)))
@@ -657,10 +657,10 @@ module Sequel
     #
     #   DB[:items].order(:name) # SELECT * FROM items ORDER BY name
     #   DB[:items].order(:a, :b) # SELECT * FROM items ORDER BY a, b
-    #   DB[:items].order('a + b'.lit) # SELECT * FROM items ORDER BY a + b
+    #   DB[:items].order(Sequel.lit('a + b')) # SELECT * FROM items ORDER BY a + b
     #   DB[:items].order(:a + :b) # SELECT * FROM items ORDER BY (a + b)
-    #   DB[:items].order(:name.desc) # SELECT * FROM items ORDER BY name DESC
-    #   DB[:items].order(:name.asc(:nulls=>:last)) # SELECT * FROM items ORDER BY name ASC NULLS LAST
+    #   DB[:items].order(Sequel.desc(:name)) # SELECT * FROM items ORDER BY name DESC
+    #   DB[:items].order(Sequel.asc(:name, :nulls=>:last)) # SELECT * FROM items ORDER BY name ASC NULLS LAST
     #   DB[:items].order{sum(name).desc} # SELECT * FROM items ORDER BY sum(name) DESC
     #   DB[:items].order(nil) # SELECT * FROM items
     def order(*columns, &block)
@@ -756,7 +756,7 @@ module Sequel
     #
     #   DB[:items].reverse(:id) # SELECT * FROM items ORDER BY id DESC
     #   DB[:items].order(:id).reverse # SELECT * FROM items ORDER BY id DESC
-    #   DB[:items].order(:id).reverse(:name.asc) # SELECT * FROM items ORDER BY name ASC
+    #   DB[:items].order(:id).reverse(Sequel.desc(:name)) # SELECT * FROM items ORDER BY name ASC
     def reverse(*order)
       order(*invert_order(order.empty? ? @opts[:order] : order))
     end
@@ -1119,8 +1119,8 @@ module Sequel
     # Inverts the given order by breaking it into a list of column references
     # and inverting them.
     #
-    #   DB[:items].invert_order([:id.desc]]) #=> [:id]
-    #   DB[:items].invert_order(:category, :price.desc]) #=> [:category.desc, :price]
+    #   DB[:items].invert_order([Sequel.desc(:id)]]) #=> [Sequel.asc(:id)]
+    #   DB[:items].invert_order([:category, Sequel.desc(:price)]) #=> [Sequel.desc(:category), Sequel.asc(:price)]
     def invert_order(order)
       return nil unless order
       new_order = []

data/lib/sequel/dataset/sql.rb

@@ -200,9 +200,9 @@ module Sequel
     CASE_THEN = " THEN ".freeze
     CASE_WHEN = " WHEN ".freeze
     CAST_OPEN = 'CAST('.freeze
-    COLUMN_REF_RE1 = /\A((?:(?!__).)+)__((?:(?!___).)+)___(.+)\z/.freeze
-    COLUMN_REF_RE2 = /\A((?:(?!___).)+)___(.+)\z/.freeze
-    COLUMN_REF_RE3 = /\A((?:(?!__).)+)__(.+)\z/.freeze
+    COLUMN_REF_RE1 = Sequel::COLUMN_REF_RE1
+    COLUMN_REF_RE2 = Sequel::COLUMN_REF_RE2
+    COLUMN_REF_RE3 = Sequel::COLUMN_REF_RE3
     COMMA = ', '.freeze
     COMMA_SEPARATOR = COMMA
     CONDITION_FALSE = '(1 = 0)'.freeze
@@ -1320,22 +1320,9 @@ module Sequel
       end
     end
     
-    # Splits the symbol into three parts.  Each part will
-    # either be a string or nil.
-    #
-    # For columns, these parts are the table, column, and alias.
-    # For tables, these parts are the schema, table, and alias.
+    # Delegate to Sequel.split_symbol.
     def split_symbol(sym)
-      case s = sym.to_s
-      when COLUMN_REF_RE1
-        [$1, $2, $3]
-      when COLUMN_REF_RE2
-        [nil, $1, $2]
-      when COLUMN_REF_RE3
-        [$1, $2, nil]
-      else
-        [nil, s, nil]
-      end
+      Sequel.split_symbol(sym)
     end
 
     # The string that is appended to to create the SQL query, the empty

data/lib/sequel/extensions/core_extensions.rb

@@ -199,28 +199,24 @@ end
 
 # Sequel extends +Symbol+ to add methods to implement the SQL DSL.
 class Symbol
-  include Sequel::SQL::QualifyingMethods
-  include Sequel::SQL::IdentifierMethods
   include Sequel::SQL::AliasMethods
   include Sequel::SQL::CastMethods
   include Sequel::SQL::OrderMethods
   include Sequel::SQL::BooleanMethods
   include Sequel::SQL::NumericMethods
+  include Sequel::SQL::QualifyingMethods
   include Sequel::SQL::StringMethods
   include Sequel::SQL::SubscriptMethods
   include Sequel::SQL::ComplexExpressionMethods
   include Sequel::SQL::InequalityMethods if RUBY_VERSION < '1.9.0'
 
-  # If no argument is given, returns a <tt>Sequel::SQL::ColumnAll</tt> object specifying all
-  # columns for this table.
-  # If an argument is given, returns a <tt>Sequel::SQL::NumericExpression</tt> using the *
-  # (multiplication) operator with this and the given argument.
-  # 
-  #   :table.* # SQL: table.*
-  #   :column * 2 # SQL: column * 2
-  def *(ce=(arg=false;nil))
-    return super(ce) unless arg == false
-    Sequel::SQL::ColumnAll.new(self);
+  # Returns receiver wrapped in an <tt>Sequel::SQL::Identifier</tt>.  Usually used to
+  # prevent splitting the symbol.
+  #
+  #   :a__b # SQL: "a"."b"
+  #   :a__b.identifier # SQL: "a__b"
+  def identifier
+    Sequel::SQL::Identifier.new(self)
   end
 
   # Returns a <tt>Sequel::SQL::Function</tt> with this as the function name,

data/lib/sequel/extensions/pg_array.rb

@@ -15,15 +15,21 @@
 #
 # To turn an existing Array into a PGArray:
 #
+#   Sequel.pg_array(array)
+#
+# If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html]),
+# you can also use Array#pg_array:
+#
 #   array.pg_array
 #
 # You can also provide a type, though it many cases it isn't necessary:
 #
+#   Sequel.pg_array(array, :varchar) # or :integer, :"double precision", etc.
 #   array.pg_array(:varchar) # or :integer, :"double precision", etc.
 #
 # So if you want to insert an array into an integer[] database column:
 #
-#   DB[:table].insert(:column=>[1, 2, 3].pg_array)
+#   DB[:table].insert(:column=>Sequel.pg_array([1, 2, 3]))
 #
 # If you would like to use PostgreSQL arrays in your model objects, you
 # probably want to modify the schema parsing/typecasting so that it
@@ -135,6 +141,8 @@ module Sequel
       #                     typecast method.  For example, for an array of integers, this could be set to
       #                     :integer, so that the typecast_value_integer method is called on all of the
       #                     array elements.  Defaults to :type_symbol option.
+      # :type_procs :: A hash mapping oids to conversion procs, used for looking up the :scalar_oid and
+      #                value and setting the :oid value.  Defaults to the global Sequel::Postgres::PG_TYPES.
       # :type_symbol :: The base of the schema type symbol for this type.  For example, if you provide
       #                 :integer, Sequel will recognize this type as :integer_array during schema parsing.
       #                 Defaults to the db_type argument.
@@ -142,12 +150,16 @@ module Sequel
       #                     typecasting method to be created in the database.  This should only be used
       #                     to alias existing array types.  For example, if there is an array type that can be
       #                     treated just like an integer array, you can do :typecast_method=>:integer.
+      # :typecast_methods_module :: If given, a module object to add the typecasting method to.  Defaults
+      #                             to DatabaseMethods.
       #
       # If a block is given, it is treated as the :converter option.
       def self.register(db_type, opts={}, &block)
         db_type = db_type.to_s
         typecast_method = opts[:typecast_method]
         type = (typecast_method || opts[:type_symbol] || db_type).to_sym
+        type_procs = opts[:type_procs] || PG_TYPES
+        mod = opts[:typecast_methods_module] || DatabaseMethods
 
         if converter = opts[:converter]
           raise Error, "can't provide both a block and :converter option to register" if block
@@ -157,7 +169,7 @@ module Sequel
 
         if soid = opts[:scalar_oid]
           raise Error, "can't provide both a converter and :scalar_oid option to register" if converter 
-          raise Error, "no conversion proc for :scalar_oid=>#{soid.inspect} in PG_TYPES" unless converter = PG_TYPES[soid]
+          raise Error, "no conversion proc for :scalar_oid=>#{soid.inspect}" unless converter = type_procs[soid]
         end
 
         array_type = (opts[:array_type] || db_type).to_s.dup.freeze
@@ -165,15 +177,27 @@ module Sequel
 
         ARRAY_TYPES[db_type] = :"#{type}_array"
 
-        DatabaseMethods.define_array_typecast_method(type, creator, opts.fetch(:scalar_typecast, type)) unless typecast_method
+        define_array_typecast_method(mod, type, creator, opts.fetch(:scalar_typecast, type)) unless typecast_method
 
         if oid = opts[:oid]
-          Sequel::Postgres::PG_TYPES[oid] = creator
+          type_procs[oid] = creator
         end
 
         nil
       end
 
+      # Define a private array typecasting method in the given module for the given type that uses
+      # the creator argument to do the type conversion.
+      def self.define_array_typecast_method(mod, type, creator, scalar_typecast)
+        mod.class_eval do
+          meth = :"typecast_value_#{type}_array"
+          scalar_typecast_method = :"typecast_value_#{scalar_typecast}"
+          define_method(meth){|v| typecast_value_pg_array(v, creator, scalar_typecast_method)}
+          private meth
+        end
+      end
+      private_class_method :define_array_typecast_method
+
       module DatabaseMethods
         APOS = "'".freeze
         DOUBLE_APOS = "''".freeze
@@ -181,22 +205,6 @@ module Sequel
         ESCAPE_REPLACEMENT = '\\\\\1'.freeze
         BLOB_RANGE = 1...-1
 
-        # Reset the conversion procs when extending the Database object, so
-        # it will pick up the array convertors.  This is only done for the native
-        # postgres adapter.
-        def self.extended(db)
-          db.reset_conversion_procs if db.respond_to?(:reset_conversion_procs)
-        end
-
-        # Define a private array typecasting method for the given type that uses
-        # the creator argument to do the type conversion.
-        def self.define_array_typecast_method(type, creator, scalar_typecast)
-          meth = :"typecast_value_#{type}_array"
-          scalar_typecast_method = :"typecast_value_#{scalar_typecast}"
-          define_method(meth){|v| typecast_value_pg_array(v, creator, scalar_typecast_method)}
-          private meth
-        end
-
         # Handle arrays in bound variables
         def bound_variable_arg(arg, conn)
           case arg
@@ -239,12 +247,11 @@ module Sequel
         # Manually override the typecasting for timestamp array types so that
         # they use the database's timezone instead of the global Sequel
         # timezone.
-        def get_conversion_procs(conn)
+        def get_conversion_procs
           procs = super
 
-          converter = method(:to_application_timestamp)
-          procs[1115] = Creator.new("timestamp without time zone", converter)
-          procs[1185] = Creator.new("timestamp with time zone", converter)
+          procs[1115] = Creator.new("timestamp without time zone", procs[1114])
+          procs[1185] = Creator.new("timestamp with time zone", procs[1184])
 
           procs
         end
@@ -271,8 +278,6 @@ module Sequel
               value = Sequel.recursive_map(value, method(scalar_typecast_method))
             end
             PGArray.new(value, creator.type)
-          when String
-            creator.call(value)
           else
             raise Sequel::InvalidValue, "invalid value for array type: #{value.inspect}"
           end
@@ -497,15 +502,36 @@ module Sequel
     end
   end
 
+  module SQL::Builders
+    # Return a Postgres::PGArray proxy for the given array and database array type.
+    def pg_array(v, array_type=nil)
+      case v
+      when Postgres::PGArray
+        if array_type.nil? || v.array_type == array_type
+          v
+        else
+          Postgres::PGArray.new(v.to_a, array_type)
+        end
+      when Array
+        Postgres::PGArray.new(v, array_type)
+      else
+        # May not be defined unless the pg_array_ops extension is used
+        pg_array_op(v)
+      end
+    end
+  end
+
   Database.register_extension(:pg_array, Postgres::PGArray::DatabaseMethods)
 end
 
-class Array
-  # Return a PGArray proxy to the receiver, using a
-  # specific database type if given.  This is mostly useful
-  # as a short cut for creating PGArray objects that didn't
-  # come from the database.
-  def pg_array(type=nil)
-    Sequel::Postgres::PGArray.new(self, type)
+if Sequel.core_extensions?
+  class Array
+    # Return a PGArray proxy to the receiver, using a
+    # specific database type if given.  This is mostly useful
+    # as a short cut for creating PGArray objects that didn't
+    # come from the database.
+    def pg_array(type=nil)
+      Sequel::Postgres::PGArray.new(self, type)
+    end
   end
 end

data/lib/sequel/extensions/pg_array_ops.rb

@@ -5,8 +5,22 @@
 #
 #   Sequel.extension :pg_array_ops
 #
-# The most common usage is taking an object that represents an SQL
-# identifier (such as a :symbol), and calling #pg_array on it:
+# The most common usage is passing an expression to Sequel.pg_array_op:
+#
+#   ia = Sequel.pg_array_op(:int_array_column)
+#
+# If you have also loaded the pg_array extension, you can use
+# Sequel.pg_array as well:
+#
+#   ia = Sequel.pg_array(:int_array_column)
+#
+# Also, on most Sequel expression objects, you can call the pg_array
+# method:
+#
+#   ia = Sequel.expr(:int_array_column).pg_array
+#
+# If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html]),
+# you can also call Symbol#pg_array:
 #
 #   ia = :int_array_column.pg_array
 #
@@ -211,6 +225,18 @@ module Sequel
     end
   end
 
+  module SQL::Builders
+    # Return the object wrapped in an Postgres::ArrayOp.
+    def pg_array_op(v)
+      case v
+      when Postgres::ArrayOp
+        v
+      else
+        Postgres::ArrayOp.new(v)
+      end
+    end
+  end
+
   class SQL::GenericExpression
     include Sequel::Postgres::ArrayOpMethods
   end
@@ -220,6 +246,8 @@ module Sequel
   end
 end
 
-class Symbol
-  include Sequel::Postgres::ArrayOpMethods
+if Sequel.core_extensions?
+  class Symbol
+    include Sequel::Postgres::ArrayOpMethods
+  end
 end