sequel 3.4.0 → 3.5.0

data/lib/sequel/exceptions.rb

@@ -2,6 +2,9 @@ module Sequel
   # The default exception class for exceptions raised by Sequel.
   # All exception classes defined by Sequel are descendants of this class.
   class Error < ::StandardError
+    # If this exception wraps an underlying exception, the underlying
+    # exception is held here.
+    attr_accessor :wrapped_exception
   end  
     
   # Raised when the adapter requested doesn't exist or can't be loaded.

data/lib/sequel/extensions/looser_typecasting.rb

@@ -0,0 +1,21 @@
+# The LooserTypecasting extension changes the float and integer typecasting to
+# use the looser .to_f and .to_i instead of the more strict Kernel.Float and
+# Kernel.Integer.  To use it, you should extend the database with the
+# Sequel::LooserTypecasting module after loading the extension:
+#
+#   Sequel.extension :looser_typecasting
+#   DB.extend(Sequel::LooserTypecasting)
+
+module Sequel
+  module LooserTypecasting
+    # Typecast the value to a Float using to_f instead of Kernel.Float
+    def typecast_value_float(value)
+      value.to_f
+    end
+
+    # Typecast the value to an Integer using to_i instead of Kernel.Integer
+    def typecast_value_integer(value)
+      value.to_i
+    end
+  end
+end

data/lib/sequel/extensions/named_timezones.rb

@@ -0,0 +1,61 @@
+# Allows the use of named timezones via TZInfo (requires tzinfo).
+# Forces the use of DateTime as Sequel's datetime_class, since
+# ruby's Time class doesn't support timezones other than local
+# and UTC.
+#
+# This allows you to either pass strings or TZInfo::Timezone
+# instance to Sequel.database_timezone=, application_timezone=, and
+# typecast_timezone=.  If a string is passed, it is converted to a
+# TZInfo::Timezone using TZInfo::Timezone.get.
+#
+# Let's say you have the database server in New York and the
+# application server in Los Angeles.  For historical reasons, data
+# is stored in local New York time, but the application server only
+# services clients in Los Angeles, so you want to use New York
+# time in the database and Los Angeles time in the application.  This
+# is easily done via:
+#
+#   Sequel.database_timezone = 'America/New_York'
+#   Sequel.application_timezone = 'America/Los_Angeles'
+#
+# Then, before data is stored in the database, it is converted to New
+# York time.  When data is retrieved from the database, it is
+# converted to Los Angeles time.
+
+require 'tzinfo'
+
+module Sequel
+  self.datetime_class = DateTime
+  
+  module NamedTimezones
+    private 
+    
+    # Assume the given DateTime has a correct time but a wrong timezone.  It is
+    # currently in UTC timezone, but it should be converted to the input_timzone.
+    # Keep the time the same but convert the timezone to the input_timezone.
+    # Expects the input_timezone to be a TZInfo::Timezone instance.
+    def convert_input_datetime_other(v, input_timezone)
+      local_offset = input_timezone.period_for_local(v).utc_total_offset_rational
+      (v - local_offset).new_offset(local_offset)
+    end
+
+    # Convert the given DateTime to use the given output_timezone.
+    # Expects the output_timezone to be a TZInfo::Timezone instance.
+    def convert_output_datetime_other(v, output_timezone)
+      # TZInfo converts times, but expects the given DateTime to have an offset
+      # of 0 and always leaves the timezone offset as 0
+      v = output_timezone.utc_to_local(v.new_offset(0))
+      local_offset = output_timezone.period_for_local(v).utc_total_offset_rational
+      # Convert timezone offset from UTC to the offset for the output_timezone
+      (v - local_offset).new_offset(local_offset)
+    end
+    
+    # Convert the timezone setter argument.  Returns argument given by default,
+    # exists for easier overriding in extensions.
+    def convert_timezone_setter_arg(tz)
+      tz.is_a?(String) ? TZInfo::Timezone.get(tz) : super
+    end
+  end
+  
+  extend NamedTimezones
+end

data/lib/sequel/extensions/schema_dumper.rb

@@ -73,7 +73,7 @@ END_MIG
     # method modified so that .lit is always appended after it, only if the
     # :same_db option is used.
     def column_schema_to_ruby_default_fallback(default, options)
