sequel 3.37.0 → 3.38.0

data/lib/sequel/extensions/pg_row_ops.rb

@@ -0,0 +1,164 @@
+# The pg_row_ops extension adds support to Sequel's DSL to make
+# it easier to deal with PostgreSQL row-valued/composite types.
+#
+# To load the extension:
+#
+#   Sequel.extension :pg_row_ops
+#
+# The most common usage is passing an expression to Sequel.pg_row_op:
+#
+#   r = Sequel.pg_row_op(:row_column)
+#
+# If you have also loaded the pg_row extension, you can use
+# Sequel.pg_row as well:
+#
+#   r = Sequel.pg_row(:row_column)
+#
+# Also, on most Sequel expression objects, you can call the pg_row
+# method:
+#
+#   r = Sequel.expr(:row_column).pg_row
+#
+# If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html]),
+# you can also call Symbol#pg_row:
+#
+#   r = :row_column.pg_row
+#
+# There's only fairly basic support currently.  You can use the [] method to access
+# a member of the composite type:
+#
+#   r[:a] # (row_column).a
+#
+# This can be chained:
+#
+#   r[:a][:b] # ((row_column).a).b
+#
+# If you've loaded the pg_array_ops extension, you there is also support for composite
+# types that include arrays, or arrays of composite types:
+#
+#   r[1][:a] # (row_column[1]).a
+#   r[:a][1] # (row_column).a[1]
+#
+# The only other support is the splat method:
+#
+#   r.splat # (row_column.*)
+#
+# The splat method is necessary if you are trying to reference a table's type when the
+# table has the same name as one of it's columns.  For example:
+#
+#   DB.create_table(:a){Integer :a; Integer :b}
+#
+# Let's say you want to reference the composite type for the table:
+#
+#   a = Sequel.pg_row_op(:a)
+#   DB[:a].select(a[:b]) # SELECT (a).b FROM a
+#
+# Unfortunately, that doesn't work, as it references the integer column, not the table.
+# The splat method works around this:
+#
+#   DB[:a].select(a.splat[:b]) # SELECT (a.*).b FROM a
+#
+# Splat also takes an argument which is used for casting.  This is necessary if you
+# want to return the composite type itself, instead of the columns in the composite
+# type.  For example:
+#
+#   DB[:a].select(a.splat).first # SELECT (a.*) FROM a
+#   # => {:a=>1, :b=>2}
+#
+# By casting the expression, you can get a composite type returned:
+#
+#   DB[:a].select(a.splat).first # SELECT (a.*)::a FROM a
+#   # => {:a=>"(1,2)"} # or {:a=>{:a=>1, :b=>2}} if the "a" type has been registered
+#                      # with the 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))
+#   # 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}}
+
+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
+
+      # Wrap the expression in a PGRowOp, without changing the
+      # SQL it would use.
+      def self.wrap(expr)
+        PGRowOp.new(WRAP, [expr])
+      end
+
+      # Access a member of the composite type if given a
+      # symbol or an SQL::Identifier.  For all other access,
+      # assuming the pg_array_ops extension is loaded and
+      # that it represents an array access.  In either
+      # case, return a PgRowOp so that access can be cascaded.
+      def [](member)
+        case member
+        when Symbol, SQL::Identifier
+          PGRowOp.new(QUALIFY, [self, member])
+        else
+          PGRowOp.wrap(Sequel.pg_array_op(self)[member])
+        end
+      end
+
+      # Use the (identifier.*) syntax to indicate that this
+      # expression represents the composite type of one
+      # of the tables being referenced, if it has the same
+      # name as one of the columns.  If the cast_to argument
+      # is given, also cast the expression to that type
+      # (which should be a symbol representing the composite type).
+      # This is used if you want to return whole table row as a
+      # composite type.
+      def splat(cast_to=nil)
+        if args.length > 1
+          raise Error, 'cannot splat a PGRowOp with multiple arguments'
+        end
+
+        if cast_to
+          PGRowOp.new(ROW_CAST, args + [cast_to])
+        else
+          PGRowOp.new(ROW, args)
+        end
+      end
+
+      module ExpressionMethods
+        # Return a PGRowOp wrapping the receiver.
+        def pg_row
+          Sequel.pg_row_op(self)
+        end
+      end
+    end
+  end
+
+  module SQL::Builders
+    # Return a PGRowOp wrapping the given expression.
+    def pg_row_op(expr)
+      Postgres::PGRowOp.wrap(expr)
+    end
+  end
+
+  class SQL::GenericExpression
+    include Sequel::Postgres::PGRowOp::ExpressionMethods
+  end
+
+  class LiteralString
+    include Sequel::Postgres::PGRowOp::ExpressionMethods
+  end
+end
+
+if Sequel.core_extensions?
+  class Symbol
+    include Sequel::Postgres::PGRowOp::ExpressionMethods
+  end
+end

