db_schema 0.2.5 → 0.3.rc1

data/lib/db_schema/migration.rb

@@ -0,0 +1,12 @@
+module DbSchema
+  class Migration
+    include Dry::Equalizer(:name, :conditions, :body)
+    attr_reader :name, :conditions
+    attr_accessor :body
+
+    def initialize(name)
+      @name = name
+      @conditions = { apply: [], skip: [] }
+    end
+  end
+end

data/lib/db_schema/migrator.rb

@@ -0,0 +1,177 @@
+module DbSchema
+  class Migrator
+    attr_reader :migration
+
+    def initialize(migration)
+      @migration = migration
+    end
+
+    def applicable?(schema)
+      migration.conditions[:apply].all? do |condition|
+        condition.call(schema)
+      end && migration.conditions[:skip].none? do |condition|
+        condition.call(schema)
+      end
+    end
+
+    def run!(connection)
+      migration.body.call(BodyYielder.new(connection)) unless migration.body.nil?
+    end
+
+    class BodyYielder
+      attr_reader :connection
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def create_table(name, &block)
+        table_yielder = DSL::TableYielder.new(name, block)
+
+        table = Definitions::Table.new(
+          name,
+          fields:       table_yielder.fields,
+          indices:      table_yielder.indices,
+          checks:       table_yielder.checks,
+          foreign_keys: table_yielder.foreign_keys
+        )
+
+        run Operations::CreateTable.new(table)
+
+        table.foreign_keys.each do |fkey|
+          run Operations::CreateForeignKey.new(table.name, fkey)
+        end
+      end
+
+      def drop_table(name)
+        run Operations::DropTable.new(name)
+      end
+
+      def rename_table(from, to:)
+        run Operations::RenameTable.new(old_name: from, new_name: to)
+      end
+
+      def alter_table(name, &block)
+        run AlterTableYielder.new(name).run(block)
+      end
+
+      class AlterTableYielder
+        attr_reader :alter_table, :fkey_operations
+
+        def initialize(table_name)
+          @alter_table = Operations::AlterTable.new(table_name)
+          @fkey_operations = []
+        end
+
+        def run(block)
+          block.call(self)
+
+          [alter_table, *fkey_operations]
+        end
+
+        def add_column(name, type, **options)
+          alter_table.changes << Operations::CreateColumn.new(
+            Definitions::Field.build(name, type, options)
+          )
+        end
+
+        def drop_column(name)
+          alter_table.changes << Operations::DropColumn.new(name)
+        end
+
+        def rename_column(from, to:)
+          alter_table.changes << Operations::RenameColumn.new(old_name: from, new_name: to)
+        end
+
+        def alter_column_type(name, new_type, using: nil, **new_attributes)
+          alter_table.changes << Operations::AlterColumnType.new(
+            name,
+            new_type: new_type,
+            using: using,
+            **new_attributes
+          )
+        end
+
+        def allow_null(name)
+          alter_table.changes << Operations::AllowNull.new(name)
+        end
+
+        def disallow_null(name)
+          alter_table.changes << Operations::DisallowNull.new(name)
+        end
+
+        def alter_column_default(name, new_default)
+          alter_table.changes << Operations::AlterColumnDefault.new(name, new_default: new_default)
+        end
+
+        def add_index(*columns, **index_options)
+          alter_table.changes << Operations::CreateIndex.new(
+            DSL::TableYielder.build_index(
+              columns,
+              table_name: alter_table.table_name,
+              **index_options
+            )
+          )
+        end
+
+        def drop_index(name)
+          alter_table.changes << Operations::DropIndex.new(name)
+        end
+
+        def add_check(name, condition)
+          alter_table.changes << Operations::CreateCheckConstraint.new(
+            Definitions::CheckConstraint.new(name: name, condition: condition)
+          )
+        end
+
+        def drop_check(name)
+          alter_table.changes << Operations::DropCheckConstraint.new(name)
+        end
+
+        def add_foreign_key(*fkey_fields, **fkey_options)
+          fkey_operations << Operations::CreateForeignKey.new(
+            alter_table.table_name,
+            DSL::TableYielder.build_foreign_key(
+              fkey_fields,
+              table_name: alter_table.table_name,
+              **fkey_options
+            )
+          )
+        end
+
+        def drop_foreign_key(fkey_name)
+          fkey_operations << Operations::DropForeignKey.new(
+            alter_table.table_name,
+            fkey_name
+          )
+        end
+      end
+
+      def create_enum(name, values)
+        run Operations::CreateEnum.new(Definitions::Enum.new(name, values))
+      end
+
+      def drop_enum(name)
+        run Operations::DropEnum.new(name)
+      end
+
+      def create_extension(name)
+        run Operations::CreateExtension.new(Definitions::Extension.new(name))
+      end
+
+      def drop_extension(name)
+        run Operations::DropExtension.new(name)
+      end
+
+      def execute(query)
+        run Operations::ExecuteQuery.new(query)
+      end
+
+      private
+
+      def run(operation)
+        Runner.new(Array(operation), connection).run!
+      end
+    end
+  end
+end

data/lib/db_schema/normalizer.rb

@@ -2,20 +2,21 @@ require 'digest/md5'
 
 module DbSchema
   class Normalizer
-    attr_reader :schema
+    attr_reader :schema, :connection
 
-    def initialize(schema)
-      @schema = schema
+    def initialize(schema, connection)
+      @schema     = schema
+      @connection = connection
     end
 
     def normalize_tables
-      DbSchema.connection.transaction do
+      connection.transaction do
         create_extensions!
         create_enums!
 
         schema.tables = schema.tables.map do |table|
           if table.has_expressions?
-            Table.new(table, hash).normalized_table
+            Table.new(table, hash, connection).normalized_table
           else
             table
           end
@@ -27,19 +28,19 @@ module DbSchema
 
   private
     def create_extensions!
-      operations = (schema.extensions - Reader.read_extensions).map do |extension|
-        Changes::CreateExtension.new(extension)
+      operations = (schema.extensions - Reader.read_extensions(connection)).map do |extension|
+        Operations::CreateExtension.new(extension)
       end
 
-      Runner.new(operations).run!
+      Runner.new(operations, connection).run!
     end
 
     def create_enums!
       operations = schema.enums.map do |enum|
-        Changes::CreateEnum.new(enum.with_name(append_hash(enum.name)))
+        Operations::CreateEnum.new(enum.with_name(append_hash(enum.name)))
       end
 
-      Runner.new(operations).run!
+      Runner.new(operations, connection).run!
     end
 
     def append_hash(name)
@@ -57,11 +58,12 @@ module DbSchema
     end
 
     class Table
-      attr_reader :table, :hash
+      attr_reader :table, :hash, :connection
 
-      def initialize(table, hash)
-        @table = table
-        @hash  = hash
+      def initialize(table, hash, connection)
+        @table      = table
+        @hash       = hash
+        @connection = connection
       end
 
       def normalized_table
@@ -71,17 +73,17 @@ module DbSchema
 
     private
       def create_temporary_table!
-        operation = Changes::CreateTable.new(
+        operation = Operations::CreateTable.new(
           table.with_name(temporary_table_name)
             .with_fields(rename_types(table.fields))
             .with_indices(rename_indices(table.indices))
         )
 
-        Runner.new([operation]).run!
+        Runner.new([operation], connection).run!
       end
 
       def read_temporary_table
-        temporary_table = Reader.read_table(temporary_table_name)
+        temporary_table = Reader.read_table(temporary_table_name, connection)
 
         temporary_table.with_name(table.name)
           .with_fields(rename_types_back(temporary_table.fields))

data/lib/db_schema/operations.rb

@@ -0,0 +1,211 @@
+module DbSchema
+  module Operations
+    class CreateTable
+      include Dry::Equalizer(:table)
+      attr_reader :table
+
+      def initialize(table)
+        @table = table
+      end
+    end
+
+    class DropTable
+      include Dry::Equalizer(:name)
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      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
+    end
+
+    class AlterTable
+      include Dry::Equalizer(:table_name, :changes)
+      attr_reader :table_name, :changes
+
+      def initialize(table_name, changes = [])
+        @table_name = table_name
+        @changes    = changes
+      end
+    end
+
+    # Abstract base class for single-column toggle operations.
+    class ColumnOperation
+      include Dry::Equalizer(:name)
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+    end
+
+    class CreateColumn
+      include Dry::Equalizer(:field)
+      attr_reader :field
+
+      def initialize(field)
+        @field = field
+      end
+
+      def name
+        field.name
+      end
+
+      def type
+        field.type
+      end
+
+      def primary_key?
+        field.primary_key?
+      end
+
+      def options
+        field.options
+      end
+    end
+
+    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
+    end
+
+    class AlterColumnType
+      include Dry::Equalizer(:name, :new_type, :using, :new_attributes)
+      attr_reader :name, :new_type, :using, :new_attributes
+
+      def initialize(name, new_type:, using: nil, **new_attributes)
+        @name           = name
+        @new_type       = new_type
+        @using          = using
+        @new_attributes = new_attributes
+      end
+    end
+
+    class CreatePrimaryKey < ColumnOperation
+    end
+
+    class DropPrimaryKey < ColumnOperation
+    end
+
+    class AllowNull < ColumnOperation
+    end
+
+    class DisallowNull < ColumnOperation
+    end
+
+    class AlterColumnDefault
+      include Dry::Equalizer(:name, :new_default)
+      attr_reader :name, :new_default
+
+      def initialize(name, new_default:)
+        @name        = name
+        @new_default = new_default
+      end
+    end
+
+    class CreateIndex
+      include Dry::Equalizer(:index)
+      attr_reader :index
+
+      def initialize(index)
+        @index = index
+      end
+    end
+
+    class DropIndex < ColumnOperation
+    end
+
+    class CreateCheckConstraint
+      include Dry::Equalizer(:check)
+      attr_reader :check
+
+      def initialize(check)
+        @check = check
+      end
+    end
+
+    class DropCheckConstraint < ColumnOperation
+    end
+
+    class CreateForeignKey
+      include Dry::Equalizer(:table_name, :foreign_key)
+      attr_reader :table_name, :foreign_key
+
+      def initialize(table_name, foreign_key)
+        @table_name  = table_name
+        @foreign_key = foreign_key
+      end
+    end
+
+    class DropForeignKey
+      include Dry::Equalizer(:table_name, :fkey_name)
+      attr_reader :table_name, :fkey_name
+
+      def initialize(table_name, fkey_name)
+        @table_name = table_name
+        @fkey_name  = fkey_name
+      end
+    end
+
+    class CreateEnum
+      include Dry::Equalizer(:enum)
+      attr_reader :enum
+
+      def initialize(enum)
+        @enum = enum
+      end
+    end
+
+    class DropEnum < ColumnOperation
+    end
+
+    class AlterEnumValues
+      include Dry::Equalizer(:enum_name, :new_values, :enum_fields)
+      attr_reader :enum_name, :new_values, :enum_fields
+
+      def initialize(enum_name, new_values, enum_fields)
+        @enum_name   = enum_name
+        @new_values  = new_values
+        @enum_fields = enum_fields
+      end
+    end
+
+    class CreateExtension
+      include Dry::Equalizer(:extension)
+      attr_reader :extension
+
+      def initialize(extension)
+        @extension = extension
+      end
+    end
+
+    class DropExtension < ColumnOperation
+    end
+
+    class ExecuteQuery
+      include Dry::Equalizer(:query)
+      attr_reader :query
+
+      def initialize(query)
+        @query = query
+      end
+    end
+  end
+end