-      if options[:same_db] && default.is_a?(String)
+      if default.is_a?(String) && options[:same_db] && use_column_schema_to_ruby_default_fallback?
         default = default.to_s
         def default.inspect
           "#{super}.lit"
@@ -165,6 +165,12 @@ END_MIG
       h[:unique] = true if index_opts[:unique]
       h
     end
+    
+    # Don't use the "...".lit 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
+    end
   end
 
   module Schema

data/lib/sequel/extensions/sql_expr.rb

@@ -0,0 +1,122 @@
+# The sql_expr extension adds the sql_expr method to every object, which
+# returns an object that works nicely with Sequel's DSL.  This is
+# best shown by example:
+#
+#   1.sql_expr < :a     # 1 < a
+#   false.sql_expr & :a # FALSE AND a
+#   true.sql_expr | :a  # TRUE OR a
+#   ~nil.sql_expr       # NOT NULL
+#   "a".sql_expr + "b"  # 'a' || 'b'
+
+module Sequel
+  module SQL
+    # The GenericComplexExpression acts like a 
+    # GenericExpression in terms of methods,
+    # but has an internal structure of a
+    # ComplexExpression.  It is used by Object#sql_expr.
+    # Since we don't know what specific type of object
+    # we are dealing with it, we treat it similarly to
+    # how we treat symbols or literal strings, allowing
+    # many different types of methods.
+    class GenericComplexExpression < ComplexExpression
+      include AliasMethods
+      include BooleanMethods
+      include CastMethods
+      include ComplexExpressionMethods
+      include InequalityMethods
+      include NumericMethods
+      include OrderMethods
+      include StringMethods
+      include SubscriptMethods
+    end
+  end
+end
+
+class Object
+  # Return a copy of the object wrapped in a
+  # Sequel::SQL::GenericComplexExpression.  Allows easy use
+  # of the Object with Sequel's DSL.  You'll probably have
+  # to make sure that Sequel knows how to literalize the
+  # object properly, though.
+  def sql_expr
+    Sequel::SQL::GenericComplexExpression.new(:NOOP, self)
+  end
+end
+
+class FalseClass
+  # Returns a copy of the object wrapped in a
+  # Sequel::SQL::BooleanExpression, allowing easy use
+  # of Sequel's DSL:
+  #
+  #   false.sql_expr & :a  # FALSE AND a
+  def sql_expr
+    Sequel::SQL::BooleanExpression.new(:NOOP, self)
+  end
+end
+
+class NilClass
+  # Returns a copy of the object wrapped in a
+  # Sequel::SQL::BooleanExpression, allowing easy use
+  # of Sequel's DSL:
+  #
+  #   ~nil.sql_expr  # NOT NULL
+  def sql_expr
+    Sequel::SQL::BooleanExpression.new(:NOOP, self)
+  end
+end
+
+class Numeric
+  # Returns a copy of the object wrapped in a
+  # Sequel::SQL::NumericExpression, allowing easy use
+  # of Sequel's DSL:
+  #
+  #   1.sql_expr < :a  # 1 < a
+  def sql_expr
+    Sequel::SQL::NumericExpression.new(:NOOP, self)
+  end
+end
+
+class Proc
+  # Evaluates the proc as a virtual row block.
+  # If a hash or array of two element arrays is returned,
+  # they are converted to a Sequel::SQL::BooleanExpression.  Otherwise,
+  # unless the object returned is already an Sequel::SQL::Expression,
+  # convert the object to an Sequel::SQL::GenericComplexExpression.
+  #
+  #   proc{a(b)}.sql_expr + 1  # a(b) + 1
+  #   proc{{a=>b}}.sql_expr | true  # (a = b) OR TRUE
+  #   proc{1}.sql_expr + :a  # 1 + a
+  def sql_expr
+    o = Sequel.virtual_row(&self)
+    if Sequel.condition_specifier?(o)
+      Sequel::SQL::BooleanExpression.from_value_pairs(o, :AND)
+    elsif o.is_a?(Sequel::SQL::Expression)
+      o
+    else
+      Sequel::SQL::GenericComplexExpression.new(:NOOP, o)
+    end
+  end
+end
+
+class String
+  # Returns a copy of the object wrapped in a
+  # Sequel::SQL::StringExpression, allowing easy use
+  # of Sequel's DSL:
+  #
+  #   "a".sql_expr + :a  # 'a' || a
+  def sql_expr
+    Sequel::SQL::StringExpression.new(:NOOP, self)
+  end
+end
+
+class TrueClass
+  # Returns a copy of the object wrapped in a
+  # Sequel::SQL::BooleanExpression, allowing easy use
+  # of Sequel's DSL:
+  #
+  #   true.sql_expr | :a  # TRUE OR a
+  def sql_expr
+    Sequel::SQL::BooleanExpression.new(:NOOP, self)
+  end
+end
+

