sequel 3.9.0 → 3.10.0

data/lib/sequel/adapters/jdbc/oracle.rb

@@ -7,11 +7,41 @@ module Sequel
       # Instance methods for Oracle Database objects accessed via JDBC.
       module DatabaseMethods
         include Sequel::Oracle::DatabaseMethods
+        TRANSACTION_BEGIN = 'Transaction.begin'.freeze
+        TRANSACTION_COMMIT = 'Transaction.commit'.freeze
+        TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
         
         # Return Sequel::JDBC::Oracle::Dataset object with the given opts.
         def dataset(opts=nil)
           Sequel::JDBC::Oracle::Dataset.new(self, opts)
         end
+        
+        private
+        
+        # Use JDBC connection's setAutoCommit to false to start transactions
+        def begin_transaction(conn)
+          log_info(TRANSACTION_BEGIN)
+          conn.setAutoCommit(false)
+          conn
+        end
+        
+        # Use JDBC connection's commit method to commit transactions
+        def commit_transaction(conn)
+          log_info(TRANSACTION_COMMIT)
+          conn.commit
+        end
+        
+        # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
+        def remove_transaction(conn)
+          conn.setAutoCommit(true) if conn
+          super
+        end
+        
+        # Use JDBC connection's rollback method to rollback transactions
+        def rollback_transaction(conn)
+          log_info(TRANSACTION_ROLLBACK)
+          conn.rollback
+        end
       end
       
       # Dataset class for Oracle datasets accessed via JDBC.

data/lib/sequel/adapters/shared/mssql.rb

@@ -183,8 +183,10 @@ module Sequel
       COMMA_SEPARATOR = ', '.freeze
       DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'with from output from2 where')
       INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'with into columns output values')
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with limit distinct columns into from table_options join where group having order compounds')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with limit distinct columns into from lock join where group having order compounds')
       UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'with table set output from where')
+      NOLOCK = ' WITH (NOLOCK)'.freeze
+      UPDLOCK = ' WITH (UPDLOCK)'.freeze
       WILDCARD = LiteralString.new('*').freeze
       CONSTANT_MAP = {:CURRENT_DATE=>'CAST(CURRENT_TIMESTAMP AS DATE)'.freeze, :CURRENT_TIME=>'CAST(CURRENT_TIMESTAMP AS TIME)'.freeze}
 
@@ -244,9 +246,9 @@ module Sequel
         [insert_sql(columns, LiteralString.new(values.map {|r| "SELECT #{expression_list(r)}" }.join(" UNION ALL ")))]
       end
 
-      # Allows you to do .nolock on a query
+      # Allows you to do a dirty read of uncommitted data using WITH (NOLOCK).
       def nolock
-        clone(:table_options => "(NOLOCK)")
+        lock_style(:dirty)
       end
 
       # Include an OUTPUT clause in the eventual INSERT, UPDATE, or DELETE query.
@@ -299,7 +301,7 @@ module Sequel
         raise(Error, 'MSSQL requires an order be provided if using an offset') unless order = @opts[:order]
         dsa1 = dataset_alias(1)
         rn = row_number_column
-        sel = [Sequel::SQL::WindowFunction.new(:ROW_NUMBER.sql_function, Sequel::SQL::Window.new(:order=>order)).as(rn)]
+        sel = [Sequel::SQL::WindowFunction.new(SQL::Function.new(:ROW_NUMBER), Sequel::SQL::Window.new(:order=>order)).as(rn)]
         sel.unshift(WILDCARD) unless osel = @opts[:select] and !osel.empty?
         subselect_sql(unlimited.
           unordered.
@@ -428,14 +430,26 @@ module Sequel
         sql << " INTO #{table_ref(@opts[:into])}" if @opts[:into]
       end
 
-      # MSSQL uses TOP for limit
+      # MSSQL uses TOP N for limit.  For MSSQL 2005+ TOP (N) is used
+      # to allow the limit to be a bound variable.
       def select_limit_sql(sql)
-        sql << " TOP (#{literal(@opts[:limit])})" if @opts[:limit]
+        if l = @opts[:limit]
+          l = literal(l)
+          l = "(#{l})" if server_version >= 9000000
+          sql << " TOP #{l}"
+        end
       end
 
-      # MSSQL uses the WITH statement to lock tables
-      def select_table_options_sql(sql)
-        sql << " WITH #{@opts[:table_options]}" if @opts[:table_options]
+      # Support different types of locking styles
+      def select_lock_sql(sql)
+        case @opts[:lock]
+        when :update
+          sql << UPDLOCK
+        when :dirty
+          sql << NOLOCK
+        else
+          super
+        end
       end
 
       # SQL fragment for MSSQL's OUTPUT clause.

data/lib/sequel/adapters/shared/mysql.rb

@@ -227,9 +227,10 @@ module Sequel
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
       COMMA_SEPARATOR = ', '.freeze
+      FOR_SHARE = ' LOCK IN SHARE MODE'.freeze
       DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'from where order limit')
       INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'ignore into columns values on_duplicate_key_update')
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'distinct columns from join where group having compounds order limit')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'distinct columns from join where group having compounds order limit lock')
       UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'table set where order limit')
       
       # MySQL specific syntax for LIKE/REGEXP searches, as well as
