sequel 3.0.0 → 3.1.0

data/lib/sequel/plugins/schema.rb

@@ -1,5 +1,13 @@
 module Sequel
   module Plugins
+    # Sequel's built in schema plugin allows you to define your schema
+    # directly in the model using Model.set_schema (which takes a block
+    # similar to Database#create_table), and use Model.create_table to
+    # create a table using the schema information.
+    #
+    # This plugin is mostly suited to test code.  If there is any
+    # chance that your application's schema could change, you should
+    # be using the migration extension instead.
     module Schema
       module ClassMethods
         # Creates table, using the column information from set_schema.
@@ -15,6 +23,11 @@ module Sequel
           drop_table rescue nil
           create_table
         end
+
+        # Creates the table unless the table already exists
+        def create_table?
+          create_table unless table_exists?
+        end
         
         # Drops table.
         def drop_table

data/lib/sequel/plugins/serialization.rb

@@ -21,47 +21,59 @@ module Sequel
     module Serialization
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values.
-      def self.apply(model, format, *columns)
-        raise(Error, "Unsupported serialization format (#{format}), should be :marshal or :yaml") unless [:marshal, :yaml].include?(format)
-        raise(Error, "No columns given.  The serialization plugin requires you specify which columns to serialize") if columns.empty?
-        model.instance_eval do
-          @serialization_format = format
-          @serialized_columns = columns
-          InstanceMethods.module_eval do
-            columns.each do |column|
-              define_method(column) do 
-                if deserialized_values.has_key?(column)
-                  deserialized_values[column]
-                else
-                  deserialized_values[column] = deserialize_value(@values[column])
-                end
-              end
-              define_method("#{column}=") do |v| 
-                changed_columns << column unless changed_columns.include?(column)
-                deserialized_values[column] = v
-              end
-            end
-          end
-        end
+      def self.apply(model, *args)
+        model.instance_eval{@serialization_map = {}}
+      end
+      
+      def self.configure(model, format=nil, *columns)
+        model.serialize_attributes(format, *columns) unless columns.empty?
       end
 
       module ClassMethods
-        # The serialization format to use, should be :marshal or :yaml
-        attr_reader :serialization_format
-
-        # The columns to serialize
-        attr_reader :serialized_columns
+        # A map of the serialized columns for this model.  Keys are column
+        # symbols, values are serialization formats (:marshal or :yaml).
+        attr_reader :serialization_map
 
         # Copy the serialization format and columns to serialize into the subclass.
         def inherited(subclass)
           super
-          sf = serialization_format
-          sc = serialized_columns
-          subclass.instance_eval do
-            @serialization_format = sf
-            @serialized_columns = sc
+          sm = serialization_map.dup
+          subclass.instance_eval{@serialization_map = sm}
+        end
+        
+        # The first value in the serialization map.  This is only for
+        # backwards compatibility, use serialization_map in new code.
+        def serialization_format
+          serialization_map.values.first
+        end
+        
+        # Create instance level reader that deserializes column values on request,
+        # and instance level writer that stores new deserialized value in deserialized
+        # columns
+        def serialize_attributes(format, *columns)
+          raise(Error, "Unsupported serialization format (#{format}), should be :marshal or :yaml") unless [:marshal, :yaml].include?(format)
+          raise(Error, "No columns given.  The serialization plugin requires you specify which columns to serialize") if columns.empty?
+          columns.each do |column|
+            serialization_map[column] = format
+            define_method(column) do 
+              if deserialized_values.has_key?(column)
+                deserialized_values[column]
+              else
+                deserialized_values[column] = deserialize_value(column, @values[column])
+              end
+            end
+            define_method("#{column}=") do |v| 
+              changed_columns << column unless changed_columns.include?(column)
+              deserialized_values[column] = v
+            end
           end
         end
+        
+        # The columns that will be serialized.  This is only for
+        # backwards compatibility, use serialization_map in new code.
+        def serialized_columns
+          serialization_map.keys
+        end
       end
 
       module InstanceMethods
@@ -78,7 +90,7 @@ module Sequel
         def before_save
           super
           deserialized_values.each do |k,v|
-            @values[k] = serialize_value(v)
+            @values[k] = serialize_value(k, v)
           end
         end
         
@@ -91,24 +103,28 @@ module Sequel
         private
 
         # Deserialize the column from either marshal or yaml format
-        def deserialize_value(v)
+        def deserialize_value(column, v)
           return v if v.nil?
-          case model.serialization_format 
+          case model.serialization_map[column] 
           when :marshal
             Marshal.load(v.unpack('m')[0]) rescue Marshal.load(v)
           when :yaml
             YAML.load v if v
+          else
+            raise Error, "Bad serialization format (#{model.serialization_map[column].inspect}) for column #{column.inspect}"
           end
         end
 
         # Serialize the column to either marshal or yaml format
-        def serialize_value(v)
+        def serialize_value(column, v)
           return v if v.nil?
-          case model.serialization_format 
+          case model.serialization_map[column] 
           when :marshal
             [Marshal.dump(v)].pack('m')
           when :yaml
             v.to_yaml
+          else
+            raise Error, "Bad serialization format (#{model.serialization_map[column].inspect}) for column #{column.inspect}"
           end
         end
       end

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -18,7 +18,7 @@ module Sequel
       # Set the sti_key and sti_dataset for the model, and change the
       # dataset's row_proc so that the dataset yields objects of varying classes,
       # where the class used has the same name as the key field.
-      def self.apply(model, key)
+      def self.configure(model, key)
         m = model.method(:constantize)
         model.instance_eval do
           @sti_key = key 

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -0,0 +1,61 @@
+module Sequel
+  module Plugins
+    # The tactical_eager_loading plugin allows you to eagerly load
+    # an association for all objects retrieved from the same dataset
+    # without calling eager on the dataset.  If you attempt to load
+    # associated objects for a record and the association for that
+    # object is currently not cached, it assumes you want to get
+    # the associated objects for all objects retrieved with the dataset that
+    # retrieved the current object.
+    #
+    # Tactical eager loading only takes affect if you retrieved the
+    # current object with Dataset#all, it doesn't work if you
+    # retrieved the current object with Dataset#each.
+    #
+    # Basically, this allows the following code to issue only two queries:
+    #
+    #   Album.filter{id<100}.all do |a|
+    #     a.artists
+    #   end
+    module TacticalEagerLoading
+      module InstanceMethods
+        # The dataset that retrieved this object, set if the object was
+        # reteived via Dataset#all with an active identity map.
+        attr_accessor :retrieved_by
+
+        # All model objects retrieved with this object, set if the object was
+        # reteived via Dataset#all with an active identity map.
+        attr_accessor :retrieved_with
+
+        private
+
+        # If there is an active identity map and the association is not in the
+        # associations cache and the object was reteived via Dataset#all,
+        # eagerly load the association for all model objects retrieved with the
+        # current object.
+        def load_associated_objects(opts, reload=false)
+          name = opts[:name]
+          if !associations.include?(name) && retrieved_by
+            retrieved_by.send(:eager_load, retrieved_with, name=>{})
+          end
+          super
+        end
+      end
+
+      module DatasetMethods
+        private
+
+        # If there is an active identity map, set the reteived_with attribute for the object
+        # with the current dataset and array of all objects.
+        def post_load(objects)
+          super
+          objects.each do |o|
+            next unless o.is_a?(Sequel::Model)
+            o.retrieved_by = self
+            o.retrieved_with = objects
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/validation_class_methods.rb

@@ -1,9 +1,26 @@
 module Sequel
-  require 'extensions/blank'
+  extension :blank
 
   module Plugins
+    # Sequel's built-in validation_class_methods plugin adds backwards compatibility
+    # for the legacy class-level validation methods (e.g. validates_presence_of :column).
+    #
+    # It is recommended to use the validation_helpers plugin instead of this one,
+    # as it is less complex and more flexible.
     module ValidationClassMethods