data/lib/sequel/extensions/string_date_time.rb

@@ -8,7 +8,7 @@ class String
     begin
       Date.parse(self, Sequel.convert_two_digit_years)
     rescue => e
-      raise Sequel::InvalidValue, "Invalid Date value '#{self}' (#{e.message})"
+      raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
     end
   end
 
@@ -17,7 +17,7 @@ class String
     begin
       DateTime.parse(self, Sequel.convert_two_digit_years)
     rescue => e
-      raise Sequel::InvalidValue, "Invalid DateTime value '#{self}' (#{e.message})"
+      raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
     end
   end
 
@@ -31,7 +31,7 @@ class String
         Sequel.datetime_class.parse(self)
       end
     rescue => e
-      raise Sequel::InvalidValue, "Invalid #{Sequel.datetime_class} value '#{self}' (#{e.message})"
+      raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
     end
   end
 
@@ -40,7 +40,7 @@ class String
     begin
       Time.parse(self)
     rescue => e
-      raise Sequel::InvalidValue, "Invalid Time value '#{self}' (#{e.message})"
+      raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
     end
   end
 end

data/lib/sequel/extensions/thread_local_timezones.rb

@@ -0,0 +1,48 @@
+# The thread_local_timezones extension allows you to set a per-thread timezone that
+# will override the default global timezone while the thread is executing.  The
+# main use case is for web applications that execute each request in its own thread,
+# and want to set the timezones based on the request.  The most common example
+# is having the database always store time in UTC, but have the application deal
+# with the timezone of the current user.  That can be done with:
+#
+#   Sequel.database_timezone = :utc
+#   # In each thread:
+#   Sequel.thread_application_timezone = current_user.timezone
+#
+# This extension is designed to work with the named_timezones extension.
+#
+# This extension adds the thread_application_timezone=, thread_database_timezone=,
+# and thread_typecast_timezone= methods to the Sequel module.  It overrides
+# the application_timezone, database_timezone, and typecast_timezone
+# methods to check the related thread local timezone first, and use it if present.
+# If the related thread local timezone is not present, it falls back to the
+# default global timezone.
+#
+# There is one special case of note.  If you have a default global timezone
+# and you want to have a nil thread local timezone, you have to set the thread
+# local value to :nil instead of nil:
+#
+#   Sequel.application_timezone = :utc
+#   Sequel.thread_application_timezone = nil
+#   Sequel.application_timezone # => :utc
+#   Sequel.thread_application_timezone = :nil
+#   Sequel.application_timezone # => nil
+
+module Sequel
+  module ThreadLocalTimezones
+    %w'application database typecast'.each do |t|
+      class_eval("def thread_#{t}_timezone=(tz); Thread.current[:#{t}_timezone] = convert_timezone_setter_arg(tz); end", __FILE__, __LINE__)
+      class_eval(<<END, __FILE__, __LINE__)
+        def #{t}_timezone
+          if tz = Thread.current[:#{t}_timezone]
+            tz unless tz == :nil
+          else
+            super
+          end
+        end
+END
+    end
+  end
+  
+  extend ThreadLocalTimezones
+end

data/lib/sequel/model/associations.rb

@@ -101,9 +101,9 @@ module Sequel
         def reciprocal
           return self[:reciprocal] if include?(:reciprocal)
           r_type = reciprocal_type
-          key = self[:key]
+          keys = self[:keys]
           associated_class.all_association_reflections.each do |assoc_reflect|
-            if assoc_reflect[:type] == r_type && assoc_reflect[:key] == key && assoc_reflect.associated_class == self[:model]
+            if assoc_reflect[:type] == r_type && assoc_reflect[:keys] == keys && assoc_reflect.associated_class == self[:model]
               return self[:reciprocal] = assoc_reflect[:name]
             end
           end
@@ -174,10 +174,15 @@ module Sequel
           self[:key]
         end
     
-        # The column in the associated table that the key in the current table references.
+        # The column(s) in the associated table that the key in the current table references (either a symbol or an array).
         def primary_key
          self[:primary_key] ||= associated_class.primary_key
         end
+       
+        # The columns in the associated table that the key in the current table references (always an array).
+        def primary_keys
+         self[:primary_keys] ||= Array(primary_key)
+        end
       
         # Whether this association returns an array of objects instead of a single object,
         # false for a many_to_one association.
@@ -245,9 +250,10 @@ module Sequel
           self[:join_table]
         end
 
-        # The default associated key alias
+        # The default associated key alias(es) to use when eager loading
+        # associations via eager.
         def default_associated_key_alias
-          :x_foreign_key_x
+          self[:uses_left_composite_keys] ? (0...self[:left_keys].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x
         end
       
         # Default name symbol for the join table.
@@ -286,12 +292,12 @@ module Sequel
         # Returns the reciprocal association symbol, if one exists.
         def reciprocal
           return self[:reciprocal] if include?(:reciprocal)
-          left_key = self[:left_key]
-          right_key = self[:right_key]
+          left_keys = self[:left_keys]
+          right_keys = self[:right_keys]
           join_table = self[:join_table]
           associated_class.all_association_reflections.each do |assoc_reflect|
-            if assoc_reflect[:type] == :many_to_many && assoc_reflect[:left_key] == right_key &&
-               assoc_reflect[:right_key] == left_key && assoc_reflect[:join_table] == join_table &&
+            if assoc_reflect[:type] == :many_to_many && assoc_reflect[:left_keys] == right_keys &&
+               assoc_reflect[:right_keys] == left_keys && assoc_reflect[:join_table] == join_table &&
                assoc_reflect.associated_class == self[:model]
               return self[:reciprocal] = assoc_reflect[:name]
             end
@@ -299,10 +305,15 @@ module Sequel
           self[:reciprocal] = nil
         end
     
-        # The primary key column to use in the associated table.
+        # The primary key column(s) to use in the associated table (can be symbol or array).
         def right_primary_key
           self[:right_primary_key] ||= associated_class.primary_key
         end
+        
+        # The primary key columns to use in the associated table (always array).
+        def right_primary_keys
+          self[:right_primary_keys] ||= Array(right_primary_key)
+        end
     
         # The columns to select when loading the association, associated_class.table_name.* by default.
         def select
@@ -473,15 +484,19 @@ module Sequel
         #     use this option, but beware that the join table attributes can clash with
         #     attributes from the model table, so you should alias any attributes that have
         #     the same name in both the join table and the associated table.
+        #   - :validate - Set to false to not validate when implicitly saving any associated object.
         # * :many_to_one:
         #   - :key - foreign_key in current model's table that references
-        #     associated model's primary key, as a symbol.  Defaults to :"#{name}_id".
+        #     associated model's primary key, as a symbol.  Defaults to :"#{name}_id".  Can use an
+        #     array of symbols for a composite key association.
         #   - :primary_key - column in the associated table that :key option references, as a symbol.
-        #     Defaults to the primary key of the associated table.
+        #     Defaults to the primary key of the associated table. Can use an
+        #     array of symbols for a composite key association.
         # * :one_to_many:
         #   - :key - foreign key in associated model's table that references
         #     current model's primary key, as a symbol.  Defaults to
-        #     :"#{self.name.underscore}_id".
+        #     :"#{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
@@ -492,7 +507,8 @@ module Sequel
         #     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.
+        #     Defaults to primary key of the current table. Can use an
+        #     array of symbols for a composite key association.
         # * :many_to_many:
         #   - :graph_join_table_block - The block to pass to join_table for
         #     the join table when eagerly loading the association via eager_graph.
@@ -511,13 +527,17 @@ module Sequel
         #     of current model and name of associated model, pluralized,
         #     underscored, sorted, and joined with '_'.
         #   - :left_key - foreign key in join table that points to current model's
-        #     primary key, as a symbol. Defaults to :"#{self.name.underscore}_id".
+        #     primary key, as a symbol. Defaults to :"#{self.name.underscore}_id".  
+        #     Can use an array of symbols for a composite key association.
         #   - :left_primary_key - column in current table that :left_key points to, as a symbol.
-        #     Defaults to primary key of current table.
+        #     Defaults to primary key of current table.  Can use an
+        #     array of symbols for a composite key association.
         #   - :right_key - foreign key in join table that points to associated
         #     model's primary key, as a symbol.  Defaults to Defaults to :"#{name.to_s.singularize}_id".
+        #     Can use an array of symbols for a composite key association.
         #   - :right_primary_key - column in associated table that :right_key points to, as a symbol.
-        #     Defaults to primary key of the associated table.
+        #     Defaults to primary key of the associated table.  Can use an
+        #     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, 'invalid association type') unless assoc_class = ASSOCIATION_TYPES[type]
@@ -580,8 +600,13 @@ module Sequel
           if opts[:eager_graph]
             ds = ds.eager_graph(opts[:eager_graph])
             ds = ds.add_graph_aliases(opts.associated_key_alias=>[opts.associated_class.table_name, opts.associated_key_alias, SQL::QualifiedIdentifier.new(opts.associated_key_table, opts.associated_key_column)]) if opts.eager_loading_use_associated_key?
-          else
-            ds.select_more(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(opts.associated_key_table, opts.associated_key_column), opts.associated_key_alias)) if opts.eager_loading_use_associated_key?
+          elsif opts.eager_loading_use_associated_key?
+            ds = if opts[:uses_left_composite_keys]
+              t = opts.associated_key_table
+              ds.select_more(*opts.associated_key_alias.zip(opts.associated_key_column).map{|a, c| SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, c), a)})
+            else
+              ds.select_more(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(opts.associated_key_table, opts.associated_key_column), opts.associated_key_alias)) 
+            end
           end
           ds = ds.eager(associations) unless Array(associations).empty?
           ds = opts[:eager_block].call(ds) if opts[:eager_block]
