sequel 2.10.0 → 2.11.0

data/lib/sequel_core/schema/sql.rb

@@ -12,7 +12,7 @@ module Sequel
       SET_DEFAULT = 'SET DEFAULT'.freeze
       SET_NULL = 'SET NULL'.freeze
       TYPES = Hash.new {|h, k| k}
-      TYPES.merge!(:double=>'double precision', String=>'varchar',
+      TYPES.merge!(:double=>'double precision', String=>'varchar(255)',
         Integer=>'integer', Fixnum=>'integer', Bignum=>'bigint',
         Float=>'double precision', BigDecimal=>'numeric', Numeric=>'numeric',
         Date=>'date', DateTime=>'timestamp', Time=>'timestamp', File=>'blob',
@@ -124,7 +124,7 @@ module Sequel
       # for certain databases.
       def default_index_name(table_name, columns)
         schema, table = schema_and_table(table_name)
-        "#{"#{schema}_" if schema and schema != default_schema}#{table}_#{columns.join(UNDERSCORE)}_index"
+        "#{"#{schema}_" if schema and schema != default_schema}#{table}_#{columns.map{|c| c.is_one_of?(String, Symbol) ? c : literal(c).gsub(/\W/, '_')}.join(UNDERSCORE)}_index"
       end
     
       # The SQL to drop an index for the table.

data/lib/sequel_core/sql.rb

@@ -181,21 +181,21 @@ module Sequel
     module CastMethods 
       # Cast the reciever to the given SQL type
       def cast(sql_type)
-        IrregularFunction.new(:cast, self, :AS, sql_type.to_s.lit)
+        Cast.new(self, sql_type)
       end
       alias_method :cast_as, :cast
 
       # Cast the reciever to the given SQL type (or integer if none given),
       # and return the result as a NumericExpression. 
       def cast_numeric(sql_type = nil)
-        cast(sql_type || :integer).sql_number
+        cast(sql_type || Integer).sql_number
       end
 
       # Cast the reciever to the given SQL type (or text if none given),
       # and return the result as a StringExpression, so you can use +
       # directly on the result for SQL string concatenation.
       def cast_string(sql_type = nil)
-        cast(sql_type || :text).sql_string
+        cast(sql_type || String).sql_string
       end
     end
     
@@ -336,12 +336,12 @@ module Sequel
     module ComplexExpressionMethods
       # Extract a datetime_part (e.g. year, month) from self:
       #
-      #   :date.extract(:year) # SQL:  extract(year FROM date)
+      #   :date.extract(:year) # SQL:  extract(year FROM "date")
       #
       # Also has the benefit of returning the result as a
       # NumericExpression instead of a generic ComplexExpression.
       def extract(datetime_part)
-        IrregularFunction.new(:extract, datetime_part.to_s.lit, :FROM, self).sql_number
+        Function.new(:extract, PlaceholderLiteralString.new("#{datetime_part} FROM ?", [self])).sql_number
       end
 
       # Return a BooleanExpression representation of self.
@@ -400,22 +400,6 @@ module Sequel
       end
     end
 
-    # Represents an SQL array.  Added so it is possible to deal with a
-    # ruby array of all two pairs as an SQL array instead of an ordered
-    # hash-like conditions specifier.
-    class SQLArray < Expression
-      # Create an object with the given array.
-      def initialize(array)
-        @array = array
-      end
-
-      # Delegate the creation of the resulting SQL to the given dataset,
-      # since it may be database dependent.
-      def to_s(ds)
-        ds.array_sql(@array)
-      end
-    end
-
     # Blob is used to represent binary data in the Ruby environment that is
     # stored as a blob type in the database. In PostgreSQL, the blob type is 
     # called bytea. Sequel represents binary data as a Blob object because 
@@ -423,9 +407,10 @@ module Sequel
     # escaped.
     class Blob < ::String
       # return self.
-      def to_blob
+      def to_sequel_blob
         self
       end
+      alias to_blob to_sequel_blob
     end
 
     # Subclass of ComplexExpression where the expression results
@@ -516,6 +501,27 @@ module Sequel
       end
     end
 
+    # Represents a cast of an SQL expression to a specific type.
+    class Cast < GenericExpression
+      # The expression to cast
+      attr_reader :expr
+
+      # The type to which to cast the expression
+      attr_reader :type
+      
+      # Set the attributes to the given arguments
+      def initialize(expr, type)
+        @expr = expr
+        @type = type
+      end
+
+      # Delegate the creation of the resulting SQL to the given dataset,
+      # since it may be database dependent.
+      def to_s(ds)
+        ds.cast_sql(expr, type)
+      end
+    end
+
     # Represents all columns in a given table, table.* in SQL
     class ColumnAll < SpecificExpression
       # The table containing the columns being selected
@@ -586,35 +592,6 @@ module Sequel
       end 
     end
     
-    # IrregularFunction is used for the SQL EXTRACT and CAST functions,
-    # which don't use regular function calling syntax. The IrregularFunction
-    # replaces the commas the regular function uses with a custom
-    # join string.
-    #
-    # This shouldn't be used directly, see CastMethods#cast and 
-    # ComplexExpressionMethods#extract.
-    class IrregularFunction < Function
-      # The arguments to pass to the function (may be blank)
-      attr_reader :arg1, :arg2
-
-      # The SQL function to call
-      attr_reader :f
-      
-      # The literal string to use in place of a comma to join arguments
-      attr_reader :joiner
-
-      # Set the attributes to the given arguments
-      def initialize(f, arg1, joiner, arg2)
-        @f, @arg1, @joiner, @arg2 = f, arg1, joiner, arg2
-      end
-
-      # Delegate the creation of the resulting SQL to the given dataset,
-      # since it may be database dependent.
-      def to_s(ds)
-        ds.irregular_function_sql(self)
-      end
-    end
-
     # Represents an SQL JOIN clause, used for joining tables.
     class JoinClause < SpecificExpression
       # The type of join to do
@@ -785,6 +762,22 @@ module Sequel
       end
     end
 
+    # Represents an SQL array.  Added so it is possible to deal with a
+    # ruby array of all two pairs as an SQL array instead of an ordered
+    # hash-like conditions specifier.
+    class SQLArray < Expression
+      # Create an object with the given array.
+      def initialize(array)
+        @array = array
+      end
+
+      # Delegate the creation of the resulting SQL to the given dataset,
+      # since it may be database dependent.
+      def to_s(ds)
+        ds.array_sql(@array)
+      end
+    end
+
     # Represents an SQL array access, with multiple possible arguments.
     class Subscript < GenericExpression
       # The SQL array column

data/lib/sequel_core/version.rb

@@ -1,6 +1,6 @@
 module Sequel
   MAJOR = 2
-  MINOR = 10
+  MINOR = 11
   TINY  = 0
   
   VERSION = [MAJOR, MINOR, TINY].join('.')

data/lib/sequel_model/associations.rb

@@ -51,6 +51,15 @@
 #   one_to_many :attributes
 #   has_many :attributes
 module Sequel::Model::Associations
+  # This module contains methods added to all association datasets
+  module DatasetMethods
+    # The model object that created the association dataset
+    attr_accessor :model_object
+
+    # The association reflection related to the association dataset
+    attr_accessor :association_reflection
+  end
+
   # Array of all association reflections for this model class
   def all_association_reflections
     association_reflections.values
@@ -100,6 +109,10 @@ module Sequel::Model::Associations
   #   - :class - The associated class or its name. If not
   #     given, uses the association's name, which is camelized (and
   #     singularized unless the type is :many_to_one)
+  #   - :clone - Merge the current options and block into the options and block used in defining
+  #     the given association.  Can be used to DRY up a bunch of similar associations that
+  #     all share the same options such as :class and :key, while changing the order and block used.
+  #   - :conditions - The conditions to use to filter the association, can be any argument passed to filter.
   #   - :dataset - A proc that is instance_evaled to get the base dataset
   #     to use for the _dataset method (before the other options are applied).
   #   - :eager - The associations to eagerly load via EagerLoading#eager when loading the associated object(s).
@@ -126,7 +139,8 @@ module Sequel::Model::Associations
   #   - :graph_block - The block to pass to join_table when eagerly loading
   #     the association via eager_graph.
   #   - :graph_conditions - The additional conditions to use on the SQL join when eagerly loading
-  #     the association via eager_graph.  Should be a hash or an array of all two pairs.
+  #     the association via eager_graph.  Should be a hash or an array of all two pairs. If not
+  #     specified, the :conditions option is used if it is a hash or array of all two pairs.
   #   - :graph_join_type - The type of SQL join to use when eagerly loading the association via
   #     eager_graph.  Defaults to :left_outer.
   #   - :graph_only_conditions - The conditions to use on the SQL join when eagerly loading
@@ -203,11 +217,16 @@ module Sequel::Model::Associations
     raise(Error, 'Model.associate name argument must be a symbol') unless Symbol === name
 
     # merge early so we don't modify opts
-    opts = opts.merge(:type => type, :name => name, :block => block, :cache => true, :model => self)
+    orig_opts = opts.dup
+    orig_opts = association_reflection(opts[:clone])[:orig_opts].merge(orig_opts) if opts[:clone]
+    opts = orig_opts.merge(:type => type, :name => name, :cache => true, :model => self)
+    opts[:block] = block if block
     opts = assoc_class.new.merge!(opts)
     opts[:eager_block] = block unless opts.include?(:eager_block)
     opts[:graph_join_type] ||= :left_outer
     opts[:order_eager_graph] = true unless opts.include?(:order_eager_graph)
+    conds = opts[:conditions]
+    opts[:graph_conditions] = conds if !opts.include?(:graph_conditions) and (conds.is_a?(Hash) or (conds.is_a?(Array) and conds.all_two_pairs?))
     opts[:graph_conditions] = opts[:graph_conditions] ? opts[:graph_conditions].to_a : []
     opts[:graph_select] = Array(opts[:graph_select]) if opts[:graph_select]
     [:before_add, :before_remove, :after_add, :after_remove, :after_load, :extend].each do |cb_type|
@@ -225,6 +244,9 @@ module Sequel::Model::Associations
 
     send(:"def_#{type}", opts)
 
+    orig_opts.delete(:clone)
+    orig_opts.merge!(:class_name=>opts[:class_name], :class=>opts[:class], :block=>block)
+    opts[:orig_opts] = orig_opts
     # don't add to association_reflections until we are sure there are no errors
     association_reflections[name] = opts
   end
@@ -386,21 +408,7 @@ module Sequel::Model::Associations
     return if opts[:read_only]
 
     association_module_private_def(opts._setter_method){|o| send(:"#{key}=", (o.send(opts.primary_key) if o))}
-
-    association_module_def(opts.setter_method) do |o|  
-      raise(Sequel::Error, "model object #{model} does not have a primary key") if o && !o.pk
-      old_val = send(opts.association_method)
-      return o if old_val == o
-      return if old_val and run_association_callbacks(opts, :before_remove, old_val) == false
-      return if o and run_association_callbacks(opts, :before_add, o) == false
-      send(opts._setter_method, o)
-      associations[name] = o
-      remove_reciprocal_object(opts, old_val) if old_val
-      add_reciprocal_object(opts, o) if o
-      run_association_callbacks(opts, :after_add, o) if o
-      run_association_callbacks(opts, :after_remove, old_val) if old_val
-      o
-    end
+    association_module_def(opts.setter_method){|o| set_associated_object(opts, o)}
   end
   
   # Adds one_to_many association instance methods

data/lib/sequel_model/base.rb

@@ -2,16 +2,25 @@ module Sequel
   class Model
     @allowed_columns = nil
     @association_reflections = {}
+    @cache_store = nil
+    @cache_ttl = nil
+    @db = nil
+    @db_schema = nil
     @dataset_methods = {}
     @hooks = {}
+    @overridable_methods_module = nil
     @primary_key = :id
     @raise_on_save_failure = true
     @raise_on_typecast_failure = true
     @restrict_primary_key = true
     @restricted_columns = nil
+    @simple_pk = nil
+    @simple_table = nil
+    @skip_superclass_validations = nil
     @sti_dataset = nil
     @sti_key = nil
     @strict_param_setting = true
+    @transform = nil
     @typecast_empty_string_to_nil = true
     @typecast_on_assignment = true
 
@@ -41,6 +50,14 @@ module Sequel
     # (default: no columns).
     metaattr_reader :restricted_columns
 
+    # Should be the literal primary key column name if this Model's table has a simple primary key, or
+    # nil if the model has a compound primary key or no primary key.
+    metaattr_reader :simple_pk
+
+    # Should be the literal table name if this Model's dataset is a simple table (no select, order, join, etc.),
+    # or nil otherwise.
+    metaattr_reader :simple_table
+
     # The base dataset for STI, to which filters are added to get
     # only the models for the specific STI subclass.
     metaattr_reader :sti_dataset
@@ -68,15 +85,19 @@ module Sequel
        left_outer_join limit map multi_insert naked order order_by order_more 
        paginate print query range reverse_order right_outer_join select 
        select_all select_more server set set_graph_aliases single_value size to_csv to_hash
-       transform union uniq unfiltered unordered update where'.map{|x| x.to_sym}
+       transform union uniq unfiltered unordered update where with_sql'.map{|x| x.to_sym}
 
     # Instance variables that are inherited in subclasses
     INHERITED_INSTANCE_VARIABLES = {:@allowed_columns=>:dup, :@cache_store=>nil,
       :@cache_ttl=>nil, :@dataset_methods=>:dup, :@primary_key=>nil, 
       :@raise_on_save_failure=>nil, :@restricted_columns=>:dup, :@restrict_primary_key=>nil,
+      :@simple_pk=>nil, :@simple_table=>nil,
       :@sti_dataset=>nil, :@sti_key=>nil, :@strict_param_setting=>nil,
       :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil,
       :@raise_on_typecast_failure=>nil, :@association_reflections=>:dup}
+    
+    # Empty instance variables, for -w compliance
+    EMPTY_INSTANCE_VARIABLES = [:@overridable_methods_module, :@transform, :@db, :@skip_superclass_validations]
 
     # Returns the first record from the database matching the conditions.
     # If a hash is given, it is used as the conditions.  If another
@@ -85,11 +106,12 @@ module Sequel
     # first before a dataset lookup is attempted unless a hash is supplied.
     def self.[](*args)
       args = args.first if (args.size == 1)
-
-      if Hash === args
-        dataset[args]
+      return dataset[args] if args.is_a?(Hash)
+      return cache_lookup(args) if @cache_store
+      if t = simple_table and p = simple_pk
+        with_sql("SELECT * FROM #{t} WHERE #{p} = #{dataset.literal(args)} LIMIT 1").first
       else
-        @cache_store ? cache_lookup(args) : dataset[primary_key_hash(args)]
+        dataset[primary_key_hash(args)]
       end
     end
     
@@ -174,6 +196,7 @@ module Sequel
     # Modify and return eager loading dataset based on association options
     def self.eager_loading_dataset(opts, ds, select, associations)
       ds = ds.select(*select) if select
+      ds = ds.filter(opts[:conditions]) if opts[:conditions]
       ds = ds.order(*opts[:order]) if opts[:order]
       ds = ds.eager(opts[:eager]) if opts[:eager]
       ds = ds.eager_graph(opts[:eager_graph]) if opts[:eager_graph]
@@ -201,6 +224,7 @@ module Sequel
     def self.inherited(subclass)
       sup_class = subclass.superclass
       ivs = subclass.instance_variables.collect{|x| x.to_s}
+      EMPTY_INSTANCE_VARIABLES.each{|iv| subclass.instance_variable_set(iv, nil) unless ivs.include?(iv.to_s)}
       INHERITED_INSTANCE_VARIABLES.each do |iv, dup|
         next if ivs.include?(iv.to_s)
         sup_class_value = sup_class.instance_variable_get(iv)
@@ -211,7 +235,7 @@ module Sequel
         db
         begin
           if sup_class == Model
-            subclass.set_dataset(Model.db[subclass.implicit_table_name]) unless subclass.name.blank?
+            subclass.set_dataset(subclass.implicit_table_name) unless subclass.name.blank?
           elsif ds = sup_class.instance_variable_get(:@dataset)
             subclass.set_dataset(sup_class.sti_key ? sup_class.sti_dataset.filter(sup_class.sti_key=>subclass.name.to_s) : ds.clone, :inherited=>true)
           end
@@ -239,7 +263,7 @@ module Sequel
     # Mark the model as not having a primary key. Not having a primary key
     # can cause issues, among which is that you won't be able to update records.
     def self.no_primary_key
-      @primary_key = nil
+      @simple_pk = @primary_key = nil
     end
 
     # Returns primary key attribute hash.  If using a composite primary key
@@ -317,8 +341,10 @@ module Sequel
       inherited = opts[:inherited]
       @dataset = case ds
       when Symbol
+        @simple_table = db.literal(ds)
         db[ds]
       when Dataset
+        @simple_table = nil
         @db = ds.db
         ds
       else
@@ -327,6 +353,7 @@ module Sequel
       @dataset.set_model(self)
       @dataset.transform(@transform) if @transform
       if inherited
+        @simple_table = sti_key ? nil : superclass.simple_table
         @columns = @dataset.columns rescue nil
       else
         @dataset.extend(DatasetMethods)
@@ -354,6 +381,7 @@ module Sequel
     # You can set it to nil to not have a primary key, but that
     # cause certain things not to work, see #no_primary_key.
     def self.set_primary_key(*key)
+      @simple_pk = key.length == 1 ? db.literal(key.first) : nil 
       @primary_key = (key.length == 1) ? key[0] : key.flatten
     end
 

data/lib/sequel_model/caching.rb

@@ -17,7 +17,7 @@ module Sequel
     def self.set_cache(store, opts = {})
       @cache_store = store
       @cache_ttl = opts[:ttl] || 3600
-      before_save :cache_delete_unless_new
+      before_update :cache_delete
       before_update_values :cache_delete
       before_delete :cache_delete
     end
@@ -78,10 +78,5 @@ module Sequel
     def cache_delete
       model.send(:cache_delete, cache_key)
     end
-
-    # Delete this object from the cache unless it is a new record
-    def cache_delete_unless_new
-      cache_delete unless new?
-    end
   end
 end

data/lib/sequel_model/record.rb

@@ -345,8 +345,12 @@ module Sequel
     def _dataset(opts)
       raise(Sequel::Error, "model object #{model} does not have a primary key") if opts.dataset_need_primary_key? && !pk
       ds = send(opts._dataset_method)
+      ds.extend(Associations::DatasetMethods)
+      ds.model_object = self
+      ds.association_reflection = opts
       opts[:extend].each{|m| ds.extend(m)}
       ds = ds.select(*opts.select) if opts.select
+      ds = ds.filter(opts[:conditions]) if opts[:conditions]
       ds = ds.order(*opts[:order]) if opts[:order]
       ds = ds.limit(*opts[:limit]) if opts[:limit]
       ds = ds.eager(*opts[:eager]) if opts[:eager]
@@ -470,6 +474,24 @@ module Sequel
       end
     end
 
+    # Set the given object as the associated object for the given association
+    def set_associated_object(opts, o)
+      raise(Sequel::Error, "model object #{model} does not have a primary key") if o && !o.pk
+      old_val = send(opts.association_method)
+      return o if old_val == o
+      return if old_val and run_association_callbacks(opts, :before_remove, old_val) == false
+      return if o and run_association_callbacks(opts, :before_add, o) == false
+      send(opts._setter_method, o)
+      associations[opts[:name]] = o
+      remove_reciprocal_object(opts, old_val) if old_val
+      if o
+        add_reciprocal_object(opts, o) 
+        run_association_callbacks(opts, :after_add, o)
+      end
+      run_association_callbacks(opts, :after_remove, old_val) if old_val
+      o
+    end
+
     # Set the columns, filtered by the only and except arrays.
     def set_restricted(hash, only, except)
       columns_not_set = model.instance_variable_get(:@columns).blank?
@@ -527,11 +549,7 @@ module Sequel
       begin
         model.db.typecast_value(col_schema[:type], value)
       rescue Error::InvalidValue
-        if raise_on_typecast_failure
-          raise
-        else
-          value
-        end
+        raise_on_typecast_failure ? raise : value
       end
     end