sequel 2.12.0 → 3.0.0

data/spec/extensions/serialization_spec.rb

@@ -1,5 +1,7 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
+require 'yaml'
+
 describe "Serialization plugin" do
   before do
     @c = Class.new(Sequel::Model(:items)) do
@@ -49,6 +51,8 @@ describe "Serialization plugin" do
     o = @c.first
     o.id.should == 1
     o.abc.should == 1
+    o.abc.should == 1
+    o.def.should == "hello"
     o.def.should == "hello"
 
     o.update(:abc => 23)
@@ -69,6 +73,8 @@ describe "Serialization plugin" do
     o = @c.first
     o.id.should == 1
     o.abc.should == 1
+    o.abc.should == 1
+    o.def.should == "hello"
     o.def.should == "hello"
 
     o.update(:abc => 23)
@@ -89,6 +95,8 @@ describe "Serialization plugin" do
     o = Class.new(@c).first
     o.id.should == 1
     o.abc.should == 1
+    o.abc.should == 1
+    o.def.should == "hello"
     o.def.should == "hello"
 
     o.update(:abc => 23)
@@ -103,6 +111,7 @@ describe "Serialization plugin" do
     o = @c.load(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
     o.abc = 23
     o.deserialized_values.length.should == 1
+    o.abc.should == 23
     o.refresh
     o.deserialized_values.length.should == 0
   end

data/spec/extensions/single_table_inheritance_spec.rb

@@ -4,7 +4,7 @@ describe Sequel::Model, "#sti_key" do
   before do
     class ::StiTest < Sequel::Model
       def kind=(x); self[:kind] = x; end 
-      def refresh; end 
+      def _refresh(x); end 
       plugin :single_table_inheritance, :kind
     end 
     class ::StiTestSub1 < StiTest
@@ -14,6 +14,11 @@ describe Sequel::Model, "#sti_key" do
     @ds = StiTest.dataset
     MODEL_DB.reset
   end 
+
+  specify "should have simple_table = nil" do
+    StiTest.simple_table.should == nil
+    StiTestSub1.simple_table.should == nil
+  end
   
   it "should return rows with the correct class based on the polymorphic_key value" do
     def @ds.fetch_rows(sql)

data/spec/extensions/spec_helper.rb

@@ -10,7 +10,7 @@ end
 
 Sequel.virtual_row_instance_eval = true
 
-extensions = %w'string_date_time inflector pagination query pretty_table blank migration'
+extensions = %w'string_date_time inflector pagination query pretty_table blank migration schema_dumper'
 plugins = {:hook_class_methods=>[], :schema=>[], :validation_class_methods=>[]}
 
 extensions.each{|e| require "sequel/extensions/#{e}"}
@@ -70,12 +70,10 @@ end
 
 class << Sequel::Model
   alias orig_columns columns
-  alias orig_str_columns str_columns
   def columns(*cols)
     return if cols.empty?
     define_method(:columns){cols}
     @dataset.instance_variable_set(:@columns, cols) if @dataset
-    define_method(:str_columns){cols.map{|x|x.to_s.freeze}}
     def_column_accessor(*cols)
     @columns = cols
     @db_schema = {}

data/spec/extensions/validation_helpers_spec.rb

@@ -241,10 +241,10 @@ describe "Sequel::Plugins::ValidationHelpers" do
 
     @user = @c.load(:id=>1, :username => "0records", :password => "anothertest")
     @user.should be_valid
-    MODEL_DB.sqls.last.should == "SELECT COUNT(*) FROM items WHERE ((username = '0records') AND (id != 1)) LIMIT 1"
+    MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (id != 1)) LIMIT 1"
     @user = @c.new(:username => "0records", :password => "anothertest")
     @user.should be_valid
-    MODEL_DB.sqls.last.should == "SELECT COUNT(*) FROM items WHERE (username = '0records') LIMIT 1"
+    MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE (username = '0records') LIMIT 1"
   end
   
   it "should support validates_unique with multiple attributes" do
@@ -283,9 +283,9 @@ describe "Sequel::Plugins::ValidationHelpers" do
 
     @user = @c.load(:id=>1, :username => "0records", :password => "anothertest")
     @user.should be_valid
-    MODEL_DB.sqls.last.should == "SELECT COUNT(*) FROM items WHERE (((username = '0records') AND (password = 'anothertest')) AND (id != 1)) LIMIT 1"
+    MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE (((username = '0records') AND (password = 'anothertest')) AND (id != 1)) LIMIT 1"
     @user = @c.new(:username => "0records", :password => "anothertest")
     @user.should be_valid
