db_schema 0.3.1 → 0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 92f4601dd7a4513014fd782391bfe69f8400f06d
-  data.tar.gz: 291caae43bf4582dbf0636b8601de86ebdcf3c25
+SHA256:
+  metadata.gz: 63847549e7e2a6350f2804c5a2a251388f6b65ff206d51fc34403b4a56d883aa
+  data.tar.gz: a2d2ff387fa992afac8764cd6a0c5dff3b5f34bcd1f632d4fcb3ec216f13360c
 SHA512:
-  metadata.gz: 7a8af71a493a89113166e8a1ee0fa1808ba8bbbcbb07b263fa0d9f0884eafe4d297e64d79815a854f460ad78af3bd0c847c82741c96d5175e127452a1333120d
-  data.tar.gz: 41fb922d5f307c481f3595d27983c39a13640cd2c5cdc5e9e6a395ad34c509cf712f4d08f79825c730462855c9d66d178961bb1d48d77b599386e10ab90b831a
+  metadata.gz: 8d2793a8eed21c593be07e7c5a067a86e0d2566938f99e410808d3657898b37abaab8e1db1adff8ff8b8c311fb123204b05713f650cf9ff2de882689f2ebabf0
+  data.tar.gz: c2b2e6dca0d6c7df815bf8e8e060bb3b35727bd02ccd8c18c943c6f7373777d1e77151f0ba87f0f64014affc371848e8e05dfa6fd0a6c9387fc340caa42bfccc

data/README.md

@@ -50,10 +50,11 @@ But you would lose it even with manual migrations.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add these lines to your application's Gemfile:
 
 ``` ruby
-gem 'db_schema', '~> 0.3.1'
+gem 'db_schema', '~> 0.4.0'
+gem 'db_schema-reader-postgres', '~> 0.1.1'
 ```
 
 And then execute:
@@ -65,9 +66,12 @@ $ bundle
 Or install it yourself as:
 
 ``` sh
-$ gem install db_schema
+$ gem install db_schema db_schema-reader-postgres
 ```
 