+      # Setup the validations hash for the given model.
+      def self.apply(model)
+        model.class_eval do
+          @validation_mutex = Mutex.new
+          @validations = {}
+        end
+      end
+
       module ClassMethods
+        # A hash of associations for this model class.  Keys are column symbols,
+        # values are arrays of validation procs.
+        attr_reader :validations
+
         # The Generator class is used to generate validation definitions using 
         # the validates {} idiom.
         class Generator
@@ -23,6 +40,15 @@ module Sequel
         def has_validations?
           !validations.empty?
         end
+
+        # Setup the validations hash in the subclass
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @validation_mutex = Mutex.new
+            @validations = {}
+          end
+        end
     
         # Instructs the model to skip validations defined in superclasses
         def skip_superclass_validations
@@ -146,7 +172,7 @@ module Sequel
           end
           tag = opts[:tag]
           atts.each do |a| 
-            a_vals = validations[a]
+            a_vals = @validation_mutex.synchronize{validations[a] ||= []}
             if tag && (old = a_vals.find{|x| x[0] == tag})
               old[1] = blk
             else
@@ -348,11 +374,6 @@ module Sequel
           end
         end
     
-        # Returns the validations hash for the class.
-        def validations
-          @validations ||= Hash.new {|h, k| h[k] = []}
-        end
-        
         private
     
         # Removes and returns the last member of the array if it is a hash. Otherwise,

data/lib/sequel/plugins/validation_helpers.rb

@@ -1,30 +1,37 @@
 module Sequel
   module Plugins
+    # The validation_helpers plugin contains instance method equivalents for most of the legacy
+    # class-level validations.  The names and APIs are different, though. Example:
+    #
+    #   class Album < Sequel::Model
+    #     plugin :validation_helpers
+    #     def validate
+    #       validates_min_length 1, :num_tracks
+    #     end
+    #   end
+    #
+    # The validates_unique validation has a unique API, but the other validations have
+    # the API explained here:
+    #
+    # Arguments:
+    # * atts - Single attribute symbol or an array of attribute symbols specifying the
+    #   attribute(s) to validate.
+    # Options:
+    # * :allow_blank - Whether to skip the validation if the value is blank.  You should
+    #   make sure all objects respond to blank if you use this option, which you can do by
+    #   requiring 'sequel/extensions/blank'
+    # * :allow_missing - Whether to skip the validation if the attribute isn't a key in the
+    #   values hash.  This is different from allow_nil, because Sequel only sends the attributes
+    #   in the values when doing an insert or update.  If the attribute is not present, Sequel
+    #   doesn't specify it, so the database will use the table's default value.  This is different
+    #   from having an attribute in values with a value of nil, which Sequel will send as NULL.
+    #   If your database table has a non NULL default, this may be a good option to use.  You
+    #   don't want to use allow_nil, because if the attribute is in values but has a value nil,
+    #   Sequel will attempt to insert a NULL value into the database, instead of using the
+    #   database's default.
+    # * :allow_nil - Whether to skip the validation if the value is nil.
+    # * :message - The message to use
     module ValidationHelpers
-      # ValidationHelpers contains instance method equivalents for most of the previous
-      # default validations.  The names and APIs have changed, though.  
-      #
-      # The validates_unique validation has a unique API, but the other validations have
-      # the API explained here:
-      #
-      # Arguments:
-      # * atts - Single attribute symbol or an array of attribute symbols specifying the
-      #   attribute(s) to validate.
-      # Options:
-      # * :allow_blank - Whether to skip the validation if the value is blank.  You should
-      #   make sure all objects respond to blank if you use this option, which you can do by
-      #   requiring 'sequel/extensions/blank'
-      # * :allow_missing - Whether to skip the validation if the attribute isn't a key in the
-      #   values hash.  This is different from allow_nil, because Sequel only sends the attributes
-      #   in the values when doing an insert or update.  If the attribute is not present, Sequel
-      #   doesn't specify it, so the database will use the table's default value.  This is different
-      #   from having an attribute in values with a value of nil, which Sequel will send as NULL.
-      #   If your database table has a non NULL default, this may be a good option to use.  You
-      #   don't want to use allow_nil, because if the attribute is in values but has a value nil,
-      #   Sequel will attempt to insert a NULL value into the database, instead of using the
-      #   database's default.
-      # * :allow_nil - Whether to skip the validation if the value is nil.
-      # * :message - The message to use
       module InstanceMethods 
         # Check that the attribute values are the given exact length.
         def validates_exact_length(exact, atts, opts={})

data/lib/sequel/sql.rb

@@ -351,10 +351,22 @@ module Sequel
       end
     end
 
+    # Methods that create Subscripts (SQL array accesses).
+    module SubscriptMethods
+      # Return an SQL array subscript with the given arguments.
+      #
+      #   :array.sql_subscript(1) # SQL: array[1]
+      #   :array.sql_subscript(1, 2) # SQL: array[1, 2]
+      def sql_subscript(*sub)
+        Subscript.new(self, sub.flatten)
+      end
+    end
+
     class ComplexExpression
       include AliasMethods
       include CastMethods
       include OrderMethods
+      include SubscriptMethods
     end
 
     class GenericExpression
@@ -365,6 +377,7 @@ module Sequel
       include BooleanMethods
       include NumericMethods
       include StringMethods
+      include SubscriptMethods
       include InequalityMethods
     end
 
@@ -709,6 +722,9 @@ module Sequel
     # ruby array of all two pairs as an SQL array instead of an ordered
     # hash-like conditions specifier.
     class SQLArray < Expression
+      # The array of objects this SQLArray wraps
+      attr_reader :array
+
       # Create an object with the given array.
       def initialize(array)
         @array = array

data/lib/sequel/version.rb

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

data/spec/adapters/ado_spec.rb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
 unless defined?(ADO_DB)
-  ADO_DB = Sequel.ado(:host => 'MY_SQL_SERVER', :database => 'MyDB', :user => 'my_pwd', :password => 'my_usr')
+  ADO_DB = Sequel.ado(:host => 'MY_SQL_SERVER', :database => 'MyDB', :user => 'my_usr', :password => 'my_pwd')
 end
 
 context "An ADO dataset" do
@@ -14,6 +14,52 @@ context "An ADO dataset" do
       ADO_DB[:items].all
     }.should_not raise_error
   end
+
+  describe 'setting the :command_timeout option' do
+    before(:each) do
+      @conn_options = {:host => 'MY_SQL_SERVER',
+            :database => 'MyDB',
+            :user => 'my_usr',
+            :password => 'my_pwd',
+            :command_timeout => 120}
+    end
+
+    specify 'it should set the CommandTimeout parameter on the ADO handle' do
+      db = Sequel::ADO::Database.new(@conn_options)
+      db.connect(@conn_options).CommandTimeout.should == 120
+    end
+  end
+
+  describe 'when the :command_timeout option is not implicitly set' do
+    before(:each) do
+      @conn_options = {:host => 'MY_SQL_SERVER',
+            :database => 'MyDB',
+            :user => 'my_usr',
+            :password => 'my_pwd'}
+    end
+
+    specify 'it should remain as the default of 30 seconds' do
+      db = Sequel::ADO::Database.new(@conn_options)
+      db.connect(@conn_options).CommandTimeout.should == 30
+    end
+  end
+
+  describe 'setting the :provider option' do
+    before(:each) do
+      @conn_options = {:host => 'MY_SQL_SERVER',
+            :database => 'MyDB',
+            :user => 'my_usr',
+            :password => 'my_pwd',
+            :provider => "SQLOLEDB"}
+    end
+
+    specify 'it should set the CommandTimeout parameter on the ADO handle' do
+      db = Sequel::ADO::Database.new(@conn_options)
+      db.connect(@conn_options).Provider.should match /sqloledb/i
+    end
+  end
+
+
 end
 
 context "An MSSQL dataset" do