@@ -248,6 +249,11 @@ module Sequel
           super(op, args)
         end
       end
+      
+      # Return a cloned dataset which will use LOCK IN SHARE MODE to lock returned rows.
+      def for_share
+        lock_style(:share)
+      end
 
       # Adds full text filter
       def full_text_search(cols, terms, opts = {})
@@ -465,6 +471,11 @@ module Sequel
       def select_clause_methods
         SELECT_CLAUSE_METHODS
       end
+      
+      # Support FOR SHARE locking when using the :share lock style.
+      def select_lock_sql(sql)
+        @opts[:lock] == :share ? (sql << FOR_SHARE) : super
+      end
 
       # MySQL supports the ORDER BY and LIMIT clauses for UPDATE statements
       def update_clause_methods

data/lib/sequel/adapters/shared/postgres.rb

@@ -593,7 +593,6 @@ module Sequel
       EXPLAIN = 'EXPLAIN '.freeze
       EXPLAIN_ANALYZE = 'EXPLAIN ANALYZE '.freeze
       FOR_SHARE = ' FOR SHARE'.freeze
-      FOR_UPDATE = ' FOR UPDATE'.freeze
       LOCK = 'LOCK TABLE %s IN %s MODE'.freeze
       NULL = LiteralString.new('NULL').freeze
       PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
@@ -647,14 +646,9 @@ module Sequel
         with_sql((opts[:analyze] ? EXPLAIN_ANALYZE : EXPLAIN) + select_sql).map(QUERY_PLAN).join("\r\n")
       end
       
-      # Return a cloned dataset with a :share lock type.
+      # Return a cloned dataset which will use FOR SHARE to lock returned rows.
       def for_share
-        clone(:lock => :share)
-      end
-      
-      # Return a cloned dataset with a :update lock type.
-      def for_update
-        clone(:lock => :update)
+        lock_style(:share)
       end
       
       # PostgreSQL specific full text search syntax, using tsearch2 (included
@@ -786,21 +780,16 @@ module Sequel
       def select_clause_methods
         server_version >= 80400 ? SELECT_CLAUSE_METHODS_84 : SELECT_CLAUSE_METHODS
       end
+      
+      # Support FOR SHARE locking when using the :share lock style.
+      def select_lock_sql(sql)
+        @opts[:lock] == :share ? (sql << FOR_SHARE) : super
+      end
 
       # SQL fragment for named window specifications
       def select_window_sql(sql)
         sql << " WINDOW #{@opts[:window].map{|name, window| "#{literal(name)} AS #{literal(window)}"}.join(', ')}" if @opts[:window]
       end
-
-      # Support lock mode, allowing FOR SHARE and FOR UPDATE queries.
-      def select_lock_sql(sql)
-        case @opts[:lock]
-        when :update
-          sql << FOR_UPDATE
-        when :share
-          sql << FOR_SHARE
-        end
-      end
       
       # Use WITH RECURSIVE instead of WITH if any of the CTEs is recursive
       def select_with_sql_base

data/lib/sequel/adapters/shared/sqlite.rb

@@ -329,6 +329,11 @@ module Sequel
         SELECT_CLAUSE_METHODS
       end
       
+      # Support FOR SHARE locking when using the :share lock style.
+      def select_lock_sql(sql)
+        super unless @opts[:lock] == :update
+      end
+      
       # SQLite treats a DELETE with no WHERE clause as a TRUNCATE
       def _truncate_sql(table)
         "DELETE FROM #{table}"

data/lib/sequel/adapters/sqlite.rb

@@ -1,4 +1,9 @@
 require 'sqlite3'
+begin
+  SQLite3::Database.instance_method(:type_translation)
+rescue
+  raise(Sequel::Error, "SQLite3::Database#type_translation is not defined.  If you are using the sqlite3 gem, please install the sqlite3-ruby gem.")
+end
 Sequel.require 'adapters/shared/sqlite'
 
 module Sequel

data/lib/sequel/connection_pool/single.rb

@@ -2,13 +2,13 @@
 # It is just a wrapper around a single connection that uses the connection pool
 # API.
 class Sequel::SingleConnectionPool < Sequel::ConnectionPool  
-  # The SingleConnectionPool always has a size of 1, since the connection
-  # is always available.
+  # The SingleConnectionPool always has a size of 1 if connected
+  # and 0 if not.
   def size
     @conn ? 1 : 0
   end
   
-  # Disconnect and immediately reconnect from the database.
+  # Disconnect the connection from the database.
   def disconnect(opts=nil, &block)
     block ||= @disconnection_proc
     block.call(@conn) if block

data/lib/sequel/database.rb

@@ -158,13 +158,14 @@ module Sequel
         m
       end
       if block
+        result = nil
         begin
-          yield(db = c.new(opts))
+          result = yield(db = c.new(opts))
         ensure
           db.disconnect if db
           ::Sequel::DATABASES.delete(db)
         end
