sequel 0.3.2 → 0.3.3

data/spec/array_keys_spec.rb

@@ -53,9 +53,9 @@ context "An array with symbol keys" do
     @a.to_h.should == {:a => 1, :b => 2, :c => 3}
   end
   
-  specify "should provide #fields as alias to #keys" do
-    @a.fields.should == [:a, :b, :c]
-    @a.fields = [:x, :y, :z]
+  specify "should provide #columns as alias to #keys" do
+    @a.columns.should == [:a, :b, :c]
+    @a.columns = [:x, :y, :z]
     
     @a[:x].should == 1
   end
@@ -305,9 +305,9 @@ context "An array with string keys" do
     @a.to_h.should == {:a => 1, :b => 2, :c => 3}
   end
 
-  specify "should provide #fields as alias to #keys" do
-    @a.fields.should == ['a', 'b', 'c']
-    @a.fields = [:x, :y, :z]
+  specify "should provide #columns as alias to #keys" do
+    @a.columns.should == ['a', 'b', 'c']
+    @a.columns = [:x, :y, :z]
 
     @a[:x].should == 1
   end

data/spec/connection_pool_spec.rb

@@ -126,7 +126,7 @@ end
 context "A connection pool with a max size of 1" do
   setup do
     @invoked_count = 0
-    @pool = Sequel::ConnectionPool.new(1) {@invoked_count += 1;'herro'}
+    @pool = Sequel::ConnectionPool.new(1) {@invoked_count += 1; 'herro'}
   end
   
   specify "should let only one thread access the connection at any time" do

data/spec/core_ext_spec.rb

@@ -152,7 +152,7 @@ context "Symbol#to_column_name" do
   end
 end
 
-context "FieldCompositionMethods#column_title" do
+context "ColumnCompositionMethods#column_title" do
   specify "should return the column name for non aliased columns" do
     :xyz.column_title.should == 'xyz'
     :abc__xyz.column_title.should == 'xyz'
@@ -205,4 +205,62 @@ context "Symbol" do
     ds = db[:t]
     ds.select(:COUNT['1']).sql.should == "SELECT COUNT(1) FROM t"
   end
+end
+
+context "Range#interval" do
+  specify "should return the interval between the beginning and end of the range" do
+    (1..10).interval.should == 9
+    
+    r = rand(100000) + 10
+    t1 = Time.now; t2 = t1 + r
+    (t1..t2).interval.should == r
+  end
+end
+
+context "Numeric extensions" do
+  setup do
+    Sequel::NumericExtensions.enable
+  end
+  
+  specify "should support conversion of minutes to seconds" do
+    1.minute.should == 60
+    3.minutes.should == 180
+  end
+  
+  specify "should support conversion of hours to seconds" do
+    1.hour.should == 3600
+    3.hours.should == 3600 * 3
+  end
+
+  specify "should support conversion of days to seconds" do
+    1.day.should == 86400
+    3.days.should == 86400 * 3
+  end
+
+  specify "should support conversion of weeks to seconds" do
+    1.week.should == 86400 * 7
+    3.weeks.should == 86400 * 7 * 3
+  end
+  
+  specify "should provide #ago functionality" do
+    t1 = Time.now
+    t2 = 1.day.ago
+    t1.should > t2
+    ((t1 - t2).to_i - 86400).abs.should < 2
+    
+    t1 = Time.now
+    t2 = 1.day.before(t1)
+    t2.should == t1 - 1.day
+  end
+
+  specify "should provide #from_now functionality" do
+    t1 = Time.now
+    t2 = 1.day.from_now
+    t1.should < t2
+    ((t2 - t1).to_i - 86400).abs.should < 2
+    
+    t1 = Time.now
+    t2 = 1.day.since(t1)
+    t2.should == t1 + 1.day
+  end
 end

data/spec/database_spec.rb

@@ -197,11 +197,11 @@ class DummyDataset < Sequel::Dataset
 end
 
 class DummyDatabase < Sequel::Database
-  attr_reader :sql
+  attr_reader :sqls
   
   def execute(sql)
-    @sql ||= ""
-    @sql << sql
+    @sqls ||= []
+    @sqls << sql
   end
   
   def transaction; yield; end
@@ -222,8 +222,10 @@ context "Database#create_table" do
       column :name, :text
       index :name, :unique => true
     end
