sequel 3.5.0 → 3.6.0

data/lib/sequel/plugins/force_encoding.rb

@@ -34,18 +34,29 @@ module Sequel
           super
           subclass.forced_encoding = forced_encoding
         end
-        
-        # Force the encoding of all strings for the given row to the model's
-        # forced_encoding.
-        def load(row)
-          row.values.each{|v| v.force_encoding(forced_encoding) if v.is_a?(String)} if forced_encoding
-          super
-        end
       end
     
       module InstanceMethods
+        # Allow the force encoding plugin to work with the identity_map
+        # plugin by typecasting new values.
+        def merge_db_update(row)
+          super(force_hash_encoding(row))
+        end
+        
         private
         
+        # Force the encoding for all string values in the given row hash.
+        def force_hash_encoding(row)
+          fe = model.forced_encoding
+          row.values.each{|v| v.force_encoding(fe) if v.is_a?(String)} if fe
+          row
+        end
+        
+        # Force the encoding of all string values when setting the instance's values.
+        def set_values(row)
+          super(force_hash_encoding(row))
+        end
+        
         # Force the encoding of all returned strings to the model's forced_encoding.
         def typecast_value(column, value)
           s = super

data/lib/sequel/plugins/hook_class_methods.rb

@@ -19,6 +19,10 @@ module Sequel
     #      return false if super == false
     #      self.created_at = Time.now
     #    end
+    #
+    # Note that returning false in any before hook block will skip further
+    # before hooks and abort the action.  So if a before_save hook block returns
+    # false, future before_save hook blocks are not called, and the save is aborted.
     module HookClassMethods
       # Set up the hooks instance variable in the model.
       def self.apply(model)

data/lib/sequel/plugins/many_through_many.rb

@@ -156,7 +156,7 @@ module Sequel
           uses_lcks = opts[:uses_left_composite_keys] = left_key.is_a?(Array)
           left_keys = Array(left_key)
           left_pk = (opts[:left_primary_key] ||= self.primary_key)
-          left_pks = Array(left_pk)
+          left_pks = opts[:left_primary_keys] = Array(left_pk)
           opts[:dataset] ||= lambda do
             ds = opts.associated_class
             opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}

data/lib/sequel/plugins/nested_attributes.rb

@@ -27,6 +27,8 @@ module Sequel
         
         # Allow nested attributes to be set for the given associations.  Options:
         # * :destroy - Allow destruction of nested records.
+        # * :fields - If provided, should be an Array.  Restricts the fields allowed to be
+        #   modified through the association_attributes= method to the specific fields given.
         # * :limit - For *_to_many associations, a limit on the number of records
         #   that will be processed, to prevent denial of service attacks.
         # * :remove - Allow disassociation of nested records (can remove the associated
@@ -68,26 +70,32 @@ module Sequel
       end
       
       module InstanceMethods
-        # Assume if an instance has nested attributes set on it, that it has
-        # been modified even if none of the instance's columns have been modified.
-        def modified?
-          super || @has_nested_attributes
-        end
-        
         private
         
+        # Check that the keys related to the association are not modified inside the block.  Does
+        # not use an ensure block, so callers should be careful.
+        def nested_attributes_check_key_modifications(reflection, obj)
+          keys = reflection.associated_object_keys.map{|x| obj.send(x)}
+          yield
+          raise(Error, "Modifying association dependent key(s) when updating associated objects is not allowed") unless keys == reflection.associated_object_keys.map{|x| obj.send(x)}
+        end
+        
         # Create a new associated object with the given attributes, validate
         # it when the parent is validated, and save it when the object is saved.
+        # Returns the object created.
         def nested_attributes_create(reflection, attributes)
-          obj = reflection.associated_class.new(attributes)
+          obj = reflection.associated_class.new
+          nested_attributes_set_attributes(reflection, obj, attributes)
           after_validation_hook{validate_associated_object(reflection, obj)}
           if reflection.returns_array?
+            send(reflection[:name]) << obj
             after_save_hook{send(reflection.add_method, obj)}
           else
             # Don't need to validate the object twice if :validate association option is not false
             # and don't want to validate it at all if it is false.
             before_save_hook{send(reflection.setter_method, obj.save(:validate=>false))}
           end
+          obj
         end
         
         # Find an associated object with the matching pk.  If a matching option
@@ -114,6 +122,7 @@ module Sequel
         
         # Remove the matching associated object from the current object.
         # If the :destroy option is given, destroy the object after disassociating it.
