mini_record 0.4.3 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cfb798464fea4709be8710a161550d3f4cdf1371
-  data.tar.gz: d2bd9f1fa0fbe58af774dd5a7b66812603a9e358
+  metadata.gz: 44eb9e5c3b23585ea142c23f9b79cc8783a06204
+  data.tar.gz: 78dcc1beff902922d33bfc660b819f22d73b8061
 SHA512:
-  metadata.gz: 3d143593162f47be6b2824ce36e47d1b9b2b46b7a84225ffd2bc4e6628f443407866cde9a3d8a1b04a36638ce871c2059141f2899ab61d4f763171ccfb9ad353
-  data.tar.gz: 855af276975d4b394fd9563c6b219fbe61b860e9b1e4aca57b8fe615158df45274ac48171e95f4c7aea01a73c5ded63bbe4e8397f8ddf88d753059b07cb54fc1
+  metadata.gz: 1436a23b6d6fa2327ee7545258f3059b068cc0c85dd9964ff8d8ccc1b634fcd277c5a82d5644c6c9092e433a993e2e681f053f3bd7b70e8426bdc8e8e2ee91bd
+  data.tar.gz: 662eeecaa4f45ff27854ec646e381b71959ac143766731ee585394c3b3f1b110778171878d27f684cc5cf7971332d22ea187fba58eaada58437f02ff55df1274

data/README.md