-    MODEL_DB.sqls.last.should == "SELECT COUNT(*) FROM items WHERE ((username = '0records') AND (password = 'anothertest')) LIMIT 1"
+    MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest')) LIMIT 1"
   end
 end 

data/spec/integration/database_test.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe Sequel::Database do
+  specify "should provide disconnect functionality" do
+    INTEGRATION_DB.test_connection
+    INTEGRATION_DB.pool.size.should == 1
+    INTEGRATION_DB.disconnect
+    INTEGRATION_DB.pool.size.should == 0
+  end
+
+  specify "should raise Sequel::DatabaseError on invalid SQL" do
+    proc{INTEGRATION_DB << "SELECT"}.should raise_error(Sequel::DatabaseError)
+  end
+
+  specify "should not have the connection pool swallow non-StandardError based exceptions" do
+    proc{INTEGRATION_DB.pool.hold{raise Interrupt, "test"}}.should raise_error(Interrupt)
+  end
+end

data/spec/integration/dataset_test.rb

@@ -4,7 +4,7 @@ describe "Simple Dataset operations" do
   before do
     INTEGRATION_DB.create_table!(:items) do
       primary_key :id
-      integer :number
+      Integer :number
     end
     @ds = INTEGRATION_DB[:items]
     @ds.insert(:number=>10)
@@ -14,6 +14,15 @@ describe "Simple Dataset operations" do
     INTEGRATION_DB.drop_table(:items)
   end
 
+  specify "should support sequential primary keys" do
+    @ds << {:number=>20}
+    @ds << {:number=>30}
+    @ds.order(:number).all.should == [
+      {:id => 1, :number=>10},
+      {:id => 2, :number=>20},
+      {:id => 3, :number=>30} ]   
+  end 
+
   specify "should insert with a primary key specified" do
     @ds.insert(:id=>100, :number=>20)
     sqls_should_be(/INSERT INTO items \((number, id|id, number)\) VALUES \((100, 20|20, 100)\)/)
@@ -55,6 +64,108 @@ describe "Simple Dataset operations" do
   end
 end
 
+describe Sequel::Dataset do
+  before do
+    INTEGRATION_DB.create_table!(:test) do
+      String :name
+      Integer :value
+    end
+    @d = INTEGRATION_DB[:test]
+    clear_sqls
+  end
+  after do
+    INTEGRATION_DB.drop_table(:test)
+  end
+
+  specify "should return the correct record count" do
+    @d.count.should == 0
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.count.should == 3
+  end
+
+  specify "should return the correct records" do
+    @d.to_a.should == []
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+
+    @d.order(:value).to_a.should == [
+      {:name => 'abc', :value => 123},
+      {:name => 'abc', :value => 456},
+      {:name => 'def', :value => 789}
+    ]
+  end
+
+  specify "should update records correctly" do
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.filter(:name => 'abc').update(:value => 530)
+    @d[:name => 'def'][:value].should == 789
+    @d.filter(:value => 530).count.should == 2
+  end
+
+  specify "should delete records correctly" do
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.filter(:name => 'abc').delete
+    @d.count.should == 1
+    @d.first[:name].should == 'def'
+  end
+
+  specify "should be able to literalize booleans" do
+    proc {@d.literal(true)}.should_not raise_error
+    proc {@d.literal(false)}.should_not raise_error
+  end
+
+  specify "should correctly escape strings" do
+    INTEGRATION_DB.get("\\dingo".as(:a)) == "\\dingo"
+  end
+
+  specify "should correctly escape strings with quotes" do
+    INTEGRATION_DB.get("\\'dingo".as(:a)) == "\\'dingo"
+  end
+
+  specify "should properly escape binary data" do
+    INTEGRATION_DB.get("\1\2\3".to_sequel_blob.as(:a)) == "\1\2\3"
+  end
+end
+
+context "An SQLite dataset" do
+  before do
+    INTEGRATION_DB.create_table! :items do
+      primary_key :id 
+      Integer :value
+    end 
+    @d = INTEGRATION_DB[:items]
+    @d << {:value => 123}
+    @d << {:value => 456}
+    @d << {:value => 789}
+  end 
+  after do
+    INTEGRATION_DB.drop_table(:items)
+  end 
+  
+  specify "should correctly return avg" do
+    @d.avg(:value).to_i.should == 456
+  end 
+  
+  specify "should correctly return sum" do
+    @d.sum(:value).to_i.should == 1368
+  end 
+  
+  specify "should correctly return max" do
+    @d.max(:value).to_i.should == 789 
+  end 
+  
+  specify "should correctly return min" do
+    @d.min(:value).to_i.should == 123 
+  end 
+end
+
 describe "Simple Dataset operations" do
   before do
     INTEGRATION_DB.create_table!(:items) do