+        # Returns the object removed, if it exists.
         def nested_attributes_remove(reflection, pk, opts={})
           if obj = nested_attributes_find(reflection, pk)
             before_save_hook do
@@ -124,9 +133,20 @@ module Sequel
               end
             end
             after_save_hook{obj.destroy} if opts[:destroy]
+            obj
           end
         end
         
+        # Set the fields in the obj based on the association, only allowing
+        # specific :fields if configured.
+        def nested_attributes_set_attributes(reflection, obj, attributes)
+          if fields = reflection[:nested_attributes][:fields]
+            obj.set_only(attributes, fields)
+          else
+            obj.set(attributes)
+          end
+        end
+
         # Modify the associated object based on the contents of the attribtues hash:
         # * If a block was given to nested_attributes, call it with the attributes and return immediately if the block returns true.
         # * If no primary key exists in the attributes hash, create a new object.
@@ -135,7 +155,7 @@ module Sequel
         # * Otherwise, update the matching associated object with the contents of the hash.
         def nested_attributes_setter(reflection, attributes)
           return if (b = reflection[:nested_attributes][:reject_if]) && b.call(attributes)
-          @has_nested_attributes = true
+          modified!
           klass = reflection.associated_class
           if pk = attributes.delete(klass.primary_key) || attributes.delete(klass.primary_key.to_s)
             if klass.db.send(:typecast_value_boolean, attributes[:_delete] || attributes['_delete']) && reflection[:nested_attributes][:destroy]
@@ -153,16 +173,25 @@ module Sequel
         # Update the matching associated object with the attributes,
         # validating it when the parent object is validated and saving it
         # when the parent is saved.
+        # Returns the object updated, if it exists.
         def nested_attributes_update(reflection, pk, attributes)
           if obj = nested_attributes_find(reflection, pk)
-            obj.set(attributes)
+            nested_attributes_update_attributes(reflection, obj, attributes)
             after_validation_hook{validate_associated_object(reflection, obj)}
             # Don't need to validate the object twice if :validate association option is not false
             # and don't want to validate it at all if it is false.
-            after_save_hook{obj.save(:validate=>false)}
+            after_save_hook{obj.save_changes(:validate=>false)}
+            obj
           end
         end
-        
+
+        # Update the attributes for the given object related to the current object through the association.
+        def nested_attributes_update_attributes(reflection, obj, attributes)
+          nested_attributes_check_key_modifications(reflection, obj) do
+            nested_attributes_set_attributes(reflection, obj, attributes)
+          end
+        end
+
         # Validate the given associated object, adding any validation error messages from the
         # given object to the parent object.
         def validate_associated_object(reflection, obj)

data/lib/sequel/plugins/serialization.rb

@@ -3,7 +3,7 @@ module Sequel
     # Sequel's built in Serialization plugin allows you to keep serialized
     # ruby objects in the database, while giving you deserialized objects
     # when you call an accessor.
-    # 
+    #
     # This plugin works by keeping the serialized value in the values, and
     # adding a @deserialized_values hash.  The reader method for serialized columns
     # will check the @deserialized_values for the value, return it if present,
@@ -11,13 +11,27 @@ module Sequel
     # set the @deserialized_values entry.  This plugin adds a before_save hook
     # that serializes all @deserialized_values to @values.
     #
-    # You can use either marshal or yaml as the serialization format.
-    # If you use yaml, you should require yaml yourself.
+    # You can use either marshal, yaml, or json as the serialization format.
+    # If you use yaml or json, you should require them by yourself.
     #
     # Because of how this plugin works, it must be used inside each model class
     # that needs serialization, after any set_dataset method calls in that class.
     # Otherwise, it is possible that the default column accessors will take
     # precedence.
+    #
+    # == Example
+    #
+    #   require 'sequel'
+    #   require 'json'
+    #   class User < Sequel::Model
+    #     plugin :serialization, :json, :permissions
+    #     # or
+    #     plugin :serialization
+    #     serialize_attributes :marshal, :permissions, :attributes
+    #   end
+    #   user = User.create
+    #   user.permissions = { :global => 'read-only' }
+    #   user.save
     module Serialization
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values.

data/lib/sequel/plugins/validation_helpers.rb

@@ -30,49 +30,75 @@ module Sequel
     #   Sequel will attempt to insert a NULL value into the database, instead of using the
     #   database's default.
     # * :allow_nil - Whether to skip the validation if the value is nil.