@@ -260,6 +260,19 @@ class Fox < ActiveRecord::Base
 end
 ```
 
+### Suppress default indexes for associations
+
+If you do not need the default index for a `belongs_to` or `has_and_belongs_to_many` relationship, such as if you are using a composite index instead, you can suppress it from being created (or remove it) using `suppress_index` on the association:
+
+```ruby
+class PhoneNumber < ActiveRecord::Base
+  field :position
+  belongs_to :person
+  suppress_index :person
+  add_index [:person_id, :position]
+end
+```
+
 ### Passing options to Create Table
 
 If you need to pass particular options to your `CREATE TABLE` statement, you can do so with `create_table` in the Model:
@@ -305,4 +318,4 @@ The above copyright notice and this permission notice shall be included in all c
 THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM,
 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/mini_record/auto_schema.rb

@@ -44,6 +44,12 @@ module MiniRecord
         @_indexes ||= {}
       end
 
+      def suppressed_indexes
+        return superclass.suppressed_indexes unless (superclass == ActiveRecord::Base) || (superclass.respond_to?(:abstract_class?) && superclass.abstract_class?)
+
+        @_suppressed_indexes ||= {}
+      end
+
       def indexes_in_db
         connection.indexes(table_name).inject({}) do |hash, index|
           hash[index.name] = index
@@ -158,6 +164,12 @@ module MiniRecord
       end
       alias :index :add_index
 
+      def suppress_index(*associations)
+        associations.each do |association|
+          suppressed_indexes[association] = true
+        end
+      end
+
       def connection?
         !!connection
       rescue Exception => e
@@ -165,11 +177,14 @@ module MiniRecord
         false
       end
 
-      def clear_tables!
+      def clear_tables!(dry_run = false)
         return unless MiniRecord.configuration.destructive == true 
         (connection.tables - schema_tables).each do |name|
-          connection.drop_table(name)
-          schema_tables.delete(name)
+          logger.debug "[MiniRecord] Dropping table #{name}"
+          unless dry_run
+            connection.drop_table(name)
+            schema_tables.delete(name)
+          end
         end
       end
 
@@ -180,13 +195,14 @@ module MiniRecord
       end
 
       # Remove foreign keys for indexes with :foreign=>false option
-      def remove_foreign_keys
+      def remove_foreign_keys(dry_run)
         return unless MiniRecord.configuration.destructive == true 
         indexes.each do |name, options|
           if options[:foreign]==false
             foreign_key = foreign_keys.detect { |fk| fk.options[:column] == options[:column].to_s }
             if foreign_key
-              connection.remove_foreign_key(table_name, :name => foreign_key.options[:name])
+              logger.debug "[MiniRecord] Removing Foreign Key #{foreign_key.options[:name]} on table #{table_name}"
+              connection.remove_foreign_key(table_name, :name => foreign_key.options[:name]) unless dry_run
               foreign_keys.delete(foreign_key)
             end
           end
@@ -194,33 +210,42 @@ module MiniRecord
       end
 
       # Add foreign keys for indexes with :foreign=>true option, if the key doesn't exists
-      def add_foreign_keys
+      def add_foreign_keys(dry_run)
         indexes.each do |name, options|
           if options[:foreign]
             column = options[:column].to_s
             unless foreign_keys.detect { |fk| fk[:options][:column] == column }
               to_table = reflect_on_all_associations.detect { |a| a.foreign_key.to_s==column }.table_name
-              connection.add_foreign_key(table_name, to_table, options)
+              logger.debug "[MiniRecord] Adding Foreign Key on #{table_name} to #{to_table}"
+              connection.add_foreign_key(table_name, to_table, options) unless dry_run
               foreign_keys << { :options=> { :column=>column } }
             end
           end
         end
       end
 
-      def auto_upgrade!
+      # dry-run
+      def auto_upgrade_dry
+        auto_upgrade!(true)
+      end
+
+      def auto_upgrade!(dry_run = false)
         return unless connection?
         return if respond_to?(:abstract_class?) && abstract_class?
 
         if self == ActiveRecord::Base
-          descendants.each(&:auto_upgrade!)
-          clear_tables!
+          descendants.each { |model| model.auto_upgrade!(dry_run) }
+          clear_tables!(dry_run)
         else
           # If table doesn't exist, create it
           unless connection.tables.include?(table_name)
             class << connection; attr_accessor :table_definition; end unless connection.respond_to?(:table_definition=)
-            connection.table_definition = table_definition
-            connection.create_table(table_name, *create_table_options)
-            connection.table_definition = init_table_definition(connection)
+            logger.debug "[MiniRecord] Creating Table #{table_name}"
+            unless dry_run
+              connection.table_definition = table_definition
+              connection.create_table(table_name, *create_table_options)
+              connection.table_definition = init_table_definition(connection)
+            end
           end
 
           # Add this to our schema tables
@@ -236,9 +261,9 @@ module MiniRecord
                 field foreign_key, :as => :integer unless fields.key?(foreign_key.to_s)
                 if association.options[:polymorphic]
                   field type_key, :as => :string unless fields.key?(type_key.to_s)
-                  index [foreign_key, type_key]
+                  index [foreign_key, type_key] unless suppressed_indexes[association.name]
                 else
-                  index foreign_key
+                  index foreign_key unless suppressed_indexes[association.name]
                 end
               when :has_and_belongs_to_many
                 table = if name = association.options[:join_table]
@@ -249,13 +274,17 @@ module MiniRecord
                 unless connection.tables.include?(table.to_s)
                   foreign_key             = association.options[:foreign_key] || association.foreign_key
                   association_foreign_key = association.options[:association_foreign_key] || association.association_foreign_key
-                  connection.create_table(table, :id => false) do |t|
-                    t.integer foreign_key
-                    t.integer association_foreign_key
+                  logger.debug "[MiniRecord] Creating Join Table #{table} with keys #{foreign_key} and #{association_foreign_key}"
+                  unless dry_run
+                    connection.create_table(table, :id => false) do |t|
+                      t.integer foreign_key
+                      t.integer association_foreign_key
+                    end
                   end
                   index_name = connection.index_name(table, :column => [foreign_key, association_foreign_key])
                   index_name = index_name[0...connection.index_name_length] if index_name.length > connection.index_name_length
-                  connection.add_index table, [foreign_key, association_foreign_key], :name => index_name, :unique => true
+                  logger.debug "[MiniRecord] Creating Join Table Index #{index_name} (#{foreign_key}, #{association_foreign_key}) on #{table}"
+                  connection.add_index table, [foreign_key, association_foreign_key], :name => index_name, :unique => true unless dry_run or suppressed_indexes[association.name]
                 end
                 # Add join table to our schema tables
                 schema_tables << table unless schema_tables.include?(table)
@@ -270,14 +299,15 @@ module MiniRecord
           end
 
           # Group Destructive Actions
-          if MiniRecord.configuration.destructive == true 
+          if MiniRecord.configuration.destructive == true and connection.tables.include?(table_name)
             
             # Rename fields
             rename_fields.each do |old_name, new_name|
               old_column = fields_in_db[old_name.to_s]
               new_column = fields_in_db[new_name.to_s]
               if old_column && !new_column
-                connection.rename_column(table_name, old_column.name, new_name)
+                logger.debug "[MiniRecord] Renaming column #{table_name}.#{old_column.name} to #{new_name}"
+                connection.rename_column(table_name, old_column.name, new_name) unless dry_run
               end
             end
             
@@ -285,7 +315,8 @@ module MiniRecord
             columns_to_delete = fields_in_db.keys - fields.keys & fields_in_db.keys
             columns_to_delete.each do |field|
               column = fields_in_db[field]
-              connection.remove_column table_name, column.name
+              logger.debug "[MiniRecord] Removing column #{table_name}.#{column.name}"
+              connection.remove_column table_name, column.name unless dry_run
             end
             
             # Change attributes of existent columns
@@ -324,40 +355,48 @@ module MiniRecord
 
                 # Change the column if applicable
                 new_type = fields[field].type.to_sym
-                connection.change_column table_name, field, new_type, new_attr if changed
+                if changed
+                  logger.debug "[MiniRecord] Changing column #{table_name}.#{field} to new type #{new_type}"
+                  connection.change_column table_name, field, new_type, new_attr unless dry_run
+                end
               end
             end
             
-            remove_foreign_keys if connection.respond_to?(:foreign_keys)
+            remove_foreign_keys(dry_run) if connection.respond_to?(:foreign_keys)
 
             # Remove old index
-            index_names = indexes.collect{|name,opts| opts[:name] || name }
+            index_names = indexes.collect{ |name, opts| (opts[:name] || name).to_s }
             (indexes_in_db.keys - index_names).each do |name|
-              connection.remove_index(table_name, :name => name)
+              logger.debug "[MiniRecord] Removing index #{name} on #{table_name}"
+              connection.remove_index(table_name, :name => name) unless dry_run
             end
             
           end
 
-          # Add fields to db new to schema
-          columns_to_add = fields.keys - fields_in_db.keys
-          columns_to_add.each do |field|
-            column  = fields[field]
-            options = {:limit => column.limit, :precision => column.precision, :scale => column.scale}
-            options[:default] = column.default unless column.default.nil?
-            options[:null]    = column.null    unless column.null.nil?
-            connection.add_column table_name, column.name, column.type.to_sym, options
+          if connection.tables.include?(table_name)
+            # Add fields to db new to schema
+            columns_to_add = fields.keys - fields_in_db.keys
+            columns_to_add.each do |field|
+              column  = fields[field]
+              options = {:limit => column.limit, :precision => column.precision, :scale => column.scale}
+              options[:default] = column.default unless column.default.nil?
+              options[:null]    = column.null    unless column.null.nil?
+              logger.debug "[MiniRecord] Adding column #{table_name}.#{column.name}"
+              connection.add_column table_name, column.name, column.type.to_sym, options unless dry_run
+            end
           end
 
           # Add indexes
           indexes.each do |name, options|
             options = options.dup
-            index_name = options[:name] || name
+            index_name = (options[:name] || name).to_s
             unless connection.indexes(table_name).detect { |i| i.name == index_name }
-              connection.add_index(table_name, options.delete(:column), options)
+              logger.debug "[MiniRecord] Adding index #{index_name} #{options[:column].inspect} on #{table_name}"
+              connection.add_index(table_name, options.delete(:column), options) unless dry_run
             end
           end
 
-          add_foreign_keys if connection.respond_to?(:foreign_keys)
+          add_foreign_keys(dry_run) if connection.respond_to?(:foreign_keys)
 
           # Reload column information
           reset_column_information

data/lib/mini_record/version.rb

@@ -1,3 +1,3 @@
 module MiniRecord
-  VERSION = "0.4.3"
+  VERSION = "0.4.4"
 end

data/test/helper.rb

@@ -37,7 +37,13 @@ class ActiveRecord::Base
       ActiveRecord::Base.logs.string.gsub(/\e\[[\d;]+m/, '').lines.reject { |l| !pragma && l =~ /pragma/i }.join("\n")
     end
 
-    def auto_upgrade!
+    def auto_upgrade!(*args)
+      ActiveRecord::Base.logs = StringIO.new
+      ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new(ActiveRecord::Base.logs)
+      silence_stream(STDERR) { super }
+    end
+
+    def auto_upgrade_dry
       ActiveRecord::Base.logs = StringIO.new
       ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new(ActiveRecord::Base.logs)
       silence_stream(STDERR) { super }

data/test/test_mini_record.rb

@@ -2,13 +2,20 @@ require File.expand_path('../helper.rb', __FILE__)
 
 describe MiniRecord do
 
-  before do
-    ActiveRecord::Base.clear_reloadable_connections!
-    ActiveRecord::Base.clear_cache!
-    ActiveRecord::Base.clear_active_connections!
-    conn.tables.each { |table| silence_stream(STDERR) { conn.execute "DROP TABLE IF EXISTS #{table}" } }
+  def clear_active_record!(options = {})
+    unless options[:keep_tables]
+      ActiveRecord::Base.clear_reloadable_connections!
+      ActiveRecord::Base.clear_cache!
+      ActiveRecord::Base.clear_active_connections!
+      conn.tables.each { |table| silence_stream(STDERR) { conn.execute "DROP TABLE IF EXISTS #{table}" } }
+    end
+
     ActiveRecord::Base.descendants.each { |klass| Object.send(:remove_const, klass.to_s) if Object.const_defined?(klass.to_s) }
     ActiveSupport::DescendantsTracker.direct_descendants(ActiveRecord::Base).clear
+  end
+
+  before do
+    clear_active_record!
     load File.expand_path('../models.rb', __FILE__)
     ActiveRecord::Base.auto_upgrade!
     MiniRecord.reset_configuration!
@@ -128,9 +135,41 @@ describe MiniRecord do
       index :customer_id, :unique => true, :name => 'by_customer'
       belongs_to :customer
     end
+    # Run auto_upgrade! once to create table and index.
     Foo.auto_upgrade!
     assert_equal 1, Foo.db_indexes.size
     assert_includes Foo.db_indexes, 'by_customer'
+    # Run auto_upgrade! again and ensure no statements issued.
+    Foo.auto_upgrade!
+    assert_empty Foo.queries
+  end
+
+  it 'does not add already defined composite indexes' do
+    class Foo < ActiveRecord::Base
+      belongs_to :region
+      belongs_to :customer
+      add_index [:region_id, :customer_id], :unique => true, :name => 'by_region_and_customer'
+    end
+    # Run auto_upgrade! once to create table and index.
+    Foo.auto_upgrade!
+    assert_equal 3, Foo.db_indexes.size
+    assert_includes Foo.db_indexes, 'by_region_and_customer'
+    # Run auto_upgrade! again and ensure no statements issued.
+    Foo.auto_upgrade!
+    assert_empty Foo.queries
+  end
+
+  it 'supports indexes with symbols for names' do
+    class Foo < ActiveRecord::Base
+      col :some_field, :index => {:name => :idx_for_some_field}
+    end
+    # Run auto_upgrade! once to create table and index.
+    Foo.auto_upgrade!
+    assert_equal 1, Foo.db_indexes.size
+    assert_includes Foo.db_indexes, 'idx_for_some_field'
+    # Run auto_upgrade! again and ensure no statements issued.
+    Foo.auto_upgrade!
+    assert_empty Foo.queries
   end
 
   it 'works with STI' do
@@ -518,6 +557,24 @@ describe MiniRecord do
       assert_includes Book.db_indexes, 'index_books_on_second_publisher_id'
     end
 
+    it "does not add suppressed index" do
+      class Foo < ActiveRecord::Base
+        belongs_to :customer
+        suppress_index :customer
+      end
+      Foo.auto_upgrade!
+      assert_equal 0, Foo.db_indexes.size
+    end
+
+    it "does not add suppressed index from polymorphic relation" do
+      class Foo < ActiveRecord::Base
+        belongs_to :customer, :polymorphic => true
+        suppress_index :customer
+      end
+      Foo.auto_upgrade!
+      assert_equal 0, Foo.db_indexes.size
+    end
+
   end
 
   describe 'relation #habtm' do
@@ -580,6 +637,16 @@ describe MiniRecord do
       assert_includes conn.indexes(:long_people).map(&:name), index_name
     end
 
+    it 'creates a join table without an index when suppressed for has_and_belongs_to_many relations' do
+      class Foo < ActiveRecord::Base
+        has_and_belongs_to_many :bars
+        suppress_index :bars
+      end
+      Foo.auto_upgrade!
+      assert_includes conn.tables, 'bars_foos'
+      assert_equal 0, conn.indexes(:bars_foos).size
+    end
+
     it 'adds unique index' do
       page = Page.create(:title => 'Foo')
       photogallery = Photogallery.create(:title => 'Bar')
@@ -895,4 +962,30 @@ describe MiniRecord do
     Foo.auto_upgrade! rescue nil # eat the exception from invalid options
     assert_match /CREATE TABLE.* extra options\Z/, Foo.queries
   end
+
+  it 'can do a dry run' do
+    class Foo < ActiveRecord::Base
+    end
+
+    ActiveRecord::Base.auto_upgrade_dry
+    refute_match /\bcreate\b/i, Foo.queries
+    refute_match /\balter\b/i, Foo.queries
+
+    ActiveRecord::Base.auto_upgrade!
+    assert_match /\bcreate\b/i, Foo.queries
+    refute_match /\balter\b/i, Foo.queries
+
+    clear_active_record!(:keep_tables => true)
+    class Foo < ActiveRecord::Base
+      property :new_field, :index => true
+    end
+
+    ActiveRecord::Base.auto_upgrade_dry
+    refute_match /\bcreate\b/i, Foo.queries
+    refute_match /\balter\b/i, Foo.queries
+
+    ActiveRecord::Base.auto_upgrade!
+    assert_match /\bcreate\b/i, Foo.queries
+    assert_match /\balter\b/i, Foo.queries
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_record
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.4
 platform: ruby
 authors:
 - Davide D'Agostino
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-10 00:00:00.000000000 Z
+date: 2014-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord