db_leftovers 0.4.0 → 0.5.0

data/README.html

@@ -1,10 +1,10 @@
 <h1>db_leftovers</h1>
 
-<p>db_leftovers lets you define indexes and foreign keys for your Rails app
+<p>db_leftovers lets you define indexes, foreign keys, and CHECK constraints for your Rails app
 in one place using an easy-to-read DSL,
 then run a rake task to bring your database up-to-date.
-I wrote this because I didn't want indexes and foreign keys scattered throughout my migrations or buried in my <code>schema.rb</code>, and I wanted a command I could run to ensure that they matched across my development, test, staging, and production databases.
-This was particularly a problem for Heroku projects, because <code>db:push</code> and <code>db:pull</code> do not transfer your foreign keys.
+I wrote this because I didn't want indexes and constraints scattered throughout my migrations or buried in my <code>schema.rb</code>, and I wanted a command I could run to ensure that they matched across my development, test, staging, and production databases.
+This was particularly a problem for Heroku projects, because <code>db:push</code> and <code>db:pull</code> do not transfer your foreign keys or other constraints.
 But now that it's written, I'm finding it useful on non-Heroku projects as well.</p>
 
 <p>At present db_leftovers works only on PostgreSQL databases,
@@ -12,9 +12,9 @@ but it could easily be extended to cover other RDBMSes.</p>
 
 <h2>Configuration File</h2>
 
-<p>db_leftovers reads a file named <code>config/db_leftovers.rb</code> to find out which indexes and foreign keys you want in your database. This file is a DSL implemented in Ruby, sort of like <code>config/routes.rb</code>. There are only a few methods:</p>
+<p>db_leftovers reads a file named <code>config/db_leftovers.rb</code> to find out which indexes and constraints you want in your database. This file is a DSL implemented in Ruby, sort of like <code>config/routes.rb</code>. There are only a few methods:</p>
 
-<h3>index table_name, columns, [opts]</h3>
+<h3>index(table_name, columns, [opts])</h3>
 
 <p>This ensures that you have an index on the given table and column(s). The <code>columns</code> parameter can be either a string or a list of strings. Opts is a hash with the following possible keys:</p>
 
@@ -31,10 +31,10 @@ index :books, [:publisher_id, :published_at]
 index :books, :isbn, :unique =&gt; true
 </code></pre>
 
-<h3>foreign_key from_table, from_column, to_table, [to_column, [opts]]</h3>
+<h3>foreign_key(from_table, from_column, to_table, [to_column, [opts]])</h3>
 
 <p>This ensures that you have a foreign key relating the given tables and columns.
-All parameters are strings except <code>opts</code>, which is a hash.
+All parameters are strings/symbols except <code>opts</code>, which is a hash.
 If you don't pass anything for <code>opts</code>, you can leave off the <code>to_column</code> parameter, and it will default to <code>:id</code>.
 These options are supported:</p>
 
@@ -52,17 +52,28 @@ foreign_key :books, :publisher_id, :publishers
 foreign_key :pages, :book_id, :books, :id, :cascade =&gt; true
 </code></pre>
 
-<h3>table table_name, &amp;block</h3>
+<h3>check(constraint_name, on_table, expression)</h3>
+
+<p>This ensures that you have a CHECK constraint on the given table with the given name and expression.
+All parameters are strings or symbols.</p>
+
+<h4>Examples</h4>
+
+<pre><code>check :books, :books_have_positive_pages, 'page_count &gt; 0'
+</code></pre>
+
+<h3>table(table_name, &amp;block)</h3>
 
 <p>The <code>table</code> call is just a convenience so you can group all a table's indexes and foreign keys together and not keep repeating the table name. You use it like this:</p>
 
 <pre><code>table :books do
   index :author_id
   foreign_key :publisher_id, :publishers
+  check :books_have_positive_pages, 'page_count &gt; 0'
 end
 </code></pre>
 