data/spec/integration/eager_loader_test.rb

@@ -154,7 +154,7 @@ describe "Association Extensions" do
     INTEGRATION_DB.create_table!(:authorships) do
       primary_key :id
       foreign_key :author_id, :authors
-      text :name
+      String :name
     end
     class ::Authorship < Sequel::Model
       many_to_one :author
@@ -170,26 +170,26 @@ describe "Association Extensions" do
 
   it "should allow methods to be called on the dataset method" do
     Authorship.count.should == 0
-    sqls_should_be('SELECT COUNT(*) FROM authorships LIMIT 1')
+    sqls_should_be('SELECT COUNT(*) AS \'count\' FROM authorships LIMIT 1')
     authorship = @author.authorships_dataset.find_or_create_by_name('Bob')
     sqls_should_be("SELECT * FROM authorships WHERE ((authorships.author_id = 1) AND (name = 'Bob')) LIMIT 1",
       /INSERT INTO authorships \((author_id, name|name, author_id)\) VALUES \((1, 'Bob'|'Bob', 1)\)/,
       "SELECT * FROM authorships WHERE (id = 1) LIMIT 1")
     Authorship.count.should == 1
     Authorship.first.should == authorship
-    sqls_should_be('SELECT COUNT(*) FROM authorships LIMIT 1', "SELECT * FROM authorships LIMIT 1")
+    sqls_should_be('SELECT COUNT(*) AS \'count\' FROM authorships LIMIT 1', "SELECT * FROM authorships LIMIT 1")
     authorship.name.should == 'Bob'
     authorship.author_id.should == @author.id
     @author.authorships_dataset.find_or_create_by_name('Bob').should == authorship
     sqls_should_be("SELECT * FROM authorships WHERE ((authorships.author_id = 1) AND (name = 'Bob')) LIMIT 1")
     Authorship.count.should == 1
-    sqls_should_be('SELECT COUNT(*) FROM authorships LIMIT 1')
+    sqls_should_be('SELECT COUNT(*) AS \'count\' FROM authorships LIMIT 1')
     authorship2 = @author.authorships_dataset.find_or_create(:name=>'Jim')
     sqls_should_be("SELECT * FROM authorships WHERE ((authorships.author_id = 1) AND (name = 'Jim')) LIMIT 1",
       /INSERT INTO authorships \((author_id, name|name, author_id)\) VALUES \((1, 'Jim'|'Jim', 1)\)/,
       "SELECT * FROM authorships WHERE (id = 2) LIMIT 1")
     Authorship.count.should == 2
-    sqls_should_be('SELECT COUNT(*) FROM authorships LIMIT 1')
+    sqls_should_be('SELECT COUNT(*) AS \'count\' FROM authorships LIMIT 1')
     Authorship.order(:name).map(:name).should == ['Bob', 'Jim']
     sqls_should_be('SELECT * FROM authorships ORDER BY name')
     authorship2.name.should == 'Jim'
@@ -364,8 +364,8 @@ describe "Polymorphic Associations" do
     INTEGRATION_DB.instance_variable_set(:@schemas, nil)
     INTEGRATION_DB.create_table!(:assets) do
       primary_key :id
-      integer :attachable_id
-      text :attachable_type
+      Integer :attachable_id
+      String :attachable_type
     end
     class ::Asset < Sequel::Model
       m = method(:constantize)
@@ -536,7 +536,7 @@ describe "many_to_one/one_to_many not referencing primary key" do
     INTEGRATION_DB.instance_variable_set(:@schemas, nil)
     INTEGRATION_DB.create_table!(:clients) do
       primary_key :id
-      text :name
+      String :name
     end
     class ::Client < Sequel::Model
       one_to_many :invoices, :reciprocal=>:client, \
@@ -570,7 +570,7 @@ describe "many_to_one/one_to_many not referencing primary key" do
   
     INTEGRATION_DB.create_table!(:invoices) do
       primary_key :id
-      text :client_name
+      String :client_name
     end
     class ::Invoice < Sequel::Model
       many_to_one :client, :key=>:client_name, \
@@ -681,3 +681,64 @@ describe "many_to_one/one_to_many not referencing primary key" do
     @invoice2.client_name.should == nil
   end
 end
+
+describe "statistics associations" do
+  before do
+    INTEGRATION_DB.create_table!(:projects) do
+      primary_key :id
+      String :name
+    end
+    class ::Project < Sequel::Model
+      many_to_one :ticket_hours, :read_only=>true, :key=>:id,
+       :dataset=>proc{Ticket.filter(:project_id=>id).select{sum(hours).as(hours)}},
+       :eager_loader=>(proc do |kh, projects, a|
+        projects.each{|p| p.associations[:ticket_hours] = nil}
+        Ticket.filter(:project_id=>kh[:id].keys).
+         group(:project_id).
+         select{[project_id.as(project_id), sum(hours).as(hours)]}.
+         all do |t|
+          p = kh[:id][t.values.delete(:project_id)].first
+          p.associations[:ticket_hours] = t
+         end
+       end)  
+      def ticket_hours
+        if s = super
+          s[:hours]
+        end
+      end 
+    end 
+
+    INTEGRATION_DB.create_table!(:tickets) do
+      primary_key :id
+      foreign_key :project_id, :projects
+      Integer :hours
+    end
+    class ::Ticket < Sequel::Model
+      many_to_one :project
+    end
+
+    @project1 = Project.create(:name=>'X')
+    @project2 = Project.create(:name=>'Y')
+    @ticket1 = Ticket.create(:project=>@project1, :hours=>1)
+    @ticket2 = Ticket.create(:project=>@project1, :hours=>10)
+    @ticket3 = Ticket.create(:project=>@project2, :hours=>2)
+    @ticket4 = Ticket.create(:project=>@project2, :hours=>20)
+    clear_sqls
+  end
+  after do
+    INTEGRATION_DB.drop_table :tickets, :projects
+    Object.send(:remove_const, :Project)
+    Object.send(:remove_const, :Ticket)
+  end
+
+  it "should give the correct sum of ticket hours for each project" do
+    @project1.ticket_hours.to_i.should == 11
+    @project2.ticket_hours.to_i.should == 22
+  end
+
+  it "should give the correct sum of ticket hours for each project when eager loading" do
+    p1, p2 = Project.order(:name).eager(:ticket_hours).all
+    p1.ticket_hours.to_i.should == 11
+    p2.ticket_hours.to_i.should == 22
+  end
+end

data/spec/integration/prepared_statement_test.rb

@@ -76,7 +76,7 @@ describe "Prepared Statements and Bound Arguments" do
     INTEGRATION_DB.call(:select_n, :n=>10).should == [{:id=>1, :number=>10}]
     @ds.filter(:number=>@ds.ba(:$n)).prepare(:first, :select_n)
     INTEGRATION_DB.call(:select_n, :n=>10).should == {:id=>1, :number=>10}
-    if INTEGRATION_DB.uri =~ /jdbc:sqlite:/
+    if INTEGRATION_DB.class.adapter_scheme == :jdbc and INTEGRATION_DB.database_type == :sqlite
       # Work around for open prepared statements on a table not allowing the
       # dropping of a table when using SQLite over JDBC
       INTEGRATION_DB.synchronize{|c| c.prepared_statements[:select_n][1].close}
@@ -121,7 +121,7 @@ describe "Prepared Statements and Bound Arguments" do
     INTEGRATION_DB.call(:select_n, :n=>10).should == [@c.load(:id=>1, :number=>10)]
     @c.filter(:number=>@ds.ba(:$n)).prepare(:first, :select_n)
     INTEGRATION_DB.call(:select_n, :n=>10).should == @c.load(:id=>1, :number=>10)
-    if INTEGRATION_DB.uri =~ /jdbc:sqlite:/
+    if INTEGRATION_DB.class.adapter_scheme == :jdbc and INTEGRATION_DB.database_type == :sqlite
       # Work around for open prepared statements on a table not allowing the
       # dropping of a table when using SQLite over JDBC
       INTEGRATION_DB.synchronize{|c| c.prepared_statements[:select_n][1].close}

data/spec/integration/schema_test.rb

@@ -19,20 +19,13 @@ describe "Database schema parser" do
     INTEGRATION_DB.identifier_output_method = :reverse
     INTEGRATION_DB.identifier_input_method = :reverse
     INTEGRATION_DB.default_schema = nil if INTEGRATION_DB.default_schema
-    INTEGRATION_DB.create_table!(:items){integer :number}
+    INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.schema(:items, :reload=>true).should be_a_kind_of(Array)
     INTEGRATION_DB.schema(:items, :reload=>true).first.first.should == :number
   end
 
-  deprec_specify "should be a hash with table_names as symbols" do
-    INTEGRATION_DB.create_table!(:items){integer :number}
-    schema = INTEGRATION_DB.schema(nil, :reload=>true)
-    schema.should be_a_kind_of(Hash)
-    schema[:items].should_not == nil
-  end
-
   specify "should not issue an sql query if the schema has been loaded unless :reload is true" do
-    INTEGRATION_DB.create_table!(:items){integer :number}
+    INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.schema(:items, :reload=>true)
     clear_sqls
     INTEGRATION_DB.schema(:items)
@@ -42,17 +35,12 @@ describe "Database schema parser" do
     sqls_should_be "PRAGMA table_info('items')"
   end
 
-  deprec_specify "should give the same result for a single table regardless of whether schema was called for a single table" do
-    INTEGRATION_DB.create_table!(:items){integer :number}
-    INTEGRATION_DB.schema(:items, :reload=>true).should == INTEGRATION_DB.schema(nil, :reload=>true)[:items]
-  end
-
   specify "should raise an error when the table doesn't exist" do
     proc{INTEGRATION_DB.schema(:no_table)}.should raise_error(Sequel::Error)
   end
 
   specify "should return the schema correctly" do
-    INTEGRATION_DB.create_table!(:items){integer :number}
+    INTEGRATION_DB.create_table!(:items){Integer :number}
     schema = INTEGRATION_DB.schema(:items, :reload=>true)
     schema.should be_a_kind_of(Array)
     schema.length.should == 1
@@ -69,35 +57,96 @@ describe "Database schema parser" do
   end
 
   specify "should parse primary keys from the schema properly" do
-    INTEGRATION_DB.create_table!(:items){integer :number}
+    INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == []
     INTEGRATION_DB.create_table!(:items){primary_key :number}
     INTEGRATION_DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number]
-    INTEGRATION_DB.create_table!(:items){integer :number1; integer :number2; primary_key [:number1, :number2]}
+    INTEGRATION_DB.create_table!(:items){Integer :number1; Integer :number2; primary_key [:number1, :number2]}
     INTEGRATION_DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number1, :number2]
   end
 
   specify "should parse NULL/NOT NULL from the schema properly" do
-    INTEGRATION_DB.create_table!(:items){integer :number, :null=>true}
+    INTEGRATION_DB.create_table!(:items){Integer :number, :null=>true}
     INTEGRATION_DB.schema(:items).first.last[:allow_null].should == true
-    INTEGRATION_DB.create_table!(:items){integer :number, :null=>false}
+    INTEGRATION_DB.create_table!(:items){Integer :number, :null=>false}
     INTEGRATION_DB.schema(:items).first.last[:allow_null].should == false
   end
 
   specify "should parse defaults from the schema properly" do
-    INTEGRATION_DB.create_table!(:items){integer :number}
+    INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.schema(:items).first.last[:default].should == nil
-    INTEGRATION_DB.create_table!(:items){integer :number, :default=>0}
+    INTEGRATION_DB.create_table!(:items){Integer :number, :default=>0}
     INTEGRATION_DB.schema(:items).first.last[:default].to_s.should == "0"
-    INTEGRATION_DB.create_table!(:items){varchar :a, :default=>"blah", :size=>4}
-    INTEGRATION_DB.schema(:items).first.last[:default].gsub(/::character varying\z/, '').gsub("'", '').should == "blah"
+    INTEGRATION_DB.create_table!(:items){String :a, :default=>"blah"}
+    INTEGRATION_DB.schema(:items).first.last[:default].should include('blah')
+  end
+
+  specify "should parse types from the schema properly" do
+    INTEGRATION_DB.create_table!(:items){Integer :number}
+    INTEGRATION_DB.schema(:items).first.last[:type].should == :integer
+    INTEGRATION_DB.create_table!(:items){Fixnum :number}
+    INTEGRATION_DB.schema(:items).first.last[:type].should == :integer
+    INTEGRATION_DB.create_table!(:items){Bignum :number}
+    INTEGRATION_DB.schema(:items).first.last[:type].should == :integer
+    INTEGRATION_DB.create_table!(:items){Float :number}
+    INTEGRATION_DB.schema(:items).first.last[:type].should == :float
+    INTEGRATION_DB.create_table!(:items){BigDecimal :number}
+    INTEGRATION_DB.schema(:items).first.last[:type].should == :decimal
+    INTEGRATION_DB.create_table!(:items){Numeric :number}
+    INTEGRATION_DB.schema(:items).first.last[:type].should == :decimal
+    INTEGRATION_DB.create_table!(:items){String :number}
+    INTEGRATION_DB.schema(:items).first.last[:type].should == :string
+    INTEGRATION_DB.create_table!(:items){Date :number}
+    INTEGRATION_DB.schema(:items).first.last[:type].should == :date
+    INTEGRATION_DB.create_table!(:items){Time :number}
+    INTEGRATION_DB.schema(:items).first.last[:type].should == :datetime
+    INTEGRATION_DB.create_table!(:items){DateTime :number}
+    INTEGRATION_DB.schema(:items).first.last[:type].should == :datetime
+    INTEGRATION_DB.create_table!(:items){File :number}
+    INTEGRATION_DB.schema(:items).first.last[:type].should == :blob
+    INTEGRATION_DB.create_table!(:items){TrueClass :number}
+    INTEGRATION_DB.schema(:items).first.last[:type].should == :boolean
+    INTEGRATION_DB.create_table!(:items){FalseClass :number}
+    INTEGRATION_DB.schema(:items).first.last[:type].should == :boolean
+  end
+end
+end
+
+if INTEGRATION_DB.respond_to?(:indexes)
+describe "Database index parsing" do
+  after do
+    INTEGRATION_DB.drop_table(:items)
+  end
+
+  specify "should parse indexes into a hash" do
+    INTEGRATION_DB.create_table!(:items){Integer :n; Integer :a}
+    INTEGRATION_DB.indexes(:items).should == {}
+    INTEGRATION_DB.add_index(:items, :n)
+    INTEGRATION_DB.indexes(:items).should == {:items_n_index=>{:columns=>[:n], :unique=>false}}
+    INTEGRATION_DB.drop_index(:items, :n)
+    INTEGRATION_DB.indexes(:items).should == {}
+    INTEGRATION_DB.add_index(:items, :n, :unique=>true, :name=>:blah_blah_index)
+    INTEGRATION_DB.indexes(:items).should == {:blah_blah_index=>{:columns=>[:n], :unique=>true}}
+    INTEGRATION_DB.add_index(:items, [:n, :a])
+    INTEGRATION_DB.indexes(:items).should == {:blah_blah_index=>{:columns=>[:n], :unique=>true}, :items_n_a_index=>{:columns=>[:n, :a], :unique=>false}}
+    INTEGRATION_DB.drop_index(:items, :n, :name=>:blah_blah_index)
+    INTEGRATION_DB.indexes(:items).should == {:items_n_a_index=>{:columns=>[:n, :a], :unique=>false}}
+    INTEGRATION_DB.drop_index(:items, [:n, :a])
+    INTEGRATION_DB.indexes(:items).should == {}
+  end
+  
+  specify "should not include a primary key index" do
+    INTEGRATION_DB.create_table!(:items){primary_key :n}
+    INTEGRATION_DB.indexes(:items).should == {}
+    INTEGRATION_DB.create_table!(:items){Integer :n; Integer :a; primary_key [:n, :a]}
+    INTEGRATION_DB.indexes(:items).should == {}
   end
 end
 end
 
 describe "Database schema modifiers" do
   before do
-    INTEGRATION_DB.create_table!(:items){integer :number}
+    INTEGRATION_DB.create_table!(:items){Integer :number}
     @ds = INTEGRATION_DB[:items]
     @ds.insert([10])
     clear_sqls
@@ -118,7 +167,7 @@ describe "Database schema modifiers" do
     INTEGRATION_DB.alter_table(:items){add_column :name, :text}
     INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name]
     @ds.columns!.should == [:number, :name]
-    unless INTEGRATION_DB.url =~ /sqlite/
+    unless INTEGRATION_DB.database_type == :sqlite
       INTEGRATION_DB.alter_table(:items){add_primary_key :id}
       INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name, :id]
       @ds.columns!.should == [:number, :name, :id]
@@ -131,8 +180,8 @@ describe "Database schema modifiers" do
   specify "should remove columns from tables correctly" do
     INTEGRATION_DB.create_table!(:items) do
       primary_key :id
-      text :name
-      integer :number
+      String :name
+      Integer :number
       foreign_key :item_id, :items
     end
     @ds.insert(:number=>10)