sequel_core 2.1.0 → 2.2.0

data/spec/adapters/mysql_spec.rb

@@ -1,7 +1,10 @@
 require File.join(File.dirname(__FILE__), '../spec_helper.rb')
 
+unless defined?(MYSQL_USER)
+  MYSQL_USER = 'root'
+end
 unless defined?(MYSQL_DB)
-  MYSQL_URL = (ENV['SEQUEL_MY_SPEC_DB']||'mysql://root@localhost/sandbox') unless defined? MYSQL_URL
+  MYSQL_URL = (ENV['SEQUEL_MY_SPEC_DB']||"mysql://#{MYSQL_USER}@localhost/sandbox") unless defined? MYSQL_URL
   MYSQL_DB = Sequel.connect(MYSQL_URL)
 end
 unless defined?(MYSQL_SOCKET_FILE)
@@ -36,6 +39,9 @@ context "A MySQL database" do
   setup do
     @db = MYSQL_DB
   end
+  teardown do
+    Sequel.convert_tinyint_to_bool = true
+  end
   
   specify "should provide disconnect functionality" do
     @db.tables
@@ -66,6 +72,9 @@ context "A MySQL database" do
 
   specify "should correctly parse the schema" do
     @db.schema(:booltest, :reload=>true).should == [[:value, {:type=>:boolean, :allow_null=>true, :max_chars=>nil, :default=>nil, :db_type=>"tinyint", :numeric_precision=>3}]]
+    
+    Sequel.convert_tinyint_to_bool = false
+    @db.schema(:booltest, :reload=>true).should == [[:value, {:type=>:integer, :allow_null=>true, :max_chars=>nil, :default=>nil, :db_type=>"tinyint", :numeric_precision=>3}]]
   end
 
   specify "should get the schema all database tables if no table name is used" do
@@ -248,6 +257,9 @@ context "MySQL datasets" do
   setup do
     @d = MYSQL_DB[:orders]
   end
+  teardown do
+    Sequel.convert_tinyint_to_bool = true
+  end
   
   specify "should correctly quote column references" do
     @d.quote_identifiers = true
@@ -255,22 +267,34 @@ context "MySQL datasets" do
     ack_stamp = Time.now - 15 * 60 # 15 minutes ago
     @d.query do
       select :market, :minute[:from_unixtime[:ack]].as(:minute)
-      where do
-        :ack > ack_stamp
-        :market == market
-      end
+      where {(:ack > ack_stamp) & {:market => market}}
       group_by :minute[:from_unixtime[:ack]]
     end.sql.should == \
       "SELECT `market`, minute(from_unixtime(`ack`)) AS `minute` FROM `orders` WHERE ((`ack` > #{@d.literal(ack_stamp)}) AND (`market` = 'ICE')) GROUP BY minute(from_unixtime(`ack`))"
   end
 
-  specify "should accept and return tinyints as bools" do
+  specify "should accept and return tinyints as bools or integers when configured to do so" do
     MYSQL_DB[:booltest].delete
     MYSQL_DB[:booltest] << {:value=>true}
     MYSQL_DB[:booltest].all.should == [{:value=>true}]
     MYSQL_DB[:booltest].delete
     MYSQL_DB[:booltest] << {:value=>false}
     MYSQL_DB[:booltest].all.should == [{:value=>false}]
+    
+    Sequel.convert_tinyint_to_bool = false
+    MYSQL_DB[:booltest].delete
+    MYSQL_DB[:booltest] << {:value=>true}
+    MYSQL_DB[:booltest].all.should == [{:value=>1}]
+    MYSQL_DB[:booltest].delete
+    MYSQL_DB[:booltest] << {:value=>false}
+    MYSQL_DB[:booltest].all.should == [{:value=>0}]
+    
+    MYSQL_DB[:booltest].delete
+    MYSQL_DB[:booltest] << {:value=>1}
+    MYSQL_DB[:booltest].all.should == [{:value=>1}]
+    MYSQL_DB[:booltest].delete
+    MYSQL_DB[:booltest] << {:value=>0}
+    MYSQL_DB[:booltest].all.should == [{:value=>0}]
   end
 end
 
