db_schema 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 654c088e5c985a78e896af87cd0b4ea07a90767d
-  data.tar.gz: 559f43436988fb15091f53f6dd1aa95c8ee495f4
+  metadata.gz: 7a6dfe3738279a4199344a79ce5bfbbb7e504d50
+  data.tar.gz: 035b90071d29f3447ac99d79cd324b403e4838d2
 SHA512:
-  metadata.gz: cf94f686cf6d2659ab01f5dcce429255becf74cf2038979b283f41d2f1ea9fa486704e35d378abad9b26fdd8264f46d8fb9523923a0972ce2ba1647a17304e12
-  data.tar.gz: a1fb24c2ae4f4fd0a663cb438c7418cb991f9291e1e855572ab3dacf02ebcf000f6809de5bfabe18faeda768675858466c1544fd0c61624b2e53c84a0cc98ef7
+  metadata.gz: a19fa80ca01c4a3fd95983a73e58cc09628a5f453ca49fc290cfa7238e9eb136bf8de25e8ae7f8f179d9c65ff24a3e18418c6d380e9db7f351f8903cfe8d839f
+  data.tar.gz: 1fe00c3cada2070f96d397920aa785b4ef70cc77856e0ac6818eae46f92281cfdf92d9153c3a7db978a2ad1b13919edf1f2b734331501379c133812437ba8242

data/README.md

@@ -1,4 +1,4 @@
-# DbSchema [![Build Status](https://travis-ci.org/7even/db_schema.svg?branch=master)](https://travis-ci.org/7even/db_schema)
+# DbSchema [![Build Status](https://travis-ci.org/7even/db_schema.svg?branch=master)](https://travis-ci.org/7even/db_schema) [![Gem Version](https://badge.fury.io/rb/db_schema.svg)](https://badge.fury.io/rb/db_schema)
 
 DbSchema is an opinionated database schema management tool that lets you maintain your DB schema with a single ruby file.
 
@@ -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.1.1'
+gem 'db_schema', '~> 0.1.2'
 ```
 
 And then execute:
@@ -356,6 +356,19 @@ end
 
 Be warned though that you have to specify the condition exactly as PostgreSQL outputs it in `psql` with `\d table_name` command; otherwise your index will be recreated on each DbSchema run. This will be fixed in a later DbSchema version.
 
+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.
+
+As with partial index condition (and all other SQL segments in `db_schema`), you must write the expression in a way `psql` outputs it, so instead of `lower(email)` you should use `lower(email::text)` (assuming that `email` is a varchar field).
+
 #### Foreign keys
 
 The `#foreign_key` method defines a foreign key. In it's minimal form it takes a referencing field name and referenced table name:
@@ -519,7 +532,7 @@ All configuration options are described in the following table:
 
 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 there are no remaining differences between your `schema.rb` and the actual database schema. If DbSchema still sees any differences it will keep applying them on each run - usually this is harmless (because it does not really change your schema) but in the case of a partial index with a complex condition it may rebuild the index which is an expensive operation on a large table. You can set `post_check` to false if you are 100% sure that your persistent changes are not a problem for you but I strongly recommend that you turn it on from time to time just to make sure nothing dangerous appears in these persistent changes.
+DbSchema provides an opt-out post-run schema check; it ensures that there are no remaining differences between your `schema.rb` and the actual database schema. If DbSchema still sees any differences it will keep applying them on each run - usually this is harmless (because it does not really change your schema) but in the case of a partial index with a complex condition or an index on some expression it may rebuild the index which is an expensive operation on a large table. You can set `post_check` to false if you are 100% sure that your persistent changes are not a problem for you but I strongly recommend that you turn it on from time to time just to make sure nothing dangerous appears in these persistent changes.
 
 The `post_check` option is likely to become off by default when DbSchema becomes more stable and battle-tested, and when the partial index problem will be solved.
 

data/lib/db_schema/awesome_print.rb

@@ -21,8 +21,8 @@ if defined?(AwesomePrint)
           :dbschema_field
         when ::DbSchema::Definitions::Index
           :dbschema_index
-        when ::DbSchema::Definitions::Index::Field
-          :dbschema_index_field
+        when ::DbSchema::Definitions::Index::Column
+          :dbschema_index_column
         when ::DbSchema::Definitions::CheckConstraint
           :dbschema_check_constraint
         when ::DbSchema::Definitions::ForeignKey