-<p>You can repeat <code>table</code> calls for the same table several times if you like. This lets you put your indexes in one place and your foreign keys in another.</p>
+<p>You can repeat <code>table</code> calls for the same table several times if you like. This lets you put your indexes in one place and your foreign keys in another, for example.</p>
 
 <h2>Running db_leftovers</h2>
 
@@ -76,8 +87,20 @@ end
 <ul>
 <li><p>db_leftovers only supports PostgreSQL databases.
 If you want to add support for something else, just send me a pull request!</p></li>
-<li><p>db_leftovers will not notice if an index/foreign key definition changes.
-Right now it only checks for existence/non-existence.</p></li>
+<li><p>db_leftovers will not notice if an foreign key/constraint definition changes.
+Right now it only checks for existence/non-existence.
+You can get around this by adding a version number to your constraint names,
+so if you want to force books to have at least 12 pages, you can say this:</p>
+
+<p><code>check :books_have_positive_pages2, 'page_count &gt;= 12'</code></p>
+
+<p>Then the old constraint will be dropped and the new one will be added.</p>
+
+<p>However, db_leftovers <em>does</em> check for index definitions, so if you
+make an existing index unique, add a column, remove a WHERE clause, or
+anything else, it will notice and drop and re-create the index.
+I'm working on doing the same thing for foreign keys/constraints,
+but it's not done just yet.</p></li>
 <li><p>If your database is mostly up-to-date, then running the Rake task will spam
 you with messages about how this index and that foreign key already exist.
 These should be hidden by default and shown only if you request a higher
@@ -98,5 +121,5 @@ verbosity.</p></li>
 
 <h2>Copyright</h2>
 
-<p>Copyright (c) 2012 Paul A. Jungwirth. See LICENSE.txt for
-further details.</p>
+<p>Copyright (c) 2012 Paul A. Jungwirth.
+See LICENSE.txt for further details.</p>

data/README.md

@@ -1,11 +1,11 @@
 db\_leftovers
 =============
 
-db\_leftovers lets you define indexes and foreign keys for your Rails app
+db\_leftovers lets you define indexes, foreign keys, and CHECK constraints for your Rails app
 in one place using an easy-to-read DSL,
 then run a rake task to bring your database up-to-date.
-I wrote this because I didn't want indexes and foreign keys scattered throughout my migrations or buried in my `schema.rb`, and I wanted a command I could run to ensure that they matched across my development, test, staging, and production databases.
-This was particularly a problem for Heroku projects, because `db:push` and `db:pull` do not transfer your foreign keys.
+I wrote this because I didn't want indexes and constraints scattered throughout my migrations or buried in my `schema.rb`, and I wanted a command I could run to ensure that they matched across my development, test, staging, and production databases.
+This was particularly a problem for Heroku projects, because `db:push` and `db:pull` do not transfer your foreign keys or other constraints.
 But now that it's written, I'm finding it useful on non-Heroku projects as well.
 
 At present db\_leftovers works only on PostgreSQL databases,
@@ -14,9 +14,9 @@ but it could easily be extended to cover other RDBMSes.
 Configuration File
 ------------------
 
-db\_leftovers reads a file named `config/db_leftovers.rb` to find out which indexes and foreign keys you want in your database. This file is a DSL implemented in Ruby, sort of like `config/routes.rb`. There are only a few methods:
+db\_leftovers reads a file named `config/db_leftovers.rb` to find out which indexes and constraints you want in your database. This file is a DSL implemented in Ruby, sort of like `config/routes.rb`. There are only a few methods:
 
-### index table\_name, columns, [opts]
+### index(table\_name, columns, [opts])
 
 This ensures that you have an index on the given table and column(s). The `columns` parameter can be either a string or a list of strings. Opts is a hash with the following possible keys:
 
