sequel 4.12.0 → 4.13.0

data/lib/sequel/plugins/instance_filters.rb

@@ -59,15 +59,6 @@ module Sequel
           clear_instance_filters
         end
 
-        # Duplicate internal structures when duplicating model instance.
-        def dup
-          ifs = instance_filters.dup
-          super.instance_eval do
-            @instance_filters = ifs
-            self
-          end
-        end
-      
         # Freeze the instance filters when freezing the object
         def freeze
           instance_filters.freeze
@@ -93,6 +84,13 @@ module Sequel
           end
         end
 
+        # Duplicate internal structures when duplicating model instance.
+        def initialize_copy(other)
+          super
+          @instance_filters = other.send(:instance_filters).dup
+          self
+        end
+      
         # Lazily initialize the instance filter array.
         def instance_filters
           @instance_filters ||= []

data/lib/sequel/plugins/lazy_attributes.rb

@@ -17,6 +17,13 @@ module Sequel
     #
     #   # You can specify multiple columns to lazily load:
     #   Album.plugin :lazy_attributes, :review, :tracklist
+    #
+    # Note that by default on databases that supporting RETURNING,
+    # using explicit column selections will cause instance creations
+    # to use two queries (insert and refresh) instead of a single
+    # query using RETURNING.  You can use the insert_returning_select
+    # plugin to automatically use RETURNING for instance creations
+    # for models using the lazy_attributes plugin.
     module LazyAttributes
       # Lazy attributes requires the tactical_eager_loading plugin
       def self.apply(model, *attrs)
@@ -37,7 +44,10 @@ module Sequel
         # For each attribute given, create an accessor method that allows a lazy
         # lookup of the attribute.  Each attribute should be given as a symbol.
         def lazy_attributes(*attrs)
-          set_dataset(dataset.select(*(columns - attrs)))
+          unless select = dataset.opts[:select]
+            select = dataset.columns.map{|c| Sequel.qualify(dataset.first_source, c)}
+          end
+          set_dataset(dataset.select(*select.reject{|c| attrs.include?(dataset.send(:_hash_key_symbol, c))}))
           attrs.each{|a| define_lazy_attribute_getter(a)}
         end
         
@@ -66,8 +76,9 @@ module Sequel
         # the attribute for just the current object.  Return the value of
         # the attribute for the current object.
         def lazy_attribute_lookup(a)
+          selection = Sequel.qualify(model.table_name, a)
           if frozen?
-            return this.dup.select(a).get(a)
+            return this.dup.get(selection)
           end
 
           if retrieved_with
@@ -75,14 +86,15 @@ module Sequel
             composite_pk = true if primary_key.is_a?(Array)
             id_map = {}
             retrieved_with.each{|o| id_map[o.pk] = o unless o.values.has_key?(a) || o.frozen?}
-            model.select(*(Array(primary_key) + [a])).filter(primary_key=>id_map.keys).naked.each do |row|
+            predicate_key = composite_pk ? primary_key.map{|k| Sequel.qualify(model.table_name, k)} : Sequel.qualify(model.table_name, primary_key)
+            model.select(*(Array(primary_key).map{|k| Sequel.qualify(model.table_name, k)} + [selection])).where(predicate_key=>id_map.keys).naked.each do |row|
               obj = id_map[composite_pk ? row.values_at(*primary_key) : row[primary_key]]
               if obj && !obj.values.has_key?(a)
                 obj.values[a] = row[a]
               end
             end
           end
-          values[a] = this.select(a).get(a) unless values.has_key?(a)
+          values[a] = this.get(selection) unless values.has_key?(a)
           values[a]
         end
       end

data/lib/sequel/plugins/list.rb

@@ -96,6 +96,15 @@ module Sequel
           super
         end
 
+        # When destroying an instance, move all entries after the instance down
+        # one position, so that there aren't any gaps
+        def after_destroy
+          super
+
+          f = Sequel.expr(position_field)
+          list_dataset.where(f > position_value).update(f => f - 1)
+        end
+
         # Find the last position in the list containing this instance.
         def last_position
           list_dataset.max(position_field).to_i

data/lib/sequel/plugins/modification_detection.rb

@@ -0,0 +1,90 @@
+module Sequel
+  module Plugins
+    # This plugin automatically detects in-place modifications to
+    # columns as well as direct modifications of the values hash.
+    #
+    #   class User < Sequel::Model
+    #     plugin :modification_detection
+    #   end
+    #   user = User[1]
+    #   user.a # => 'a'
+    #   user.a << 'b'
+    #   user.save_changes
+    #   # UPDATE users SET a = 'ab' WHERE (id = 1)
+    #
+    # Note that for this plugin to work correctly, the column values must
+    # correctly implement the #hash method, returning the same value if
+    # the object is equal, and a different value if the object is not equal.
+    #
+    # Note that this plugin causes a performance hit for all retrieved
+    # objects, so it shouldn't be used in cases where performance is a
+    # primary concern.
+    #
+    # Usage:
+    #
+    #   # Make all model subclass automatically detect column modifications
+    #   Sequel::Model.plugin :modification_detection
+    #
+    #   # Make the Album class automatically detect column modifications
+    #   Album.plugin :modification_detection
+    module ModificationDetection
+      module ClassMethods
+        # Calculate the hashes for all of the column values, so that they
+        # can be compared later to determine if the column value has changed.
+        def call(_)
+          v = super
+          v.calculate_values_hashes
+          v
+        end
+      end
+
+      module InstanceMethods
+        # Recalculate the column value hashes after updating.
+        def after_update
+          super
+          recalculate_values_hashes
+        end
+
+        # Calculate the column hash values if they haven't been already calculated.
+        def calculate_values_hashes
+          @values_hashes || recalculate_values_hashes
+        end
+
+        # Detect which columns have been modified by comparing the cached hash
+        # value to the hash of the current value.
+        def changed_columns
+          cc = super
+          changed = []
+          v = @values
+          if vh = @values_hashes
+            (vh.keys - cc).each{|c| changed << c unless v.has_key?(c) && vh[c] == v[c].hash}
+          end
+          cc + changed
+        end
+
+        private
+
+        # Recalculate the column value hashes after manually refreshing.
+        def _refresh(dataset)
+          super
+          recalculate_values_hashes
+        end
+
+        # Recalculate the column value hashes after refreshing after saving a new object.
+        def _save_refresh
+          super
+          recalculate_values_hashes
+        end
+
+        # Recalculate the column value hashes, caching them for later use.
+        def recalculate_values_hashes
+          vh = {}
+          @values.each do |k,v|
+            vh[k] = v.hash
+          end
+          @values_hashes = vh.freeze
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/serialization.rb

@@ -175,26 +175,11 @@ module Sequel
       end
 
       module InstanceMethods
-        # Serialize deserialized values before saving
-        def before_save
-          serialize_deserialized_values
-          super
-        end
-        
         # Hash of deserialized values, used as a cache.
         def deserialized_values
           @deserialized_values ||= {}
         end
 
-        # Freeze the deserialized values
-        def dup
-          dv = deserialized_values.dup
-          super.instance_eval do
-            @deserialized_values = dv
-            self
-          end
-        end
-
         # Freeze the deserialized values
         def freeze
           deserialized_values.freeze
@@ -203,6 +188,12 @@ module Sequel
 
         private
 
+        # Serialize deserialized values before saving
+        def _before_validation
+          serialize_deserialized_values
+          super
+        end
+        
         # Clear any cached deserialized values when doing a manual refresh.
         def _refresh_set_values(hash)
           @deserialized_values.clear if @deserialized_values
@@ -218,6 +209,13 @@ module Sequel
           end
         end
 
+        # Dup the deserialized values when duping model instance.
+        def initialize_copy(other)
+          super
+          @deserialized_values = other.deserialized_values.dup
+          self
+        end
+
         # Serialize all deserialized values
         def serialize_deserialized_values
           deserialized_values.each{|k,v| @values[k] = serialize_value(k, v)}

data/lib/sequel/plugins/serialization_modification_detection.rb

@@ -45,15 +45,6 @@ module Sequel
           cc
         end
 
-        # Duplicate the original deserialized values when duplicating instance.
-        def dup
-          o = @original_deserialized_values
-          super.instance_eval do
-            @original_deserialized_values = o.dup if o
-            self
-          end
-        end
-
         # Freeze the original deserialized values when freezing the instance.
         def freeze
           @original_deserialized_values ||= {}
@@ -63,6 +54,15 @@ module Sequel
 
         private
 
+        # Duplicate the original deserialized values when duplicating instance.
+        def initialize_copy(other)
+          super
+          if o = other.instance_variable_get(:@original_deserialized_values)
+            @original_deserialized_values = o.dup
+          end
+          self
+        end
+
         # For new objects, serialize any existing deserialized values so that changes can
         # be detected.
         def initialize_set(values)

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -215,8 +215,10 @@ module Sequel
       end
 
       module InstanceMethods