data/lib/sequel/extensions/query.rb

@@ -20,13 +20,13 @@ module Sequel
     #
     #   dataset = DB[:items].query do
     #     select :x, :y, :z
-    #     filter{|o| (o.x > 1) & (o.y > 2)}
-    #     order :z.desc
+    #     filter{(x > 1) & (y > 2)}
+    #     reverse :z
     #   end
     #
     # Which is the same as:
     #
-    #  dataset = DB[:items].select(:x, :y, :z).filter{|o| (o.x > 1) & (o.y > 2)}.order(:z.desc)
+    #  dataset = DB[:items].select(:x, :y, :z).filter{(x > 1) & (y > 2)}.reverse(:z)
     #
     # Note that inside a call to query, you cannot call each, insert, update,
     # or delete (or any method that calls those), or Sequel will raise an

data/lib/sequel/extensions/schema_dumper.rb

@@ -97,14 +97,13 @@ END_MIG
 
     private
         
-    # If a database default exists and can't be converted, return the string with the inspect
-    # method modified so that .lit is always appended after it, only if the
-    # :same_db option is used.
+    # If a database default exists and can't be converted, and we are dumping with :same_db,
+    # return a string with the inspect method modified a literal string is created if the code is evaled.  
     def column_schema_to_ruby_default_fallback(default, options)
       if default.is_a?(String) && options[:same_db] && use_column_schema_to_ruby_default_fallback?
-        default = default.to_s
+        default = default.dup
         def default.inspect
-          "#{super}.lit"  # core_sql use
+          "Sequel::LiteralString.new(#{super})"
         end
         default
       end
@@ -137,7 +136,7 @@ END_MIG
           gen.foreign_key(name, table, col_opts)
         else
           gen.column(name, type, col_opts)
-          if (type == Integer || type == Bignum) && schema[:db_type] =~ / unsigned\z/io
+          if [Integer, Bignum, Float].include?(type) && schema[:db_type] =~ / unsigned\z/io
             Sequel.extension :eval_inspect
             gen.check(Sequel::SQL::Identifier.new(name) >= 0)
           end
@@ -162,7 +161,7 @@ END_MIG
         {:type =>schema[:type] == :boolean ? TrueClass : Integer}
       when /\Abigint(?:\((?:\d+)\))?(?: unsigned)?\z/o
         {:type=>Bignum}
-      when /\A(?:real|float|double(?: precision)?)\z/o
+      when /\A(?:real|float|double(?: precision)?|double\(\d+,\d+\)(?: unsigned)?)\z/o
         {:type=>Float}
       when 'boolean'
         {:type=>TrueClass}
@@ -371,7 +370,7 @@ END_MIG
       [sorted_tables, skipped_foreign_keys]
     end
     
-    # Don't use the "...".lit fallback on MySQL, since the defaults it uses aren't
+    # Don't use a literal string fallback on MySQL, since the defaults it uses aren't
     # valid literal SQL values.
     def use_column_schema_to_ruby_default_fallback?
       database_type != :mysql

data/lib/sequel/extensions/select_remove.rb

@@ -24,7 +24,7 @@ module Sequel
     #   In this case, the code will currently use unqualified column names for all columns
     #   the dataset returns, except for the columns given.
     # * This dataset has an existing explicit selection containing an item that returns
-    #   multiple database columns (e.g. :table.*, 'column1, column2'.lit).  In this case,
+    #   multiple database columns (e.g. Sequel.expr(:table).*, Sequel.lit('column1, column2')).  In this case,
     #   the behavior is undefined and this method should not be used.
     #
     # There may be other cases where this method does not work correctly, use it with caution.

data/lib/sequel/model/base.rb