@@ -32,10 +32,10 @@ This ensures that you have an index on the given table and column(s). The `colum
     index :books, [:publisher_id, :published_at]
     index :books, :isbn, :unique => true
 
-### foreign\_key from\_table, from\_column, to\_table, [to\_column, [opts]]
+### foreign\_key(from\_table, from\_column, to\_table, [to\_column, [opts]])
 
 This ensures that you have a foreign key relating the given tables and columns.
-All parameters are strings except `opts`, which is a hash.
+All parameters are strings/symbols except `opts`, which is a hash.
 If you don't pass anything for `opts`, you can leave off the `to_column` parameter, and it will default to `:id`.
 These options are supported:
 
@@ -50,16 +50,26 @@ These options are mutually exclusive. They should probably be consolidated into
     foreign_key :books, :publisher_id, :publishers
     foreign_key :pages, :book_id, :books, :id, :cascade => true
 
-### table table\_name, &block
+### check(constraint\_name, on\_table, expression)
+
+This ensures that you have a CHECK constraint on the given table with the given name and expression.
+All parameters are strings or symbols.
+
+#### Examples
+
+    check :books, :books_have_positive_pages, 'page_count > 0'
+
+### table(table\_name, &block)
 
 The `table` call is just a convenience so you can group all a table's indexes and foreign keys together and not keep repeating the table name. You use it like this:
 
     table :books do
       index :author_id
       foreign_key :publisher_id, :publishers
+      check :books_have_positive_pages, 'page_count > 0'
     end
 
-You can repeat `table` calls for the same table several times if you like. This lets you put your indexes in one place and your foreign keys in another.
+You can repeat `table` calls for the same table several times if you like. This lets you put your indexes in one place and your foreign keys in another, for example.
 
 
 Running db\_leftovers
@@ -76,8 +86,20 @@ Known Issues
 * db\_leftovers only supports PostgreSQL databases.
   If you want to add support for something else, just send me a pull request!
 
-* db\_leftovers will not notice if an index/foreign key definition changes.
+* db\_leftovers will not notice if an foreign key/constraint definition changes.
   Right now it only checks for existence/non-existence.
+  You can get around this by adding a version number to your constraint names,
+  so if you want to force books to have at least 12 pages, you can say this:
+
+  `check :books_have_positive_pages2, 'page_count >= 12'`
+
+  Then the old constraint will be dropped and the new one will be added.
+
+  However, db\_leftovers *does* check for index definitions, so if you
+  make an existing index unique, add a column, remove a WHERE clause, or
+  anything else, it will notice and drop and re-create the index.
+  I'm working on doing the same thing for foreign keys/constraints,
+  but it's not done just yet.
   
 * If your database is mostly up-to-date, then running the Rake task will spam
   you with messages about how this index and that foreign key already exist.

data/Rakefile

@@ -51,3 +51,7 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+task :readme => [] do |task|
+  `markdown README.md >README.html`
+end

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.5.0

data/db_leftovers.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = "db_leftovers"
-  s.version = "0.4.0"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Paul A. Jungwirth"]

data/lib/db_leftovers/database_interface.rb

@@ -4,6 +4,7 @@ module DBLeftovers
 
     def lookup_all_indexes
       ret = {}
+=begin
       sql = <<-EOQ
           SELECT  n.nspname as "Schema", c.relname as "Name",
                   CASE c.relkind WHEN 'r' THEN 'table' WHEN 'v' THEN 'view' WHEN 'i' THEN 'index' WHEN 'S' THEN 'sequence' WHEN 's' THEN 'special' END as "Type",
@@ -22,11 +23,64 @@ module DBLeftovers
           ORDER BY 1,2;
       EOQ
       ActiveRecord::Base.connection.select_rows(sql).each do |schema, index_name, object_type, owner, table_name|
-        ret[index_name] = table_name
+=end
+      sql = <<-EOQ
+          SELECT  ix.indexrelid,
+                  ix.indrelid,
+                  t.relname AS table_name,
+                  i.relname AS index_name,
+                  ix.indisunique AS is_unique,
+                  array_to_string(ix.indkey, ',') AS column_numbers,
+                  pg_get_expr(ix.indpred, ix.indrelid) AS where_clause
+          FROM    pg_class t,
+                  pg_class i,
+                  pg_index ix,
+                  pg_namespace n
+          WHERE   t.oid = ix.indrelid
+          AND     n.oid = t.relnamespace
+          AND     i.oid = ix.indexrelid
+          AND     t.relkind = 'r'
+          AND     n.nspname NOT IN ('pg_catalog', 'pg_toast')
+          AND     pg_catalog.pg_table_is_visible(t.oid)
+          AND     t.relname NOT IN ('delayed_jobs', 'schema_migrations')
+          AND     NOT ix.indisprimary
+          GROUP BY  t.relname,
+                    i.relname,
+                    ix.indisunique,
+                    ix.indexrelid,
+                    ix.indrelid
+                    ix.indkey,
+                    ix.indpred,
+          ORDER BY t.relname, i.relname
+      EOQ
+      ActiveRecord::Base.connection.select_rows(sql).each do |indexrelid, indrelid, table_name, index_name, is_unique, column_numbers, where_clause|
+        ret[index_name] = Index.new(
+          table_name,
+          column_names_for_index(indrelid, column_numbers.split(",")),
+          unique: is_unique,
+          where: where_clause,
+          name: index_name
+        )
       end
       return ret
     end
 
+
+
+    def column_names_for_index(table_id, column_numbers)
+      column_numbers.map do |c|
+        sql = <<-EOQ
+            SELECT  attname
+            FROM    pg_attribute
+            WHERE   attrelid = #{table_id}
+            AND     attnum = #{c}
+        EOQ
+        ActiveRecord::Base.connection.select_value(sql)
+      end
+    end
+
+
+
     def lookup_all_foreign_keys
       ret = {}
       sql = <<-EOQ
@@ -109,6 +163,7 @@ module DBLeftovers
       ActiveRecord::Base.connection.execute(sql)
     end
 
-  end
+    private
 
+  end
 end

data/lib/db_leftovers/dsl.rb

@@ -1,6 +1,11 @@
 module DBLeftovers
 
   class DSL
+
+    STATUS_EXISTS  = 'exists'
+    STATUS_CHANGED = 'changed'
+    STATUS_NEW     = 'new'
+
     def initialize
       @db = DatabaseInterface.new
       @indexes_by_table = {}      # Set from the DSL
@@ -44,9 +49,14 @@ module DBLeftovers
       @indexes_by_table.each do |table_name, indexes|
         indexes.each do |idx|
           # puts "#{idx.table_name}.[#{idx.column_names.join(',')}]"
-          if index_exists?(idx)
+          case index_status(idx)
+          when STATUS_EXISTS
             puts "Index already exists: #{idx.index_name} on #{idx.table_name}"
-          else
+          when STATUS_CHANGED
+            @db.execute_drop_index(idx.table_name, idx.index_name)
+            @db.execute_add_index(idx)
+            puts "Dropped & re-created index: #{idx.index_name} on #{idx.table_name}"
+          when STATUS_NEW
             @db.execute_add_index(idx)
             puts "Created index: #{idx.index_name} on #{idx.table_name}"
           end
@@ -55,11 +65,11 @@ module DBLeftovers
       end
 
       # Now drop any old indexes that are no longer in the definition file:
-      @old_indexes.each do |index_name, table_name|
+      @old_indexes.each do |index_name, idx|
         if not @new_indexes[index_name]
           # puts "#{index_name} #{table_name}"
-          @db.execute_drop_index(table_name, index_name)
-          puts "Dropped index: #{index_name} on #{table_name}"
+          @db.execute_drop_index(idx.table_name, index_name)
+          puts "Dropped index: #{index_name} on #{idx.table_name}"
         end
       end
     end
@@ -131,8 +141,13 @@ module DBLeftovers
       index_name[0,63]
     end
 
-    def index_exists?(idx)
-      @old_indexes[truncate_index_name(idx.index_name)]
+    def index_status(idx)
+      old = @old_indexes[truncate_index_name(idx.index_name)]
+      if old
+        return old.equals(idx) ? STATUS_EXISTS : STATUS_CHANGED
+      else
+        return STATUS_NEW
+      end
     end
 
     def foreign_key_exists?(fk)

data/lib/db_leftovers/foreign_key.rb

@@ -11,11 +11,11 @@ module DBLeftovers
       opts.keys.each do |k|
         raise "Unknown option: #{k}" unless [:set_null, :cascade].include?(k)
       end
-      @constraint_name = constraint_name
-      @from_table = from_table
-      @from_column = from_column
-      @to_table = to_table
-      @to_column = to_column
+      @constraint_name = constraint_name.to_s
+      @from_table = from_table.to_s
+      @from_column = from_column.to_s
+      @to_table = to_table.to_s
+      @to_column = to_column.to_s
 
       @set_null = opts[:set_null]
       @cascade = opts[:cascade]

data/lib/db_leftovers/index.rb

@@ -21,7 +21,15 @@ module DBLeftovers
     end
 
     def unique?
-      @unique
+      !!@unique
+    end
+
+    def equals(other)
+      other.table_name == table_name and
+      other.column_names == column_names and
+      other.index_name == index_name and
+      other.where_clause == where_clause and
+      other.unique == unique
     end
 
     private 

data/spec/db_leftovers_spec.rb

@@ -24,11 +24,11 @@ class DBLeftovers::DatabaseInterface
     )
   end
 
-  def self.starts_with(indexes, foreign_keys, constraints={})
+  def self.starts_with(indexes=[], foreign_keys=[], constraints=[])
     # Convert symbols to strings:
-    @@indexes = indexes.inject({}) do |h, (k, v)| h[k.to_s] = v; h end
-    @@foreign_keys = foreign_keys.inject({}) do |h, (k, v)| h[k.to_s] = v; h end
-    @@constraints = constraints.inject({}) do |h, (k, v)| h[k.to_s] = v; h end
+    @@indexes = Hash[indexes.map{|idx| [idx.index_name, idx]}]
+    @@foreign_keys = Hash[foreign_keys.map{|fk| [fk.constraint_name, fk]}]
+    @@constraints = Hash[constraints.map{|chk| [chk.constraint_name, chk]}]
   end
 
   def lookup_all_indexes
@@ -58,14 +58,14 @@ end
 describe DBLeftovers do
 
   it "should allow an empty definition" do
-    DBLeftovers::DatabaseInterface.starts_with({}, {})
+    DBLeftovers::DatabaseInterface.starts_with
     DBLeftovers::Definition.define do
     end
     DBLeftovers::DatabaseInterface.sqls.should be_empty
   end
 
   it "should allow an empty table definition" do
-    DBLeftovers::DatabaseInterface.starts_with({}, {})
+    DBLeftovers::DatabaseInterface.starts_with
     DBLeftovers::Definition.define do
       table :books do
       end
@@ -74,7 +74,7 @@ describe DBLeftovers do
   end
 
   it "should create indexes on an empty database" do
-    DBLeftovers::DatabaseInterface.starts_with({}, {})
+    DBLeftovers::DatabaseInterface.starts_with
     DBLeftovers::Definition.define do
       index :books, :shelf_id
       index :books, :publisher_id, :where => 'published'
@@ -96,7 +96,7 @@ describe DBLeftovers do
 
 
   it "should create table-prefixed indexes on an empty database" do
-    DBLeftovers::DatabaseInterface.starts_with({}, {})
+    DBLeftovers::DatabaseInterface.starts_with
     DBLeftovers::Definition.define do
       table :books do
         index :shelf_id
@@ -120,7 +120,7 @@ describe DBLeftovers do
 
 
   it "should create foreign keys on an empty database" do
-    DBLeftovers::DatabaseInterface.starts_with({}, {})
+    DBLeftovers::DatabaseInterface.starts_with
     DBLeftovers::Definition.define do
       foreign_key :books, :shelf_id, :shelves
       foreign_key :books, :publisher_id, :publishers, :id, :set_null => true
@@ -152,7 +152,7 @@ describe DBLeftovers do
 
 
   it "should create table-prefixed foreign keys on an empty database" do
-    DBLeftovers::DatabaseInterface.starts_with({}, {})
+    DBLeftovers::DatabaseInterface.starts_with
     DBLeftovers::Definition.define do
       table :books do
         foreign_key :shelf_id, :shelves
@@ -186,11 +186,10 @@ describe DBLeftovers do
 
 
   it "should not create indexes when they already exist" do
-    DBLeftovers::DatabaseInterface.starts_with({
-      :index_books_on_shelf_id => DBLeftovers::Index.new(:books, :index_id),
-      :index_books_on_publisher_id => DBLeftovers::Index.new(
-        :books, :publisher_id, :where => 'published')
-    }, {})
+    DBLeftovers::DatabaseInterface.starts_with([
+      DBLeftovers::Index.new(:books, :shelf_id),
+      DBLeftovers::Index.new(:books, :publisher_id, :where => 'published')
+    ])
     DBLeftovers::Definition.define do
       index :books, :shelf_id
       index :books, :publisher_id, :where => 'published'
@@ -200,13 +199,29 @@ describe DBLeftovers do
 
 
 
+  it "should create indexes when they have been redefined" do
+    DBLeftovers::DatabaseInterface.starts_with([
+      DBLeftovers::Index.new(:books, :shelf_id),
+      DBLeftovers::Index.new(:books, :publisher_id, :where => 'published'),
+      DBLeftovers::Index.new(:books, :isbn, :unique => true)
+    ])
+    DBLeftovers::Definition.define do
+      index :books, :shelf_id, :where => 'isbn IS NOT NULL'
+      index :books, :publisher_id
+      index :books, :isbn
+    end
+    DBLeftovers::DatabaseInterface.sqls.should have(6).items
+    DBLeftovers::DatabaseInterface.sqls[0].should =~ /DROP INDEX index_books_on_shelf_id/
+    DBLeftovers::DatabaseInterface.sqls[1].should =~ /CREATE\s+INDEX index_books_on_shelf_id/
+  end
+
+
 
   it "should not create table-prefixed indexes when they already exist" do
-    DBLeftovers::DatabaseInterface.starts_with({
-      :index_books_on_shelf_id => DBLeftovers::Index.new(:books, :index_id),
-      :index_books_on_publisher_id => DBLeftovers::Index.new(
-        :books, :publisher_id, :where => 'published')
-    }, {})
+    DBLeftovers::DatabaseInterface.starts_with([
+      DBLeftovers::Index.new(:books, :shelf_id),
+      DBLeftovers::Index.new(:books, :publisher_id, :where => 'published')
+    ])
     DBLeftovers::Definition.define do
       table :books do
         index :shelf_id
@@ -220,10 +235,9 @@ describe DBLeftovers do
 
 
   it "should not create foreign keys when they already exist" do
-    DBLeftovers::DatabaseInterface.starts_with({}, {
-      :fk_books_shelf_id => DBLeftovers::ForeignKey.new('fk_books_shelf_id',
-                                                        'books', 'shelf_id', 'shelves', 'id')
-    })
+    DBLeftovers::DatabaseInterface.starts_with([], [
+      DBLeftovers::ForeignKey.new('fk_books_shelf_id', 'books', 'shelf_id', 'shelves', 'id')
+    ])
     DBLeftovers::Definition.define do
       foreign_key :books, :shelf_id, :shelves
     end
@@ -233,10 +247,9 @@ describe DBLeftovers do
 
 
   it "should not create table-prefixed foreign keys when they already exist" do
-    DBLeftovers::DatabaseInterface.starts_with({}, {
-      :fk_books_shelf_id => DBLeftovers::ForeignKey.new('fk_books_shelf_id',
-                                                        'books', 'shelf_id', 'shelves', 'id')
-    })
+    DBLeftovers::DatabaseInterface.starts_with([], [
+      DBLeftovers::ForeignKey.new('fk_books_shelf_id', 'books', 'shelf_id', 'shelves', 'id')
+    ])
     DBLeftovers::Definition.define do
       table :books do
         foreign_key :shelf_id, :shelves
@@ -248,11 +261,10 @@ describe DBLeftovers do
 
 
   it "should drop indexes when they are removed from the definition" do
-    DBLeftovers::DatabaseInterface.starts_with({
-      :index_books_on_shelf_id => DBLeftovers::Index.new(:books, :index_id),
-      :index_books_on_publisher_id => DBLeftovers::Index.new(
-        :books, :publisher_id, :where => 'published')
-    }, {})
+    DBLeftovers::DatabaseInterface.starts_with([
+       DBLeftovers::Index.new(:books, :shelf_id),
+       DBLeftovers::Index.new(:books, :publisher_id, :where => 'published')
+    ])
     DBLeftovers::Definition.define do
       index :books, :shelf_id
     end
@@ -265,12 +277,10 @@ describe DBLeftovers do
 
 
   it "should drop foreign keys when they are removed from the definition" do
-    DBLeftovers::DatabaseInterface.starts_with({}, {
-      :fk_books_shelf_id => DBLeftovers::ForeignKey.new('fk_books_shelf_id',
-                                                        'books', 'shelf_id', 'shelves', 'id'),
-      :fk_books_author_id => DBLeftovers::ForeignKey.new('fk_books_author_id',
-                                                         'books', 'author_id', 'authors', 'id')
-    })
+    DBLeftovers::DatabaseInterface.starts_with([], [
+      DBLeftovers::ForeignKey.new('fk_books_shelf_id', 'books', 'shelf_id', 'shelves', 'id'),
+      DBLeftovers::ForeignKey.new('fk_books_author_id', 'books', 'author_id', 'authors', 'id')
+    ])
     DBLeftovers::Definition.define do
       foreign_key :books, :shelf_id, :shelves
     end
@@ -283,7 +293,7 @@ describe DBLeftovers do
 
 
   it "should support creating multi-column indexes" do
-    DBLeftovers::DatabaseInterface.starts_with({}, {})
+    DBLeftovers::DatabaseInterface.starts_with
     DBLeftovers::Definition.define do
       index :books, [:year, :title]
     end
@@ -298,9 +308,9 @@ describe DBLeftovers do
   
 
   it "should support dropping multi-column indexes" do
-    DBLeftovers::DatabaseInterface.starts_with({
-      :index_books_on_year_and_title => DBLeftovers::Index.new(:books, [:year, :title])
-    }, {})
+    DBLeftovers::DatabaseInterface.starts_with([
+      DBLeftovers::Index.new(:books, [:year, :title])
+    ])
     DBLeftovers::Definition.define do
     end
     DBLeftovers::DatabaseInterface.sqls.should have(1).item
@@ -312,7 +322,7 @@ describe DBLeftovers do
   
 
   it "should allow mixing indexes and foreign keys in the same table" do
-    DBLeftovers::DatabaseInterface.starts_with({}, {})
+    DBLeftovers::DatabaseInterface.starts_with
     DBLeftovers::Definition.define do
       table :books do
         index :author_id

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: db_leftovers
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -139,7 +139,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2560177434569701108
+      hash: 4584251961758391352
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: