sequel 4.42.1 → 4.43.0

data/spec/extensions/identifier_mangling_spec.rb

@@ -14,6 +14,13 @@ describe "identifier_mangling extension" do
     db.quote_identifiers?.must_equal true
   end
 
+  it "should respect the :quote_identifiers setting" do
+    db = Sequel::Database.new(:identifier_mangling=>true)
+    db.quote_identifiers?.must_equal false
+    db.quote_identifiers = true
+    db.quote_identifiers?.must_equal true
+  end
+
   it "should upcase on input and downcase on output by default" do
     db = Sequel::Database.new(:identifier_mangling=>true)
     db.send(:identifier_input_method_default).must_equal :upcase

data/spec/extensions/instance_filters_spec.rb

@@ -39,6 +39,7 @@ describe "instance_filters plugin" do
 
     @p = @c.load(:id=>1, :name=>'John', :num=>1)
     @p.instance_variable_set(:@this, @p.this.with_numrows(1))
+    @c.instance_variable_set(:@fast_instance_delete_sql, nil)
     @p.destroy
     DB.sqls.must_equal ["DELETE FROM people WHERE (id = 1)"]
     @p.instance_filter(:name=>'Jim')

data/spec/extensions/migration_spec.rb

@@ -772,4 +772,23 @@ describe "Sequel::TimestampMigrator" do
     Sequel::TimestampMigrator.run(@db, "spec/files/transaction_unspecified_migrations", :use_transactions=>false)
     @db.sqls.must_equal ["SELECT NULL AS nil FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)", "SELECT NULL AS nil FROM schema_info LIMIT 1", "SELECT filename FROM schema_migrations ORDER BY filename", "CREATE TABLE sm11111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_alt_basic.rb')", "CREATE TABLE sm (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_basic.rb')"]
   end
+
+  it "should use shorter primary key field on MySQL if creating schema migrations table fails" do
+    def @db.database_type; :mysql end
+    def @db.execute_ddl(sql, *)
+      super
+      raise Sequel::DatabaseError, "Specified key was too long; max key length is 767 bytes" if sql =~ /varchar\(255\)/
+    end
+    Sequel::TimestampMigrator.run(@db, "spec/files/transaction_unspecified_migrations", :use_transactions=>false)
+    @db.sqls.must_equal ["SELECT NULL AS nil FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)", "CREATE TABLE schema_migrations (filename varchar(190) PRIMARY KEY)",  "SELECT NULL AS nil FROM schema_info LIMIT 1", "SELECT filename FROM schema_migrations ORDER BY filename", "CREATE TABLE sm11111 (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('001_create_alt_basic.rb')", "CREATE TABLE sm (smc1 integer)", "INSERT INTO schema_migrations (filename) VALUES ('002_create_basic.rb')"]
+  end
+
+  it "should not use shorter primary key field on other databases if creating schema migrations table fails" do
+    def @db.execute_ddl(sql, *)
+      super
+      raise Sequel::DatabaseError, "Specified key was too long; max key length is 767 bytes" if sql =~ /varchar\(255\)/
+    end
+    proc{Sequel::TimestampMigrator.run(@db, "spec/files/transaction_unspecified_migrations", :use_transactions=>false)}.must_raise Sequel::DatabaseError
+    @db.sqls.must_equal ["SELECT NULL AS nil FROM schema_migrations LIMIT 1", "CREATE TABLE schema_migrations (filename varchar(255) PRIMARY KEY)"]
+  end
 end

data/spec/extensions/pg_array_spec.rb

@@ -330,6 +330,11 @@ describe "pg_array extension" do
     @db.literal(Sequel::Postgres::PG_TYPES[3].call('{}')).must_equal "'{}'::blah[]"
   end
 
+  it "should not support registering custom array types on a per-Database basis for frozen databases" do
+    @db.freeze
+    proc{@db.register_array_type('banana', :oid=>7865){|s| s}}.must_raise RuntimeError, TypeError
+  end
+
   it "should support registering custom array types on a per-Database basis" do
     @db.register_array_type('banana', :oid=>7865){|s| s}
     @db.typecast_value(:banana_array, []).class.must_equal(Sequel::Postgres::PGArray)

data/spec/extensions/pg_range_spec.rb

@@ -170,6 +170,11 @@ describe "pg_range extension" do
     Sequel::Postgres::PG_TYPES[331].call('[1,3)').must_be_kind_of(@R)
   end
 