+        private
+
         # Set the sti_key column based on the sti_key_map.
-        def before_validation
+        def _before_validation
           if new? && !self[model.sti_key]
             send("#{model.sti_key}=", model.sti_key_chooser.call(self))
           end

data/lib/sequel/plugins/timestamps.rb

@@ -57,12 +57,6 @@ module Sequel
       end
 
       module InstanceMethods
-        # Set the create timestamp when creating
-        def before_validation
-          set_create_timestamp if new?
-          super
-        end
-        
         # Set the update timestamp when updating
         def before_update
           set_update_timestamp
@@ -71,6 +65,12 @@ module Sequel
         
         private
         
+        # Set the create timestamp when creating
+        def _before_validation
+          set_create_timestamp if new?
+          super
+        end
+        
         # If the object has accessor methods for the create timestamp field, and
         # the create timestamp value is nil or overwriting it is allowed, set the
         # create timestamp field to the time given or the current time.  If setting

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 12
+  MINOR = 13
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/mysql_spec.rb

@@ -509,6 +509,13 @@ describe "A MySQL database" do
     end
   end
 
+  specify "should correctly format CREATE TABLE statements with foreign keys, when :key != the default (:id)" do
+    @db.create_table(:items){primary_key :id; Integer :other_than_id; foreign_key :p_id, :items, :key => :other_than_id, :null => false, :on_delete => :cascade}
+    check_sqls do
+      @db.sqls.should == ["CREATE TABLE `items` (`id` integer PRIMARY KEY AUTO_INCREMENT, `other_than_id` integer, `p_id` integer NOT NULL, UNIQUE (`other_than_id`), FOREIGN KEY (`p_id`) REFERENCES `items`(`other_than_id`) ON DELETE CASCADE)"]
+    end
+  end
+
   specify "should correctly format ALTER TABLE statements with foreign keys" do
     @db.create_table(:items){Integer :id}
     @db.create_table(:users){primary_key :id}

data/spec/adapters/postgres_spec.rb

@@ -3436,3 +3436,44 @@ describe 'pg_static_cache_updater extension' do
     q.pop
   end
 end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && DB.server_version >= 90000
+
+describe 'PostgreSQL enum types' do
+  before(:all) do
+    @db = DB
+    @db.extension :pg_array, :pg_enum
+    @db.create_enum(:test_enum, %w'a b c d')
+
+    @db.create_table!(:test_enumt) do
+      test_enum  :t
+    end
+  end
+  after(:all) do
+    @db.drop_table?(:test_enumt)
+    @db.drop_enum(:test_enum)
+  end
+
+  specify "should return correct entries in the schema" do
+    s = @db.schema(:test_enumt)
+    s.first.last[:type].should == :enum
+    s.first.last[:enum_values].should == %w'a b c d'
+  end
+
+  it "should add array parsers for enum values" do
+    @db.get(Sequel.pg_array(%w'a b', :test_enum)).should == %w'a b'
+  end if DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
+
+  it "should set up model typecasting correctly" do
+    c = Class.new(Sequel::Model(:test_enumt))
+    o = c.new
+    o.t = :a
+    o.t.should == 'a'
+  end
+
+  it "should add values to existing enum" do
+    @db.add_enum_value(:test_enum, 'e')
+    @db.add_enum_value(:test_enum, 'f', :after=>'a')
+    @db.add_enum_value(:test_enum, 'g', :before=>'b')
+    @db.add_enum_value(:test_enum, 'a', :if_not_exists=>true) if @db.server_version >= 90300
+    @db.schema(:test_enumt, :reload=>true).first.last[:enum_values].should == %w'a f g b c d e'
+  end if DB.server_version >= 90100
+end

data/spec/bin_spec.rb

@@ -56,6 +56,7 @@ describe "bin/sequel" do
     bin(:args=>'-c "print DB.tables.inspect"').should == '[]'
     DB.create_table(:a){Integer :a}
     bin(:args=>'-c "print DB.tables.inspect"').should == '[:a]'
+    bin(:args=>'-v -c "print DB.tables.inspect"').should == "sequel #{Sequel.version}\n[:a]"
   end
 
   it "-C should copy databases" do
@@ -188,7 +189,7 @@ END
     bin(:args=>'-t -c "lambda{lambda{lambda{raise \'foo\'}.call}.call}.call"', :stderr=>true).count("\n").should > 3
   end
 