-    # * :message - The message to use
+    # * :message - The message to use.  Can be a string which is used directly, or a
+    #   proc which is called.  If the validation method takes a argument before the array of attributes,
+    #   that argument is passed as an argument to the proc.  The exception is the
+    #   validates_not_string method, which doesn't take an argument, but passes
+    #   the schema type symbol as the argument to the proc.
+    #
+    # The default validation options for all models can be modified by
+    # changing the values of the Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS hash.  You
+    # change change the default options on a per model basis
+    # by overriding a private instance method default_validation_helpers_options.
     module ValidationHelpers
+      # Default validation options used by Sequel.  Can be modified to change the error
+      # messages for all models (e.g. for internationalization), or to set certain
+      # default options for validations (e.g. :allow_nil=>true for all validates_format).
+      DEFAULT_OPTIONS = {
+        :exact_length=>{:message=>lambda{|exact| "is not #{exact} characters"}},
+        :format=>{:message=>lambda{|with| 'is invalid'}},
+        :includes=>{:message=>lambda{|set| "is not in range or set: #{set.inspect}"}},
+        :integer=>{:message=>lambda{"is not a number"}},
+        :length_range=>{:message=>lambda{|range| "is too short or too long"}},
+        :max_length=>{:message=>lambda{|max| "is longer than #{max} characters"}},
+        :min_length=>{:message=>lambda{|min| "is shorter than #{min} characters"}},
+        :not_string=>{:message=>lambda{|type| type ? "is not a valid #{type}" : "is a string"}},
+        :numeric=>{:message=>lambda{"is not a number"}},
+        :presence=>{:message=>lambda{"is not present"}},
+        :unique=>{:message=>lambda{'is already taken'}}
+      }
+      
       module InstanceMethods 
         # Check that the attribute values are the given exact length.
         def validates_exact_length(exact, atts, opts={})
-          validatable_attributes(atts, opts){|a,v,m| (m || "is not #{exact} characters") unless v && v.length == exact}
+          validatable_attributes_for_type(:exact_length, atts, opts){|a,v,m| validation_error_message(m, exact) unless v && v.length == exact}
         end
 
         # Check the string representation of the attribute value(s) against the regular expression with.
         def validates_format(with, atts, opts={})
-          validatable_attributes(atts, opts){|a,v,m| (m || 'is invalid') unless v.to_s =~ with}
+          validatable_attributes_for_type(:format, atts, opts){|a,v,m| validation_error_message(m, with) unless v.to_s =~ with}
         end
     
         # Check attribute value(s) is included in the given set.
         def validates_includes(set, atts, opts={})
-          validatable_attributes(atts, opts){|a,v,m| (m || "is not in range or set: #{set.inspect}") unless set.include?(v)}
+          validatable_attributes_for_type(:includes, atts, opts){|a,v,m| validation_error_message(m, set) unless set.include?(v)}
         end
     
         # Check attribute value(s) string representation is a valid integer.
         def validates_integer(atts, opts={})
-          validatable_attributes(atts, opts) do |a,v,m|
+          validatable_attributes_for_type(:integer, atts, opts) do |a,v,m|
             begin
               Kernel.Integer(v.to_s)
               nil
             rescue
-              m || 'is not a number'
+              validation_error_message(m)
             end
           end
         end
 
         # Check that the attribute values length is in the specified range.
         def validates_length_range(range, atts, opts={})
-          validatable_attributes(atts, opts){|a,v,m| (m || "is outside the allowed range") unless v && range.include?(v.length)}
+          validatable_attributes_for_type(:length_range, atts, opts){|a,v,m| validation_error_message(m, range) unless v && range.include?(v.length)}
         end
     
         # Check that the attribute values are not longer than the given max length.
         def validates_max_length(max, atts, opts={})
-          validatable_attributes(atts, opts){|a,v,m| (m || "is longer than #{max} characters") unless v && v.length <= max}
+          validatable_attributes_for_type(:max_length, atts, opts){|a,v,m| validation_error_message(m, max) unless v && v.length <= max}
         end
 
         # Check that the attribute values are not shorter than the given min length.
         def validates_min_length(min, atts, opts={})
-          validatable_attributes(atts, opts){|a,v,m| (m || "is shorter than #{min} characters") unless v && v.length >= min}
+          validatable_attributes_for_type(:min_length, atts, opts){|a,v,m| validation_error_message(m, min) unless v && v.length >= min}
         end
 
         # Check that the attribute value(s) is not a string.  This is generally useful
@@ -82,28 +108,24 @@ module Sequel
         # be a string in an invalid format, and if typecasting succeeds, the value will
         # not be a string.
         def validates_not_string(atts, opts={})