+  it "should not support registering custom range types on a per-Database basis for frozen databases" do
+    @db.freeze
+    proc{@db.register_range_type('banana', :oid=>7865){|s| s}}.must_raise RuntimeError, TypeError
+  end
+
   it "should support registering custom range types on a per-Database basis" do
     @db.register_range_type('banana', :oid=>7865){|s| s}
     @db.typecast_value(:banana, '[1,2]').class.must_equal(Sequel::Postgres::PGRange)

data/spec/extensions/pg_row_spec.rb

@@ -231,6 +231,15 @@ describe "pg_row extension" do
     @db.literal(p1.call('(1,b)')).must_equal "ROW(1, 'bb')::foo.bar"
   end
 
+  it "should not allow registering on a frozen database" do
+    @db.conversion_procs[4] = proc{|s| s.to_i}
+    @db.conversion_procs[5] = proc{|s| s * 2}
+    @db.fetch = [[], [{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
+    c = proc{|h| [h]}
+    @db.freeze
+    proc{@db.register_row_type(:foo, :converter=>c)}.must_raise RuntimeError, TypeError
+  end
+
   it "should allow registering with a custom converter" do
     @db.conversion_procs[4] = proc{|s| s.to_i}
     @db.conversion_procs[5] = proc{|s| s * 2}

data/spec/extensions/prepared_statements_associations_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::PreparedStatementsAssociations" do
   before do
-    @db = Sequel.mock
+    @db = Sequel.mock(:servers=>{:foo=>{}})
     @db.extend_datasets do
       def select_sql
         sql = super
@@ -52,6 +52,43 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
     @db.sqls.must_equal ["SELECT tags.id, tags.id2 FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) WHERE (albums.artist_id = 1) LIMIT 1 -- prepared"]
   end
 
+  it "should run correct shard for associations when also using sharding plugin" do
+    @Artist.plugin :sharding
+    @Album.plugin :sharding
+
+    @Artist.load(:id=>1).set_server(:foo).albums
+    @db.sqls.must_equal ["SELECT id, artist_id, id2, artist_id2 FROM albums WHERE (albums.artist_id = 1) -- prepared -- foo"]
+
+    @Artist.load(:id=>1).set_server(:foo).album
+    @db.sqls.must_equal ["SELECT id, artist_id, id2, artist_id2 FROM albums WHERE (albums.artist_id = 1) LIMIT 1 -- prepared -- foo"]
+
+    @Album.load(:id=>1, :artist_id=>2).set_server(:foo).artist
+    @db.sqls.must_equal ["SELECT id, id2 FROM artists WHERE (artists.id = 2) LIMIT 1 -- prepared -- foo"]
+
+    @Album.load(:id=>1, :artist_id=>2).set_server(:foo).tags
+    @db.sqls.must_equal ["SELECT tags.id, tags.id2 FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 1) -- prepared -- foo"]
+
+    @Album.load(:id=>1, :artist_id=>2).set_server(:foo).tag
+    @db.sqls.must_equal ["SELECT tags.id, tags.id2 FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 1) LIMIT 1 -- prepared -- foo"]
+
+    @Artist.load(:id=>1).set_server(:foo).tags
+    @db.sqls.must_equal ["SELECT tags.id, tags.id2 FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) WHERE (albums.artist_id = 1) -- prepared -- foo"]
+
+    @Artist.load(:id=>1).set_server(:foo).tag
+    @db.sqls.must_equal ["SELECT tags.id, tags.id2 FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) WHERE (albums.artist_id = 1) LIMIT 1 -- prepared -- foo"]
+
+    @Tag.plugin :sharding
+    @Tag.plugin :prepared_statements_associations
+    @Tag.many_to_many :albums, :class=>@Album, :join_table=>:albums_tags, :left_key=>:tag_id
+    @Tag.load(:id=>1).set_server(:foo).albums
+    @db.sqls.must_equal ["SELECT albums.id, albums.artist_id, albums.id2, albums.artist_id2 FROM albums INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE (albums_tags.tag_id = 1) -- prepared -- foo"]
+  end
+
+  it "should not override the shard for associations if not using the sharding plugin" do
+    @Artist.load(:id=>1).set_server(:foo).albums
+    @db.sqls.must_equal ["SELECT id, artist_id, id2, artist_id2 FROM albums WHERE (albums.artist_id = 1) -- prepared"]
+  end
+
   it "should run correct SQL for composite key associations" do
     @Artist.one_to_many :albums, :class=>@Album, :key=>[:artist_id, :artist_id2], :primary_key=>[:id, :id2]
     @Artist.one_to_one :album, :class=>@Album, :key=>[:artist_id, :artist_id2], :primary_key=>[:id, :id2]
@@ -156,4 +193,11 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
     @Artist.load(:id=>1).oalbums
     @db.sqls.must_equal ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
   end
+
+  it "should work correctly when using an instance specific association" do
+    tag = @Tag 
+    @Artist.many_to_one :tag, :key=>nil, :read_only=>true, :dataset=>proc{tag.where(:id=>id).limit(1)}, :reciprocal=>nil, :reciprocal_type=>nil
+    @Artist.load(:id=>1).tag.must_be_nil
+    @db.sqls.must_equal ["SELECT * FROM tags WHERE (id = 1) LIMIT 1"]
+  end
 end

data/spec/extensions/prepared_statements_spec.rb

@@ -5,6 +5,7 @@ describe "prepared_statements plugin" do
     @db = Sequel.mock(:fetch=>{:id=>1, :name=>'foo', :i=>2}, :autoid=>proc{|sql| 1}, :numrows=>1, :servers=>{:read_only=>{}})
     @c = Class.new(Sequel::Model(@db[:people]))
     @c.columns :id, :name, :i
+    @c.set_primary_key :id
     @columns = "id, name, i"
     @c.plugin :prepared_statements
     @p = @c.load(:id=>1, :name=>'foo', :i=>2)
@@ -12,11 +13,6 @@ describe "prepared_statements plugin" do
     @db.sqls
   end
 
-  it "should correctly lookup by primary key" do
-    @c[1].must_equal @p
-    @db.sqls.must_equal ["SELECT id, name, i FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
-  end 
-
   it "should correctly lookup by primary key for joined dataset" do
     @c.dataset = @c.dataset.from(:people, :people2)
     @db.sqls
@@ -24,22 +20,46 @@ describe "prepared_statements plugin" do
     @db.sqls.must_equal ["SELECT * FROM people, people2 WHERE (people.id = 1) LIMIT 1 -- read_only"]
   end 
 
-  prepared_statements_spec = shared_description do
-    it "should correctly delete instance" do
-      @p.destroy.must_equal @p
-      @db.sqls.must_equal ["DELETE FROM people WHERE (id = 1)"]
-    end
+  it "should use prepared statements for pk lookups only if default is not optimized" do
+    @c.send(:use_prepared_statements_for_pk_lookup?).must_equal false 
+    @c.set_primary_key [:id, :name]
+    @c.send(:use_prepared_statements_for_pk_lookup?).must_equal true
+    @c.set_primary_key :id
+    @c.dataset = @c.dataset.from(:people, :people2)
+    @c.send(:use_prepared_statements_for_pk_lookup?).must_equal false
+    @c.dataset = @db[:people].select(:id, :name, :i)
+    @c.send(:use_prepared_statements_for_pk_lookup?).must_equal true
+  end
+
+  it "should use prepared statements for refreshes if default is not optimized" do
+    @p.send(:use_prepared_statements_for?, :refresh).must_equal false 
+    @c.set_primary_key [:id, :name]
+    @p.send(:use_prepared_statements_for?, :refresh).must_equal true
+  end
+
+  it "should use prepared statements for deletes if default is not optimized" do
+    @p.send(:use_prepared_statements_for?, :delete).must_equal false 
+    @c.set_primary_key [:id, :name]
+    @p.send(:use_prepared_statements_for?, :delete).must_equal true
+  end
 
+  it "should use prepared statements for deletes if default on Oracle and DB2" do
+    def @db.database_type; :oracle end
+    @p.send(:use_prepared_statements_for?, :delete).must_equal true
+    def @db.database_type; :db2 end
+    @p.send(:use_prepared_statements_for?, :delete).must_equal true
+  end
+
+  it "should raise Error for unsupported prepared statement types" do
+    proc{@p.send(:use_prepared_statements_for?, :foo)}.must_raise Sequel::Error
+  end
+
+  prepared_statements_spec = shared_description do
     it "should correctly update instance" do
       @p.update(:name=>'bar').must_equal @c.load(:id=>1, :name=>'bar', :i => 2)
       @db.sqls.must_equal ["UPDATE people SET name = 'bar' WHERE (id = 1)"]
     end
 
-    it "should correctly create instance" do
-      @c.create(:name=>'foo').must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
-      @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo')", "SELECT #{@columns} FROM people WHERE (id = 1) LIMIT 1"]
-    end
-
     it "should correctly create instance if dataset supports insert_select" do
       @c.dataset_module do
         def supports_insert_select?
@@ -61,51 +81,128 @@ describe "prepared_statements plugin" do
     end
   end
 
-  describe "when #use_prepared_statements_for? returns false" do
+  describe "when #use_prepared_statements_for? returns true" do
     before do
-      @columns = "*"
-      @c.class_eval{def use_prepared_statements_for?(type) false end}
+      @c.class_eval do
+        def self.use_prepared_statements_for_pk_lookup?; true end
+        def use_prepared_statements_for?(type) true end
+      end
     end
 
     include prepared_statements_spec
-  end
 
-  include prepared_statements_spec
+    it "should correctly create instance" do
+      @c.create(:name=>'foo').must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
+      @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo')", "SELECT #{@columns} FROM people WHERE (id = 1) LIMIT 1"]
+    end
 
-  it "should work correctly when subclassing" do
-    c = Class.new(@c)
-    c[1].must_equal c.load(:id=>1, :name=>'foo', :i=>2)
-    @db.sqls.must_equal ["SELECT id, name, i FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
-  end 
+    it "should correctly lookup by primary key" do
+      @c[1].must_equal @p
+      @db.sqls.must_equal ["SELECT id, name, i FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
+    end 
 
-  describe " with placeholder type specifiers" do 
-    before do
-      @ds = @ds.with_extend{def requires_placeholder_type_specifiers?; true end}
+    it "should correctly delete instance" do
+      @p.destroy.must_equal @p
+      @db.sqls.must_equal ["DELETE FROM people WHERE (id = 1)"]
+    end
+
+    it "should correctly delete instance when specifying server" do
+      @p.set_server(:read_only).destroy.must_equal @p
+      @db.sqls.must_equal ["DELETE FROM people WHERE (id = 1) -- read_only"]
+    end
+
+    it "should correctly update instance when specifying server" do
+      @p.set_server(:read_only).update(:name=>'bar').must_equal @c.load(:id=>1, :name=>'bar', :i => 2)
+      @db.sqls.must_equal ["UPDATE people SET name = 'bar' WHERE (id = 1) -- read_only"]
     end
 
-    it "should correctly handle without schema type" do
+    it "should correctly create instance when specifying server" do
+      @c.new(:name=>'foo').set_server(:read_only).save.must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
+      @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo') -- read_only", "SELECT #{@columns} FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
+    end
+
+    it "should correctly create instance if dataset supports insert_select when specifying server" do
+      @c.dataset_module do
+        def supports_insert_select?
+          true
+        end
+        def supports_returning?(type)
+          true
+        end
+        def insert_select(h)
+          cache_set(:_fetch, :id=>1, :name=>'foo', :i => 2)
+          server(:default).with_sql_first(insert_select_sql(h))
+        end
+        def insert_select_sql(*v)
+          "#{insert_sql(*v)} RETURNING #{(opts[:returning] && !opts[:returning].empty?) ? opts[:returning].map{|c| literal(c)}.join(', ') : '*'}"
+        end
+      end
+      @c.new(:name=>'foo').set_server(:read_only).save.must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
+      @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo') RETURNING #{@columns} -- read_only"]
+    end
+
+    it "should work correctly when subclassing" do
+      c = Class.new(@c)
+      c[1].must_equal c.load(:id=>1, :name=>'foo', :i=>2)
+      @db.sqls.must_equal ["SELECT id, name, i FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
+    end 
+
+    it "should correctly handle without schema type when placeholder type specifiers are required" do
+      @c.dataset = @ds.with_extend{def requires_placeholder_type_specifiers?; true end}
       @c[1].must_equal @p
       @db.sqls.must_equal ["SELECT id, name, i FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
     end
 
-    it "should correctly handle with schema type" do
-      @c.db_schema[:id][:type] = :integer
-      ds = @c.send(:prepared_lookup).with_extend do
-        def literal_symbol_append(sql, v)
-          if @opts[:bind_vars] and match = /\A\$(.*)\z/.match(v.to_s)
-            s = match[1].split('__')[0].to_sym
-            if prepared_arg?(s)
-              literal_append(sql, prepared_arg(s))
-            else
-              sql << v.to_s
+    it "should correctly handle with schema type when placeholder type specifiers are required" do
+      @c.dataset = @ds.with_extend do
+        def requires_placeholder_type_specifiers?; true end
+        def prepare(*)
+          super.with_extend do 
+            def literal_symbol_append(sql, v)
+              if @opts[:bind_vars] && (match = /\A\$(.*)\z/.match(v.to_s))
+                s = match[1].split('__')[0].to_sym
+                if prepared_arg?(s)
+                  literal_append(sql, prepared_arg(s))
+                else
+                  sql << v.to_s
+                end
+              else
+                super
+              end
             end
-          else
-            super
           end
         end
       end
+      @c.db_schema[:id][:type] = :integer
       @c[1].must_equal @p
       @db.sqls.must_equal ["SELECT id, name, i FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
     end 
   end
+
+  describe "when #use_prepared_statements_for? returns false" do
+    before do
+      @columns = "*"
+      @c.class_eval do
+        def self.use_prepared_statements_for_pk_lookup?; false end
+        def use_prepared_statements_for?(type) false end
+      end
+    end
+
+    include prepared_statements_spec
+
+    it "should correctly create instance" do
+      @c.create(:name=>'foo').must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
+      @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo')", "SELECT #{@columns} FROM people WHERE id = 1"]
+    end
+
+    it "should correctly lookup by primary key" do
+      @c[1].must_equal @p
+      @db.sqls.must_equal ["SELECT * FROM people WHERE id = 1 -- read_only"]
+    end 
+
+    it "should correctly delete instance" do
+      @p.destroy.must_equal @p
+      @db.sqls.must_equal ["DELETE FROM people WHERE id = 1"]
+    end
+  end
 end

data/spec/extensions/prepared_statements_with_pk_spec.rb

@@ -28,4 +28,11 @@ describe "prepared_statements_with_pk plugin" do
     @c.dataset.filter{id > 2}[1].must_equal @p
     @c.db.sqls.must_equal ["SELECT * FROM people WHERE ((id > 2) AND (people.id = 1)) LIMIT 1 -- read_only"]
   end
+
+  it "should respect explicitly set server" do
+    @c.dataset.filter(:name=>'foo')[1].must_equal @p
+    @c.db.sqls.must_equal ["SELECT * FROM people WHERE ((name = 'foo') AND (people.id = 1)) LIMIT 1 -- read_only"]
+    @c.dataset.server(:default).filter(:name=>'foo')[1].must_equal @p
+    @c.db.sqls.must_equal ["SELECT * FROM people WHERE ((name = 'foo') AND (people.id = 1)) LIMIT 1"]
+  end
 end

data/spec/extensions/serialization_spec.rb

@@ -108,7 +108,7 @@ describe "Serialization plugin" do
     DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
       "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)",
       "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')",
-      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+      "SELECT * FROM items WHERE id = 10"]
   end
 
   it "should translate values to and from marshal serialization format using accessor methods" do
@@ -128,7 +128,7 @@ describe "Serialization plugin" do
     DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
       "UPDATE items SET abc = '#{[Marshal.dump(23)].pack('m')}' WHERE (id = 1)",
       "INSERT INTO items (abc) VALUES ('#{[Marshal.dump([1, 2, 3])].pack('m')}')",
-      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+      "SELECT * FROM items WHERE id = 10"]
   end
   
   it "should handle old non-base-64 encoded marshal serialization format" do
@@ -169,7 +169,7 @@ describe "Serialization plugin" do
     DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
       "UPDATE items SET abc = '#{[23].to_json}' WHERE (id = 1)",
       "INSERT INTO items (abc) VALUES ('#{[1,2,3].to_json}')",
-      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+      "SELECT * FROM items WHERE id = 10"]
   end
 
   it "should translate values to and from arbitrary callables using accessor methods" do
@@ -190,7 +190,7 @@ describe "Serialization plugin" do
     DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
       "UPDATE items SET abc = 'oof' WHERE (id = 1)",
       "INSERT INTO items (abc) VALUES ('rab')",
-      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+      "SELECT * FROM items WHERE id = 10"]
   end
 
   it "should handle registration of custom serializer/deserializer pairs" do
@@ -213,7 +213,7 @@ describe "Serialization plugin" do
     DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
       "UPDATE items SET abc = 'oof' WHERE (id = 1)",
       "INSERT INTO items (abc) VALUES ('rab')",
-      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+      "SELECT * FROM items WHERE id = 10"]
   end
 
   it "should copy serialization formats and columns to subclasses" do
@@ -233,7 +233,7 @@ describe "Serialization plugin" do
     DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
       "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)",
       "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')",
-      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+      "SELECT * FROM items WHERE id = 10"]
   end
 
   it "should clear the deserialized columns when refreshing" do