db_schema 0.1

data/lib/db_schema/definitions/field/json.rb

@@ -0,0 +1,13 @@
+module DbSchema
+  module Definitions
+    module Field
+      class JSON < Base
+        register :json
+      end
+
+      class JSONB < Base
+        register :jsonb
+      end
+    end
+  end
+end

data/lib/db_schema/definitions/field/monetary.rb

@@ -0,0 +1,9 @@
+module DbSchema
+  module Definitions
+    module Field
+      class Money < Base
+        register :money
+      end
+    end
+  end
+end

data/lib/db_schema/definitions/field/network.rb

@@ -0,0 +1,17 @@
+module DbSchema
+  module Definitions
+    module Field
+      class Cidr < Base
+        register :cidr
+      end
+
+      class Inet < Base
+        register :inet
+      end
+
+      class MacAddr < Base
+        register :macaddr
+      end
+    end
+  end
+end

data/lib/db_schema/definitions/field/numeric.rb

@@ -0,0 +1,30 @@
+module DbSchema
+  module Definitions
+    module Field
+      class SmallInt < Base
+        register :smallint
+      end
+
+      class Integer < Base
+        register :integer
+      end
+
+      class BigInt < Base
+        register :bigint
+      end
+
+      class Numeric < Base
+        register :numeric, :decimal
+        attributes :precision, :scale
+      end
+
+      class Real < Base
+        register :real
+      end
+
+      class DoublePrecision < Base
+        register :'double precision', :float
+      end
+    end
+  end
+end

data/lib/db_schema/definitions/field/range.rb

@@ -0,0 +1,29 @@
+module DbSchema
+  module Definitions
+    module Field
+      class Int4Range < Base
+        register :int4range
+      end
+
+      class Int8Range < Base
+        register :int8range
+      end
+
+      class NumRange < Base
+        register :numrange
+      end
+
+      class TsRange < Base
+        register :tsrange
+      end
+
+      class TsTzRange < Base
+        register :tstzrange
+      end
+
+      class DateRange < Base
+        register :daterange
+      end
+    end
+  end
+end

data/lib/db_schema/definitions/field/text_search.rb

@@ -0,0 +1,13 @@
+module DbSchema
+  module Definitions
+    module Field
+      class TsVector < Base
+        register :tsvector
+      end
+
+      class TsQuery < Base
+        register :tsquery
+      end
+    end
+  end
+end

data/lib/db_schema/definitions/field/uuid.rb

@@ -0,0 +1,9 @@
+module DbSchema
+  module Definitions
+    module Field
+      class UUID < Base
+        register :uuid
+      end
+    end
+  end
+end

data/lib/db_schema/dsl.rb

@@ -0,0 +1,145 @@
+module DbSchema
+  class DSL
+    attr_reader :block
+
+    def initialize(block)
+      @block  = block
+      @schema = []
+    end
+
+    def schema
+      block.call(self)
+
+      @schema
+    end
+
+    def table(name, &block)
+      table_yielder = TableYielder.new(name, block)
+
+      @schema << Definitions::Table.new(
+        name,
+        fields:       table_yielder.fields,
+        indices:      table_yielder.indices,
+        checks:       table_yielder.checks,
+        foreign_keys: table_yielder.foreign_keys
+      )
+    end
+
+    def enum(name, values)
+      @schema << Definitions::Enum.new(name.to_sym, values.map(&:to_sym))
+    end
+
+    class TableYielder
+      attr_reader :table_name
+
+      def initialize(table_name, block)
+        @table_name = table_name
+        block.call(self)
+      end
+
+      DbSchema::Definitions::Field.registry.keys.each do |type|
+        define_method(type) do |name, **options|
+          field(name, type, options)
+        end
+      end
+
+      def primary_key(name)
+        fields << Definitions::Field::Integer.new(name, primary_key: true)
+      end
+
+      def field(name, type, **options)
+        fields << Definitions::Field.build(name, type, options)
+      end
+
+      def index(*fields, name: nil, unique: false, using: :btree, where: nil, **ordered_fields)
+        index_fields = fields.map do |field_name|
+          Definitions::Index::Field.new(field_name.to_sym)
+        end + ordered_fields.map do |field_name, field_order_options|
+          options = case field_order_options
+          when :asc
+            {}
+          when :desc
+            { order: :desc }
+          when :asc_nulls_first
+            { nulls: :first }
+          when :desc_nulls_last
+            { order: :desc, nulls: :last }
+          else
+            raise ArgumentError, 'Only :asc, :desc, :asc_nulls_first and :desc_nulls_last options are supported.'
+          end
+
+          Definitions::Index::Field.new(field_name.to_sym, **options)
+        end
+
+        index_name = name || "#{table_name}_#{index_fields.map(&:name).join('_')}_index"
+
+        indices << Definitions::Index.new(
+          name:      index_name,
+          fields:    index_fields,
+          unique:    unique,
+          type:      using,
+          condition: where
+        )
+      end
+
+      def check(name, condition)
+        checks << Definitions::CheckConstraint.new(name: name, condition: condition)
+      end
+
+      def foreign_key(*fkey_fields, references:, name: nil, on_update: :no_action, on_delete: :no_action, deferrable: false)
+        fkey_name = name || :"#{table_name}_#{fkey_fields.first}_fkey"
+
+        if references.is_a?(Array)
+          # [:table, :field]
+          referenced_table, *referenced_keys = references
+
+          foreign_keys << Definitions::ForeignKey.new(
+            name:       fkey_name,
+            fields:     fkey_fields,
+            table:      referenced_table,
+            keys:       referenced_keys,
+            on_delete:  on_delete,
+            on_update:  on_update,
+            deferrable: deferrable
+          )
+        else
+          # :table
+          foreign_keys << Definitions::ForeignKey.new(
+            name:       fkey_name,
+            fields:     fkey_fields,
+            table:      references,
+            on_delete:  on_delete,
+            on_update:  on_update,
+            deferrable: deferrable
+          )
+        end
+      end
+
+      def method_missing(method_name, name, *args, &block)
+        options = args.first || {}
+
+        fields << Definitions::Field::Custom.new(
+          name,
+          type_name: method_name,
+          **options
+        )
+      end
+
+      def fields
+        @fields ||= []
+      end
+
+      def indices
+        @indices ||= []
+      end
+
+      def checks
+        @checks ||= []
+      end
+
+      def foreign_keys
+        @foreign_keys ||= []
+      end
+    end
+  end
+end