-    @db.sql.should == 
-      'CREATE TABLE test (id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name text);CREATE UNIQUE INDEX test_name_index ON test (name);'
+    @db.sqls.should == [
+      'CREATE TABLE test (id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name text)',
+      'CREATE UNIQUE INDEX test_name_index ON test (name)'
+    ]
   end
 end
 
@@ -235,19 +237,21 @@ end
 
 context "Database#drop_table" do
   setup do
-    @db = Dummy2Database.new
+    @db = DummyDatabase.new
   end
   
   specify "should construct proper SQL" do
     @db.drop_table :test
-    @db.sql.should == 
-      'DROP TABLE test;'
+    @db.sqls.should == ['DROP TABLE test']
   end
   
   specify "should accept multiple table names" do
     @db.drop_table :a, :bb, :ccc
-    @db.sql.should ==
-      'DROP TABLE a;DROP TABLE bb;DROP TABLE ccc;'
+    @db.sqls.should == [
+      'DROP TABLE a',
+      'DROP TABLE bb',
+      'DROP TABLE ccc'
+    ]
   end
 end
 
@@ -294,8 +298,8 @@ context "Database#transaction" do
   end
   
   specify "should issue ROLLBACK if an exception is raised, and re-raise" do
-    @db.transaction {@db.execute 'DROP TABLE test;'; raise RuntimeError} rescue nil
-    @db.sql.should == ['BEGIN', 'DROP TABLE test;', 'ROLLBACK']
+    @db.transaction {@db.execute 'DROP TABLE test'; raise RuntimeError} rescue nil
+    @db.sql.should == ['BEGIN', 'DROP TABLE test', 'ROLLBACK']
     
     proc {@db.transaction {raise RuntimeError}}.should raise_error(RuntimeError)
   end
@@ -307,7 +311,7 @@ context "Database#transaction" do
       @db.drop_table(:b)
     end
     
-    @db.sql.should == ['BEGIN', 'DROP TABLE a;', 'ROLLBACK']
+    @db.sql.should == ['BEGIN', 'DROP TABLE a', 'ROLLBACK']
   end
   
   specify "should be re-entrant" do

data/spec/dataset_spec.rb

@@ -99,24 +99,24 @@ context "A simple dataset" do
   end
   
   specify "should format an insert statement with default values" do
-    @dataset.insert_sql.should == 'INSERT INTO test DEFAULT VALUES;'
+    @dataset.insert_sql.should == 'INSERT INTO test DEFAULT VALUES'
   end
   
   specify "should format an insert statement with hash" do
     @dataset.insert_sql(:name => 'wxyz', :price => 342).
       should match(/INSERT INTO test \(name, price\) VALUES \('wxyz', 342\)|INSERT INTO test \(price, name\) VALUES \(342, 'wxyz'\)/)
 
-      @dataset.insert_sql({}).should == "INSERT INTO test DEFAULT VALUES;"
+      @dataset.insert_sql({}).should == "INSERT INTO test DEFAULT VALUES"
   end
 
   specify "should format an insert statement with array with keys" do
     v = [1, 2, 3]
     v.keys = [:a, :b, :c]
-    @dataset.insert_sql(v).should == "INSERT INTO test (a, b, c) VALUES (1, 2, 3);"
+    @dataset.insert_sql(v).should == "INSERT INTO test (a, b, c) VALUES (1, 2, 3)"
     
     v = []
     v.keys = [:a, :b]
-    @dataset.insert_sql(v).should == "INSERT INTO test DEFAULT VALUES;"
+    @dataset.insert_sql(v).should == "INSERT INTO test DEFAULT VALUES"
   end
   
   specify "should format an insert statement with a model instance" do
@@ -129,25 +129,25 @@ context "A simple dataset" do
     
     v = @c.new(:a => 1)
     
-    @dataset.insert_sql(v).should == "INSERT INTO test (a) VALUES (1);"
+    @dataset.insert_sql(v).should == "INSERT INTO test (a) VALUES (1)"
     
     v = @c.new({})
-    @dataset.insert_sql(v).should == "INSERT INTO test DEFAULT VALUES;"
+    @dataset.insert_sql(v).should == "INSERT INTO test DEFAULT VALUES"
   end
   
   specify "should format an insert statement with an arbitrary value" do
-    @dataset.insert_sql(123).should == "INSERT INTO test VALUES (123);"
+    @dataset.insert_sql(123).should == "INSERT INTO test VALUES (123)"
   end
   
   specify "should format an insert statement with sub-query" do
     @sub = Sequel::Dataset.new(nil).from(:something).filter(:x => 2)
     @dataset.insert_sql(@sub).should == \