-        nil
+        result
       else
         c.new(opts)
       end

data/lib/sequel/dataset.rb

@@ -31,11 +31,12 @@ module Sequel
 
     # All methods that should have a ! method added that modifies
     # the receiver.
-    MUTATION_METHODS = %w'add_graph_aliases and distinct except exclude
-    filter from from_self full_outer_join graph
-    group group_and_count group_by having inner_join intersect invert join join_table
-    left_outer_join limit naked or order order_by order_more paginate qualify query
-    reverse reverse_order right_outer_join select select_all select_more server
+    MUTATION_METHODS = %w'add_graph_aliases and cross_join distinct except exclude
+    filter for_update from from_self full_join full_outer_join graph
+    group group_and_count group_by having inner_join intersect invert join join_table left_join
+    left_outer_join limit lock_style naked natural_full_join natural_join
+    natural_left_join natural_right_join or order order_by order_more paginate qualify query
+    reverse reverse_order right_join right_outer_join select select_all select_more server
     set_defaults set_graph_aliases set_overrides unfiltered ungraphed ungrouped union
     unlimited unordered where with with_recursive with_sql'.collect{|x| x.to_sym}
 

data/lib/sequel/dataset/convenience.rb

@@ -81,8 +81,8 @@ module Sequel
     end
 
     # Returns a dataset grouped by the given column with count by group,
-    # order by the count of records (in ascending order). Column aliases
-    # may be supplied, and will be included in the select clause.
+    # order by the count of records. Column aliases may be supplied, and will
+    # be included in the select clause.
     #
     # Examples:
     #
@@ -90,7 +90,7 @@ module Sequel
     #   ds.group_and_count(:first_name, :last_name).all => [{:first_name=>'a', :last_name=>'b', :count=>1}, ...]
     #   ds.group_and_count(:first_name___name).all => [{:name=>'a', :count=>1}, ...]
     def group_and_count(*columns)
-      group(*columns.map{|c| unaliased_identifier(c)}).select(*(columns + [COUNT_OF_ALL_AS_COUNT])).order(:count)
+      group(*columns.map{|c| unaliased_identifier(c)}).select(*(columns + [COUNT_OF_ALL_AS_COUNT]))
     end
 
     # Inserts multiple records into the associated table. This method can be

data/lib/sequel/dataset/query.rb

@@ -104,6 +104,11 @@ module Sequel
     def filter(*cond, &block)
       _filter(@opts[:having] ? :having : :where, *cond, &block)
     end
+    
+    # Returns a cloned dataset with a :update lock style.
+    def for_update
+      lock_style(:update)
+    end
 
     # Returns a copy of the dataset with the source changed.
     #
@@ -236,6 +241,14 @@ module Sequel
       clone(opts)
     end
     
+    # Returns a cloned dataset with the given lock style.  If style is a
+    # string, it will be used directly.  Otherwise, a symbol may be used
+    # for database independent locking.  Currently :update is respected
+    # by most databases, and :share is supported by some.
+    def lock_style(style)
+      clone(:lock => style)
+    end
+    
     # Adds an alternate filter to an existing filter using OR. If no filter 
     # exists an error is raised.
     #

data/lib/sequel/dataset/sql.rb

@@ -25,6 +25,7 @@ module Sequel
     COLUMN_REF_RE3 = /\A([\w ]+)__([\w ]+)\z/.freeze
     COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql, :limit, :compounds]
     DATASET_ALIAS_BASE_NAME = 't'.freeze
+    FOR_UPDATE = ' FOR UPDATE'.freeze
     IS_LITERALS = {nil=>'NULL'.freeze, true=>'TRUE'.freeze, false=>'FALSE'.freeze}.freeze
     IS_OPERATORS = ::Sequel::SQL::ComplexExpression::IS_OPERATORS
     N_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::N_ARITY_OPERATORS
@@ -33,7 +34,7 @@ module Sequel
     QUESTION_MARK = '?'.freeze
     DELETE_CLAUSE_METHODS = clause_methods(:delete, %w'from where')
     INSERT_CLAUSE_METHODS = clause_methods(:insert, %w'into columns values')
-    SELECT_CLAUSE_METHODS = clause_methods(:select, %w'with distinct columns from join where group having compounds order limit')
+    SELECT_CLAUSE_METHODS = clause_methods(:select, %w'with distinct columns from join where group having compounds order limit lock')
     UPDATE_CLAUSE_METHODS = clause_methods(:update, %w'table set where')
     TIMESTAMP_FORMAT = "'%Y-%m-%d %H:%M:%S%N%z'".freeze
     STANDARD_TIMESTAMP_FORMAT = "TIMESTAMP #{TIMESTAMP_FORMAT}".freeze
@@ -189,6 +190,25 @@ module Sequel
       end
     end
     alias first_source first_source_alias