@@ -466,17 +490,17 @@ end
 if %w'localhost 127.0.0.1 ::1'.include? MYSQL_URI.host
   context "A MySQL database" do
     specify "should accept a socket option" do
-      db = Sequel.mysql(MYSQL_DB_NAME, :host => 'localhost', :user => 'root', :socket => MYSQL_SOCKET_FILE)
+      db = Sequel.mysql(MYSQL_DB_NAME, :host => 'localhost', :user => MYSQL_USER, :socket => MYSQL_SOCKET_FILE)
       proc {db.test_connection}.should_not raise_error
     end
     
     specify "should accept a socket option without host option" do
-      db = Sequel.mysql(MYSQL_DB_NAME, :user => 'root', :socket => MYSQL_SOCKET_FILE)
+      db = Sequel.mysql(MYSQL_DB_NAME, :user => MYSQL_USER, :socket => MYSQL_SOCKET_FILE)
       proc {db.test_connection}.should_not raise_error
     end
     
     specify "should fail to connect with invalid socket" do
-      db = Sequel.mysql(MYSQL_DB_NAME, :host => 'localhost', :user => 'root', :socket => 'blah')
+      db = Sequel.mysql(MYSQL_DB_NAME, :host => 'localhost', :user => MYSQL_USER, :socket => 'blah')
       proc {db.test_connection}.should raise_error
     end
   end

data/spec/adapters/postgres_spec.rb

@@ -17,6 +17,10 @@ POSTGRES_DB.create_table! :test3 do
   integer :value
   timestamp :time
 end
+POSTGRES_DB.create_table! :test4 do
+  varchar :name, :size => 20
+  bytea :value
+end
 
 context "A PostgreSQL database" do
   setup do
@@ -43,6 +47,10 @@ context "A PostgreSQL database" do
       [:value, {:type=>:integer, :allow_null=>true, :max_chars=>nil, :default=>nil, :db_type=>"integer", :numeric_precision=>32}],
       [:time, {:type=>:datetime, :allow_null=>true, :max_chars=>nil, :default=>nil, :db_type=>"timestamp without time zone", :numeric_precision=>nil}]
     ]
+    @db.schema(:test4, :reload=>true).should == [
+      [:name, {:type=>:string, :allow_null=>true, :max_chars=>20, :default=>nil, :db_type=>"character varying", :numeric_precision=>nil}],
+      [:value, {:type=>:blob, :allow_null=>true, :max_chars=>nil, :default=>nil, :db_type=>"bytea", :numeric_precision=>nil}]
+    ]
   end
 
   specify "should get the schema all database tables if no table name is used" do
@@ -172,6 +180,12 @@ context "A PostgreSQL dataset" do
     @d.count.should == 1
   end
   
+  specify "should have #transaction yield the connection" do
+    POSTGRES_DB.transaction do |conn|
+      conn.should be_a_kind_of(Sequel::Postgres::Adapter)
+    end
+  end
+  
   specify "should correctly rollback transactions" do
     proc do
       POSTGRES_DB.transaction do
@@ -237,9 +251,27 @@ context "A PostgreSQL dataset" do
     @d.filter(:name => /^bc/).count.should == 1
   end
 
-  specify "should consider strings containing backslashes to be escaped string literals" do
-    @d.literal("\\dingo").should == "'\\\\dingo'"   # literally, E'\\dingo'
-    @d.literal("dingo").should == "'dingo'"
+  specify "should correctly escape strings" do
+    POSTGRES_DB['SELECT ? AS a', "\\dingo"].get(:a) == "\\dingo"
+  end
+
+  specify "should properly escape binary data" do
+    POSTGRES_DB['SELECT ? AS a', "\1\2\3".to_blob].get(:a) == "\1\2\3"
+  end
+
+  specify "should retrieve binary data as Blob object" do
+    d = POSTGRES_DB[:test4]
+    d << {:name => '123', :value => "\1\2\3".to_blob}
+    retrieved_binary_value = d[:name => '123'][:value]
+    retrieved_binary_value.should be_a_kind_of(::Sequel::SQL::Blob)
+    retrieved_binary_value.should == "\1\2\3"
+    retrieved_binary_value = d[:value => "\1\2\3".to_blob][:value]
+    retrieved_binary_value.should be_a_kind_of(::Sequel::SQL::Blob)
+    retrieved_binary_value.should == "\1\2\3"
+  end
+
+  specify "should properly receive binary data" do
+    POSTGRES_DB['SELECT ?::bytea AS a', "a"].get(:a) == "a"
   end
 end
 

data/spec/adapters/sqlite_spec.rb

@@ -387,8 +387,11 @@ context "A SQLite database" do
     @db[:test2].first.should == {:name => 'mmm', :value => 111, :xyz=>'000'}
   end
   
-  specify "should not support drop_column operations" do
-    proc {@db.drop_column :test2, :value}.should raise_error(Sequel::Error)
+  specify "should support drop_column operations" do
+    @db.drop_column :test2, :value
+    @db[:test2].columns.should == [:name]
+    @db[:test2] << {:name => 'mmm'}
+    @db[:test2].first.should == {:name => 'mmm'}
   end
   
   specify "should not support rename_column operations" do
@@ -398,4 +401,13 @@ context "A SQLite database" do
   specify "should not support set_column_type operations" do
     proc {@db.set_column_type :test2, :value, :integer}.should raise_error(Sequel::Error)
   end
+  
+  specify "should support add_index" do
+    @db.add_index :test2, :value, :unique => true
+    @db.add_index :test2, [:name, :value]
+  end
+  
+  specify "should not support drop_index" do
+    proc {@db.drop_index :test2, :value}.should raise_error(Sequel::Error)
+  end
 end  

data/spec/core_sql_spec.rb

@@ -111,6 +111,17 @@ context "String#lit" do
   end
 end
 
+context "String#to_blob" do
+  specify "should return a Blob object" do
+    'xyz'.to_blob.should be_a_kind_of(::Sequel::SQL::Blob)
+    'xyz'.to_blob.should == 'xyz'
+  end
+
+  specify "should retain binary data" do
+    "\1\2\3\4".to_blob.should == "\1\2\3\4"
+  end
+end
+
 context "String#split_sql" do
   specify "should split a string containing multiple statements" do
     "DROP TABLE a; DROP TABLE c".split_sql.should == \
@@ -212,6 +223,13 @@ context "Column references" do
   end
 end
 
+context "Blob" do
+  specify "#to_blob should return self" do
+    blob = "x".to_blob
+    blob.to_blob.object_id.should == blob.object_id
+  end
+end
+
 context "Symbol#*" do
   setup do
     @ds = Sequel::Dataset.new(nil)
@@ -228,9 +246,26 @@ context "Symbol#*" do
   end
 end
 
-context "Symbol#qualify" do
-  specify "should format a qualified column" do
-    :xyz.qualify(:abc).to_s(Sequel::Dataset.new(nil)).should == 'abc.xyz'
+context "Symbol" do
+  before do
+    @ds = Sequel::Dataset.new(nil)
+    @ds.quote_identifiers = true
+  end
+
+  specify "#identifier should format an identifier" do
+    @ds.literal(:xyz__abc.identifier).should == '"XYZ__ABC"'
+  end
+
+  specify "#qualify should format a qualified column" do
+    @ds.literal(:xyz.qualify(:abc)).should == '"ABC"."XYZ"'
+  end
+
+  specify "should be able to qualify an identifier" do
+    @ds.literal(:xyz.identifier.qualify(:xyz__abc)).should == '"XYZ__ABC"."XYZ"'
+  end
+
+  specify "should be able to specify a schema.table.column" do
+    @ds.literal(:column.qualify(:table__name.qualify(:schema))).should == '"SCHEMA"."TABLE__NAME"."COLUMN"'
   end
 end
 

data/spec/database_spec.rb

@@ -35,6 +35,15 @@ context "A new Database" do
     d.synchronize {|c| cc = c}
     cc.should == 1234
   end
+
+  specify "should respect the :quote_identifiers and :single_threaded options" do
+    db = Sequel::Database.new(:quote_identifiers=>false, :single_threaded=>true)
+    db.quote_identifiers?.should == false
+    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
+    db = Sequel::Database.new(:quote_identifiers=>true, :single_threaded=>false)
+    db.quote_identifiers?.should == true
+    db.pool.should be_a_kind_of(Sequel::ConnectionPool)
+  end
 end
 
 context "Database#connect" do
@@ -97,7 +106,7 @@ context "Database#dataset" do
     e.sql.should == 'SELECT * FROM miu'
   end
   
-  pt_specify "should provide a filtered #from dataset if a block is given" do
+  specify "should provide a filtered #from dataset if a block is given" do
     d = @db.from(:mau) {:x > 100}
     d.should be_a_kind_of(Sequel::Dataset)
     d.sql.should == 'SELECT * FROM mau WHERE (x > 100)'
@@ -587,6 +596,15 @@ context "A Database adapter with a scheme" do
     c.should be_a_kind_of(CCC)
     c.opts.should == {:adapter => :ccc, :database => 'mydb'}
   end
+
+  specify "should be accessible through Sequel.connect with URL parameters" do
+    c = Sequel.connect 'ccc://localhost/db?host=/tmp&user=test'
+    c.should be_a_kind_of(CCC)
+    c.opts[:host].should == '/tmp'
+    c.opts[:database].should == 'db'
+    c.opts[:user].should == 'test'
+  end
+
 end
 
 context "An unknown database scheme" do

data/spec/dataset_spec.rb

@@ -164,11 +164,6 @@ context "A simple dataset" do
       "UPDATE test SET name = 'abc'"
   end
 
-  pt_specify "should format an update statement with block" do
-    @dataset.update_sql {:x << :y}.should ==
-      "UPDATE test SET x = y"
-  end
-  
   specify "should be able to return rows for arbitrary SQL" do
     @dataset.select_sql(:sql => 'xxx yyy zzz').should ==
       "xxx yyy zzz"
@@ -271,7 +266,7 @@ context "Dataset#where" do
       "SELECT * FROM test WHERE ((a = 1) AND (d = 4))"
   end
       
-  pt_specify "should be composable using AND operator (for scoping) with block" do
+  specify "should be composable using AND operator (for scoping) with block" do
     @d3.where{:e < 5}.select_sql.should ==
       "SELECT * FROM test WHERE ((a = 1) AND (e < 5))"
   end
@@ -294,28 +289,11 @@ context "Dataset#where" do
       'SELECT * FROM test WHERE ((table.id >= 4) AND (table.id < 7))'
   end
 
-  pt_specify "should accept ranges with a block" do
-    @dataset.filter {:id == (4..7)}.sql.should ==
-      'SELECT * FROM test WHERE (id >= 4 AND id <= 7)'
-    @dataset.filter {:id.in?(4..7)}.sql.should ==
-      'SELECT * FROM test WHERE (id >= 4 AND id <= 7)'
-
-    @dataset.filter {:table__id == (4..7)}.sql.should ==
-      'SELECT * FROM test WHERE (table.id >= 4 AND table.id <= 7)'
-    @dataset.filter {:table__id.in?(4..7)}.sql.should ==
-      'SELECT * FROM test WHERE (table.id >= 4 AND table.id <= 7)'
-  end
-  
   specify "should accept nil" do
     @dataset.filter(:owner_id => nil).sql.should ==
       'SELECT * FROM test WHERE (owner_id IS NULL)'
   end
 
-  pt_specify "should accept nil with a block" do
-    @dataset.filter{:owner_id.nil?}.sql.should ==
-      'SELECT * FROM test WHERE (owner_id IS NULL)'
-  end
-  
   specify "should accept a subquery" do
     @dataset.filter('gdp > ?', @d1.select(:avg[:gdp])).sql.should ==
       "SELECT * FROM test WHERE (gdp > (SELECT avg(gdp) FROM test WHERE (region = 'Asia')))"
@@ -330,36 +308,24 @@ context "Dataset#where" do
       'SELECT * FROM test WHERE (EXISTS (SELECT * FROM test WHERE (price < 100)))'
   end
   
-  pt_specify "should accept proc expressions" do
+  specify "should accept proc expressions" do
     d = @d1.select(:avg[:gdp])
     @dataset.filter {:gdp > d}.sql.should ==
       "SELECT * FROM test WHERE (gdp > (SELECT avg(gdp) FROM test WHERE (region = 'Asia')))"
     
-    @dataset.filter {:id.in(4..7)}.sql.should ==
-      'SELECT * FROM test WHERE (id >= 4 AND id <= 7)'
-    
-    @dataset.filter {:c == 3}.sql.should ==
-      'SELECT * FROM test WHERE (c = 3)'
-      
-    @dataset.filter {:id == :items__id}.sql.should ==
-      'SELECT * FROM test WHERE (id = items.id)'
-      
     @dataset.filter {:a < 1}.sql.should ==
       'SELECT * FROM test WHERE (a < 1)'
 
-    @dataset.filter {:a != 1}.sql.should ==
-      'SELECT * FROM test WHERE (NOT (a = 1))'
-      
-    @dataset.filter {:a >= 1 && :b <= 2}.sql.should ==
+    @dataset.filter {(:a >= 1) & (:b <= 2)}.sql.should ==
       'SELECT * FROM test WHERE ((a >= 1) AND (b <= 2))'
       
     @dataset.filter {:c.like 'ABC%'}.sql.should ==
       "SELECT * FROM test WHERE (c LIKE 'ABC%')"
 
-    @dataset.filter {:c.like? 'ABC%'}.sql.should ==
+    @dataset.filter {:c.like 'ABC%'}.sql.should ==
       "SELECT * FROM test WHERE (c LIKE 'ABC%')"
 
-    @dataset.filter {:c.like? ['ABC%', '%XYZ']}.sql.should ==
+    @dataset.filter {:c.like 'ABC%', '%XYZ'}.sql.should ==
       "SELECT * FROM test WHERE ((c LIKE 'ABC%') OR (c LIKE '%XYZ'))"
   end
   
@@ -375,10 +341,18 @@ context "Dataset#where" do
       "SELECT * FROM test WHERE 'f'"
   end
 
-  pt_specify "should allow the use of blocks and arguments simultaneously" do
+  specify "should allow the use of blocks and arguments simultaneously" do
     @dataset.filter(:zz < 3){:yy > 3}.sql.should ==
       'SELECT * FROM test WHERE ((zz < 3) AND (yy > 3))'
   end
+
+  specify "should yield a VirtualRow to the block" do
+    x = nil
+    @dataset.filter{|r| x = r; false}
+    x.should be_a_kind_of(Sequel::SQL::VirtualRow)
+    @dataset.filter{|r| ((r.name < 'b') & {r.table__id => 1}) | r.is_active(r.blah, r.xx, r.x__y_z)}.sql.should ==
+      "SELECT * FROM test WHERE (((name < 'b') AND (table.id = 1)) OR is_active(blah, xx, x.y_z))"
+  end
 end
 
 context "Dataset#or" do
@@ -403,7 +377,7 @@ context "Dataset#or" do
       'SELECT * FROM test WHERE ((x = 1) OR (yy > 3))'
   end    
 
-  pt_specify "should accept blocks passed to filter" do
+  specify "should accept blocks passed to filter" do
     @d1.or{:yy > 3}.sql.should ==
       'SELECT * FROM test WHERE ((x = 1) OR (yy > 3))'
   end
@@ -416,7 +390,7 @@ context "Dataset#or" do
       'SELECT * FROM test WHERE (((x = 1) OR (y = 2)) AND (z = 3))'
   end
 
-  pt_specify "should allow the use of blocks and arguments simultaneously" do
+  specify "should allow the use of blocks and arguments simultaneously" do
     @d1.or(:zz < 3){:yy > 3}.sql.should ==
       'SELECT * FROM test WHERE ((x = 1) OR ((zz < 3) AND (yy > 3)))'
   end
@@ -448,7 +422,7 @@ context "Dataset#and" do
       'SELECT * FROM test WHERE ((x = 1) AND (yy > 3))'
   end
       
-  pt_specify "should accept blocks passed to filter" do
+  specify "should accept blocks passed to filter" do
     @d1.and {:yy > 3}.sql.should ==
       'SELECT * FROM test WHERE ((x = 1) AND (yy > 3))'
   end
@@ -493,14 +467,14 @@ context "Dataset#exclude" do
       "SELECT * FROM test WHERE ((region != 'Asia') AND (name != 'Japan'))"
   end
   
-  pt_specify "should support proc expressions" do
-    @dataset.exclude{:id == (6...12)}.sql.should == 
-      'SELECT * FROM test WHERE NOT (id >= 6 AND id < 12)'
+  specify "should support proc expressions" do
+    @dataset.exclude{:id < 6}.sql.should == 
+      'SELECT * FROM test WHERE (id >= 6)'
   end
   
-  pt_specify "should allow the use of blocks and arguments simultaneously" do
-    @dataset.exclude(:id => (7..11)){:id == (6...12)}.sql.should == 
-      'SELECT * FROM test WHERE (((id < 7) OR (id > 11)) OR NOT (id >= 6 AND id < 12))'
+  specify "should allow the use of blocks and arguments simultaneously" do
+    @dataset.exclude(:id => (7..11)){:id < 6}.sql.should == 
+      'SELECT * FROM test WHERE (((id < 7) OR (id > 11)) OR (id >= 6))'
   end
 end
 
@@ -540,7 +514,7 @@ context "Dataset#having" do
       "SELECT #{@columns} FROM test GROUP BY region HAVING (sum(population) > 10)"
   end
 
-  pt_specify "should support proc expressions" do
+  specify "should support proc expressions" do
     @grouped.having {:sum[:population] > 10}.sql.should == 
       "SELECT #{@columns} FROM test GROUP BY region HAVING (sum(population) > 10)"
   end
@@ -592,6 +566,18 @@ context "Dataset#group_by" do
   specify "should specify the grouping in generated select statement" do
     @dataset.select_sql.should ==
       "SELECT * FROM test GROUP BY type_id"
+    @dataset.group_by(:a, :b).select_sql.should ==
+      "SELECT * FROM test GROUP BY a, b"
+  end
+
+  specify "should specify the grouping in generated select statement" do
+    @dataset.group_by(:type_id=>nil).select_sql.should ==
+      "SELECT * FROM test GROUP BY (type_id IS NULL)"
+  end
+
+  specify "should be aliased as #group" do
+    @dataset.group(:type_id=>nil).select_sql.should ==
+      "SELECT * FROM test GROUP BY (type_id IS NULL)"
   end
 end
 
@@ -829,11 +815,16 @@ context "Dataset#order" do
       'SELECT * FROM test ORDER BY stamp'
   end
   
-  specify "should accept a string" do
+  specify "should accept a literal string" do
     @dataset.order('dada ASC'.lit).sql.should ==
       'SELECT * FROM test ORDER BY dada ASC'
   end
   
+  specify "should accept a hash as an expression" do
+    @dataset.order(:name=>nil).sql.should ==
+      'SELECT * FROM test ORDER BY (name IS NULL)'
+  end
+  
   specify "should accept a nil to remove ordering" do
     @dataset.order(:bah).order(nil).sql.should == 
       'SELECT * FROM test'
@@ -1090,7 +1081,7 @@ context "Dataset#uniq" do
   specify "should accept an expression list" do
     @dataset.uniq(:a, :b).sql.should == 'SELECT DISTINCT ON (a, b) name FROM test'
 
-    @dataset.uniq(:stamp.cast_as(:integer), :node_id).sql.should == 'SELECT DISTINCT ON (cast(stamp AS integer), node_id) name FROM test'
+    @dataset.uniq(:stamp.cast_as(:integer), :node_id=>nil).sql.should == 'SELECT DISTINCT ON (cast(stamp AS integer), (node_id IS NULL)) name FROM test'
   end
 
   specify "should do a subselect for count" do
@@ -1133,6 +1124,11 @@ context "Dataset#count" do
     @dataset.count.should == 1
     @c.sql.should == "SELECT COUNT(*) FROM (select abc from xyz) t1 LIMIT 1"
   end
+
+  specify "should return limit if count is greater than it" do
+    @dataset.limit(5).count.should == 1
+    @c.sql.should == "SELECT COUNT(*) FROM (SELECT * FROM test LIMIT 5) t1 LIMIT 1"
+  end
 end
 
 
@@ -1475,14 +1471,6 @@ context "Dataset#set" do
     @d.set({:x => 3})
     @d.last_sql.should == 'UPDATE items SET x = 3'
   end
-
-  pt_specify "should accept a block" do
-    @d.set{:x << :x + 1}
-    @d.last_sql.should == 'UPDATE items SET x = (x + 1)'
-
-    @d.set{(:x|1) << (:x|2) + 1}
-    @d.last_sql.should == 'UPDATE items SET x[1] = (x[2] + 1)'
-  end
 end
 
 
@@ -1629,17 +1617,17 @@ context "Dataset #first and #last" do
     r = @d.order(:a).last(i).should == [[:a,1,:b,2, "SELECT * FROM test ORDER BY a DESC LIMIT #{i}"]] * i
   end
   
-  pt_specify "should return the first matching record if a block is given without an argument" do
+  specify "should return the first matching record if a block is given without an argument" do
     @d.first{:z > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE (z > 26) LIMIT 1']
     @d.order(:name).last{:z > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE (z > 26) ORDER BY name DESC LIMIT 1']
   end
   
-  pt_specify "should combine block and standard argument filters if argument is not an Integer" do
+  specify "should combine block and standard argument filters if argument is not an Integer" do
     @d.first(:y=>25){:z > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE ((z > 26) AND (y = 25)) LIMIT 1']
     @d.order(:name).last('y = ?', 16){:z > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE ((z > 26) AND (y = 16)) ORDER BY name DESC LIMIT 1']
   end
   
-  pt_specify "should filter and return an array of records if an Integer argument is provided and a block is given" do
+  specify "should filter and return an array of records if an Integer argument is provided and a block is given" do
     i = rand(10) + 10
     r = @d.order(:a).first(i){:z > 26}.should == [[:a,1,:b,2, "SELECT * FROM test WHERE (z > 26) ORDER BY a LIMIT #{i}"]] * i
     i = rand(10) + 10
@@ -2205,6 +2193,12 @@ context "Dataset#columns" do
     @dataset.opts[:from] = [:nana]
     @dataset.columns.should == 'SELECT * FROM items LIMIT 1a'
   end
+  
+  specify "should ignore any filters, orders, or DISTINCT clauses" do
+    @dataset.filter!(:b=>100).order!(:b).distinct!(:b)
+    @dataset.columns = nil
+    @dataset.columns.should == 'SELECT * FROM items LIMIT 1a'
+  end
 end
 
 context "Dataset#columns!" do
@@ -2487,9 +2481,9 @@ context "Dataset" do
     @d.sql.should == "SELECT * FROM x WHERE (y = 1)"
   end
 
-  pt_specify "should support self-changing filter! with block" do
-    @d.filter!{:y == 2}
-    @d.sql.should == "SELECT * FROM x WHERE (y = 2)"
+  specify "should support self-changing filter! with block" do
+    @d.filter!{:y < 2}
+    @d.sql.should == "SELECT * FROM x WHERE (y < 2)"
   end
   
   specify "should raise for ! methods that don't return a dataset" do