@@ -872,6 +872,7 @@ module Sequel
       #   Artist.new(:name=>'Bob').values # => {:name=>'Bob'}
       #   Artist[1].values # => {:id=>1, :name=>'Jim', ...}
       attr_reader :values
+      alias to_hash values
 
       # Creates new instance and passes the given values to set.
       # If a block is given, yield the instance to the block unless

data/lib/sequel/no_core_ext.rb

@@ -1,2 +1,2 @@
-::SEQUEL_NO_CORE_EXTENSIONS = true
+::SEQUEL_NO_CORE_EXTENSIONS = true unless defined?(::SEQUEL_NO_CORE_EXTENSIONS)
 require 'sequel'

data/lib/sequel/plugins/pg_row.rb

@@ -0,0 +1,121 @@
+module Sequel
+  module Plugins
+    # The pg_row plugin allows you to use Sequel::Model classes as composite type
+    # classes, via the pg_row extension.  So if you have an address table:
+    #
+    #   DB.create_table(:address) do
+    #     String :street
+    #     String :city
+    #     String :zip
+    #   end
+    #
+    # and a company table with an address:
+    #
+    #   DB.create_table(:company) do
+    #     String :name
+    #     address :address
+    #   end
+    # 
+    # You can create a Sequel::Model for the address table, and load the plugin,
+    # which registers the row type:
+    #
+    #   class Address < Sequel::Model(:address)
+    #     plugin :pg_row
+    #   end
+    #
+    # Then when you select from the company table (even using a plain dataset),
+    # it will return address values as instances of Address:
+    #
+    #   DB[:company].first
+    #   # => {:name=>'MS', :address=>
+    #     Address.load(:street=>'123 Foo St', :city=>'Bar Town', :zip=>'12345')}
+    #
+    # If you want a lot of your models to be used as row types, you can load the
+    # plugin into Sequel::Model itself:
+    #
+    #   Sequel::Model.plugin :pg_row
+    #
+    # And then call register_row_type in the class
+    #
+    #   Address.register_row_type
+    #
+    # Note that automatic conversion only works with the native postgres adapter.
+    # For other adapters that connect to PostgreSQL, you need to call the conversion
+    # proc manually.
+    #
+    # In addition to returning row-valued/composite types as instances of Sequel::Model,
+    # this also lets you use model instances in datasets when inserting, updating, and
+    # filtering:
+    #
+    #   DB[:company].insert(:name=>'MS', :address=>
+    #     Address.load(:street=>'123 Foo St', :city=>'Bar Town', :zip=>'12345'))
+    module PgRow
+      # When loading the extension, make sure the database has the pg_row extension
+      # loaded, load the custom database extensions, and automatically register the
+      # row type if the model has a dataset.
+      def self.configure(model)
+        model.db.extension(:pg_row)
+        model.db.extend(DatabaseMethods)
+        model.register_row_type if model.instance_variable_get(:@dataset)
+      end
+
+      module DatabaseMethods
+        ESCAPE_RE = /("|\\)/.freeze
+        ESCAPE_REPLACEMENT = '\\\\\1'.freeze
+        COMMA = ','
+
+        # Handle Sequel::Model instances in bound variables.
+        def bound_variable_arg(arg, conn)
+          case arg
+          when Sequel::Model
+            "(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA)})"
+          else
+            super
+          end
+        end
+
+        # If a Sequel::Model instance is given, return it as-is
+        # instead of attempting to convert it.
+        def row_type(db_type, v)
+          if v.is_a?(Sequel::Model)
+            v
+          else
+            super
+          end
+        end
+
+        private
+
+        # Handle Sequel::Model instances in bound variable arrays.
+        def bound_variable_array(arg)
+          case arg
+          when Sequel::Model
+            "\"(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)})\""
+          else
+            super
+          end
+        end
+      end
+
+      module ClassMethods
+        # Register the model's row type with the database.
+        def register_row_type
+          db.register_row_type(model.table_name, :converter=>self, :typecaster=>method(:new))
+        end
+      end
+
+      module InstanceMethods
+        ROW = 'ROW'.freeze
+        CAST = '::'.freeze
+
+        # Literalize the model instance and append it to the sql.
+        def sql_literal_append(ds, sql)
+          sql << ROW
+          ds.literal_append(sql, values.values_at(*columns))
+          sql << CAST
+          ds.quote_schema_table_append(sql, model.table_name)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/pg_typecast_on_load.rb

@@ -0,0 +1,65 @@
+module Sequel
+  module Plugins
+    # The PgTypecastOnLoad plugin exists because when you connect to PostgreSQL
+    # using the do, swift, or jdbc adapter, Sequel doesn't have complete
+    # control over typecasting, and may return columns as strings instead of how
+    # the native postgres adapter would typecast them.  This is mostly needed for
+    # the additional support that the pg_* extensions add for advanced PostgreSQL
+    # types such as arrays.
+    #
+    # This plugin modifies Model#set_values to do the same conversion that the
+    # native postgres adapter would do for all columns given.  You can either
+    # specify the columns to typecast on load in the plugin call itself, or
+    # afterwards using add_pg_typecast_on_load_columns:
+    #
+    #   # aliases => text[] column
+    #   # config => hstore column
+    #
+    #   Album.plugin :pg_typecast_on_load, :aliases, :config
+    #   # or:
+    #   Album.plugin :pg_typecast_on_load
+    #   Album.add_pg_typecast_on_load_columns :aliases, :config
+    #
+    # This plugin only handles values that the adapter returns as strings.  If
+    # the adapter returns a value other than a string for a column, that value
+    # will be used directly without typecasting.
+    module PgTypecastOnLoad
+      # Call add_pg_typecast_on_load_columns on the passed column arguments.
+      def self.configure(model, *columns)
+        model.instance_eval do
+          @pg_typecast_on_load_columns ||= []
+          add_pg_typecast_on_load_columns(*columns)
+        end
+      end
+
+      module ClassMethods
+        # The columns to typecast on load for this model.
+        attr_reader :pg_typecast_on_load_columns
+
+        # Add additional columns to typecast on load for this model.
+        def add_pg_typecast_on_load_columns(*columns)
+          @pg_typecast_on_load_columns.concat(columns)
+        end
+
+        # Give the subclass a copy of the columns to typecast on load.
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@pg_typecast_on_load_columns, pg_typecast_on_load_columns.dup)
+        end
+      end
+
+      module InstanceMethods
+        # Lookup the conversion proc for the column's oid in the Database
+        # object, and use it to convert the value.
+        def set_values(values)
+          model.pg_typecast_on_load_columns.each do |c|
+            if (v = values[c]).is_a?(String) && (oid = db_schema[c][:oid])
+              values[c] = db.conversion_procs[oid].call(v)
+            end
+          end
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/validation_helpers.rb

@@ -40,6 +40,37 @@ module Sequel
     # changing the values of the Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS hash.  You
     # change change the default options on a per model basis
     # by overriding a private instance method default_validation_helpers_options.
+    #
+    # By changing the default options, you can setup internationalization of the
+    # error messages.  For example, you would modify the default options:
+    #
+    #   Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS.merge!(
+    #     :exact_length=>{:message=>lambda{|exact| I18n.t("errors.exact_length", :exact => exact)}},
+    #     :integer=>{:message=>lambda{I18n.t("errors.integer")}},
+    #     ...
+    #   )
+    #
+    # and then use something like this in your yaml translation file:
+    #
+    #   en:
+    #     errors:
+    #       exact_length: "is not %{exact} characters"
+    #       integer: "is not a number"
+    #
+    # Note that if you want to support internationalization of Errors#full_messages,
+    # you need to override the method.  Here's an example:
+    #   
+    #   class Sequel::Model::Errors
+    #     ATTRIBUTE_JOINER = I18n.t('errors.joiner').freeze
+    #     def full_messages
+    #       inject([]) do |m, kv|
+    #         att, errors = *kv
+    #         att.is_a?(Array) ? Array(att).map!{|v| I18n.t("attributes.#{v}")} : att = I18n.t("attributes.#{att}")
+    #         errors.each {|e| m << (e.is_a?(LiteralString) ? e : "#{Array(att).join(ATTRIBUTE_JOINER)} #{e}")}
+    #         m
+    #       end
+    #     end
+    #   end
     module ValidationHelpers
       # Default validation options used by Sequel.  Can be modified to change the error
       # messages for all models (e.g. for internationalization), or to set certain