@@ -649,22 +674,36 @@ module Sequel
           name = opts[:name]
           model = self
           left = (opts[:left_key] ||= opts.default_left_key)
+          lcks = opts[:left_keys] = Array(left)
           right = (opts[:right_key] ||= opts.default_right_key)
+          rcks = opts[:right_keys] = Array(right)
           left_pk = (opts[:left_primary_key] ||= self.primary_key)
+          lcpks = opts[:left_primary_keys] = Array(left_pk)
+          raise(Error, 'mismatched number of left composite keys') unless lcks.length == lcpks.length
+          raise(Error, 'mismatched number of right composite keys') if opts[:right_primary_key] && rcks.length != Array(opts[:right_primary_key]).length
+          uses_lcks = opts[:uses_left_composite_keys] = lcks.length > 1
+          uses_rcks = opts[:uses_right_composite_keys] = rcks.length > 1
           opts[:cartesian_product_number] ||= 1
           join_table = (opts[:join_table] ||= opts.default_join_table)
           left_key_alias = opts[:left_key_alias] ||= opts.default_associated_key_alias
           graph_jt_conds = opts[:graph_join_table_conditions] = opts[:graph_join_table_conditions] ? opts[:graph_join_table_conditions].to_a : []
           opts[:graph_join_table_join_type] ||= opts[:graph_join_type]
           opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