+    
+    # The first source (primary table) for this dataset.  If the dataset doesn't
+    # have a table, raises an error.  If the table is aliased, returns the original
+    # table, not the alias
+    def first_source_table
+      source = @opts[:from]
+      if source.nil? || source.empty?
+        raise Error, 'No source specified for query'
+      end
+      case s = source.first
+      when SQL::AliasedExpression
+        s.expression
+      when Symbol
+        sch, table, aliaz = split_symbol(s)
+        aliaz ? (sch ? SQL::QualifiedIdentifier.new(sch, table) : table.to_sym) : s
+      else
+        s
+      end
+    end
 
     # SQL fragment specifying an SQL function call
     def function_sql(f)
@@ -1074,6 +1094,16 @@ module Sequel
       sql << " LIMIT #{literal(@opts[:limit])}" if @opts[:limit]
       sql << " OFFSET #{literal(@opts[:offset])}" if @opts[:offset]
     end
+  
+    # Modify the sql to support the different types of locking modes.
+    def select_lock_sql(sql)
+      case @opts[:lock]
+      when :update
+        sql << FOR_UPDATE
+      when String
+        sql << " #{@opts[:lock]}"
+      end
+    end
 
     # Modify the sql to add the expressions to ORDER BY
     def select_order_sql(sql)

data/lib/sequel/extensions/schema_dumper.rb

@@ -86,8 +86,8 @@ END_MIG
     # name and arguments to it to pass to a Schema::Generator to recreate the column.
     def column_schema_to_generator_opts(name, schema, options)
       if options[:single_pk] && schema_autoincrementing_primary_key?(schema)
-        type_hash = column_schema_to_ruby_type(schema)
-        if type_hash == {:type=>Integer}
+        type_hash = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
+        if type_hash == {:type=>Integer} || type_hash == {:type=>"integer"}
           [:primary_key, name]
         else
           [:primary_key, name, type_hash]
@@ -115,7 +115,7 @@ END_MIG
       when /\A(?:medium|small)?int(?:eger)?(?:\((?:\d+)\))?\z/o
         {:type=>Integer}
       when /\Atinyint(?:\((\d+)\))?\z/o
-        {:type=>(self.class.adapter_scheme == :mysql && $1 == '1' && Sequel::MySQL.convert_tinyint_to_bool ? TrueClass : Integer)}
+        {:type =>schema[:type] == :boolean ? TrueClass : Integer}
       when /\Abigint(?:\((?:\d+)\))?\z/o
         {:type=>Bignum}
       when /\A(?:real|float|double(?: precision)?)\z/o

data/lib/sequel/model.rb

@@ -44,13 +44,15 @@ module Sequel
     ANONYMOUS_MODEL_CLASSES = {}
 
     # Class methods added to model that call the method of the same name on the dataset
-    DATASET_METHODS = %w'<< add_graph_aliases all avg count delete distinct
-       each each_page eager eager_graph empty? except exclude filter first from from_self
-       full_outer_join get graph grep group group_and_count group_by having import
+    DATASET_METHODS = %w'<< add_graph_aliases all avg count cross_join delete distinct
+       each each_page each_server eager eager_graph empty? except exclude filter first for_update from from_self
+       full_join full_outer_join get graph grep group group_and_count group_by having import
        inner_join insert insert_multiple intersect interval invert join join_table
-       last left_outer_join limit map max min multi_insert naked order order_by
-       order_more paginate print qualify query range reverse reverse_order right_outer_join
-       select select_all select_more server set set_defaults set_graph_aliases set_overrides
+       last left_join left_outer_join limit lock_style map max min multi_insert naked
+       natural_full_join natural_join natural_left_join natural_right_join order order_by
+       order_more paginate print qualify query range reverse reverse_order right_join right_outer_join
+       select select_all select_hash select_map select_more select_order_map
+       server set set_defaults set_graph_aliases set_overrides
        single_value sum to_csv to_hash truncate unfiltered ungraphed ungrouped union unlimited unordered 
        update where with with_recursive with_sql'.map{|x| x.to_sym}
   

data/lib/sequel/model/associations.rb

@@ -106,10 +106,11 @@ module Sequel
         # it sets album.artist to this_artist.
         def reciprocal
           return self[:reciprocal] if include?(:reciprocal)
-          r_type = reciprocal_type
+          r_types = Array(reciprocal_type)
           keys = self[:keys]
           associated_class.all_association_reflections.each do |assoc_reflect|
-            if assoc_reflect[:type] == r_type && assoc_reflect[:keys] == keys && assoc_reflect.associated_class == self[:model]
+            if r_types.include?(assoc_reflect[:type]) && assoc_reflect[:keys] == keys && assoc_reflect.associated_class == self[:model]
+              self[:reciprocal_type] = assoc_reflect[:type]
               return self[:reciprocal] = assoc_reflect[:name]
             end
           end
@@ -188,7 +189,7 @@ module Sequel
     
         # The key to use for the key hash when eager loading
         def eager_loader_key
-          self[:key]
+          self[:eager_loader_key] ||= self[:key]
         end
     
         # The column(s) in the associated table that the key in the current table references (either a symbol or an array).
@@ -201,18 +202,30 @@ module Sequel
          self[:primary_keys] ||= Array(primary_key)
         end
         alias associated_object_keys primary_keys
+        
+        # True only if the reciprocal is a one_to_many association.
+        def reciprocal_array?
+          !set_reciprocal_to_self?
+        end
       
         # Whether this association returns an array of objects instead of a single object,
         # false for a many_to_one association.
         def returns_array?
           false
         end
+        
+        # True only if the reciprocal is a one_to_one association.
+        def set_reciprocal_to_self?
+          reciprocal
+          self[:reciprocal_type] == :one_to_one
+        end
     
         private
     
-        # The reciprocal type of a many_to_one association is a one_to_many association.
+        # The reciprocal type of a many_to_one association is either
+        # a one_to_many or a one_to_one association.
         def reciprocal_type
-          :one_to_many
+          self[:reciprocal_type] ||= [:one_to_many, :one_to_one]
         end
       end
     
@@ -235,12 +248,16 @@ module Sequel
         def default_key
           :"#{underscore(demodulize(self[:model].name))}_id"
         end
+        
+        # The key to use for the key hash when eager loading
+        def eager_loader_key
+          self[:eager_loader_key] ||= primary_key
+        end
     
         # The column in the current table that the key in the associated table references.
         def primary_key
          self[:primary_key] ||= self[:model].primary_key
         end
-        alias eager_loader_key primary_key
       
         # One to many associations set the reciprocal to self when loading associated records.
         def set_reciprocal_to_self?
@@ -265,6 +282,15 @@ module Sequel
           :many_to_one
         end
       end
+      
+      class OneToOneAssociationReflection < OneToManyAssociationReflection
+        ASSOCIATION_TYPES[:one_to_one] = self
+        
+        # one_to_one associations return a single object, not an array
+        def returns_array?
+          false
+        end
+      end
     
       class ManyToManyAssociationReflection < AssociationReflection
         ASSOCIATION_TYPES[:many_to_many] = self
@@ -315,7 +341,7 @@ module Sequel
       
         # The key to use for the key hash when eager loading
         def eager_loader_key
-          self[:left_primary_key]
+          self[:eager_loader_key] ||= self[:left_primary_key]
         end
     
         # many_to_many associations need to select a key in an associated table to eagerly load
@@ -378,6 +404,7 @@ module Sequel
       # 
       #   class Project < Sequel::Model
       #     many_to_one :portfolio
+      #     # or: one_to_one :portfolio
       #     one_to_many :milestones
       #     # or: many_to_many :milestones 
       #   end
@@ -385,7 +412,7 @@ module Sequel
       # The project class now has the following instance methods:
       # * portfolio - Returns the associated portfolio.
       # * portfolio=(obj) - Sets the associated portfolio to the object,
-      #   but the change is not persisted until you save the record.
+      #   but the change is not persisted until you save the record (for many_to_one associations).
       # * portfolio_dataset - Returns a dataset that would return the associated
       #   portfolio, only useful in fairly specific circumstances.
       # * milestones - Returns an array of associated milestones
@@ -395,16 +422,16 @@ module Sequel
       # * milestones_dataset - Returns a dataset that would return the associated
       #   milestones, allowing for further filtering/limiting/etc.
       #
-      # If you want to override the behavior of the add_/remove_/remove_all_ methods,
-      # there are private instance methods created that a prepended with an
-      # underscore (e.g. _add_milestone).  The private instance methods can be
+      # If you want to override the behavior of the add_/remove_/remove_all_/ methods
+      # or the association setter method, there are private instance methods created that are prepended
+      # with an underscore (e.g. _add_milestone or _portfolio=).  The private instance methods can be
       # easily overridden, but you shouldn't override the public instance methods without
       # calling super, as they deal with callbacks and caching.
       #
       # By default the classes for the associations are inferred from the association
       # name, so for example the Project#portfolio will return an instance of 
       # Portfolio, and Project#milestones will return an array of Milestone 
-      # instances.
+      # instances.  You can use the :class option to change which class is used.
       #
       # Association definitions are also reflected by the class, e.g.:
       #
@@ -432,20 +459,16 @@ module Sequel
         #   model's primary key.   Each current model object can be associated with
         #   more than one associated model objects.  Each associated model object
         #   can be associated with only one current model object.
+        # * :one_to_one - Similar to one_to_many in terms of foreign keys, but
+        #   only one object is associated to the current object through the
+        #   association.  The methods created are similar to many_to_one, except
+        #   that the one_to_one setter method saves the passed object.
         # * :many_to_many - A join table is used that has a foreign key that points
         #   to this model's primary key and a foreign key that points to the
         #   associated model's primary key.  Each current model object can be
         #   associated with many associated model objects, and each associated
         #   model object can be associated with many current model objects.
         #
-        # A one to one relationship can be set up with a many_to_one association
-        # on the table with the foreign key, and a one_to_many association with the
-        # :one_to_one option specified on the table without the foreign key.  The
-        # two associations will operate similarly, except that the many_to_one
-        # association setter doesn't update the database until you call save manually.
-        # Also, in most cases you need to specify the plural association name when using
-        # one_to_many with the :one_to_one option.
-        # 
         # The following options can be supplied:
         # * *ALL types*:
         #   - :after_add - Symbol, Proc, or array of both/either specifying a callback to call
@@ -455,12 +478,16 @@ module Sequel
         #     when eager loading via eager_graph, but called when eager loading via eager.
         #   - :after_remove - Symbol, Proc, or array of both/either specifying a callback to call
         #     after an item is removed from the association.
+        #   - :after_set - Symbol, Proc, or array of both/either specifying a callback to call
+        #     after an item is set using the association setter method.
         #   - :allow_eager - If set to false, you cannot load the association eagerly
         #     via eager or eager_graph
         #   - :before_add - Symbol, Proc, or array of both/either specifying a callback to call
         #     before a new item is added to the association.
         #   - :before_remove - Symbol, Proc, or array of both/either specifying a callback to call
         #     before an item is removed from the association.
+        #   - :before_set - Symbol, Proc, or array of both/either specifying a callback to call
+        #     before an item is set using the association setter method.
         #   - :cartesian_product_number - the number of joins completed by this association that could cause more
         #     than one row for each row in the current table (default: 0 for many_to_one associations,
         #     1 for *_to_many associations).
@@ -495,6 +522,8 @@ module Sequel
         #     and a hash of dependent associations.  The associated records should
         #     be queried from the database and the associations cache for each
         #     record should be populated for this to work correctly.
+        #   - :eager_loader_key - A symbol for the key column to use to populate the key hash
+        #     for the eager loader.
         #   - :extend - A module or array of modules to extend the dataset with.
         #   - :graph_block - The block to pass to join_table when eagerly loading
         #     the association via eager_graph.
@@ -540,15 +569,6 @@ module Sequel
         #     current model's primary key, as a symbol.  Defaults to
         #     :"#{self.name.underscore}_id".  Can use an
         #     array of symbols for a composite key association.
-        #   - :one_to_one: Create a getter and setter similar to those of many_to_one
-        #     associations.  The getter returns a singular matching record, or raises an
-        #     error if multiple records match.  The setter updates the record given and removes
-        #     associations with all other records. When this option is used, the other
-        #     association methods usually added are either removed or made private,
-        #     so using this is similar to using many_to_one, in terms of the methods
-        #     it adds, the main difference is that the foreign key is in the associated
-        #     table instead of the current table.  Note that using this option still requires
-        #     you to use a plural name when creating and using the association (e.g. for reflections, eager loading, etc.).
         #   - :primary_key - column in the current table that :key option references, as a symbol.
         #     Defaults to primary key of the current table. Can use an
         #     array of symbols for a composite key association.
@@ -583,6 +603,7 @@ module Sequel
         #     array of symbols for a composite key association.
         #   - :uniq - Adds a after_load callback that makes the array of objects unique.
         def associate(type, name, opts = {}, &block)
+          raise(Error, 'one_to_many association type with :one_to_one option removed, used one_to_one association type') if opts[:one_to_one] && type == :one_to_many
           raise(Error, 'invalid association type') unless assoc_class = ASSOCIATION_TYPES[type]
           raise(Error, 'Model.associate name argument must be a symbol') unless Symbol === name
       
@@ -599,20 +620,11 @@ module Sequel
           opts[:graph_conditions] = conds if !opts.include?(:graph_conditions) and Sequel.condition_specifier?(conds)
           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|
+          [:before_add, :before_remove, :after_add, :after_remove, :after_load, :before_set, :after_set, :extend].each do |cb_type|
             opts[cb_type] = Array(opts[cb_type])
           end
-      
-          # find class
-          case opts[:class]
-            when String, Symbol
-              # Delete :class to allow late binding
-              opts[:class_name] ||= opts.delete(:class).to_s
-            when Class
-              opts[:class_name] ||= opts[:class].name
-          end
-          opts[:class_name] ||= ((self.name || '').split("::")[0..-2] + [camelize(opts.returns_array? ? singularize(name) : name)]).join('::')
-      
+          late_binding_class_option(opts, opts.returns_array? ? singularize(name) : name)
+          
           send(:"def_#{type}", opts)
       
           orig_opts.delete(:clone)
@@ -664,18 +676,23 @@ module Sequel
         end
       
         # Shortcut for adding a many_to_many association, see associate
-        def many_to_many(*args, &block)
-          associate(:many_to_many, *args, &block)
+        def many_to_many(name, opts={}, &block)
+          associate(:many_to_many, name, opts, &block)
         end
         
         # Shortcut for adding a many_to_one association, see associate
-        def many_to_one(*args, &block)
-          associate(:many_to_one, *args, &block)
+        def many_to_one(name, opts={}, &block)
+          associate(:many_to_one, name, opts, &block)
         end
         
         # Shortcut for adding a one_to_many association, see associate
-        def one_to_many(*args, &block)
-          associate(:one_to_many, *args, &block)
+        def one_to_many(name, opts={}, &block)
+          associate(:one_to_many, name, opts, &block)
+        end
+
+        # Shortcut for adding a one_to_one association, see associate.
+        def one_to_one(name, opts={}, &block)
+          associate(:one_to_one, name, opts, &block)
         end
         
         private
@@ -781,7 +798,7 @@ module Sequel
             database.dataset.from(join_table).filter(lcks.zip(lcpks.map{|k| send(k)}) + rcks.zip(opts.right_primary_keys.map{|k| o.send(k)})).delete
           end
           association_module_private_def(opts._remove_all_method) do
-            database.dataset.from(join_table).filter(lcks.zip(lcpks.map{|k| send(k)})).delete
+            _apply_association_options(opts, database.dataset.from(join_table).filter(lcks.zip(lcpks.map{|k| send(k)}))).delete
           end
       
           def_add_method(opts)
@@ -839,6 +856,7 @@ module Sequel
         
         # Adds one_to_many association instance methods
         def def_one_to_many(opts)
+          one_to_one = opts[:type] == :one_to_one
           name = opts[:name]
           model = self
           key = (opts[:key] ||= opts.default_key)
@@ -853,15 +871,26 @@ module Sequel
           end
           opts[:eager_loader] ||= proc do |key_hash, records, associations|
             h = key_hash[primary_key]
-            records.each{|object| object.associations[name] = []}
+            if one_to_one
+              records.each{|object| object.associations[name] = nil}
+            else
+              records.each{|object| object.associations[name] = []}
+            end
             reciprocal = opts.reciprocal
             klass = opts.associated_class
             model.eager_loading_dataset(opts, klass.filter(uses_cks ? {cks.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}=>SQL::SQLArray.new(h.keys)} : {SQL::QualifiedIdentifier.new(klass.table_name, key)=>h.keys}), opts.select, associations).all do |assoc_record|
               hash_key = uses_cks ? cks.map{|k| assoc_record.send(k)} : assoc_record.send(key)
               next unless objects = h[hash_key]
-              objects.each do |object| 
-                object.associations[name].push(assoc_record)
-                assoc_record.associations[reciprocal] = object if reciprocal
+              if one_to_one
+                objects.each do |object| 
+                  object.associations[name] = assoc_record
+                  assoc_record.associations[reciprocal] = object if reciprocal
+                end
+              else
+                objects.each do |object| 
+                  object.associations[name].push(assoc_record)
+                  assoc_record.associations[reciprocal] = object if reciprocal
+                end
               end
             end
           end
@@ -871,7 +900,7 @@ module Sequel
           use_only_conditions = opts.include?(:graph_only_conditions)
           only_conditions = opts[:graph_only_conditions]
           conditions = opts[:graph_conditions]
-          opts[:cartesian_product_number] ||= 1
+          opts[:cartesian_product_number] ||= one_to_one ? 0 : 1
           graph_block = opts[:graph_block]
           opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
             ds = ds.graph(opts.associated_class, use_only_conditions ? only_conditions : cks.zip(cpks) + conditions, :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, :implicit_qualifier=>table_alias, :from_self_alias=>ds.opts[:eager_graph][:master], &graph_block)
@@ -884,48 +913,43 @@ module Sequel
           
           ck_nil_hash ={}
           cks.each{|k| ck_nil_hash[k] = nil}
-          
+
           unless opts[:read_only]
             validate = opts[:validate]
-            association_module_private_def(opts._add_method) do |o|
-              cks.zip(cpks).each{|k, pk| o.send(:"#{k}=", send(pk))}
-              o.save(:validate=>validate) || raise(Sequel::Error, "invalid associated object, cannot save")
-            end
-            def_add_method(opts)
+
+            if one_to_one
+              association_module_private_def(opts._setter_method) do |o|
+                up_ds = _apply_association_options(opts, opts.associated_class.filter(cks.zip(cpks.map{|k| send(k)})))
+                if o
+                  up_ds = up_ds.exclude(o.pk_hash)
+                  cks.zip(cpks).each{|k, pk| o.send(:"#{k}=", send(pk))}
+                end
+                update_database = lambda do
+                  up_ds.update(ck_nil_hash)
+                  o.save(:validate=>validate) || raise(Sequel::Error, "invalid associated object, cannot save") if o
+                end
+                use_transactions && o ? db.transaction(opts){update_database.call} : update_database.call
+              end
+              association_module_def(opts.setter_method){|o| set_one_to_one_associated_object(opts, o)}
+            else 
+              association_module_private_def(opts._add_method) do |o|
+                cks.zip(cpks).each{|k, pk| o.send(:"#{k}=", send(pk))}
+                o.save(:validate=>validate) || raise(Sequel::Error, "invalid associated object, cannot save")
+              end
+              def_add_method(opts)
       
-            unless opts[:one_to_one]
               association_module_private_def(opts._remove_method) do |o|
                 cks.each{|k| o.send(:"#{k}=", nil)}
                 o.save(:validate=>validate) || raise(Sequel::Error, "invalid associated object, cannot save")
               end
               association_module_private_def(opts._remove_all_method) do
-                opts.associated_class.filter(cks.zip(cpks.map{|k| send(k)})).update(ck_nil_hash)
+                _apply_association_options(opts, opts.associated_class.filter(cks.zip(cpks.map{|k| send(k)}))).update(ck_nil_hash)
               end
               def_remove_methods(opts)
             end
           end