-          validatable_attributes(atts, opts) do |a,v,m|
-            next unless v.is_a?(String)
-            next m if m
-            (sch = db_schema[a] and typ = sch[:type]) ?  "is not a valid #{typ}" : "is a string"
-          end
+          validatable_attributes_for_type(:not_string, atts, opts){|a,v,m| validation_error_message(m, (db_schema[a]||{})[:type]) if v.is_a?(String)}
         end
     
         # Check attribute value(s) string representation is a valid float.
         def validates_numeric(atts, opts={})
-          validatable_attributes(atts, opts) do |a,v,m|
+          validatable_attributes_for_type(:numeric, atts, opts) do |a,v,m|
             begin
               Kernel.Float(v.to_s)
               nil
             rescue
-              m || 'is not a number'
+              validation_error_message(m)
             end
           end
         end
     
         # Check attribute value(s) is not considered blank by the database, but allow false values.
         def validates_presence(atts, opts={})
-          validatable_attributes(atts, opts){|a,v,m| (m || "is not present") if model.db.send(:blank_object?, v) && v != false}
+          validatable_attributes_for_type(:presence, atts, opts){|a,v,m| validation_error_message(m) if model.db.send(:blank_object?, v) && v != false}
         end
         
         # Checks that there are no duplicate values in the database for the given
@@ -132,7 +154,11 @@ module Sequel
         # Possible Options:
         # * :message - The message to use (default: 'is already taken')
         def validates_unique(*atts)
-          message = (atts.pop[:message] if atts.last.is_a?(Hash)) || 'is already taken'
+          opts = default_validation_helpers_options(:unique)
+          if atts.last.is_a?(Hash)
+            opts = opts.merge(atts.pop)
+          end
+          message = validation_error_message(opts[:message])
           atts.each do |a|
             ds = model.filter(Array(a).map{|x| [x, send(x)]})
             ds = yield(ds) if block_given?
@@ -141,6 +167,14 @@ module Sequel
         end
         
         private
+        
+        # The default options hash for the given type of validation.  Can
+        # be overridden on a per-model basis for different per model defaults.
+        # The hash return must include a :message option that is either a
+        # proc or string.
+        def default_validation_helpers_options(type)
+          DEFAULT_OPTIONS[type]
+        end
 
         # Skip validating any attribute that matches one of the allow_* options.
         # Otherwise, yield the attribute, value, and passed option :message to
@@ -158,6 +192,19 @@ module Sequel
             end
           end
         end
+        
+        # Merge the given options with the default options for the given type
+        # and call validatable_attributes with the merged options.
+        def validatable_attributes_for_type(type, atts, opts, &block)
+          validatable_attributes(atts, default_validation_helpers_options(type).merge(opts), &block)
+        end
+        
+        # The validation error message to use, as a string.  If message
+        # is a Proc, call it with the args.  Otherwise, assume it is a string and
+        # return it.
+        def validation_error_message(message, *args)
+          message.is_a?(Proc) ? message.call(*args) : message
+        end
       end
     end
   end

data/lib/sequel/sql.rb

@@ -6,6 +6,19 @@ module Sequel
     class BasicObject
       (instance_methods - %w"__id__ __send__ instance_eval == equal?").each{|m| undef_method(m)}
     end
+  else
+    # If on 1.9, create a Sequel::BasicObject class that is just like the
+    # default BasicObject class, except that missing constants are resolved in
+    # Object.  This allows the virtual row support to work with classes
+    # without prefixing them with ::, such as:
+    #
+    #   DB[:bonds].filter{maturity_date > Time.now}
+    class BasicObject < ::BasicObject
+      # Lookup missing constants in ::Object
+      def self.const_missing(name)
+        ::Object.const_get(name)
+      end
+    end
   end
 
   class LiteralString < ::String
@@ -36,6 +49,11 @@ module Sequel
       def lit
         self
       end
+      
+      # Alias for to_s
+      def sql_literal(ds)
+        to_s(ds)
+      end
     end
 
     # Represents a complex SQL expression, with a given operator and one
@@ -652,6 +670,9 @@ module Sequel
     # required for the prepared statement support
     class PlaceholderLiteralString < Expression
       # The arguments that will be subsituted into the placeholders.
+      # Either an array of unnamed placeholders (which will be substituted in
+      # order for ? characters), or a hash of named placeholders (which will be
+      # substituted for :key phrases).
       attr_reader :args
 
       # The literal string containing placeholders
@@ -663,7 +684,7 @@ module Sequel
       # Create an object with the given string, placeholder arguments, and parens flag.
       def initialize(str, args, parens=false)
         @str = str
-        @args = args
+        @args = args.is_a?(Array) && args.length == 1 && (v = args.at(0)).is_a?(Hash) ? v : args
         @parens = parens
       end
 
@@ -783,6 +804,7 @@ module Sequel
     class SQLArray < Expression
       # The array of objects this SQLArray wraps
       attr_reader :array
+      alias to_a array
 
       # Create an object with the given array.
       def initialize(array)

data/lib/sequel/version.rb

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

data/spec/adapters/mssql_spec.rb

@@ -6,6 +6,32 @@ unless defined?(MSSQL_DB)
 end
 INTEGRATION_DB = MSSQL_DB unless defined?(INTEGRATION_DB)
 
+def MSSQL_DB.sqls
+  (@sqls ||= [])
+end
+logger = Object.new
+def logger.method_missing(m, msg)
+  MSSQL_DB.sqls << msg
+end
+MSSQL_DB.logger = logger
+
+MSSQL_DB.create_table! :test do
+  text :name
+  integer :value, :index => true
+end
+MSSQL_DB.create_table! :test2 do
+  text :name
+  integer :value
+end
+MSSQL_DB.create_table! :test3 do
+  integer :value
+  timestamp :time
+end
+MSSQL_DB.create_table! :test4 do
+  varchar :name, :size => 20
+  varbinary :value
+end
+
 context "A MSSQL database" do
   before do
     @db = MSSQL_DB
@@ -27,6 +53,17 @@ context "A MSSQL database" do
   end
 end
 
+context "MSSQL Dataset#join_table" do
+  specify "should emulate the USING clause with ON" do
+    MSSQL_DB[:items].join(:categories, [:id]).sql.should ==
+      'SELECT * FROM ITEMS INNER JOIN CATEGORIES ON (CATEGORIES.ID = ITEMS.ID)'
+    MSSQL_DB[:items].join(:categories, [:id1, :id2]).sql.should ==
+      'SELECT * FROM ITEMS INNER JOIN CATEGORIES ON ((CATEGORIES.ID1 = ITEMS.ID1) AND (CATEGORIES.ID2 = ITEMS.ID2))'
+    MSSQL_DB[:items___i].join(:categories___c, [:id]).sql.should ==
+      'SELECT * FROM ITEMS AS I INNER JOIN CATEGORIES AS C ON (C.ID = I.ID)'
+  end
+end
+
 context "MSSQL Dataset#output" do
   before do
     @db = MSSQL_DB
@@ -39,21 +76,42 @@ context "MSSQL Dataset#output" do
     @db.drop_table(:out)
   end
 
-  specify "should format OUTPUT clauses for DELETE statements" do
+  specify "should format OUTPUT clauses without INTO for DELETE statements" do
+    @ds.output(nil, [:deleted__name, :deleted__value]).delete_sql.should =~
+      /DELETE FROM ITEMS OUTPUT DELETED.(NAME|VALUE), DELETED.(NAME|VALUE)/
+    @ds.output(nil, [:deleted.*]).delete_sql.should =~
+      /DELETE FROM ITEMS OUTPUT DELETED.*/
+  end
+  
+  specify "should format OUTPUT clauses with INTO for DELETE statements" do
     @ds.output(:out, [:deleted__name, :deleted__value]).delete_sql.should =~
       /DELETE FROM ITEMS OUTPUT DELETED.(NAME|VALUE), DELETED.(NAME|VALUE) INTO OUT/
     @ds.output(:out, {:name => :deleted__name, :value => :deleted__value}).delete_sql.should =~
       /DELETE FROM ITEMS OUTPUT DELETED.(NAME|VALUE), DELETED.(NAME|VALUE) INTO OUT \((NAME|VALUE), (NAME|VALUE)\)/
   end
 
-  specify "should format OUTPUT clauses for INSERT statements" do
+  specify "should format OUTPUT clauses without INTO for INSERT statements" do
+    @ds.output(nil, [:inserted__name, :inserted__value]).insert_sql(:name => "name", :value => 1).should =~
+      /INSERT INTO ITEMS \((NAME|VALUE), (NAME|VALUE)\) OUTPUT INSERTED.(NAME|VALUE), INSERTED.(NAME|VALUE) VALUES \((N'name'|1), (N'name'|1)\)/
+    @ds.output(nil, [:inserted.*]).insert_sql(:name => "name", :value => 1).should =~
+      /INSERT INTO ITEMS \((NAME|VALUE), (NAME|VALUE)\) OUTPUT INSERTED.* VALUES \((N'name'|1), (N'name'|1)\)/
+  end
+
+  specify "should format OUTPUT clauses with INTO for INSERT statements" do
     @ds.output(:out, [:inserted__name, :inserted__value]).insert_sql(:name => "name", :value => 1).should =~
       /INSERT INTO ITEMS \((NAME|VALUE), (NAME|VALUE)\) OUTPUT INSERTED.(NAME|VALUE), INSERTED.(NAME|VALUE) INTO OUT VALUES \((N'name'|1), (N'name'|1)\)/
     @ds.output(:out, {:name => :inserted__name, :value => :inserted__value}).insert_sql(:name => "name", :value => 1).should =~
       /INSERT INTO ITEMS \((NAME|VALUE), (NAME|VALUE)\) OUTPUT INSERTED.(NAME|VALUE), INSERTED.(NAME|VALUE) INTO OUT \((NAME|VALUE), (NAME|VALUE)\) VALUES \((N'name'|1), (N'name'|1)\)/
   end
 
-  specify "should format OUTPUT clauses for UPDATE statements" do
+  specify "should format OUTPUT clauses without INTO for UPDATE statements" do
+    @ds.output(nil, [:inserted__name, :deleted__value]).update_sql(:value => 2).should =~
+      /UPDATE ITEMS SET VALUE = 2 OUTPUT (INSERTED.NAME|DELETED.VALUE), (INSERTED.NAME|DELETED.VALUE)/
+    @ds.output(nil, [:inserted.*]).update_sql(:value => 2).should =~
+      /UPDATE ITEMS SET VALUE = 2 OUTPUT INSERTED.*/
+  end
+
+  specify "should format OUTPUT clauses with INTO for UPDATE statements" do
     @ds.output(:out, [:inserted__name, :deleted__value]).update_sql(:value => 2).should =~
       /UPDATE ITEMS SET VALUE = 2 OUTPUT (INSERTED.NAME|DELETED.VALUE), (INSERTED.NAME|DELETED.VALUE) INTO OUT/
     @ds.output(:out, {:name => :inserted__name, :value => :deleted__value}).update_sql(:value => 2).should =~
@@ -116,26 +174,26 @@ context "MSSQL dataset" do
       before do
         @db = @db.clone
         class << @db
-          attr_reader :sqls
+          attr_reader :import_sqls
 
           def execute(sql, opts={})
-            @sqls ||= []
-            @sqls << sql
+            @import_sqls ||= []
+            @import_sqls << sql
           end
           alias execute_dui execute
 
           def transaction(opts={})
-            @sqls ||= []
-            @sqls << 'BEGIN'
+            @import_sqls ||= []
+            @import_sqls << 'BEGIN'
             yield
-            @sqls << 'COMMIT'
+            @import_sqls << 'COMMIT'
           end
         end
       end
 
       specify "should prepend INSERT statements with WITH clause" do
         @db[:items].with(:items, @db[:inventory].group(:type)).import([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2)
-        @db.sqls.should == [
+        @db.import_sqls.should == [
           'BEGIN',
           "WITH ITEMS AS (SELECT * FROM INVENTORY GROUP BY TYPE) INSERT INTO ITEMS (X, Y) SELECT 1, 2 UNION ALL SELECT 3, 4",
           'COMMIT',
@@ -260,3 +318,31 @@ describe "Common Table Expressions" do
   end
 end
 
+context "MSSSQL::Dataset#insert" do
+  before do
+    @db = MSSQL_DB
+    @db.create_table!(:test5){primary_key :xid; Integer :value}
+    @db.sqls.clear
+    @ds = @db[:test5]
+  end
+  after do
+    @db.drop_table(:test5) rescue nil
+  end
+
+  specify "should have insert_select return nil if disable_insert_output is used" do
+    @ds.disable_insert_output.insert_select(:value=>10).should == nil
+  end
+
+  specify "should have insert_select insert the record and return the inserted record" do
+    @ds.meta_def(:server_version){80201}
+    h = @ds.insert_select(:value=>10)
+    h[:value].should == 10
+    @ds.first(:xid=>h[:xid])[:value].should == 10
+  end
+end
+
+context "MSSSQL::Dataset#disable_insert_output" do
+  specify "should play nicely with simple_select_all?" do
+    MSSQL_DB[:test].disable_insert_output.send(:simple_select_all?).should == true
+  end
+end