-          opts[:dataset] ||= proc{opts.associated_class.inner_join(join_table, [[right, opts.right_primary_key], [left, send(left_pk)]])}
+          opts[:dataset] ||= proc{opts.associated_class.inner_join(join_table, rcks.zip(opts.right_primary_keys) + lcks.zip(lcpks.map{|k| send(k)}))}
           database = db
           
           opts[:eager_loader] ||= proc do |key_hash, records, associations|
             h = key_hash[left_pk]
             records.each{|object| object.associations[name] = []}
-            model.eager_loading_dataset(opts, opts.associated_class.inner_join(join_table, [[right, opts.right_primary_key], [left, h.keys]]), Array(opts.select), associations).all do |assoc_record|
-              next unless objects = h[assoc_record.values.delete(left_key_alias)]
+            r = uses_rcks ? rcks.zip(opts.right_primary_keys) : [[right, opts.right_primary_key]]
+            l = uses_lcks ? [[lcks.map{|k| SQL::QualifiedIdentifier.new(join_table, k)}, SQL::SQLArray.new(h.keys)]] : [[left, h.keys]]
+            model.eager_loading_dataset(opts, opts.associated_class.inner_join(join_table, r + l), Array(opts.select), associations).all do |assoc_record|
+              hash_key = if uses_lcks
+                left_key_alias.map{|k| assoc_record.values.delete(k)}
+              else
+                assoc_record.values.delete(left_key_alias)
+              end
+              next unless objects = h[hash_key]
               objects.each{|object| object.associations[name].push(assoc_record)}
             end
           end
@@ -680,8 +719,8 @@ module Sequel
           jt_join_type = opts[:graph_join_table_join_type]
           jt_graph_block = opts[:graph_join_table_block]
           opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
-            ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : [[left, left_pk]] + graph_jt_conds, :select=>false, :table_alias=>ds.send(:eager_unique_table_alias, ds, join_table), :join_type=>jt_join_type, :implicit_qualifier=>table_alias, &jt_graph_block)
-            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : [[opts.right_primary_key, right]] + conditions, :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, &graph_block)
+            ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lcpks) + graph_jt_conds, :select=>false, :table_alias=>ds.send(:eager_unique_table_alias, ds, join_table), :join_type=>jt_join_type, :implicit_qualifier=>table_alias, :from_self_alias=>ds.opts[:eager_graph][:master], &jt_graph_block)
+            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : opts.right_primary_keys.zip(rcks) + conditions, :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, &graph_block)
           end
       
           def_association_dataset_methods(opts)
@@ -689,13 +728,16 @@ module Sequel
           return if opts[:read_only]
       
           association_module_private_def(opts._add_method) do |o|
-            database.dataset.from(join_table).insert(left=>send(left_pk), right=>o.send(opts.right_primary_key))
+            h = {}
+            lcks.zip(lcpks).each{|k, pk| h[k] = send(pk)}
+            rcks.zip(opts.right_primary_keys).each{|k, pk| h[k] = o.send(pk)}
+            database.dataset.from(join_table).insert(h)
           end
           association_module_private_def(opts._remove_method) do |o|
-            database.dataset.from(join_table).filter([[left, send(left_pk)], [right, o.send(opts.right_primary_key)]]).delete
+            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(left=>send(left_pk)).delete
+            database.dataset.from(join_table).filter(lcks.zip(lcpks.map{|k| send(k)})).delete
           end
       
           def_add_method(opts)
@@ -708,10 +750,13 @@ module Sequel
           model = self
           opts[:key] = opts.default_key unless opts.include?(:key)
           key = opts[:key]
+          cks = opts[:keys] = Array(opts[:key])
+          raise(Error, 'mismatched number of composite keys') if opts[:primary_key] && cks.length != Array(opts[:primary_key]).length
+          uses_cks = opts[:uses_composite_keys] = cks.length > 1
           opts[:cartesian_product_number] ||= 0
           opts[:dataset] ||= proc do
             klass = opts.associated_class
-            klass.filter(SQL::QualifiedIdentifier.new(klass.table_name, opts.primary_key)=>send(key))
+            klass.filter(opts.primary_keys.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}.zip(cks.map{|k| send(k)}))
           end
           opts[:eager_loader] ||= proc do |key_hash, records, associations|
             h = key_hash[key]
@@ -722,8 +767,9 @@ module Sequel
             # Skip eager loading if no objects have a foreign key for this association
             unless keys.empty?
               klass = opts.associated_class
-              model.eager_loading_dataset(opts, klass.filter(SQL::QualifiedIdentifier.new(klass.table_name, opts.primary_key)=>keys), opts.select, associations).all do |assoc_record|
-                next unless objects = h[assoc_record.send(opts.primary_key)]
+              model.eager_loading_dataset(opts, klass.filter(uses_cks ? {opts.primary_keys.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}=>SQL::SQLArray.new(keys)} : {SQL::QualifiedIdentifier.new(klass.table_name, opts.primary_key)=>keys}), opts.select, associations).all do |assoc_record|
+                hash_key = uses_cks ? opts.primary_keys.map{|k| assoc_record.send(k)} : assoc_record.send(opts.primary_key)
+                next unless objects = h[hash_key]
                 objects.each{|object| object.associations[name] = assoc_record}
               end
             end
@@ -736,14 +782,14 @@ module Sequel
           conditions = opts[:graph_conditions]
           graph_block = opts[:graph_block]
           opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
-            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : [[opts.primary_key, key]] + conditions, :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, :implicit_qualifier=>table_alias, &graph_block)
+            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : opts.primary_keys.zip(cks) + 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)
           end
       
           def_association_dataset_methods(opts)
           
           return if opts[:read_only]
       