+The `db_schema-reader-postgres` [gem](https://github.com/db-schema/reader-postgres) is a PostgreSQL adapter
+for `DbSchema::Reader` (a module which is responsible for reading the current database schema).
+
 ## Usage
 
 First you need to configure DbSchema so it knows how to connect to your database. This should happen

data/db_schema.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'sequel'
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
+  spec.add_runtime_dependency 'db_schema-definitions', '~> 0.1.1'
 
   spec.add_development_dependency 'bundler', '~> 1.11'
   spec.add_development_dependency 'rake', '~> 10.0'
@@ -31,5 +32,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'terminal-notifier'
   spec.add_development_dependency 'terminal-notifier-guard'
 
-  spec.add_development_dependency 'pg'
+  spec.add_development_dependency 'db_schema-reader-postgres', '~> 0.1.1'
 end

data/lib/db_schema.rb

@@ -114,7 +114,8 @@ module DbSchema
     end
 
     def run_migrations(migrations, connection)
-      @current_schema = Reader.read_schema(connection)
+      reader = Reader.reader_for(connection)
+      @current_schema = reader.read_schema
 
       migrations.reduce(@current_schema) do |schema, migration|
         migrator = Migrator.new(migration)
@@ -122,7 +123,7 @@ module DbSchema
         if migrator.applicable?(schema)
           log_migration(migration) if configuration.log_changes?
           migrator.run!(connection)
-          Reader.read_schema(connection)
+          reader.read_schema
         else
           schema
         end
@@ -145,7 +146,7 @@ module DbSchema
     end
 
     def perform_post_check(desired_schema, connection)
-      unapplied_changes = Changes.between(desired_schema, Reader.read_schema(connection))
+      unapplied_changes = Changes.between(desired_schema, Reader.reader_for(connection).read_schema)
       return if unapplied_changes.empty?
 
       readable_changes = if unapplied_changes.respond_to?(:ai)

data/lib/db_schema/normalizer.rb

@@ -28,7 +28,7 @@ module DbSchema
 
   private
     def create_extensions!
-      operations = (schema.extensions - Reader.read_extensions(connection)).map do |extension|
+      operations = (schema.extensions - Reader.reader_for(connection).read_extensions).map do |extension|
         Operations::CreateExtension.new(extension)
       end
 
@@ -85,7 +85,7 @@ module DbSchema
       end
 
       def read_temporary_table
-        temporary_table = Reader.read_table(temporary_table_name, connection)
+        temporary_table = Reader.reader_for(connection).read_table(temporary_table_name)
 
         temporary_table.with_name(table.name)
           .with_fields(rename_types_back(temporary_table.fields))

data/lib/db_schema/reader.rb

@@ -1,360 +1,18 @@
 module DbSchema
   module Reader
     class << self
-      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 read_extensions(connection)
-        adapter(connection).read_extensions(connection)
-      end
-
-    private
-      def adapter(connection)
-        registry.fetch(connection.adapter_scheme) do |adapter_name|
-          raise NotImplementedError, "DbSchema::Reader does not support #{adapter_name}."
-        end
-      end
-
-      def registry
-        @registry ||= {}
-      end
-    end
-
-    module Postgres
-      DEFAULT_VALUE = /\A(
-        ('(?<date>\d{4}-\d{2}-\d{2})'::date)
-          |
-        ('(?<time>\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}([+-]\d{2})?)'::timestamp)
-          |
-        ('(?<string>.*)')
-          |
-        (?<float>\d+\.\d+)
-          |
-        (?<integer>\d+)
-          |
-        (?<boolean>true|false)
-      )/x
-
-      COLUMN_NAMES_QUERY = <<-SQL.freeze
-   SELECT c.column_name AS name,
-          c.ordinal_position AS pos,
-          c.column_default AS default,
-          c.is_nullable AS null,
-          c.data_type AS type,
-          c.udt_name AS custom_type_name,
-          c.character_maximum_length AS char_length,
-          c.numeric_precision AS num_precision,
-          c.numeric_scale AS num_scale,
-          c.datetime_precision AS dt_precision,
-          c.interval_type,
-          e.data_type AS element_type,
-          e.udt_name AS element_custom_type_name
-     FROM information_schema.columns AS c
-LEFT JOIN information_schema.element_types AS e
-       ON e.object_catalog = c.table_catalog
-      AND e.object_schema = c.table_schema
-      AND e.object_name = c.table_name
-      AND e.object_type = 'TABLE'
-      AND e.collection_type_identifier = c.dtd_identifier
-    WHERE c.table_schema = 'public'
-      AND c.table_name = ?
-      SQL
-
-      CONSTRAINTS_QUERY = <<-SQL.freeze
-SELECT conname AS name,
-       pg_get_expr(conbin, conrelid, true) AS condition
-  FROM pg_constraint, pg_class
- WHERE conrelid = pg_class.oid
-   AND relname = ?
-   AND contype = 'c'
-      SQL
-
-      INDEXES_QUERY = <<-SQL.freeze
-   SELECT relname AS name,
-          indkey AS column_positions,
-          indisunique AS unique,
-          indoption AS index_options,
-          pg_get_expr(indpred, indrelid, true) AS condition,
-          amname AS index_type,
-          indexrelid AS index_oid
-     FROM pg_class, pg_index
-LEFT JOIN pg_opclass
-       ON pg_opclass.oid = ANY(pg_index.indclass::int[])
-LEFT JOIN pg_am
-       ON pg_am.oid = pg_opclass.opcmethod
-    WHERE pg_class.oid = pg_index.indexrelid
-      AND pg_class.oid IN (
-     SELECT indexrelid
-       FROM pg_index, pg_class
-      WHERE pg_class.relname = ?
-        AND pg_class.oid = pg_index.indrelid
-        AND indisprimary != 't'
-)
-  GROUP BY name, column_positions, indisunique, index_options, condition, index_type, index_oid
-      SQL
-
-      EXPRESSION_INDEXES_QUERY = <<-SQL.freeze
-    WITH index_ids AS (SELECT unnest(?) AS index_id),
-         elements AS (SELECT unnest(?) AS element)
-  SELECT index_id,
-         array_agg(pg_get_indexdef(index_id, element, 't')) AS definitions
-    FROM index_ids, elements
-GROUP BY index_id;
-      SQL
-
-      ENUMS_QUERY = <<-SQL.freeze
-  SELECT t.typname AS name,
-         array_agg(e.enumlabel ORDER BY e.enumsortorder) AS values
-    FROM pg_enum AS e
-    JOIN pg_type AS t
-      ON t.oid = e.enumtypid
-GROUP BY name
-      SQL
-
-      EXTENSIONS_QUERY = <<-SQL.freeze
-SELECT extname
-  FROM pg_extension
- WHERE extname != 'plpgsql'
-      SQL
-
-      class << self
-        def read_schema(connection)
-          Definitions::Schema.new(
-            tables:     read_tables(connection),
-            enums:      read_enums(connection),
-            extensions: read_extensions(connection)
-          )
-        end
-
-        def read_table(table_name, connection)
-          primary_key_name = connection.primary_key(table_name)
-
-          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
-
-          indexes = indexes_data_for(table_name, connection).map do |index_data|
-            Definitions::Index.new(index_data)
-          end.sort_by(&:name)
-
-          foreign_keys = connection.foreign_key_list(table_name).map do |foreign_key_data|
-            build_foreign_key(foreign_key_data, connection)
-          end
-
-          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]
-            )
-          end
-
-          Definitions::Table.new(
-            table_name,
-            fields:       fields,
-            indexes:      indexes,
-            checks:       checks,
-            foreign_keys: foreign_keys
-          )
-        end
-
-        def indexes_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
-
-          indexes_data     = connection[INDEXES_QUERY, table_name.to_s].to_a
-          expressions_data = index_expressions_data(indexes_data, connection)
-
-          indexes_data.map do |index|
-            positions = index[:column_positions].split(' ').map(&:to_i)
-            options   = index[:index_options].split(' ').map(&:to_i)
-
-            columns = positions.zip(options).map do |column_position, column_order_options|
-              options = case column_order_options
-              when 0
-                {}
-              when 3
-                { order: :desc }
-              when 2
-                { nulls: :first }
-              when 1
-                { order: :desc, nulls: :last }
-              end
-
-              if column_position.zero?
-                expression = expressions_data.fetch(index[:index_oid]).shift
-                DbSchema::Definitions::Index::Expression.new(expression, **options)
-              else
-                DbSchema::Definitions::Index::TableField.new(column_names.fetch(column_position), **options)
-              end
-            end
-
-            {
-              name:      index[:name].to_sym,
-              columns:   columns,
-              unique:    index[:unique],
-              type:      index[:index_type].to_sym,
-              condition: index[:condition]
-            }
-          end
-        end
-
-        def read_tables(connection)
-          connection.tables.map do |table_name|
-            read_table(table_name, connection)
-          end
-        end
-
-        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(connection)
-          connection[EXTENSIONS_QUERY].map do |extension_data|
-            Definitions::Extension.new(extension_data[:extname].to_sym)
-          end
-        end
-
-      private
-        def index_expressions_data(indexes_data, connection)
-          all_positions, max_position = {}, 0
-
-          indexes_data.each do |index_data|
-            positions = index_data[:column_positions].split(' ').map(&:to_i)
-            expression_positions = positions.each_index.select { |i| positions[i].zero? }
-
-            if expression_positions.any?
-              all_positions[index_data[:index_oid]] = expression_positions
-              max_position = [max_position, expression_positions.max].max
-            end
-          end
-
-          if all_positions.any?
-            connection[
-              EXPRESSION_INDEXES_QUERY,
-              Sequel.pg_array(all_positions.keys),
-              Sequel.pg_array((1..max_position.succ).to_a)
-            ].each_with_object({}) do |index_data, indexes_data|
-              index_id = index_data[:index_id]
-              expressions = all_positions[index_id].map { |pos| index_data[:definitions][pos] }
-
-              indexes_data[index_id] = expressions
-            end
-          else
-            {}
-          end
-        end
-
-        def build_field(data, primary_key: false)
-          type = data[:type].to_sym.downcase
-          if type == :'user-defined'
-            type = data[:custom_type_name].to_sym
-          end
-
-          nullable = (data[:null] != 'NO')
-
-          unless primary_key || data[:default].nil?
-            default = if match = DEFAULT_VALUE.match(data[:default])
-              if match[:date]
-                Date.parse(match[:date])
-              elsif match[:time]
-                Time.parse(match[:time])
-              elsif match[:string]
-                match[:string]
-              elsif match[:integer]
-                match[:integer].to_i
-              elsif match[:float]
-                match[:float].to_f
-              elsif match[:boolean]
-                match[:boolean] == 'true'
-              end
-            else
-              data[:default].to_sym
-            end
-          end
-
-          options = case type
-          when :character, :'character varying', :bit, :'bit varying'
-            Utils.rename_keys(
-              Utils.filter_by_keys(data, :char_length),
-              char_length: :length
-            )
-          when :numeric
-            Utils.rename_keys(
-              Utils.filter_by_keys(data, :num_precision, :num_scale),
-              num_precision: :precision,
-              num_scale: :scale
-            )
-          when :interval
-            Utils.rename_keys(
-              Utils.filter_by_keys(data, :dt_precision, :interval_type),
-              dt_precision: :precision
-            ) do |attributes|
-              if interval_type = attributes.delete(:interval_type)
-                attributes[:fields] = interval_type.gsub(/\(\d\)/, '').downcase.to_sym
-              end
-            end
-          when :array
-            Utils.rename_keys(
-              Utils.filter_by_keys(data, :element_type, :element_custom_type_name)
-            ) do |attributes|
-              attributes[:element_type] = if attributes[:element_type] == 'USER-DEFINED'
-                attributes[:element_custom_type_name]
-              else
-                attributes[:element_type]
-              end.to_sym
-            end
-          else
-            {}
-          end
-
-          Definitions::Field.build(
-            data[:name].to_sym,
-            type,
-            primary_key: primary_key,
-            null:        nullable,
-            default:     default,
-            **options
-          )
-        end
-
-        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]
+      def reader_for(connection)
+        case connection.adapter_scheme
+        when :postgres
+          unless defined?(Reader::Postgres)
+            raise 'You need the \'db_schema-reader-postgres\' gem in order to work with PostgreSQL database structure.'
           end
 
-          Definitions::ForeignKey.new(
-            name:       data[:name],
-            fields:     data[:columns],
-            table:      data[:table],
-            keys:       keys,
-            on_delete:  data[:on_delete],
-            on_update:  data[:on_update],
-            deferrable: data[:deferrable]
-          )
-        end
-
-        def primary_key_for(table_name, connection)
-          if pkey = connection.primary_key(table_name)
-            pkey.to_sym
-          end
+          Reader::Postgres.new(connection)
+        else
+          raise NotImplementedError, "DbSchema::Reader does not support #{connection.adapter_scheme}."
         end
       end
     end
-
-    registry[:postgres] = Postgres
   end
 end