-  it "-v should output the Sequel version" do
+  it "-v should output the Sequel version and exit if database is not given" do
     bin(:args=>"-v", :no_conn=>true).should == "sequel #{Sequel.version}\n"
   end
 
@@ -201,6 +202,7 @@ END
     bin(:args=>'-D -d', :stderr=>true).should == "Error: Cannot specify -D and -d together\n"
     bin(:args=>'-m foo -d', :stderr=>true).should == "Error: Cannot specify -m and -d together\n"
     bin(:args=>'-S foo -d', :stderr=>true).should == "Error: Cannot specify -S and -d together\n"
+    bin(:args=>'-S foo -C', :stderr=>true).should == "Error: Cannot specify -S and -C together\n"
   end
 
   it "should use a mock database if no database is given" do
@@ -243,6 +245,7 @@ END
     bin(:post=>TMP_FILE).should == '[]'
     DB.create_table(:a){Integer :a}
     bin(:post=>TMP_FILE).should == '[:a]'
+    bin(:post=>TMP_FILE, :args=>'-v').should == "sequel #{Sequel.version}\n[:a]"
   end
 
   it "should run code provided on stdin" do

data/spec/core/database_spec.rb

@@ -1290,6 +1290,12 @@ describe "A broken adapter (lib is there but the class is not)" do
   end
 end
 
+describe "Sequel::Database.load_adapter" do
+  specify "should not raise an error if subadapter does not exist" do
+    Sequel::Database.load_adapter(:foo, :subdir=>'bar').should == nil
+  end
+end
+
 describe "A single threaded database" do
   after do
     Sequel::Database.single_threaded = false

data/spec/core/dataset_spec.rb

@@ -982,22 +982,17 @@ describe "Dataset#literal" do
     d.literal(d).should == "(#{d.sql})"
   end
   
-  specify "should literalize Sequel::SQLTime properly" do
-    t = Sequel::SQLTime.now
-    s = t.strftime("'%H:%M:%S")
-    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.usec)}'"
+  specify "should literalize times properly" do
+    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 500000)).should == "'01:02:03.500000'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5, 500000)).should == "'2010-01-02 03:04:05.500000'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(55, 10))).should == "'2010-01-02 03:04:05.500000'"
   end
   
-  specify "should literalize Time properly" do
-    t = Time.now
-    s = t.strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.usec)}'"
-  end
-  
-  specify "should literalize DateTime properly" do
-    t = DateTime.now
-    s = t.strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.sec_fraction * (RUBY_VERSION < '1.9.0' ? 86400000000 : 1000000))}'"
+  specify "should literalize times properly for databases supporting millisecond precision" do
+    meta_def(@dataset, :timestamp_precision){3}
+    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 500000)).should == "'01:02:03.500'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5, 500000)).should == "'2010-01-02 03:04:05.500'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(55, 10))).should == "'2010-01-02 03:04:05.500'"
   end
   
   specify "should literalize Date properly" do
@@ -1015,52 +1010,19 @@ describe "Dataset#literal" do
 
   specify "should literalize Time, DateTime, Date properly if SQL standard format is required" do
     meta_def(@dataset, :requires_sql_standard_datetimes?){true}
-
-    t = Time.now
-    s = t.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.usec)}'"
-
-    t = DateTime.now
-    s = t.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.sec_fraction* (RUBY_VERSION < '1.9.0' ? 86400000000 : 1000000))}'"
-
-    d = Date.today
-    s = d.strftime("DATE '%Y-%m-%d'")
-    @dataset.literal(d).should == s
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5, 500000)).should == "TIMESTAMP '2010-01-02 03:04:05.500000'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(55, 10))).should == "TIMESTAMP '2010-01-02 03:04:05.500000'"
+    @dataset.literal(Date.new(2010, 1, 2)).should == "DATE '2010-01-02'"
   end
   
   specify "should literalize Time and DateTime properly if the database support timezones in timestamps" do
     meta_def(@dataset, :supports_timestamp_timezones?){true}
+    @dataset.literal(Time.utc(2010, 1, 2, 3, 4, 5, 500000)).should == "'2010-01-02 03:04:05.500000+0000'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(55, 10))).should == "'2010-01-02 03:04:05.500000+0000'"
 
