db_schema 0.2.5 → 0.3.rc1

data/lib/db_schema/reader.rb

@@ -1,18 +1,29 @@
 module DbSchema
   module Reader
     class << self
-      extend Forwardable
+      def read_schema(connection)
+        adapter(connection).read_schema(connection)
+      end
+
+      def read_table(table_name, connection)
+        adapter(connection).read_table(table_name, connection)
+      end
+
+      def read_enums(connection)
+        adapter(connection).read_enums(connection)
+      end
 
-      def_delegators :adapter, :read_schema, :read_table, :read_enums, :read_extensions
+      def read_extensions(connection)
+        adapter(connection).read_extensions(connection)
+      end
 
-      def adapter
-        adapter_name = DbSchema.configuration.adapter
-        registry.fetch(adapter_name) do |adapter_name|
+    private
+      def adapter(connection)
+        registry.fetch(connection.adapter_scheme) do |adapter_name|
           raise NotImplementedError, "DbSchema::Reader does not support #{adapter_name}."
         end
       end
 
-    private
       def registry
         @registry ||= {}
       end
@@ -116,30 +127,30 @@ SELECT extname
       SQL
 
       class << self
-        def read_schema
+        def read_schema(connection)
           Definitions::Schema.new(
-            tables:     read_tables,
-            enums:      read_enums,
-            extensions: read_extensions
+            tables:     read_tables(connection),
+            enums:      read_enums(connection),
+            extensions: read_extensions(connection)
           )
         end
 
-        def read_table(table_name)
-          primary_key_name = DbSchema.connection.primary_key(table_name)
+        def read_table(table_name, connection)
+          primary_key_name = connection.primary_key(table_name)
 
-          fields = DbSchema.connection[COLUMN_NAMES_QUERY, table_name.to_s].map do |column_data|
+          fields = connection[COLUMN_NAMES_QUERY, table_name.to_s].map do |column_data|
             build_field(column_data, primary_key: column_data[:name] == primary_key_name)
           end
 
-          indices = indices_data_for(table_name).map do |index_data|
+          indices = indices_data_for(table_name, connection).map do |index_data|
             Definitions::Index.new(index_data)
           end.sort_by(&:name)
 
-          foreign_keys = DbSchema.connection.foreign_key_list(table_name).map do |foreign_key_data|
-            build_foreign_key(foreign_key_data)
+          foreign_keys = connection.foreign_key_list(table_name).map do |foreign_key_data|
+            build_foreign_key(foreign_key_data, connection)
           end
 
-          checks = DbSchema.connection[CONSTRAINTS_QUERY, table_name.to_s].map do |check_data|
+          checks = connection[CONSTRAINTS_QUERY, table_name.to_s].map do |check_data|
             Definitions::CheckConstraint.new(
               name:      check_data[:name].to_sym,
               condition: check_data[:condition]
@@ -155,13 +166,13 @@ SELECT extname
           )
         end
 
-        def indices_data_for(table_name)
-          column_names = DbSchema.connection[COLUMN_NAMES_QUERY, table_name.to_s].reduce({}) do |names, column|
+        def indices_data_for(table_name, connection)
+          column_names = connection[COLUMN_NAMES_QUERY, table_name.to_s].reduce({}) do |names, column|
             names.merge(column[:pos] => column[:name].to_sym)
           end
 
-          indices_data     = DbSchema.connection[INDICES_QUERY, table_name.to_s].to_a
-          expressions_data = index_expressions_data(indices_data)
+          indices_data     = connection[INDICES_QUERY, table_name.to_s].to_a
+          expressions_data = index_expressions_data(indices_data, connection)
 
           indices_data.map do |index|
             positions = index[:column_positions].split(' ').map(&:to_i)
@@ -197,26 +208,26 @@ SELECT extname
           end
         end
 
-        def read_tables
-          DbSchema.connection.tables.map do |table_name|
-            read_table(table_name)
+        def read_tables(connection)
+          connection.tables.map do |table_name|
+            read_table(table_name, connection)
           end
         end
 
-        def read_enums
-          DbSchema.connection[ENUMS_QUERY].map do |enum_data|
+        def read_enums(connection)
+          connection[ENUMS_QUERY].map do |enum_data|
             Definitions::Enum.new(enum_data[:name].to_sym, enum_data[:values].map(&:to_sym))
           end
         end
 