-          if opts[:one_to_one]
-            overridable_methods_module.send(:private, opts.association_method, opts.dataset_method)
-            n = singularize(name).to_sym
-            raise(Sequel::Error, "one_to_many association names should still be plural even when using the :one_to_one option") if n == name
-            association_module_def(n) do |*o|
-              objs = send(name, *o)
-              raise(Sequel::Error, "multiple values found for a one-to-one relationship") if objs.length > 1
-              objs.first
-            end
-            unless opts[:read_only]
-              overridable_methods_module.send(:private, opts.add_method)
-              association_module_def(:"#{n}=") do |o|
-                klass = opts.associated_class
-                update_database = lambda do 
-                  send(opts.add_method, o)
-                  klass.filter(cks.zip(cpks.map{|k| send(k)})).exclude(o.pk_hash).update(ck_nil_hash)
-                end
-                use_transactions ? db.transaction(opts){update_database.call} : update_database.call
-              end
-            end
-          end
         end
+        alias def_one_to_one def_one_to_many
         
         # Add the remove_ and remove_all instance methods
         def def_remove_methods(opts)
@@ -944,11 +968,8 @@ module Sequel
         end
 
         private
-
-        # Backbone behind association dataset methods
-        def _dataset(opts)
-          raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
-          ds = send(opts._dataset_method)
+        
+        def _apply_association_options(opts, ds)
           ds.extend(AssociationDatasetMethods)
           ds.model_object = self
           ds.association_reflection = opts
@@ -959,6 +980,7 @@ module Sequel
           end
           ds = ds.order(*opts[:order]) if opts[:order]
           ds = ds.limit(*opts[:limit]) if opts[:limit]
+          ds = ds.limit(1) if !opts.returns_array? && opts[:key]
           ds = ds.eager(*opts[:eager]) if opts[:eager]
           ds = ds.distinct if opts[:distinct]
           ds = ds.eager_graph(opts[:eager_graph]) if opts[:eager_graph] && opts.eager_graph_lazy_dataset?
@@ -966,15 +988,19 @@ module Sequel
           ds
         end
 
+        # Backbone behind association dataset methods
+        def _dataset(opts)
+          raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
+          _apply_association_options(opts, send(opts._dataset_method))
+        end
+
         # Return the associated objects from the dataset, without callbacks, reciprocals, and caching.
         def _load_associated_objects(opts)
           if opts.returns_array?
             opts.can_have_associated_objects?(self) ? send(opts.dataset_method).all : []
           else
-            if !opts[:key]
+            if opts.can_have_associated_objects?(self)
               send(opts.dataset_method).all.first
-            elsif opts.can_have_associated_objects?(self)
-              send(opts.dataset_method).first
             end
           end
         end
@@ -1028,7 +1054,13 @@ module Sequel
           else
             objs = _load_associated_objects(opts)
             run_association_callbacks(opts, :after_load, objs)
-            objs.each{|o| add_reciprocal_object(opts, o)} if opts.set_reciprocal_to_self?
+            if opts.set_reciprocal_to_self?
+              if opts.returns_array?
+                objs.each{|o| add_reciprocal_object(opts, o)}
+              elsif objs
+                add_reciprocal_object(opts, objs)
+              end
+            end
             associations[name] = objs
           end
         end
@@ -1079,7 +1111,7 @@ module Sequel
         # Run the callback for the association with the object.
         def run_association_callbacks(reflection, callback_type, object)
           raise_error = raise_on_save_failure || !reflection.returns_array?
-          stop_on_false = [:before_add, :before_remove].include?(callback_type)
+          stop_on_false = [:before_add, :before_remove, :before_set].include?(callback_type)
           reflection[callback_type].each do |cb|
             res = case cb
             when Symbol
@@ -1098,19 +1130,29 @@ module Sequel
 
         # Set the given object as the associated object for the given association
         def set_associated_object(opts, o)
-          raise(Sequel::Error, "associated object #{o.inspect} 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
+          raise(Error, "associated object #{o.inspect} does not have a primary key") if o && !o.pk
+          run_association_callbacks(opts, :before_set, o)
+          if a = associations[opts[:name]]
+            remove_reciprocal_object(opts, a)
+          end
           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)
+          add_reciprocal_object(opts, o) if o
+          run_association_callbacks(opts, :after_set, o)
+          o
+        end
+        
+        # Set the given object as the associated object for the given association
+        def set_one_to_one_associated_object(opts, o)
+          raise(Error, "object #{inspect} does not have a primary key") unless pk
+          run_association_callbacks(opts, :before_set, o)
+          if a = associations[opts[:name]]
+            remove_reciprocal_object(opts, a)
           end
-          run_association_callbacks(opts, :after_remove, old_val) if old_val
+          send(opts._setter_method, o)
+          associations[opts[:name]] = o
+          add_reciprocal_object(opts, o) if o
+          run_association_callbacks(opts, :after_set, o)
           o
         end
       end