db_schema 0.3.rc1 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60b581e6c318ed7bf979417435dce0ec4960a978
-  data.tar.gz: 0f296ac7525965a1bd3026e76cfa0cd2bb24b821
+  metadata.gz: 216fab4c9e20545d7653f46cdb5fe9ce5528a68a
+  data.tar.gz: a3115a63fd0a6da8289d1b7e6848e57620785563
 SHA512:
-  metadata.gz: 19375ec9fac1576a3c8164de6584ceacc21019d111bb2e584850713d89936a3714c394c0338c16eb5873c2f86d319286136690fad8cb28b2748dc911c625f3e8
-  data.tar.gz: b80cb8b4a448e5f0014763d89b1e2e2e376d48cd84f03380c55c823a71efe952d7187242888f021b27ccdbf3f85191b5286cefa11fd31d40ce7a3757f3d7dff4
+  metadata.gz: 2ef95f7dcf532b83a288423f0626943479a4353797e281e0df5aa0788508811b19de3382576a7ed78f40c0b664bcd7f455ce12c335cf8c7a59cbdf33eccf093c
+  data.tar.gz: 660d11cc3e03fb68b2227ebe4f6febb544d17454d842daa6ad6d8d5cc8ec8af550f3e6ef936c8a7cf18f177ec1edfc56c792e4c0f51407b509868acd39b16b0d

data/.travis.yml

@@ -2,7 +2,9 @@ dist: trusty
 sudo: false
 language: ruby
 rvm:
-  - 2.3.3
+  - 2.2.8
+  - 2.3.5
+  - 2.4.2
 services:
   - postgresql
 addons:

data/Guardfile

@@ -13,5 +13,6 @@ guard :rspec, cmd: 'bundle exec rspec', all_on_start: true do
   dsl.watch_spec_files_for(ruby.lib_files)
   watch(%r{lib/db_schema/definitions\.rb})    { rspec.spec_dir }
   watch(%r{lib/db_schema/definitions/.*\.rb}) { rspec.spec_dir }
+  watch(%r{lib/db_schema/operations\.rb})     { rspec.spec_dir }
   watch('lib/db_schema/utils.rb')             { rspec.spec_dir }
 end

data/README.md

@@ -53,7 +53,7 @@ But you would lose it even with manual migrations.
 Add this line to your application's Gemfile:
 
 ``` ruby
-gem 'db_schema', '~> 0.3.rc1'
+gem 'db_schema', '~> 0.3.0'
 ```
 
 And then execute:
@@ -65,521 +65,164 @@ $ bundle
 Or install it yourself as:
 
 ``` sh
-$ gem install db_schema --prerelease
+$ gem install db_schema
 ```
 
 ## Usage
 
-You define your schema with a special DSL; you can put it in `db/schema.rb` file or anywhere you want. Be sure to keep this file under version control.
+First you need to configure DbSchema so it knows how to connect to your database. This should happen
+in a file that is loaded during the application boot process - a Rails or Hanami initializer would do.
 
-DbSchema DSL looks like this:
-
-``` ruby
-DbSchema.describe do |db|
-  db.table :users do |t|
-    t.primary_key :id
-    t.varchar     :email,           null: false, unique: true
-    t.varchar     :password_digest, length: 40
-    t.timestamptz :created_at
-    t.timestamptz :updated_at
-  end
-end
-```
-
-Before DbSchema connects to the database you need to configure it:
+DbSchema can be configured with a call to `DbSchema.configure`:
 
 ``` ruby
+# config/initializers/db_schema.rb
 DbSchema.configure(
-  adapter:  'postgresql',
-  database: 'my_database',
-  user:     'bob',
-  password: 'secret'
-)
-
-# or in Rails
-DbSchema.configure_from_yaml(
-  Rails.root.join('config', 'database.yml'),
-  Rails.env
+  database: 'my_app_development'
 )
 ```
 
-Then you can load your schema definition (it is executable - it instantly applies itself to your database):
-
-``` ruby
-load 'path/to/schema.rb'
-```
-
-In order to get an always-up-to-date database schema in development and test environments you need to load the schema definition when your application is starting up. For instance, in Rails an initializer would be a good place to do that.
-
-On the other hand, in production environment this can cause race condition problems as your schema can be applied concurrently by different worker processes (this also applies to staging and any other environments where the application is being run by multi-worker servers); therefore it is wiser to disable schema auto loading in such environments and run it from a rake task on each deploy.
+There is also a Rails' `database.yml`-compatible `configure_from_yaml` method. DbSchema configuration
+is discussed in detail [here](https://github.com/7even/db_schema/wiki/Configuration).
 
-Here's an initializer example for a Rails app:
+After DbSchema is configured you can load your schema definition file:
 
 ``` ruby
 # config/initializers/db_schema.rb
-DbSchema.configure_from_yaml(
-  Rails.root.join('config', 'database.yml'),
-  Rails.env
-)
 
-if Rails.env.development? || Rails.env.test?
-  load Rails.root.join('db', 'schema.rb')
-end
+# ...
+load application_root.join('db/schema.rb')
 ```
 
-And the rake task:
-
-``` ruby
-# lib/tasks/db_schema.rake
-namespace :db do
-  namespace :schema do
-    desc 'Apply database schema'
-    task apply: :environment do
-      load Rails.root.join('db', 'schema.rb')
-    end
-  end
-end
-```
-
-Then you just call `rake db:schema:apply` from your deploy script before restarting the app.
-
-If your production setup doesn't include multiple workers starting simultaneously (for example if you run one Puma worker per docker container and restart containers one by one on deploy) you can go the simple way and just `load Rails.root.join('db', 'schema.rb')` in any environment without a separate rake task. The first DbSchema run will apply the schema while the subsequent ones will see there's nothing left to do.
-
-## DSL
-
-Database schema is defined with a block passed to `DbSchema.describe` method.
-This block receives a `db` object on which you can call `#table` to define a table,
-`#enum` to define a custom enum type and `#extension` to plug a Postgres extension into your database.
-Everything that belongs to a specific table is described in a block passed to `#table`.
+This `db/schema.rb` file will contain a description of your database structure
+(you can choose any filename you want). When you load this file it instantly
+applies the described structure to your database. Be sure to keep this file
+under version control as it will be a single source of truth about
+the database structure.
 
 ``` ruby
+# db/schema.rb
 DbSchema.describe do |db|
-  db.extension :hstore
-
   db.table :users do |t|
     t.primary_key :id
-    t.varchar     :email,    null: false, unique: true
-    t.varchar     :password, null: false
-    t.varchar     :name,     null: false
-    t.integer     :age
-    t.user_status :status,   null: false, default: 'registered'
-    t.hstore      :tracking, null: false, default: ''
-  end
-
-  db.enum :user_status, [:registered, :confirmed_email, :subscriber]
-
-  db.table :posts do |t|
-    t.primary_key :id
-    t.integer     :user_id, null: false, index: true, references: :users
-    t.varchar     :title,   null: false, length: 50
-    t.text        :content
-    t.array       :tags,    of: :varchar
+    t.varchar     :email,           null: false, unique: true
+    t.varchar     :password_digest, length: 40
+    t.timestamptz :created_at
+    t.timestamptz :updated_at
   end
 end
 ```
 
-### Tables
-
-Tables are described with the `#table` method; you pass it the name of the table and describe the table structure in the block:
-
-``` ruby
-db.table :users do |t|
-  t.varchar :email
-  t.varchar :password
-end
-```
-
-#### Fields
-
-You can define a field of any type by calling the corresponding method inside the table block passing it the field name and it's attributes. Most of the attributes are optional.
-
-Here's an example table with various kinds of data:
-
-``` ruby
-db.table :people do |t|
-  t.varchar     :first_name, length: 50, null: false
-  t.varchar     :last_name,  length: 60, null: false
-  t.integer     :age
-  t.numeric     :salary, precision: 10, scale: 2
-  t.text        :about
-  t.date        :birthday
-  t.boolean     :developer
-  t.inet        :ip_address
-  t.jsonb       :preferences, default: '{}'
-  t.array       :interests, of: :varchar
-  t.numrange    :salary_expectations
-
-  t.timestamptz :created_at
-  t.timestamptz :updated_at
-end
-```
-
-Passing `null: false` to the field definition makes it `NOT NULL`; passing some value under the `:default` key makes it the default value. You can use `String`s as SQL strings, `Fixnum`s as integers, `Float`s as floating point numbers, `true` & `false` as their SQL counterparts, `Date`s as SQL dates and `Time`s as timestamps. A symbol passed as a default is a special case: it is interpreted as an SQL expression so `t.timestamp :created_at, default: :'now()'` defines a field with a default value of `NOW()`.
-
-Other attributes are type specific, like `:length` for varchars; the following table lists them all (values in parentheses are default attribute values).
-
-| Type          | Attributes       |
-| ------------- | ---------------- |
-| `smallint`    |                  |
-| `integer`     |                  |
-| `bigint`      |                  |
-| `numeric`     | precision, scale |
-| `real`        |                  |
-| `float`       |                  |
-| `money`       |                  |
-| `char`        | length(1)        |
-| `varchar`     | length           |
-| `text`        |                  |
-| `bytea`       |                  |
-| `timestamp`   |                  |
-| `timestamptz` |                  |
-| `date`        |                  |
-| `time`        |                  |
-| `timetz`      |                  |
-| `interval`    | fields           |
-| `boolean`     |                  |
-| `point`       |                  |
-| `line`        |                  |
-| `lseg`        |                  |
-| `box`         |                  |
-| `path`        |                  |
-| `polygon`     |                  |
-| `circle`      |                  |
-| `cidr`        |                  |
-| `inet`        |                  |
-| `macaddr`     |                  |
-| `bit`         | length(1)        |
-| `varbit`      | length           |
-| `tsvector`    |                  |
-| `tsquery`     |                  |
-| `uuid`        |                  |
-| `json`        |                  |
-| `jsonb`       |                  |
-| `array`       | of               |
-| `int4range`   |                  |
-| `int8range`   |                  |
-| `numrange`    |                  |
-| `tsrange`     |                  |
-| `tstzrange`   |                  |
-| `daterange`   |                  |
-| `chkpass`     |                  |
-| `citext`      |                  |
-| `cube`        |                  |
-| `hstore`      |                  |
-| `ean13`       |                  |
-| `isbn13`      |                  |
-| `ismn13`      |                  |
-| `issn13`      |                  |
-| `isbn`        |                  |
-| `ismn`        |                  |
-| `issn`        |                  |
-| `upc`         |                  |
-| `ltree`       |                  |
-| `seg`         |                  |
-
-The `of` attribute of the array type is the only required attribute (you need to specify the array element type here); other attributes either have default values or can be omitted at all.
-
-You can also use your custom types in the same way: `t.user_status :status` creates a field called `status` with `user_status` type. Custom types are explained in a later section of this document.
-
-Primary key is a special case; currently when you create a primary key with DbSchema you get a NOT NULL autoincrementing (by a sequence) integer field with a primary key constraint. There is no way to change the primary key field type or make a complex primary key at the moment; this is planned for future versions of DbSchema.
-
-Primary keys are created with the `#primary_key` method:
-
-``` ruby
-db.table :posts do |t|
-  t.primary_key :id
-  t.varchar :title
-end
-```
-
-**Important: you can't rename a table or a column just by changing it's name in the schema definition - this will result in a column with the old name being deleted and a column with the new name being added; all data in that table or column will be lost.**
-
-#### Indexes
-
-Indexes are created using the `#index` method: you pass it the field name you want to index:
-
-``` ruby
-db.table :users do |t|
-  t.varchar :email
-  t.index :email
-end
-```
-
-Unique indexes are created with `unique: true`:
-
-``` ruby
-t.index :email, unique: true
-```
-
-Simple one-field indexes can be created with `index: true` and `unique: true` options passed to the field definition method so
-
-``` ruby
-db.table :users do |t|
-  t.varchar :name,  index: true
-  t.varchar :email, unique: true
-end
-```
-
-is essentially the same as
-
-``` ruby
-db.table :users do |t|
-  t.varchar :name
-  t.varchar :email
-
-  t.index :name
-  t.index :email, unique: true
-end
-```
-
-Passing several field names to `#index` makes a multiple index:
-
-``` ruby
-db.table :users do |t|
-  t.varchar :first_name
-  t.varchar :last_name
-
-  t.index :first_name, :last_name
-end
-```
-
-If you want to specify a custom name for your index, you can pass it in the `:name` option:
-
-``` ruby
-t.index :first_name, :last_name, name: :username_index
-```
-
-Otherwise the index name will be generated as `"#{table_name}_#{field_names.join('_')}_index"` so the index above will be called `users_first_name_last_name_index`.
-
-You can specify the order of each field in your index - it's either `ASC` (`:asc`, the default), `DESC` (`:desc`), `ASC NULLS FIRST` (`:asc_nulls_first`), or `DESC NULLS LAST` (`:desc_nulls_last`). It looks like this:
-
-``` ruby
-db.table :some_table do |t|
-  t.integer :col1
-  t.integer :col2
-  t.integer :col3
-  t.integer :col4
-
-  t.index col1: :asc, col2: :desc, col3: :asc_nulls_first, col4: :desc_nulls_last
-end
-```
-
-By default B-tree indexes are created; if you need an index of a different type you can pass it in the `:using` option:
+Database schema definition DSL is documented [here](https://github.com/7even/db_schema/wiki/Schema-definition-DSL).
 
-``` ruby
-db.table :users do |t|
-  t.array :interests, of: :varchar
-  t.index :interests, using: :gin
-end
-```
-
-You can also create a partial index if you pass some condition as SQL string in the `:where` option:
-
-``` ruby
-db.table :users do |t|
-  t.varchar :email
-  t.index :email, unique: true, where: 'email IS NOT NULL'
-end
-```
-
-If you need an index on expression you can use the same syntax replacing column names with SQL strings containing the expressions:
-
-``` ruby
-db.table :users do |t|
-  t.timestamp :created_at
-  t.index 'date(created_at)'
-end
-```
-
-Expression indexes syntax allows specifying an order exactly like in a common index on table fields - just use a hash form like `t.index 'date(created_at)' => :desc`. You can also use an expression in a multiple index.
+If you want to analyze your database structure in any way from your app (e.g. defining methods
+with `#define_method` for each enum value) you can use `DbSchema.current_schema` - it returns
+a cached copy of the database structure as a `DbSchema::Definitions::Schema` object which you
+can query in different ways. It is available after the schema was applied by DbSchema
+(`DbSchema.describe` remembers the current schema of the database and exposes it
+at `.current_schema`). Documentation for schema analysis DSL can be found
+[here](https://github.com/7even/db_schema/wiki/Schema-analysis-DSL).
 
-#### Foreign keys
+### Production setup
 
-The `#foreign_key` method defines a foreign key. In it's minimal form it takes a referencing field name and referenced table name:
+In order to get an always-up-to-date database schema in development and test environments
+you need to load the schema definition when your application is starting up. But if you use
+an application server with multiple workers (puma in cluster mode, unicorn) in other environments
+(production, staging) you may get yourself into situation when different workers simultaneously
+run DbSchema code applying the same changes to your database. If this is the case you will need
+to disable loading the schema definition in those environments and do that from a rake task called
+from your deploy script:
 
 ``` ruby
-db.table :users do |t|
-  t.primary_key :id
-  t.varchar :name
-end
-
-db.table :posts do |t|
-  t.integer :user_id
-  t.varchar :title
-
-  t.foreign_key :user_id, references: :users
-end
-```
-
-The syntax above assumes that this foreign key references the primary key. If you need to reference another field you can pass a 2-element array in `:references` option, the first element being table name and the second being field name:
-
-``` ruby
-db.table :users do |t|
-  t.varchar :name
-  t.index :name, unique: true # you can only reference either primary keys or unique columns
-end
-
-db.table :posts do |t|
-  t.varchar :username
-  t.foreign_key :username, references: [:users, :name]
-end
-```
-
-DbSchema also provides a short syntax for simple one-column foreign keys - just pass the `:references` option to the field definition:
-
-``` ruby
-db.table :posts do |t|
-  t.integer :user_id,  references: :users
-  t.varchar :username, references: [:users, :name]
-end
-```
-
-As with indexes, you can pass your custom name in the `:name` option; default foreign key name looks like `"#{table_name}_#{fkey_fields.first}_fkey"`.
-
-You can also define a composite foreign key consisting of (and referencing) multiple columns; just list them all:
-
-``` ruby
-db.table :table_a do |t|
-  t.integer :col1
-  t.integer :col2
-  t.index :col1, :col2, unique: true
-end
-
-db.table :table_b do |t|
-  t.integer :a_col1
-  t.integer :a_col2
-  t.foreign_key :a_col1, :a_col2, references: [:table_a, :col1, :col2]
-end
-```
-
-There are 3 more options to the `#foreign_key` method: `:on_update`, `:on_delete` and `:deferrable`. First two define an action that will be taken when a referenced column is changed or the whole referenced row is deleted, respectively; you can set these to one of `:no_action` (the default), `:restrict`, `:cascade`, `:set_null` or `:set_default`. See [PostgreSQL documentation](https://www.postgresql.org/docs/current/static/ddl-constraints.html#DDL-CONSTRAINTS-FK) for more information.
-
-Passing `deferrable: true` defines a foreign key that is checked at the end of transaction.
-
-#### Check constraints
-
-A check constraint is like a validation on the database side: it checks if the inserted/updated row has valid values.
-
-To define a check constraint you can use the `#check` method passing it the constraint name (no auto-generated names here, sorry) and the condition that must be satisfied, in a form of SQL string.
-
-``` ruby
-db.table :users do |t|
-  t.primary_key :id
-  t.varchar :name
-  t.integer :age, null: false
-
-  t.check :valid_age, 'age >= 18'
-end
-```
-
-As with indexes and foreign keys, DbSchema has a short syntax for simple check constraints - a `:check` option in the method definition:
-
-``` ruby
-db.table :products do |t|
-  t.primary_key :id
-  t.text :name,     null: false
-  t.numeric :price, check: 'price > 0'
-end
-```
-
-### Enum types
-
-PostgreSQL allows developers to create custom enum types; value of enum type is one of a fixed set of values stored in the type definition.
-
-Enum types are declared with the `#enum` method (note that you must call it from the top level of your schema and not from within some table definition):
-
-``` ruby
-db.enum :user_status, [:registered, :confirmed_email]
-```
-
-Then you can create fields of that type exactly as you would create a field of any built-in type - just call the method with the same name as the type you defined:
+# config/initializers/db_schema.rb
+DbSchema.configure(url: ENV['DATABASE_URL'])
 
-``` ruby
-db.table :users do |t|
-  t.user_status :status, default: 'registered'
+if ENV['APP_ENV'] == 'development' || ENV['APP_ENV'] == 'test'
+  load application_root.join('db/schema.rb')
 end
-```
-
-Arrays of enums are also supported - they are described just like arrays of any other element type:
-
-``` ruby
-db.enum :user_role, [:user, :manager, :admin]
 
-db.table :users do |t|
-  t.array :roles, of: :user_role, default: '{user}'
+# lib/tasks/db_schema.rake
+namespace :db do
+  namespace :schema do
+    desc 'Apply database schema'
+    task apply: :environment do
+      load application_root.join('db/schema.rb')
+    end
+  end
 end
 ```
 
-### Extensions
-
-PostgreSQL has a [wide variety](https://www.postgresql.org/docs/9.5/static/contrib.html) of extensions providing additional data types, functions and operators. You can use DbSchema to add and remove extensions in your database:
-
-``` ruby
-db.extension :hstore
-```
-
-*Note that adding and removing extensions in Postgres requires superuser privileges.*
-
-## Configuration
-
-DbSchema must be configured prior to applying the schema. There are 2 methods you can use for that: `configure` and `configure_from_yaml`.
-
-### DbSchema.configure
-
-`configure` is a generic method that receives a hash with all configuration options:
-
-``` ruby
-DbSchema.configure(
-  adapter:  'postgresql',
-  host:     ENV['db_host'],
-  port:     ENV['db_port'],
-  database: ENV['db_name'],
-  user:     ENV['db_user'],
-  password: ENV['db_password']
-)
-```
-
-### DbSchema.configure_from_yaml
-
-`configure_from_yaml` is designed to use with Rails so you don't have to duplicate database connection settings from your `database.yml` in DbSchema configuration. Pass it the full path to your `database.yml` file and your current application environment (`development`, `production` etc), and it will read the db connection settings from that file.
-
-``` ruby
-DbSchema.configure_from_yaml(Rails.root.join('config', 'database.yml'), Rails.env)
-```
-
-If you need to specify other options you can simply pass them as keyword arguments after the environment:
-
-``` ruby
-DbSchema.configure_from_yaml(
-  Rails.root.join('config', 'database.yml'),
-  Rails.env,
-  dry_run: true
-)
-```
-
-### Configuration options
-
-All configuration options are described in the following table:
-
-| Option      | Default value | Description                                      |
-| ----------- | ------------- | ------------------------------------------------ |
-| adapter     | `'postgres'`  | Database adapter                                 |
-| host        | `'localhost'` | Database host                                    |
-| port        | `5432`        | Database port                                    |
-| database    | (no default)  | Database name                                    |
-| user        | `nil`         | Database user                                    |
-| password    | `''`          | Database password                                |
-| log_changes | `true`        | When true, schema changes are logged             |
-| post_check  | `true`        | When true, database schema is checked afterwards |
-| dry_run     | `false`       | When true, no operations are actually made       |
-
-By default DbSchema logs the changes it applies to your database; you can disable that by setting `log_changes` to false.
-
-DbSchema provides an opt-out post-run schema check; it ensures that the schema was applied correctly and there are no remaining differences between your `schema.rb` and the actual database schema. The corresponding `post_check` option is likely to become off by default when DbSchema becomes more stable and battle-tested.
-
-There is also a dry run mode which does not apply the changes to your database - it just logs the necessary changes (if you leave `log_changes` set to `true`). Post check is also skipped in that case.
+Then you just call `rake db:schema:apply` from your deploy script before restarting the app.
 
-Dry run may be useful while you are building your schema definition for an existing app; adjust your `schema.rb` and apply it in dry run mode until it fits your database and next dry run doesn't report any changes. Don't forget to turn `dry_run` off afterwards!
+If your production setup doesn't include multiple application processes starting simultaneously
+(for example if you run one Puma process per docker container and replace containers
+successively on deploy) you can go the simple way and just
+`load application_root.join('db/schema.rb')` in any environment right from the initializer.
+The first puma process will apply the schema while the subsequent ones will see there's nothing
+left to do.
+
+### How it works
+
+When you call `DbSchema.describe` with a block that describes the database structure for your
+application DbSchema compares this *desired* structure with the *actual* structure your
+database has at the moment.
+
+The database structure is a tree; it's top-level node is a `Schema` object that has several
+child nodes - tables, enums and extensions. `Table` objects in turn have child nodes describing
+everything that belongs to a table - fields, indexes etc. The full tree structure looks like this:
+
+* Schema
+  * Table
+    * Field
+    * Index
+    * Check constraint
+    * Foreign key
+  * Enum type
+  * Extension
+
+DbSchema compares two structure trees by finding *objects with matching names* in both trees.
+*Desired* objects that don't have a match in the *actual* schema produce a **create** operation,
+while *actual* objects that don't have a counterpart in the *desired* schema generate a **drop**
+operation.
+
+Then each matching pair is compared by attributes and child objects:
+
+* if the objects differ in their attributes they make an **alter** operation if it is supported
+for that kind of object (that's tables, fields and enum types at the moment) or a pair of **drop**
+and **create** operations if it's not
+* if the objects differ in their child nodes then the process continues recursively for these
+two sets of child objects
+* if the objects are identical no operations take place on them
+
+Then DbSchema runs all these operations inside a transaction.
+
+For example if *desired* schema has tables `users`, `cities` and `posts`, and *actual* schema
+only has `users` and `posts` (where `posts` lack a couple of fields compared to the *desired*
+version), then the `cities` table will be created and new fields will be added to `posts`.
+
+The fact that objects are compared by name implies a very important detail: **you can't rename
+anything just by changing the name in the definition.**
+
+Imagine that you have a `foo` table in your schema definition and an identical table in the database.
+If you change it's name to `bar` in the definition and run your app DbSchema will see there
+is a `bar` table in the *desired* schema but no match in the database so a new `bar` table will be created;
+and since there is a `foo` table in the *actual* schema without a counterpart in the *desired*
+schema DbSchema will drop this table. Of course all data in the `foo` table will be lost.
+
+This can be solved with conditional migrations - a tool that allows you to make some changes to your database
+*before* the schema comparison described earlier takes control. A migration describes all required operations
+in an imperative manner (`rename_table`, `drop_index` etc) with a dedicated DSL. DbSchema doesn't store
+anything about migrations in the database though (as opposed to ActiveRecord or Sequel migrations);
+instead you have to provide some conditions required to run the migration (the goal here is to come up with
+conditions that a) will only trigger if the migration wasn't applied yet and b) are necessary for the
+migration to work) - like "rename the `users`
+table to `people` only if the database has a `users` table" (DbSchema also provides
+a [simple DSL](https://github.com/7even/db_schema/wiki/Schema-analysis-DSL) for schema analysis).
+This way the migration won't be applied again and the whole DbSchema process stays idempotent.
+Also you don't have to keep these migrations forever - once a migration is applied to databases
+in all environments you can safely delete it (though you can give your teammates a week or two to keep up).
+
+Conditional migrations are described [here](https://github.com/7even/db_schema/wiki/Conditional-Migrations).
 
 ## Known problems and limitations
 
@@ -587,7 +230,6 @@ Dry run may be useful while you are building your schema definition for an exist
 * array element type attributes are not supported
 * precision in all date/time types isn't supported
 * no support for databases other than PostgreSQL
-* no support for renaming tables & columns
 
 ## Development
 

data/lib/db_schema/awesome_print.rb

@@ -15,8 +15,13 @@ if defined?(AwesomePrint)
         case object
         when ::DbSchema::Definitions::Schema
           :dbschema_schema
-        when ::DbSchema::Definitions::NullTable
-          :dbschema_null_table
+        when ::DbSchema::Definitions::NullTable,
+             ::DbSchema::Definitions::NullField,
+             ::DbSchema::Definitions::NullIndex,
+             ::DbSchema::Definitions::NullCheckConstraint,
+             ::DbSchema::Definitions::NullForeignKey,
+             ::DbSchema::Definitions::NullEnum
+          :dbschema_null_object
         when ::DbSchema::Definitions::Table
           :dbschema_table
         when ::DbSchema::Definitions::Field::Custom
@@ -43,42 +48,28 @@ if defined?(AwesomePrint)
           :dbschema_alter_table
         when ::DbSchema::Operations::CreateColumn
           :dbschema_create_column
-        when ::DbSchema::Operations::DropColumn
+        when ::DbSchema::Operations::ColumnOperation
           :dbschema_column_operation
-        when ::DbSchema::Operations::RenameTable,
-             ::DbSchema::Operations::RenameColumn
+        when ::DbSchema::Operations::RenameOperation
           :dbschema_rename
         when ::DbSchema::Operations::AlterColumnType
           :dbschema_alter_column_type
-        when ::DbSchema::Operations::CreatePrimaryKey,
-             ::DbSchema::Operations::DropPrimaryKey,
-             ::DbSchema::Operations::AllowNull,
-             ::DbSchema::Operations::DisallowNull
-          :dbschema_column_operation
         when ::DbSchema::Operations::AlterColumnDefault
           :dbschema_alter_column_default
         when ::DbSchema::Operations::CreateIndex
           :dbschema_create_index
-        when ::DbSchema::Operations::DropIndex
-          :dbschema_column_operation
         when ::DbSchema::Operations::CreateCheckConstraint
           :dbschema_create_check_constraint
-        when ::DbSchema::Operations::DropCheckConstraint
-          :dbschema_column_operation
         when ::DbSchema::Operations::CreateForeignKey
           :dbschema_create_foreign_key
         when ::DbSchema::Operations::DropForeignKey
           :dbschema_drop_foreign_key
         when ::DbSchema::Operations::CreateEnum
           :dbschema_create_enum
-        when ::DbSchema::Operations::DropEnum
-          :dbschema_column_operation
         when ::DbSchema::Operations::AlterEnumValues
           :dbschema_alter_enum_values
         when ::DbSchema::Operations::CreateExtension
           :dbschema_create_extension
-        when ::DbSchema::Operations::DropExtension
-          :dbschema_column_operation
         else
           cast_without_dbschema(object, type)
         end
@@ -104,8 +95,8 @@ if defined?(AwesomePrint)
         "#<DbSchema::Definitions::Table #{object.name.ai} #{data_string}>"
       end
 
-      def awesome_dbschema_null_table(object)
-        '#<DbSchema::Definitions::NullTable>'
+      def awesome_dbschema_null_object(object)
+        "#<#{object.class}>"
       end
 
       def awesome_dbschema_field(object)

data/lib/db_schema/configuration.rb

@@ -4,7 +4,7 @@ module DbSchema
   class Configuration
     include Dry::Equalizer(:params)
 
-    DEFAULT_VALUES = {
+    DEFAULT_PARAMS = {
       adapter:     'postgres',
       host:        'localhost',
       port:        5432,
@@ -16,12 +16,18 @@ module DbSchema
       post_check:  true
     }.freeze
 
-    def initialize(params = {})
-      @params = DEFAULT_VALUES.merge(params)
+    def initialize(params = DEFAULT_PARAMS)
+      @params = params
     end
 
     def merge(new_params)
-      Configuration.new(@params.merge(new_params))
+      params = [
+        @params,
+        Configuration.params_from_url(new_params[:url]),
+        Utils.filter_by_keys(new_params, *DEFAULT_PARAMS.keys)
+      ].reduce(:merge)
+
+      Configuration.new(params)
     end
 
     [:adapter, :host, :port, :database, :user, :password].each do |param_name|
@@ -42,6 +48,22 @@ module DbSchema
       @params[:post_check]
     end
 
+    class << self
+      def params_from_url(url_string)
+        return {} if url_string.nil?
+        url = URI.parse(url_string)
+
+        Utils.remove_nil_values(
+          adapter:  url.scheme,
+          host:     url.host,
+          port:     url.port,
+          database: url.path.sub(/\A\//, ''),
+          user:     url.user,
+          password: url.password
+        )
+      end
+    end
+
   protected
     attr_reader :params
   end

data/lib/db_schema/definitions/enum.rb

@@ -15,7 +15,9 @@ module DbSchema
     end
 
     class NullEnum < Enum
-      def initialize; end
+      def initialize
+        @values = []
+      end
     end
   end
 end

data/lib/db_schema/definitions/foreign_key.rb

@@ -35,7 +35,10 @@ module DbSchema
     end
 
     class NullForeignKey < ForeignKey
-      def initialize; end
+      def initialize
+        @fields = []
+        @keys   = []
+      end
     end
   end
 end

data/lib/db_schema/definitions/table.rb

@@ -109,7 +109,12 @@ module DbSchema
     end
 
     class NullTable < Table
-      def initialize; end
+      def initialize
+        @fields       = []
+        @indices      = []
+        @checks       = []
+        @foreign_keys = []
+      end
     end
   end
 end

data/lib/db_schema/migrator.rb

@@ -15,7 +15,7 @@ module DbSchema
     end
 
     def run!(connection)
-      migration.body.call(BodyYielder.new(connection)) unless migration.body.nil?
+      migration.body.call(BodyYielder.new(connection), connection) unless migration.body.nil?
     end
 
     class BodyYielder
@@ -155,6 +155,10 @@ module DbSchema
         run Operations::DropEnum.new(name)
       end
 
+      def rename_enum(from, to:)
+        run Operations::RenameEnum.new(old_name: from, new_name: to)
+      end
+
       def create_extension(name)
         run Operations::CreateExtension.new(Definitions::Extension.new(name))
       end
@@ -167,8 +171,7 @@ module DbSchema
         run Operations::ExecuteQuery.new(query)
       end
 
-      private
-
+    private
       def run(operation)
         Runner.new(Array(operation), connection).run!
       end

data/lib/db_schema/operations.rb

@@ -1,5 +1,16 @@
 module DbSchema
   module Operations
+    # Abstract base class for rename operations.
+    class RenameOperation
+      include Dry::Equalizer(:old_name, :new_name)
+      attr_reader :old_name, :new_name
+
+      def initialize(old_name:, new_name:)
+        @old_name = old_name
+        @new_name = new_name
+      end
+    end
+
     class CreateTable
       include Dry::Equalizer(:table)
       attr_reader :table
@@ -18,14 +29,7 @@ module DbSchema
       end
     end
 
-    class RenameTable
-      include Dry::Equalizer(:old_name, :new_name)
-      attr_reader :old_name, :new_name
-
-      def initialize(old_name:, new_name:)
-        @old_name = old_name
-        @new_name = new_name
-      end
+    class RenameTable < RenameOperation
     end
 
     class AlterTable
@@ -76,14 +80,7 @@ module DbSchema
     class DropColumn < ColumnOperation
     end
 
-    class RenameColumn
-      include Dry::Equalizer(:old_name, :new_name)
-      attr_reader :old_name, :new_name
-
-      def initialize(old_name:, new_name:)
-        @old_name = old_name
-        @new_name = new_name
-      end
+    class RenameColumn < RenameOperation
     end
 
     class AlterColumnType
@@ -176,6 +173,9 @@ module DbSchema
     class DropEnum < ColumnOperation
     end
 
+    class RenameEnum < RenameOperation
+    end
+
     class AlterEnumValues
       include Dry::Equalizer(:enum_name, :new_values, :enum_fields)
       attr_reader :enum_name, :new_values, :enum_fields

data/lib/db_schema/runner.rb

@@ -26,6 +26,8 @@ module DbSchema
           create_enum(change)
         when Operations::DropEnum
           drop_enum(change)
+        when Operations::RenameEnum
+          rename_enum(change)
         when Operations::AlterEnumValues
           alter_enum_values(change)
         when Operations::CreateExtension
@@ -141,6 +143,13 @@ module DbSchema
       connection.drop_enum(change.name)
     end
 
+    def rename_enum(change)
+      old_name = connection.quote_identifier(change.old_name)
+      new_name = connection.quote_identifier(change.new_name)
+
+      connection.run(%Q(ALTER TYPE #{old_name} RENAME TO #{new_name}))
+    end
+
     def alter_enum_values(change)
       change.enum_fields.each do |field_data|
         connection.alter_table(field_data[:table_name]) do
@@ -172,11 +181,11 @@ module DbSchema
     end
 
     def create_extension(change)
-      connection.run(%Q(CREATE EXTENSION "#{change.extension.name}"))
+      connection.run(%Q(CREATE EXTENSION #{connection.quote_identifier(change.extension.name)}))
     end
 
     def drop_extension(change)
-      connection.run(%Q(DROP EXTENSION "#{change.name}"))
+      connection.run(%Q(DROP EXTENSION #{connection.quote_identifier(change.name)}))
     end
 
     def execute_query(change)

data/lib/db_schema/utils.rb

@@ -34,6 +34,16 @@ module DbSchema
         end
       end
 
+      def remove_nil_values(hash)
+        hash.reduce({}) do |new_hash, (key, value)|
+          if value.nil?
+            new_hash
+          else
+            new_hash.merge(key => value)
+          end
+        end
+      end
+
       def sort_by_class(array, sorted_classes)
         sorted_classes.flat_map do |klass|
           array.select { |object| object.is_a?(klass) }

data/lib/db_schema/version.rb

@@ -1,3 +1,3 @@
 module DbSchema
-  VERSION = '0.3.rc1'
+  VERSION = '0.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: db_schema
 version: !ruby/object:Gem::Version
-  version: 0.3.rc1
+  version: '0.3'
 platform: ruby
 authors:
 - Vsevolod Romashov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-08-17 00:00:00.000000000 Z
+date: 2017-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -249,12 +249,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Declarative database schema definition.