-        def read_extensions
-          DbSchema.connection[EXTENSIONS_QUERY].map do |extension_data|
+        def read_extensions(connection)
+          connection[EXTENSIONS_QUERY].map do |extension_data|
             Definitions::Extension.new(extension_data[:extname].to_sym)
           end
         end
 
       private
-        def index_expressions_data(indices_data)
+        def index_expressions_data(indices_data, connection)
           all_positions, max_position = {}, 0
 
           indices_data.each do |index_data|
@@ -230,7 +241,7 @@ SELECT extname
           end
 
           if all_positions.any?
-            DbSchema.connection[
+            connection[
               EXPRESSION_INDICES_QUERY,
               Sequel.pg_array(all_positions.keys),
               Sequel.pg_array((1..max_position.succ).to_a)
@@ -318,8 +329,8 @@ SELECT extname
           )
         end
 
-        def build_foreign_key(data)
-          keys = if data[:key] == [primary_key_for(data[:table])]
+        def build_foreign_key(data, connection)
+          keys = if data[:key] == [primary_key_for(data[:table], connection)]
             [] # this foreign key references a primary key
           else
             data[:key]
@@ -336,15 +347,14 @@ SELECT extname
           )
         end
 
-        def primary_key_for(table_name)
-          if pkey = DbSchema.connection.primary_key(table_name)
+        def primary_key_for(table_name, connection)
+          if pkey = connection.primary_key(table_name)
             pkey.to_sym
           end
         end
       end
     end
 
-    registry['postgres'] = Postgres
-    registry['postgresql'] = Postgres
+    registry[:postgres] = Postgres
   end
 end

data/lib/db_schema/runner.rb

@@ -1,213 +1,189 @@
 module DbSchema
   class Runner
-    attr_reader :changes
+    attr_reader :changes, :connection
 
-    def initialize(changes)
-      @changes = preprocess_changes(changes)
+    def initialize(changes, connection)
+      @changes    = changes
+      @connection = connection
     end
 
     def run!
-      DbSchema.connection.transaction do
-        changes.each do |change|
-          case change
-          when Changes::CreateTable
-            self.class.create_table(change)
-          when Changes::DropTable
-            self.class.drop_table(change)
-          when Changes::AlterTable
-            self.class.alter_table(change)
-          when Changes::CreateForeignKey
-            self.class.create_foreign_key(change)
-          when Changes::DropForeignKey
-            self.class.drop_foreign_key(change)
-          when Changes::CreateEnum
-            self.class.create_enum(change)
-          when Changes::DropEnum
-            self.class.drop_enum(change)
-          when Changes::AlterEnumValues
-            self.class.alter_enum_values(change)
-          when Changes::CreateExtension
-            self.class.create_extension(change)
-          when Changes::DropExtension
-            self.class.drop_extension(change)
-          end
+      changes.each do |change|
+        case change
+        when Operations::CreateTable
+          create_table(change)
+        when Operations::DropTable
+          drop_table(change)
+        when Operations::RenameTable
+          rename_table(change)
+        when Operations::AlterTable
+          alter_table(change)
+        when Operations::CreateForeignKey
+          create_foreign_key(change)
+        when Operations::DropForeignKey
+          drop_foreign_key(change)
+        when Operations::CreateEnum
+          create_enum(change)
+        when Operations::DropEnum
+          drop_enum(change)
+        when Operations::AlterEnumValues
+          alter_enum_values(change)
+        when Operations::CreateExtension
+          create_extension(change)
+        when Operations::DropExtension
+          drop_extension(change)
+        when Operations::ExecuteQuery
+          execute_query(change)
         end
       end
     end
 
   private
-    def preprocess_changes(changes)
-      Utils.sort_by_class(
-        changes,
-        [
-          Changes::CreateExtension,
-          Changes::DropForeignKey,
-          Changes::AlterEnumValues,
-          Changes::CreateEnum,
-          Changes::CreateTable,
-          Changes::AlterTable,
-          Changes::DropTable,
-          Changes::DropEnum,
-          Changes::CreateForeignKey,
-          Changes::DropExtension
-        ]
-      )
-    end
-
-    class << self
-      def create_table(change)
-        DbSchema.connection.create_table(change.table.name) do
-          change.table.fields.each do |field|
-            if field.primary_key?
-              primary_key(field.name)
-            else
-              options = Runner.map_options(field.class.type, field.options)
-              column(field.name, field.type.capitalize, options)
-            end
+    def create_table(change)
+      connection.create_table(change.table.name) do
+        change.table.fields.each do |field|
+          if field.primary_key?
+            primary_key(field.name)
+          else
+            options = Runner.map_options(field.class.type, field.options)
+            column(field.name, field.type.capitalize, options)
           end
+        end
 
-          change.table.indices.each do |index|
-            index(
-              index.columns_to_sequel,
-              name:   index.name,
-              unique: index.unique?,
-              type:   index.type,
-              where:  index.condition
-            )
-          end
+        change.table.indices.each do |index|
+          index(
+            index.columns_to_sequel,
+            name:   index.name,
+            unique: index.unique?,
+            type:   index.type,
+            where:  index.condition
+          )
+        end
 
-          change.table.checks.each do |check|
-            constraint(check.name, check.condition)
-          end
+        change.table.checks.each do |check|
+          constraint(check.name, check.condition)
         end
       end
+    end
 
-      def drop_table(change)
-        DbSchema.connection.drop_table(change.name)
-      end
+    def drop_table(change)
+      connection.drop_table(change.name)
+    end
 
-      def alter_table(change)
-        DbSchema.connection.alter_table(change.table_name) do
-          Utils.sort_by_class(
-            change.changes,
-            [
-              DbSchema::Changes::DropPrimaryKey,
-              DbSchema::Changes::DropCheckConstraint,
-              DbSchema::Changes::DropIndex,
-              DbSchema::Changes::DropColumn,
-              DbSchema::Changes::RenameColumn,
-              DbSchema::Changes::AlterColumnType,
-              DbSchema::Changes::AllowNull,
-              DbSchema::Changes::DisallowNull,
-              DbSchema::Changes::AlterColumnDefault,
-              DbSchema::Changes::CreateColumn,
-              DbSchema::Changes::CreateIndex,
-              DbSchema::Changes::CreateCheckConstraint,
-              DbSchema::Changes::CreatePrimaryKey
-            ]
-          ).each do |element|
-            case element
-            when Changes::CreateColumn
-              if element.primary_key?
-                add_primary_key(element.name)
-              else
-                options = Runner.map_options(element.type, element.options)
-                add_column(element.name, element.type.capitalize, options)
-              end
-            when Changes::DropColumn
-              drop_column(element.name)
-            when Changes::RenameColumn
-              rename_column(element.old_name, element.new_name)
-            when Changes::AlterColumnType
-              attributes = Runner.map_options(element.new_type, element.new_attributes)
-              set_column_type(element.name, element.new_type.capitalize, attributes)
-            when Changes::CreatePrimaryKey
-              raise NotImplementedError, 'Converting an existing column to primary key is currently unsupported'
-            when Changes::DropPrimaryKey
-              raise NotImplementedError, 'Removing a primary key while leaving the column is currently unsupported'
-            when Changes::AllowNull
-              set_column_allow_null(element.name)
-            when Changes::DisallowNull
-              set_column_not_null(element.name)
-            when Changes::AlterColumnDefault
-              set_column_default(element.name, Runner.default_to_sequel(element.new_default))
-            when Changes::CreateIndex
-              add_index(
-                element.index.columns_to_sequel,
-                name:   element.index.name,
-                unique: element.index.unique?,
-                type:   element.index.type,
-                where:  element.index.condition
-              )
-            when Changes::DropIndex
-              drop_index([], name: element.name)
-            when Changes::CreateCheckConstraint
-              add_constraint(element.check.name, element.check.condition)
-            when Changes::DropCheckConstraint
-              drop_constraint(element.name)
+    def rename_table(change)
+      connection.rename_table(change.old_name, change.new_name)
+    end
+
+    def alter_table(change)
+      connection.alter_table(change.table_name) do
+        change.changes.each do |element|
+          case element
+          when Operations::CreateColumn
+            if element.primary_key?
+              add_primary_key(element.name)
+            else
+              options = Runner.map_options(element.type, element.options)
+              add_column(element.name, element.type.capitalize, options)
             end
+          when Operations::DropColumn
+            drop_column(element.name)
+          when Operations::RenameColumn
+            rename_column(element.old_name, element.new_name)
+          when Operations::AlterColumnType
+            attributes = Runner.map_options(element.new_type, element.new_attributes)
+            set_column_type(element.name, element.new_type.capitalize, using: element.using, **attributes)
+          when Operations::CreatePrimaryKey
+            raise NotImplementedError, 'Converting an existing column to primary key is currently unsupported'
+          when Operations::DropPrimaryKey
+            raise NotImplementedError, 'Removing a primary key while leaving the column is currently unsupported'
+          when Operations::AllowNull
+            set_column_allow_null(element.name)
+          when Operations::DisallowNull
+            set_column_not_null(element.name)
+          when Operations::AlterColumnDefault
+            set_column_default(element.name, Runner.default_to_sequel(element.new_default))
+          when Operations::CreateIndex
+            add_index(
+              element.index.columns_to_sequel,
+              name:   element.index.name,
+              unique: element.index.unique?,
+              type:   element.index.type,
+              where:  element.index.condition
+            )
+          when Operations::DropIndex
+            drop_index([], name: element.name)
+          when Operations::CreateCheckConstraint
+            add_constraint(element.check.name, element.check.condition)
+          when Operations::DropCheckConstraint
+            drop_constraint(element.name)
           end
         end
       end
+    end
 
-      def create_foreign_key(change)
-        DbSchema.connection.alter_table(change.table_name) do
-          add_foreign_key(change.foreign_key.fields, change.foreign_key.table, change.foreign_key.options)
-        end
+    def create_foreign_key(change)
+      connection.alter_table(change.table_name) do
+        add_foreign_key(change.foreign_key.fields, change.foreign_key.table, change.foreign_key.options)
       end
+    end
 
-      def drop_foreign_key(change)
-        DbSchema.connection.alter_table(change.table_name) do
-          drop_foreign_key([], name: change.fkey_name)
-        end
+    def drop_foreign_key(change)
+      connection.alter_table(change.table_name) do
+        drop_foreign_key([], name: change.fkey_name)
       end
+    end
 
-      def create_enum(change)
-        DbSchema.connection.create_enum(change.enum.name, change.enum.values)
-      end
+    def create_enum(change)
+      connection.create_enum(change.enum.name, change.enum.values)
+    end
 
-      def drop_enum(change)
-        DbSchema.connection.drop_enum(change.name)
-      end
+    def drop_enum(change)
+      connection.drop_enum(change.name)
+    end
 
-      def alter_enum_values(change)
-        change.enum_fields.each do |field_data|
-          DbSchema.connection.alter_table(field_data[:table_name]) do
-            set_column_type(field_data[:field_name], :VARCHAR)
-            set_column_default(field_data[:field_name], nil)
-          end
+    def alter_enum_values(change)
+      change.enum_fields.each do |field_data|
+        connection.alter_table(field_data[:table_name]) do
+          set_column_type(field_data[:field_name], :VARCHAR)
+          set_column_default(field_data[:field_name], nil)
         end
+      end
 
-        DbSchema.connection.drop_enum(change.enum_name)
-        DbSchema.connection.create_enum(change.enum_name, change.new_values)
+      connection.drop_enum(change.enum_name)
+      connection.create_enum(change.enum_name, change.new_values)
 
-        change.enum_fields.each do |field_data|
-          DbSchema.connection.alter_table(field_data[:table_name]) do
-            field_type = if field_data[:array]
-              "#{change.enum_name}[]"
-            else
-              change.enum_name
-            end
+      change.enum_fields.each do |field_data|
+        connection.alter_table(field_data[:table_name]) do
+          field_type = if field_data[:array]
+            "#{change.enum_name}[]"
+          else
+            change.enum_name
+          end
 
-            set_column_type(
-              field_data[:field_name],
-              field_type,
-              using: "#{field_data[:field_name]}::#{field_type}"
-            )
+          set_column_type(
+            field_data[:field_name],
+            field_type,
+            using: "#{field_data[:field_name]}::#{field_type}"
+          )
 
-            set_column_default(field_data[:field_name], field_data[:new_default]) unless field_data[:new_default].nil?
-          end
+          set_column_default(field_data[:field_name], field_data[:new_default]) unless field_data[:new_default].nil?
         end
       end
+    end
 
-      def create_extension(change)
-        DbSchema.connection.run(%Q(CREATE EXTENSION "#{change.extension.name}"))
-      end
+    def create_extension(change)
+      connection.run(%Q(CREATE EXTENSION "#{change.extension.name}"))
+    end
 
-      def drop_extension(change)
-        DbSchema.connection.run(%Q(DROP EXTENSION "#{change.name}"))
-      end
+    def drop_extension(change)
+      connection.run(%Q(DROP EXTENSION "#{change.name}"))
+    end
 
+    def execute_query(change)
+      connection.run(change.query)
+    end
+
+    class << self
       def map_options(type, options)
         mapping = case type
         when :char, :varchar, :bit, :varbit