data/lib/db_schema/reader.rb

@@ -0,0 +1,270 @@
+module DbSchema
+  module Reader
+    class << self
+      def read_schema
+        adapter.read_schema
+      end
+
+      def adapter
+        adapter_name = DbSchema.configuration.adapter
+        registry.fetch(adapter_name) do |adapter_name|
+          raise NotImplementedError, "DbSchema::Reader does not support #{adapter_name}."
+        end
+      end
+
+    private
+      def registry
+        @registry ||= {}
+      end
+    end
+
+    module Postgres
+      DEFAULT_VALUE = /\A(('(?<string>.*)')|(?<float>\d+\.\d+)|(?<integer>\d+)|(?<boolean>true|false)|((?<function>[A-Za-z_]+)\(\)))/
+
+      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
+     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
+
+      INDICES_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,
+          pg_get_expr(indexprs, indrelid, true) AS expression,
+          amname AS index_type
+     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, expression, index_type
+      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
+
+      class << self
+        def read_schema
+          enums = DbSchema.connection[ENUMS_QUERY].map do |enum_data|
+            Definitions::Enum.new(enum_data[:name].to_sym, enum_data[:values].map(&:to_sym))
+          end
+
+          tables = DbSchema.connection.tables.map do |table_name|
+            primary_key_name = DbSchema.connection.primary_key(table_name)
+
+            fields = DbSchema.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|
+              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)
+            end
+
+            checks = DbSchema.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,
+              indices:      indices,
+              checks:       checks,
+              foreign_keys: foreign_keys
+            )
+          end
+
+          enums + tables
+        end
+
+        def indices_data_for(table_name)
+          column_names = DbSchema.connection[COLUMN_NAMES_QUERY, table_name.to_s].reduce({}) do |names, column|
+            names.merge(column[:pos] => column[:name])
+          end
+
+          DbSchema.connection[INDICES_QUERY, table_name.to_s].map do |index|
+            positions = index[:column_positions].split(' ').map(&:to_i)
+            options   = index[:index_options].split(' ').map(&:to_i)
+
+            fields = column_names.values_at(*positions).zip(options).map do |column_name, 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
+
+              DbSchema::Definitions::Index::Field.new(column_name.to_sym, **options)
+            end
+
+            {
+              name:      index[:name].to_sym,
+              fields:    fields,
+              unique:    index[:unique],
+              type:      index[:index_type].to_sym,
+              condition: index[:condition]
+            }
+          end
+        end
+
+      private
+        def build_field(data, primary_key: false)
+          type = data[:type].to_sym.downcase
+
+          nullable = (data[:null] != 'NO')
+
+          unless primary_key || data[:default].nil?
+            if match = DEFAULT_VALUE.match(data[:default])
+              default = if match[:string]
+                match[:string]
+              elsif match[:integer]
+                match[:integer].to_i
+              elsif match[:float]
+                match[:float].to_f
+              elsif match[:boolean]
+                match[:boolean] == 'true'
+              elsif match[:function]
+                match[:function].to_sym
+              end
+            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)) do |attributes|
+              attributes[:of] = attributes[:element_type].to_sym
+            end
+          else
+            {}
+          end
+
+          if data[:type] == 'USER-DEFINED'
+            Definitions::Field::Custom.new(
+              data[:name].to_sym,
+              type_name:   data[:custom_type_name].to_sym,
+              primary_key: primary_key,
+              null:        nullable,
+              default:     default
+            )
+          else
+            Definitions::Field.build(
+              data[:name].to_sym,
+              type,
+              primary_key: primary_key,
+              null:        nullable,
+              default:     default,
+              **options
+            )
+          end
+        end
+
+        def build_foreign_key(data)
+          keys = if data[:key] == [primary_key_for(data[:table])]
+            [] # this foreign key references a primary key
+          else
+            data[:key]
+          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)
+          if pkey = primary_keys[table_name]
+            pkey.to_sym
+          end
+        end
+
+        def primary_keys
+          @primary_keys ||= DbSchema.connection.tables.reduce({}) do |primary_keys, table_name|
+            primary_keys.merge(table_name => DbSchema.connection.primary_key(table_name))
+          end
+        end
+      end
+    end
+
+    registry['postgres'] = Postgres
+    registry['postgresql'] = Postgres
+  end
+end