-    t = Time.now.utc
-    s = t.strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.usec)}+0000'"
-
-    t = DateTime.now.new_offset(0)
-    s = t.strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.sec_fraction* (RUBY_VERSION < '1.9.0' ? 86400000000 : 1000000))}+0000'"
-  end
-  
-  specify "should literalize Time and DateTime properly if the database doesn't support usecs in timestamps" do
     meta_def(@dataset, :supports_timestamp_usecs?){false}
-    
-    t = Time.now.utc
-    s = t.strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}'"
-
-    t = DateTime.now.new_offset(0)
-    s = t.strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}'"
-    
-    meta_def(@dataset, :supports_timestamp_timezones?){true}
-    
-    t = Time.now.utc
-    s = t.strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}+0000'"
-
-    t = DateTime.now.new_offset(0)
-    s = t.strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}+0000'"
+    @dataset.literal(Time.utc(2010, 1, 2, 3, 4, 5)).should == "'2010-01-02 03:04:05+0000'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, 5)).should == "'2010-01-02 03:04:05+0000'"
   end
   
   specify "should not modify literal strings" do
@@ -3249,6 +3211,11 @@ describe "Dataset#insert_sql" do
   specify "should accept an array of columns and an LiteralString" do
     @ds.insert_sql([:a, :b, :c], Sequel.lit('VALUES (1, 2, 3)')).should == "INSERT INTO items (a, b, c) VALUES (1, 2, 3)"
   end
+
+  specify "should use unaliased table name" do
+    @ds.from(:items___i).insert_sql(1).should == "INSERT INTO items VALUES (1)"
+    @ds.from(Sequel.as(:items, :i)).insert_sql(1).should == "INSERT INTO items VALUES (1)"
+  end
 end
 
 describe "Dataset#inspect" do
@@ -3457,7 +3424,7 @@ describe "Dataset prepared statements and bound variables " do
   before do
     @db = Sequel.mock
     @ds = @db[:items]
-    meta_def(@ds, :insert_sql){|*v| "#{super(*v)}#{' RETURNING *' if opts.has_key?(:returning)}" }
+    meta_def(@ds, :insert_select_sql){|*v| "#{insert_sql(*v)} RETURNING *" }
   end
   
   specify "#call should take a type and bind hash and interpolate it" do
@@ -3935,7 +3902,12 @@ describe "Sequel timezone support" do
     @dataset = @db.dataset
     meta_def(@dataset, :supports_timestamp_timezones?){true}
     meta_def(@dataset, :supports_timestamp_usecs?){false}
-    @offset = sprintf("%+03i%02i", *(Time.now.utc_offset/60).divmod(60))
+    @utc_time = Time.utc(2010, 1, 2, 3, 4, 5)
+    @local_time = Time.local(2010, 1, 2, 3, 4, 5)
+    @offset = sprintf("%+03i%02i", *(@local_time.utc_offset/60).divmod(60))
+    @dt_offset = @local_time.utc_offset/Rational(86400, 1)
+    @utc_datetime = DateTime.new(2010, 1, 2, 3, 4, 5)
+    @local_datetime = DateTime.new(2010, 1, 2, 3, 4, 5, @dt_offset)
   end
   after do
     Sequel.default_timezone = nil
@@ -3944,50 +3916,26 @@ describe "Sequel timezone support" do
   
   specify "should handle an database timezone of :utc when literalizing values" do
     Sequel.database_timezone = :utc
-
-    t = Time.now
-    s = t.getutc.strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}+0000'"
-
-    t = DateTime.now
-    s = t.new_offset(0).strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}+0000'"
+    @dataset.literal(Time.utc(2010, 1, 2, 3, 4, 5)).should == "'2010-01-02 03:04:05+0000'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, 5)).should == "'2010-01-02 03:04:05+0000'"
   end
   
   specify "should handle an database timezone of :local when literalizing values" do
     Sequel.database_timezone = :local
-
-    t = Time.now.utc
-    s = t.getlocal.strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}#{@offset}'"
-
-    t = DateTime.now.new_offset(0)
-    s = t.new_offset(DateTime.now.offset).strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}#{@offset}'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5)).should == "'2010-01-02 03:04:05#{@offset}'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, 5, @dt_offset)).should == "'2010-01-02 03:04:05#{@offset}'"
   end
   
   specify "should have Database#timezone override Sequel.database_timezone" do
     Sequel.database_timezone = :local
     @db.timezone = :utc
-
-    t = Time.now
-    s = t.getutc.strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}+0000'"
-
-    t = DateTime.now
-    s = t.new_offset(0).strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}+0000'"
+    @dataset.literal(Time.utc(2010, 1, 2, 3, 4, 5)).should == "'2010-01-02 03:04:05+0000'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, 5)).should == "'2010-01-02 03:04:05+0000'"
 
     Sequel.database_timezone = :utc
     @db.timezone = :local
-
-    t = Time.now.utc
-    s = t.getlocal.strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}#{@offset}'"
-
-    t = DateTime.now.new_offset(0)
-    s = t.new_offset(DateTime.now.offset).strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}#{@offset}'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5)).should == "'2010-01-02 03:04:05#{@offset}'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, 5, @dt_offset)).should == "'2010-01-02 03:04:05#{@offset}'"
   end
   
   specify "should handle converting database timestamps into application timestamps" do
@@ -4418,9 +4366,10 @@ end
 
 describe "Dataset#returning" do
   before do
-    @ds = Sequel.mock(:fetch=>proc{|s| {:foo=>s}})[:t].returning(:foo)
+    @db = Sequel.mock(:fetch=>proc{|s| {:foo=>s}})
+    @db.extend_datasets{def supports_returning?(type) true end}
+    @ds = @db[:t].returning(:foo)
     @pr = proc do
-      def @ds.supports_returning?(*) true end
       sc = class << @ds; self; end
       Sequel::Dataset.def_sql_method(sc, :delete, %w'delete from where returning')
       Sequel::Dataset.def_sql_method(sc, :insert, %w'insert into columns values returning')
@@ -4458,6 +4407,11 @@ describe "Dataset#returning" do
     @ds.insert(1).should == [{:foo=>"INSERT INTO t VALUES (1) RETURNING foo"}]
     @ds.update(:foo=>1).should == [{:foo=>"UPDATE t SET foo = 1 RETURNING foo"}]
   end
+
+  specify "should raise an error if RETURNING is not supported" do
+    @db.extend_datasets{def supports_returning?(type) false end}
+    proc{@db[:t].returning}.should raise_error(Sequel::Error)
+  end
 end
 
 describe "Dataset emulating bitwise operator support" do
@@ -4943,3 +4897,59 @@ describe "Dataset emulated complex expression operators" do
     @ds.literal(~@n).should == "((0 - x) - 1)"
   end
 end
+
+describe "#joined_dataset?" do
+  before do
+    @ds = Sequel.mock.dataset
+  end
+
+  it "should be false if the dataset has 0 or 1 from table" do
+    @ds.joined_dataset?.should == false
+    @ds.from(:a).joined_dataset?.should == false
+  end
+
+  it "should be true if the dataset has 2 or more from tables" do
+    @ds.from(:a, :b).joined_dataset?.should == true
+    @ds.from(:a, :b, :c).joined_dataset?.should == true
+  end
+
+  it "should be true if the dataset has any join tables" do
+    @ds.from(:a).cross_join(:b).joined_dataset?.should == true
+  end
+end
+
+describe "#unqualified_column_for" do
+  before do
+    @ds = Sequel.mock.dataset
+  end
+
+  it "should handle Symbols" do
+    @ds.unqualified_column_for(:a).should == Sequel.identifier('a')
+    @ds.unqualified_column_for(:b__a).should == Sequel.identifier('a')
+    @ds.unqualified_column_for(:a___c).should == Sequel.identifier('a').as('c')
+    @ds.unqualified_column_for(:b__a___c).should == Sequel.identifier('a').as('c')
+  end
+
+  it "should handle SQL::Identifiers" do
+    @ds.unqualified_column_for(Sequel.identifier(:a)).should == Sequel.identifier(:a)
+  end
+
+  it "should handle SQL::QualifiedIdentifiers" do
+    @ds.unqualified_column_for(Sequel.qualify(:b, :a)).should == Sequel.identifier('a')
+    @ds.unqualified_column_for(Sequel.qualify(:b, 'a')).should == Sequel.identifier('a')
+  end
+
+  it "should handle SQL::AliasedExpressions" do
+    @ds.unqualified_column_for(Sequel.qualify(:b, :a).as(:c)).should == Sequel.identifier('a').as(:c)
+  end
+
+  it "should return nil for other objects" do
+    @ds.unqualified_column_for(Object.new).should == nil
+    @ds.unqualified_column_for('a').should == nil
+  end
+
+  it "should return nil for other objects inside SQL::AliasedExpressions" do
+    @ds.unqualified_column_for(Sequel.as(Object.new, 'a')).should == nil
+    @ds.unqualified_column_for(Sequel.as('a', 'b')).should == nil
+  end
+end