@@ -120,17 +120,17 @@ if defined?(AwesomePrint)
       end
 
       def awesome_dbschema_index(object)
-        fields = format_dbschema_fields(object.fields)
+        columns = format_dbschema_fields(object.columns)
         using = ' using ' + colorize(object.type.to_s, :symbol) unless object.btree?
 
         data = [nil]
         data << colorize('unique', :nilclass) if object.unique?
         data << colorize('condition: ', :symbol) + object.condition.ai unless object.condition.nil?
 
-        "#<#{object.class} #{object.name.ai} on #{fields}#{using}#{data.join(', ')}>"
+        "#<#{object.class} #{object.name.ai} on #{columns}#{using}#{data.join(', ')}>"
       end
 
-      def awesome_dbschema_index_field(object)
+      def awesome_dbschema_index_column(object)
         data = [object.name.ai]
 
         if object.desc?

data/lib/db_schema/changes.rb

@@ -155,7 +155,7 @@ module DbSchema
           if desired && !actual
             table_changes << CreateIndex.new(
               name:      index_name,
-              fields:    desired.fields,
+              columns:   desired.columns,
               unique:    desired.unique?,
               type:      desired.type,
               condition: desired.condition
@@ -166,7 +166,7 @@ module DbSchema
             table_changes << DropIndex.new(index_name)
             table_changes << CreateIndex.new(
               name:      index_name,
-              fields:    desired.fields,
+              columns:   desired.columns,
               unique:    desired.unique?,
               type:      desired.type,
               condition: desired.condition

data/lib/db_schema/definitions.rb

@@ -3,12 +3,12 @@ require 'dry/equalizer'
 module DbSchema
   module Definitions
     class Index
-      include Dry::Equalizer(:name, :fields, :unique?, :type, :condition)
-      attr_reader :name, :fields, :type, :condition
+      include Dry::Equalizer(:name, :columns, :unique?, :type, :condition)
+      attr_reader :name, :columns, :type, :condition
 
-      def initialize(name:, fields:, unique: false, type: :btree, condition: nil)
+      def initialize(name:, columns:, unique: false, type: :btree, condition: nil)
         @name      = name.to_sym
-        @fields    = fields
+        @columns   = columns
         @unique    = unique
         @type      = type
         @condition = condition
@@ -22,7 +22,15 @@ module DbSchema
         type == :btree
       end
 
-      class Field
+      def columns_to_sequel
+        if btree?
+          columns.map(&:ordered_expression)
+        else
+          columns.map(&:to_sequel)
+        end
+      end
+
+      class Column
         include Dry::Equalizer(:name, :order, :nulls)
         attr_reader :name, :order, :nulls
 
@@ -40,14 +48,42 @@ module DbSchema
           @order == :desc
         end
 
-        def to_sequel
+        def ordered_expression
           if asc?
-            Sequel.asc(name, nulls: nulls)
+            Sequel.asc(to_sequel, nulls: nulls)
           else
-            Sequel.desc(name, nulls: nulls)
+            Sequel.desc(to_sequel, nulls: nulls)
           end
         end
       end
+
+      class TableField < Column
+        def expression?
+          false
+        end
+
+        def index_name_segment
+          name
+        end
+
+        def to_sequel
+          name
+        end
+      end
+
+      class Expression < Column
+        def expression?
+          true
+        end
+
+        def index_name_segment
+          name.scan(/\b[A-Za-z0-9_]+\b/).join('_')
+        end
+
+        def to_sequel
+          Sequel.lit("(#{name})")
+        end
+      end
     end
 
     class ForeignKey

data/lib/db_schema/dsl.rb

@@ -55,11 +55,20 @@ module DbSchema
         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
+      def index(*columns, name: nil, unique: false, using: :btree, where: nil, **ordered_fields)
+        if columns.last.is_a?(Hash)
+          *ascending_columns, ordered_expressions = columns
+        else
+          ascending_columns = columns
+          ordered_expressions = {}
+        end
+
+        columns_data = ascending_columns.each_with_object({}) do |column_name, columns|
+          columns[column_name] = :asc
+        end.merge(ordered_fields).merge(ordered_expressions)
+
+        index_columns = columns_data.map do |column_name, column_order_options|
+          options = case column_order_options
           when :asc
             {}
           when :desc
@@ -72,14 +81,18 @@ module DbSchema
             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)
+          if column_name.is_a?(String)
+            Definitions::Index::Expression.new(column_name, **options)
+          else
+            Definitions::Index::TableField.new(column_name, **options)
+          end
         end
 
-        index_name = name || "#{table_name}_#{index_fields.map(&:name).join('_')}_index"
+        index_name = name || "#{table_name}_#{index_columns.map(&:index_name_segment).join('_')}_index"
 
         indices << Definitions::Index.new(
           name:      index_name,
-          fields:    index_fields,
+          columns:   index_columns,
           unique:    unique,
           type:      using,
           condition: where

data/lib/db_schema/reader.rb

@@ -60,8 +60,8 @@ SELECT conname AS name,
           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
+          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[])
@@ -75,7 +75,16 @@ LEFT JOIN pg_am
         AND pg_class.oid = pg_index.indrelid
         AND indisprimary != 't'
 )