-      "INSERT INTO test (SELECT * FROM something WHERE (x = 2));"
+      "INSERT INTO test (SELECT * FROM something WHERE (x = 2))"
   end
   
   specify "should format an insert statement with array" do
     @dataset.insert_sql('a', 2, 6.5).should ==
-      "INSERT INTO test VALUES ('a', 2, 6.5);"
+      "INSERT INTO test VALUES ('a', 2, 6.5)"
   end
   
   specify "should format an update statement" do
@@ -1818,9 +1818,9 @@ context "Dataset#multi_insert" do
       
       def transaction
         @sqls ||= []
-        @sqls << 'BEGIN;'
+        @sqls << 'BEGIN'
         yield
-        @sqls << 'COMMIT;'
+        @sqls << 'COMMIT'
       end
     end
     @db = @dbc.new
@@ -1833,24 +1833,24 @@ context "Dataset#multi_insert" do
   specify "should join all inserts into a single SQL string" do
     @ds.multi_insert(@list)
     @db.sqls.should == [
-      'BEGIN;',
-      "INSERT INTO items (name) VALUES ('abc');",
-      "INSERT INTO items (name) VALUES ('def');",
-      "INSERT INTO items (name) VALUES ('ghi');",
-      'COMMIT;'
+      'BEGIN',
+      "INSERT INTO items (name) VALUES ('abc')",
+      "INSERT INTO items (name) VALUES ('def')",
+      "INSERT INTO items (name) VALUES ('ghi')",
+      'COMMIT'
     ]
   end
   
   specify "should accept the commit_every option for committing every x records" do
     @ds.multi_insert(@list, :commit_every => 2)
     @db.sqls.should == [
-      'BEGIN;',
-      "INSERT INTO items (name) VALUES ('abc');",
-      "INSERT INTO items (name) VALUES ('def');",
-      'COMMIT;',
-      'BEGIN;',
-      "INSERT INTO items (name) VALUES ('ghi');",
-      'COMMIT;'
+      'BEGIN',
+      "INSERT INTO items (name) VALUES ('abc')",
+      "INSERT INTO items (name) VALUES ('def')",
+      'COMMIT',
+      'BEGIN',
+      "INSERT INTO items (name) VALUES ('ghi')",
+      'COMMIT'
     ]
   end
 end
@@ -2007,10 +2007,10 @@ context "Dataset#transform" do
   
   specify "should change the dataset to transform values saved to the database" do
     @ds.insert(:x => :toast)
-    @ds.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}');"
+    @ds.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}')"
 
     @ds.insert(:y => 'butter')
-    @ds.sql.should == "INSERT INTO items (y) VALUES ('butter');"
+    @ds.sql.should == "INSERT INTO items (y) VALUES ('butter')"
     
     @ds.update(:x => ['dream'])
     @ds.sql.should == "UPDATE items SET x = '#{Marshal.dump(['dream'])}'"
@@ -2023,7 +2023,7 @@ context "Dataset#transform" do
     @ds2.first.should == {:x => [1, 2, 3], :y => 'hello'}
 
     @ds2.insert(:x => :toast)
-    @ds2.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}');"
+    @ds2.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}')"
   end
   
   specify "should work correctly together with set_row_proc" do
@@ -2075,9 +2075,9 @@ context "Dataset#transform" do
     @ds.first.should == {:x => [1, 2, 3], :y => 'hello'}
 
     @ds.insert(:x => :toast)
-    @ds.sql.should == "INSERT INTO items (x) VALUES ('#{:toast.to_yaml}');"
+    @ds.sql.should == "INSERT INTO items (x) VALUES ('#{:toast.to_yaml}')"
     @ds.insert(:y => 'butter')
-    @ds.sql.should == "INSERT INTO items (y) VALUES ('butter');"
+    @ds.sql.should == "INSERT INTO items (y) VALUES ('butter')"
     @ds.update(:x => ['dream'])
     @ds.sql.should == "UPDATE items SET x = '#{['dream'].to_yaml}'"
 
@@ -2085,7 +2085,7 @@ context "Dataset#transform" do
     @ds2.raw = {:x => [1, 2, 3].to_yaml, :y => 'hello'}
     @ds2.first.should == {:x => [1, 2, 3], :y => 'hello'}
     @ds2.insert(:x => :toast)
-    @ds2.sql.should == "INSERT INTO items (x) VALUES ('#{:toast.to_yaml}');"
+    @ds2.sql.should == "INSERT INTO items (x) VALUES ('#{:toast.to_yaml}')"
 
     @ds.set_row_proc {|r| r[:z] = r[:x] * 2; r}
     @ds.raw = {:x => "wow".to_yaml, :y => 'hello'}
@@ -2103,9 +2103,9 @@ context "Dataset#transform" do
     @ds.first.should == {:x => [1, 2, 3], :y => 'hello'}
 
     @ds.insert(:x => :toast)
-    @ds.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}');"
+    @ds.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}')"
     @ds.insert(:y => 'butter')
-    @ds.sql.should == "INSERT INTO items (y) VALUES ('butter');"
+    @ds.sql.should == "INSERT INTO items (y) VALUES ('butter')"
     @ds.update(:x => ['dream'])
     @ds.sql.should == "UPDATE items SET x = '#{Marshal.dump(['dream'])}'"
 
@@ -2113,7 +2113,7 @@ context "Dataset#transform" do
     @ds2.raw = {:x => Marshal.dump([1, 2, 3]), :y => 'hello'}
     @ds2.first.should == {:x => [1, 2, 3], :y => 'hello'}
     @ds2.insert(:x => :toast)
-    @ds2.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}');"
+    @ds2.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}')"
 
     @ds.set_row_proc {|r| r[:z] = r[:x] * 2; r}
     @ds.raw = {:x => Marshal.dump("wow"), :y => 'hello'}

data/spec/model_spec.rb

@@ -252,13 +252,13 @@ context "A model class" do
   specify "should be able to create rows in the associated table" do
     o = @c.create(:x => 1)
     o.class.should == @c
-    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1);',  "SELECT * FROM items WHERE (id IN ('INSERT INTO items (x) VALUES (1);')) LIMIT 1"]
+    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1)',  "SELECT * FROM items WHERE (id IN ('INSERT INTO items (x) VALUES (1)')) LIMIT 1"]
   end
   
   specify "should be able to create rows without any values specified" do
     o = @c.create
     o.class.should == @c
-    MODEL_DB.sqls.should == ["INSERT INTO items DEFAULT VALUES;", "SELECT * FROM items WHERE (id IN ('INSERT INTO items DEFAULT VALUES;')) LIMIT 1"]
+    MODEL_DB.sqls.should == ["INSERT INTO items DEFAULT VALUES", "SELECT * FROM items WHERE (id IN ('INSERT INTO items DEFAULT VALUES')) LIMIT 1"]
   end
 end
 
@@ -276,7 +276,7 @@ context "A model class without a primary key" do
     i.class.should be(@c)
     i.values.to_hash.should == {:x => 1}
     
-    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1);']
+    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1)']
   end
   
   specify "should raise when deleting" do
@@ -288,7 +288,7 @@ context "A model class without a primary key" do
     o = @c.new(:x => 2)
     o.should be_new
     o.save
-    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (2);']
+    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (2)']
   end
 end
 
@@ -307,8 +307,8 @@ context "Model#serialize" do
     @c.create(:abc => "hello")
     
     MODEL_DB.sqls.should == [ \
-      "INSERT INTO items (abc) VALUES ('--- 1\n');", \
-      "INSERT INTO items (abc) VALUES ('--- hello\n');", \
+      "INSERT INTO items (abc) VALUES ('--- 1\n')", \
+      "INSERT INTO items (abc) VALUES ('--- hello\n')", \
     ]
   end
   
@@ -324,8 +324,8 @@ context "Model#serialize" do
     @c.create(:def => "hello")
     
     MODEL_DB.sqls.should == [ \
-      "INSERT INTO items (def) VALUES ('--- 1\n');", \
-      "INSERT INTO items (def) VALUES ('--- hello\n');", \
+      "INSERT INTO items (def) VALUES ('--- 1\n')", \
+      "INSERT INTO items (def) VALUES ('--- hello\n')", \
     ]
   end
   
@@ -339,8 +339,8 @@ context "Model#serialize" do
     @c.create(:abc => "hello")
     
     MODEL_DB.sqls.should == [ \
-      "INSERT INTO items (abc) VALUES ('\004\bi\006');", \
-      "INSERT INTO items (abc) VALUES ('\004\b\"\nhello');", \
+      "INSERT INTO items (abc) VALUES ('\004\bi\006')", \
+      "INSERT INTO items (abc) VALUES ('\004\b\"\nhello')", \
     ]
   end
   
@@ -387,7 +387,7 @@ context "Model#serialize" do
     
     ds.raw = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
     o = @c.create(:abc => [1, 2, 3])
-    ds.sqls.should == "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}');"
+    ds.sqls.should == "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"
   end
 end
 
@@ -490,8 +490,8 @@ context "Model.after_create" do
     end
     
     n = @c.create(:x => 1)
-    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1);", "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
-    s.should == ["INSERT INTO items (x) VALUES (1);", "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+    s.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
   end
   
   specify "should allow calling save in the hook" do
@@ -502,7 +502,7 @@ context "Model.after_create" do
     end
     
     n = @c.create(:id => 1)
-    MODEL_DB.sqls.should == ["INSERT INTO items (id) VALUES (1);", "SELECT * FROM items WHERE (id = 1) LIMIT 1", "UPDATE items SET id = 2 WHERE (id = 1)"]
+    MODEL_DB.sqls.should == ["INSERT INTO items (id) VALUES (1)", "SELECT * FROM items WHERE (id = 1) LIMIT 1", "UPDATE items SET id = 2 WHERE (id = 1)"]
   end
 end
 

data/spec/schema_spec.rb

@@ -16,7 +16,7 @@ context "DB#create_table" do
   
   specify "should accept the table name" do
     @db.create_table(:cats) {}
-    @db.sqls.should == ['CREATE TABLE cats ();']
+    @db.sqls.should == ['CREATE TABLE cats ()']
   end
 
   specify "should accept multiple columns" do
@@ -24,7 +24,7 @@ context "DB#create_table" do
       column :id, :integer
       column :name, :text
     end
-    @db.sqls.should == ['CREATE TABLE cats (id integer, name text);']
+    @db.sqls.should == ['CREATE TABLE cats (id integer, name text)']
   end
   
   specify "should accept method calls as data types" do
@@ -32,26 +32,26 @@ context "DB#create_table" do
       integer :id
       text :name
     end
-    @db.sqls.should == ['CREATE TABLE cats (id integer, name text);']
+    @db.sqls.should == ['CREATE TABLE cats (id integer, name text)']
   end
 
   specify "should accept primary key definition" do
     @db.create_table(:cats) do
       primary_key :id
     end
-    @db.sqls.should == ['CREATE TABLE cats (id integer PRIMARY KEY AUTOINCREMENT);']
+    @db.sqls.should == ['CREATE TABLE cats (id integer PRIMARY KEY AUTOINCREMENT)']
 
     @db.sqls.clear
     @db.create_table(:cats) do
       primary_key :id, :serial, :auto_increment => false
     end
-    @db.sqls.should == ['CREATE TABLE cats (id serial PRIMARY KEY);']
+    @db.sqls.should == ['CREATE TABLE cats (id serial PRIMARY KEY)']
 
     @db.sqls.clear
     @db.create_table(:cats) do
       primary_key :id, :type => :serial, :auto_increment => false
     end
-    @db.sqls.should == ['CREATE TABLE cats (id serial PRIMARY KEY);']
+    @db.sqls.should == ['CREATE TABLE cats (id serial PRIMARY KEY)']
   end
 
   specify "should accept and literalize default values" do
@@ -59,7 +59,7 @@ context "DB#create_table" do
       integer :id, :default => 123
       text :name, :default => "abc'def"
     end
-    @db.sqls.should == ["CREATE TABLE cats (id integer DEFAULT 123, name text DEFAULT 'abc''def');"]
+    @db.sqls.should == ["CREATE TABLE cats (id integer DEFAULT 123, name text DEFAULT 'abc''def')"]
   end
   
   specify "should accept not null definition" do
@@ -67,7 +67,7 @@ context "DB#create_table" do
       integer :id
       text :name, :null => false
     end
-    @db.sqls.should == ["CREATE TABLE cats (id integer, name text NOT NULL);"]
+    @db.sqls.should == ["CREATE TABLE cats (id integer, name text NOT NULL)"]
   end
   
   specify "should accept unique definition" do
@@ -75,79 +75,79 @@ context "DB#create_table" do
       integer :id
       text :name, :unique => true
     end
-    @db.sqls.should == ["CREATE TABLE cats (id integer, name text UNIQUE);"]
+    @db.sqls.should == ["CREATE TABLE cats (id integer, name text UNIQUE)"]
   end
   
   specify "should accept [SET|ENUM](...) types" do
     @db.create_table(:cats) do
       set :color, :elements => ['black', 'tricolor', 'grey']
     end
-    @db.sqls.should == ["CREATE TABLE cats (color set('black', 'tricolor', 'grey'));"]
+    @db.sqls.should == ["CREATE TABLE cats (color set('black', 'tricolor', 'grey'))"]
   end
   
   specify "should accept varchar size" do
     @db.create_table(:cats) do
       varchar :name
     end
-    @db.sqls.should == ["CREATE TABLE cats (name varchar(255));"]
+    @db.sqls.should == ["CREATE TABLE cats (name varchar(255))"]
     @db.sqls.clear
     @db.create_table(:cats) do
       varchar :name, :size => 51
     end
-    @db.sqls.should == ["CREATE TABLE cats (name varchar(51));"]
+    @db.sqls.should == ["CREATE TABLE cats (name varchar(51))"]
   end
 
   specify "should accept foreign keys" do
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects
     end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects);"]
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects)"]
   end
   
   specify "should accept foreign keys with arbitrary keys" do
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :key => :id
     end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects(id));"]
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects(id))"]
 
     @db.sqls.clear
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :key => :zzz
     end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects(zzz));"]
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects(zzz))"]
   end
   
   specify "should accept foreign keys with ON DELETE clause" do
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :on_delete => :restrict
     end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE RESTRICT);"]
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE RESTRICT)"]
 
     @db.sqls.clear
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :on_delete => :cascade
     end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE CASCADE);"]
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE CASCADE)"]
 
     @db.sqls.clear
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :on_delete => :no_action
     end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE NO ACTION);"]
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE NO ACTION)"]
     @db.sqls.clear
 
     @db.sqls.clear
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :on_delete => :set_null
     end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE SET NULL);"]
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE SET NULL)"]
     @db.sqls.clear
 
     @db.sqls.clear
     @db.create_table(:cats) do
       foreign_key :project_id, :table => :projects, :on_delete => :set_default
     end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE SET DEFAULT);"]
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE SET DEFAULT)"]
     @db.sqls.clear
   end
   
@@ -156,7 +156,7 @@ context "DB#create_table" do
       integer :id
       index :id
     end
-    @db.sqls.should == ["CREATE TABLE cats (id integer);", "CREATE INDEX cats_id_index ON cats (id);"]
+    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_id_index ON cats (id)"]
   end
 
   specify "should accept multiple index definitions" do
@@ -165,7 +165,7 @@ context "DB#create_table" do
       index :id
       index :name
     end
-    @db.sqls.should == ["CREATE TABLE cats (id integer);", "CREATE INDEX cats_id_index ON cats (id);", "CREATE INDEX cats_name_index ON cats (name);"]
+    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_id_index ON cats (id)", "CREATE INDEX cats_name_index ON cats (name)"]
   end
   
   specify "should accept custom index names" do
@@ -173,7 +173,7 @@ context "DB#create_table" do
       integer :id
       index :id, :name => 'abc'
     end
-    @db.sqls.should == ["CREATE TABLE cats (id integer);", "CREATE INDEX abc ON cats (id);"]
+    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX abc ON cats (id)"]
   end
 
   specify "should accept unique index definitions" do
@@ -181,7 +181,7 @@ context "DB#create_table" do
       integer :id
       index :id, :unique => true
     end
-    @db.sqls.should == ["CREATE TABLE cats (id integer);", "CREATE UNIQUE INDEX cats_id_index ON cats (id);"]
+    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE UNIQUE INDEX cats_id_index ON cats (id)"]
   end
   
   specify "should accept compound index definitions" do
@@ -189,7 +189,7 @@ context "DB#create_table" do
       integer :id
       index [:id, :name], :unique => true
     end
-    @db.sqls.should == ["CREATE TABLE cats (id integer);", "CREATE UNIQUE INDEX cats_id_name_index ON cats (id, name);"]
+    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE UNIQUE INDEX cats_id_name_index ON cats (id, name)"]
   end
 end
 
@@ -200,6 +200,6 @@ context "DB#drop_table" do
 
   specify "should generate a DROP TABLE statement" do
     @db.drop_table :cats
-    @db.sqls.should == ['DROP TABLE cats;']
+    @db.sqls.should == ['DROP TABLE cats']
   end
 end