-          association_module_private_def(opts._setter_method){|o| send(:"#{key}=", (o.send(opts.primary_key) if o))}
+          association_module_private_def(opts._setter_method){|o| cks.zip(opts.primary_keys).each{|k, pk| send(:"#{k}=", (o.send(pk) if o))}}
           association_module_def(opts.setter_method){|o| set_associated_object(opts, o)}
         end
         
@@ -752,18 +798,23 @@ module Sequel
           name = opts[:name]
           model = self
           key = (opts[:key] ||= opts.default_key)
+          cks = opts[:keys] = Array(key)
           primary_key = (opts[:primary_key] ||= self.primary_key)
+          cpks = opts[:primary_keys] = Array(primary_key)
+          raise(Error, 'mismatched number of composite keys') unless cks.length == cpks.length
+          uses_cks = opts[:uses_composite_keys] = cks.length > 1
           opts[:dataset] ||= proc do
             klass = opts.associated_class
-            klass.filter(SQL::QualifiedIdentifier.new(klass.table_name, key) => send(primary_key))
+            klass.filter(cks.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}.zip(cpks.map{|k| send(k)}))
           end
           opts[:eager_loader] ||= proc do |key_hash, records, associations|
             h = key_hash[primary_key]
             records.each{|object| object.associations[name] = []}
             reciprocal = opts.reciprocal
             klass = opts.associated_class
-            model.eager_loading_dataset(opts, klass.filter(SQL::QualifiedIdentifier.new(klass.table_name, key)=>h.keys), opts.select, associations).all do |assoc_record|
-              next unless objects = h[assoc_record[key]]
+            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
@@ -779,7 +830,7 @@ module Sequel
           opts[:cartesian_product_number] ||= 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 : [[key, primary_key]] + conditions, :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, :implicit_qualifier=>table_alias, &graph_block)
+            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)
             # We only load reciprocals for one_to_many associations, as other reciprocals don't make sense
             ds.opts[:eager_graph][:reciprocals][assoc_alias] = opts.reciprocal
             ds
@@ -787,20 +838,24 @@ module Sequel
       
           def_association_dataset_methods(opts)
           
+          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|
-              o.send(:"#{key}=", send(primary_key))
-              o.save || raise(Sequel::Error, "invalid associated object, cannot save")
+              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|
-                o.send(:"#{key}=", nil)
-                o.save || raise(Sequel::Error, "invalid associated object, cannot save")
+                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(key=>send(primary_key)).update(key=>nil)
+                opts.associated_class.filter(cks.zip(cpks.map{|k| send(k)})).update(ck_nil_hash)
               end
               def_remove_methods(opts)
             end
@@ -820,7 +875,7 @@ module Sequel
                 klass = opts.associated_class
                 update_database = lambda do 
                   send(opts.add_method, o)
-                  klass.filter(Sequel::SQL::BooleanExpression.new(:AND, {key=>send(primary_key)}, SQL::BooleanExpression.new(:'!=', klass.primary_key, o.pk))).update(key=>nil)
+                  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
@@ -873,7 +928,7 @@ module Sequel
           else
             if !opts[:key]
               send(opts.dataset_method).all.first
-            elsif send(opts[:key])
+            elsif opts[:keys].all?{|k| send(k)}
               send(opts.dataset_method).first
             end
           end
@@ -883,7 +938,7 @@ module Sequel
         def add_associated_object(opts, o, *args)
           raise(Sequel::Error, "model object #{model} does not have a primary key") unless pk
           if opts.need_associated_primary_key?
-            o.save if o.new?
+            o.save(:validate=>opts[:validate]) if o.new?
             raise(Sequel::Error, "associated object #{o.model} does not have a primary key") unless o.pk
           end
           return if run_association_callbacks(opts, :before_add, o) == false
@@ -1348,7 +1403,12 @@ module Sequel
           # Associate each object with every key being monitored
           a.each do |rec|
             key_hash.each do |key, id_map|
-              id_map[rec[key]] << rec if rec[key]
+              case key
+              when Array
+                id_map[key.map{|k| rec[k]}] << rec if key.all?{|k| rec[k]}
+              when Symbol
+                id_map[rec[key]] << rec if rec[key]
+              end
             end
           end