-  GROUP BY name, column_positions, indisunique, index_options, condition, expression, index_type
+  GROUP BY name, column_positions, indisunique, index_options, condition, index_type, index_oid
+      SQL
+
+      EXPRESSION_INDICES_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
@@ -139,14 +148,17 @@ SELECT extname
 
         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])
+            names.merge(column[:pos] => column[:name].to_sym)
           end
 
-          DbSchema.connection[INDICES_QUERY, table_name.to_s].map do |index|
+          indices_data     = DbSchema.connection[INDICES_QUERY, table_name.to_s].to_a
+          expressions_data = index_expressions_data(indices_data)
+
+          indices_data.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|
+            columns = positions.zip(options).map do |column_position, column_order_options|
               options = case column_order_options
               when 0
                 {}
@@ -158,12 +170,17 @@ SELECT extname
                 { order: :desc, nulls: :last }
               end
 
-              DbSchema::Definitions::Index::Field.new(column_name.to_sym, **options)
+              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,
-              fields:    fields,
+              columns:   columns,
               unique:    index[:unique],
               type:      index[:index_type].to_sym,
               condition: index[:condition]
@@ -172,6 +189,29 @@ SELECT extname
         end
 
       private
+        def index_expressions_data(indices_data)
+          expressions_stats = indices_data.each_with_object(ids: [], max: 0) do |index_data, stats|
+            expressions_count = index_data[:column_positions].split(' ').count('0')
+
+            if expressions_count > 0
+              stats[:ids] << index_data[:index_oid]
+              stats[:max] = [stats[:max], expressions_count].max
+            end
+          end
+
+          if expressions_stats[:max] > 0
+            DbSchema.connection[
+              EXPRESSION_INDICES_QUERY,
+              Sequel.pg_array(expressions_stats[:ids]),
+              Sequel.pg_array((1..expressions_stats[:max]).to_a)
+            ].each_with_object({}) do |index_data, indices_data|
+              indices_data[index_data[:index_id]] = index_data[:definitions]
+            end
+          else
+            {}
+          end
+        end
+
         def build_field(data, primary_key: false)
           type = data[:type].to_sym.downcase
           if type == :'user-defined'

data/lib/db_schema/runner.rb

@@ -70,14 +70,8 @@ module DbSchema
           end
 
           change.indices.each do |index|
-            fields = if index.btree?
-              index.fields.map(&:to_sequel)
-            else
-              index.fields.map(&:name)
-            end
-
             index(
-              fields,
+              index.columns_to_sequel,
               name:   index.name,
               unique: index.unique?,
               type:   index.type,
@@ -141,14 +135,8 @@ module DbSchema
             when Changes::AlterColumnDefault
               set_column_default(element.name, element.new_default)
             when Changes::CreateIndex
-              fields = if element.btree?
-                element.fields.map(&:to_sequel)
-              else
-                element.fields.map(&:name)
-              end
-
               add_index(
-                fields,
+                element.columns_to_sequel,
                 name:   element.name,
                 unique: element.unique?,
                 type:   element.type,

data/lib/db_schema/validator.rb

@@ -24,7 +24,7 @@ module DbSchema
           field_names = table.fields.map(&:name)
 
           table.indices.each do |index|
-            index.fields.map(&:name).each do |field_name|
+            index.columns.reject(&:expression?).map(&:name).each do |field_name|
               unless field_names.include?(field_name)
                 error_message = %(Index "#{index.name}" refers to a missing field "#{table.name}.#{field_name}")
                 errors << error_message

data/lib/db_schema/version.rb

@@ -1,3 +1,3 @@
 module DbSchema
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: db_schema
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Vsevolod Romashov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-24 00:00:00.000000000 Z
+date: 2016-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel