low_card_tables 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  metadata.gz: d7c2ebbfc8004ec52dcffbae127d9b17dadf62cb
+  data.tar.gz: f8b2f393e3a18649a01b8d53baefd0101e879c17
+SHA512: 
+  metadata.gz: d37e5bddb60b90c475b6a33a42979f15ebc88fc78f6581856b6d2f971370c175d7fdc10000981027c5660f3fd709e1075160f88f2255106a9dd577b16454abc7
+  data.tar.gz: 312b865016ead5b60440bed7a9cb80b7aed32c110eb87847062570e7f86ba59e8f3f688270b39a0e675af8d9603cd650e34fd0adc5b27d4414285692b65d6da7

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+/spec_database_config.rb

data/.travis.yml

@@ -0,0 +1,59 @@
+rvm:
+    - "1.8.7"
+    - "1.9.3"
+    - "2.0.0"
+    - "jruby-1.7.6"
+env:
+    # Sadly, Travis seems to have a version of SQLite < 3.7.11 installed on many of its workers;
+    # this prevents activerecord-import from working, since those versions of the SQLite engine
+    # don't have support for multi-row inserts in a single statement. There really isn't anything
+    # we can do about this, unfortunately..
+    - LOW_CARD_TABLES_AR_TEST_VERSION=3.0.20 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
+    - LOW_CARD_TABLES_AR_TEST_VERSION=3.0.20 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+    # - LOW_CARD_TABLES_AR_TEST_VERSION=3.0.20 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+    - LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
+    - LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+    # - LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+    - LOW_CARD_TABLES_AR_TEST_VERSION=3.2.15 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
+    - LOW_CARD_TABLES_AR_TEST_VERSION=3.2.15 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+    # - LOW_CARD_TABLES_AR_TEST_VERSION=3.2.15 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+    - LOW_CARD_TABLES_AR_TEST_VERSION=4.0.1 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
+    - LOW_CARD_TABLES_AR_TEST_VERSION=4.0.1 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+    # - LOW_CARD_TABLES_AR_TEST_VERSION=4.0.1 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+before_script:
+    - export JRUBY_OPTS="-J-Xmx256m -J-Xms256m $JRUBY_OPTS"
+    - mysql -e 'create database myapp_test;'
+    - psql -c 'create database myapp_test;' -U postgres
+matrix:
+    exclude:
+        # ActiveRecord 4.x doesn't support Ruby 1.8.7
+        -   rvm: 1.8.7
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.0.1 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
+        -   rvm: 1.8.7
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.0.1 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+        -   rvm: 1.8.7
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.0.1 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+        # There's a bug in ActiveRecord 3.1.x that makes it incompatible with Ruby 2.0
+        -   rvm: 2.0.0
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
+        -   rvm: 2.0.0
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+        -   rvm: 2.0.0
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+        # The activerecord-import gem currently doesn't support JRuby JDBC adapters with anything but MySQL
+        -   rvm: jruby-1.7.6
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=3.0.20 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+        -   rvm: jruby-1.7.6
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+        -   rvm: jruby-1.7.6
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=3.2.15 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+        -   rvm: jruby-1.7.6
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.0.1 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+        -   rvm: jruby-1.7.6
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=3.0.20 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+        -   rvm: jruby-1.7.6
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+        -   rvm: jruby-1.7.6
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=3.2.15 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+        -   rvm: jruby-1.7.6
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.0.1 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in low_card_tables.gemspec
+gemspec
+
+ar_version = ENV['LOW_CARD_TABLES_AR_TEST_VERSION']
+ar_version = ar_version.strip if ar_version
+
+version_spec = case ar_version
+when nil then nil
+when 'master' then { :git => 'git://github.com/rails/activerecord.git' }
+else "=#{ar_version}"
+end
+
+if version_spec
+  gem("activerecord", version_spec)
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2013, Andrew Geweke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

data/README.md

@@ -0,0 +1,75 @@
+# low_card_tables
+
+Think of `low_card_tables` as "bitfields for ActiveRecord, but done right". It allows you to store multiple values
+as compactly as possible in a given database column, but using a technique that's vastly friendlier to queries,
+future expansion, separate analysis, and other (non-Rails) tools than actual bitfields. It works with any data that
+has few distinct values in the table; boolean fields are one example, but any `enum`-style fields are great candidates
+for use.
+
+Greatly improve scalability and maintainability of your database tables by breaking out columns containing few distinct values (e.g., booleans and other flags) into a separate table that's transparently referenced and used. Supports Rails 3.0.x, 3.1.x, 3.2.x, and 4.0.x, running on Ruby 1.8.7, 1.9.3, and 2.0.0 with MySQL, PostgreSQL, and Sqlite. (JRuby is supported, but only with MySQL, because `low_card_tables` depends on the `activerecord-import` gem, and it currently does not have JRuby support for anything but MySQL.) Adding support for other databases is trivial.
+
+`low_card_tables` is the successor to similar, but more primitive, systems that have been in place at very large commercial websites serving tens of millions of pages a day, and in database tables with hundreds of millions of rows. The predecessor systems were extremely successful and reliable — hence the desire to evolve this into an open-source gem.
+
+`low_card_tables` is short for "low-cardinality tables". Cardinality, when applied to a database column, is the measure of the number of distinct values that column can hold. This Gem is meant to be used for columns that hold few distinct values throughout the table — hence, they have low cardinality.
+
+Current build status: ![Current Build Status](https://api.travis-ci.org/ageweke/low_card_tables.png?branch=master)
+
+===
+# Documentation is on [the Wiki](https://github.com/ageweke/low_card_tables/wiki)!
+
+This file would be incredibly long if it contained all the information present there. A quickstart guide is below;
+see the Wiki for everything else.
+
+===
+
+### Installing low_card_tables
+
+	# Gemfile
+	gem 'low_card_tables'
+
+### Getting Started
+
+We'll first discuss adding entirely new tables, and then talk about how you can migrate existing tables.
+
+#### Creating the Database Structure
+
+Create the table structure you need in your database:
+
+	class MyMigration < ActiveRecord::Migration
+	  def up
+	    create_table :users do |t|
+	      t.string :first_name, :null => false
+	      t.string :last_name, :null => false
+	      ...
+	      t.integer :user_status_id, :null => false, :limit => 2
+	      ...
+	    end
+
+	    create_table :user_statuses, :low_card => true do |t|
+	      t.boolean :deleted, :null => false
+	      t.boolean :deceased, :null => false
+	      t.string :gender, :null => false, :limit => 20
+	      t.string :payment_status, :null => false, :limit => 30
+	    end
+	  end
+	end
+
+In the migration, we simply create the table structure in the most straightforward way possible, with one exception: we add `:low_card => true` to the `create_table` command on the low-card table itself. The only thing this does is that, once the table has been created, it automatically adds a unique index across all columns in the table &mdash; this is very important, since it allows the database to enforce the key property of the low-card system: that there is exactly one row for each unique combination of values in the low-card columns.
+
+#### Creating the Models
+
+Create the models:
+
+	# app/models/user_status.rb
+	class UserStatus < ActiveRecord::Base
+	  is_low_card_table
+	end
+
+	# app/models/user.rb
+	class User < ActiveRecord::Base
+	  has_low_card_table :status
+	end
+
+And boom, you're done. Any columns present on `user_statuses` will appear as virtual columns on `User` &mdash; for reading and writing, for queries, for scopes, for validations, and so on.
+
+Please see [the Wiki](https://github.com/ageweke/low_card_tables/wiki) for further documentation!

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/low_card_tables.rb

@@ -0,0 +1,72 @@
+require 'active_record'
+require 'active_support'
+require 'active_record/migration'
+require "low_card_tables/version"
+require "low_card_tables/version_support"
+require 'low_card_tables/active_record/base'
+require 'low_card_tables/active_record/migrations'
+require 'low_card_tables/active_record/relation'
+require 'low_card_tables/active_record/scoping'
+require 'low_card_tables/low_card_table/cache_expiration/has_cache_expiration'
+
+# This is the root 'require' file for +low_card_tables+. It loads a number of dependencies, and sets up some very
+# basic infrastructure.
+
+# The only thing that's actually present on the root LowCardTables module is cache-expiration settings -- you can say
+# <tt>LowCardTables.low_card_cache_expiration ...</tt> to set the cache expiration for any table that has not explicitly
+# had its own cache expiration defined.
+module LowCardTables
+  include LowCardTables::LowCardTable::CacheExpiration::HasCacheExpiration
+
+  # By default, we use the ExponentialCacheExpirationPolicy with default settings.
+  low_card_cache_expiration :exponential
+end
+
+# Include into ActiveRecord::Base two modules -- one allows you to declare +is_low_card_table+ or +has_low_card_table+,
+# and the other makes sure that you don't define scopes statically. (See LowCardTables::ActiveRecord::Scoping for more
+# information on why this is really bad.)
+class ActiveRecord::Base
+  include LowCardTables::ActiveRecord::Base
+  include LowCardTables::ActiveRecord::Scoping
+end
+
+# ActiveRecord migration methods (e.g., #create_table, #remove_column, etc.) are actually defined on the connection
+# classes used by ActiveRecord. Here, we make sure that we get a chance to patch any connection used in any migration
+# properly, so that we can add our migration support to it. See LowCardTables::ActiveRecord::Migrations for more
+# information.
+class ActiveRecord::Migration
+  if LowCardTables::VersionSupport.migrate_is_a_class_method?
+    class << self
+      def migrate_with_low_card_connection_patching(*args, &block)
+        _low_card_patch_connection_class_if_necessary(connection.class)
+        migrate_without_low_card_connection_patching(*args, &block)
+      end
+
+      alias_method_chain :migrate, :low_card_connection_patching
+    end
+  else
+    def migrate_with_low_card_connection_patching(*args, &block)
+      self.class._low_card_patch_connection_class_if_necessary(connection.class)
+      migrate_without_low_card_connection_patching(*args, &block)
+    end
+
+    alias_method_chain :migrate, :low_card_connection_patching
+  end
+
+  class << self
+    def _low_card_patch_connection_class_if_necessary(connection_class)
+      @_low_card_patched_connection_classes = { }
+      @_low_card_patched_connection_classes[connection_class] ||= begin
+        connection_class.send(:include, ::LowCardTables::ActiveRecord::Migrations)
+        true
+      end
+    end
+  end
+end
+
+# This patches in our support for queries (like #where) to all ActiveRecord::Relation objects, so that you can say
+# things like <tt>User.where(:deleted => false)</tt> and it'll do exactly the right thing, automatically, even if
+# +:deleted+ is actually an attribute on a low-card table associated with +User+.
+class ActiveRecord::Relation
+  include LowCardTables::ActiveRecord::Relation
+end

data/lib/low_card_tables/active_record/base.rb

@@ -0,0 +1,55 @@
+require 'active_record'
+require 'active_support/concern'
+require 'low_card_tables/low_card_table/base'
+require 'low_card_tables/has_low_card_table/base'
+
+module LowCardTables
+  module ActiveRecord
+    # This is a module that gets included into ActiveRecord::Base. It provides just the bootstrap
+    # for LowCardTables methods that let you declare +is_low_card_table+ or +has_low_card_table+,
+    # and see if it's a low-card table or not.
+    module Base
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Declares that this is a low-card table. This simply includes the LowCardTables::LowCardTable::Base
+        # module, and then calls that module's is_low_card_table method, which is the one that does all
+        # the real work.
+        def is_low_card_table(options = { })
+          unless @_low_card_is_low_card_table_included
+            include LowCardTables::LowCardTable::Base
+            @_low_card_is_low_card_table_included = true
+          end
+
+          is_low_card_table(options)
+        end
+
+        # Is this a low-card table? This implementation just returns false -- if this is a low-card table,
+        # then it will have had the LowCardTables::LowCardTable::Base module included in after this one, and
+        # that implementation will return true.
+        def is_low_card_table?
+          false
+        end
+
+        # Declares that this table references a low-card table. This simply includes the
+        # LowCardTables::HasLowCardTable::Base method, and then calls that module's has_low_card_table method,
+        # which is the one that does all the real work.
+        def has_low_card_table(*args)
+          unless @_low_card_has_low_card_table_included
+            include LowCardTables::HasLowCardTable::Base
+            @_low_card_has_low_card_table_included = true
+          end
+
+          has_low_card_table(*args)
+        end
+
+        # Does this model reference any low-card tables? This implementation just returns false -- if this is
+        # a low-card table, then it will have had the LowCardTables::HasLowCardTable::Base module included in
+        # after this one, and that implementation will return true.
+        def has_any_low_card_tables?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/low_card_tables/active_record/migrations.rb

@@ -0,0 +1,223 @@
+require 'active_record'
+require 'active_support/concern'
+require 'low_card_tables/low_card_table/base'
+require 'low_card_tables/has_low_card_table/base'
+
+module LowCardTables
+  module ActiveRecord
+    # This module gets included into ::ActiveRecord::Migrations, and overrides key methods (using +alias_method_chain+)
+    # to add low-card support. Its job is to detect if a low-card table is being modified, and, if so:
+    #
+    # * Remove the all-columns unique index before the operation in question, and add it back afterwards
+    # * If a column has been removed, collapse any now-duplicate rows in question and update all referring tables
+    #
+    # It also adds a single method to migrations, #change_low_card_table, which does nothing of its own rather than
+    # to call the passed block -- but it does all the checking above at the start and end, and disables any such
+    # checking within the block. It thus gives you control over exactly when this happens.
+    module Migrations
+      extend ActiveSupport::Concern
+
+      # Overrides ::ActiveRecord::Migrations#create_table with low-cardinality support, as described in the comment
+      # for LowCardTables::ActiveRecord::Migrations.
+      def create_table_with_low_card_support(table_name, options = { }, &block)
+        ::LowCardTables::ActiveRecord::Migrations.with_low_card_support(table_name, options) do |new_options|
+          create_table_without_low_card_support(table_name, new_options, &block)
+        end
+      end
+
+      # Overrides ::ActiveRecord::Migrations#add_column with low-cardinality support, as described in the comment
+      # for LowCardTables::ActiveRecord::Migrations.
+      def add_column_with_low_card_support(table_name, column_name, type, options = {})
+        ::LowCardTables::ActiveRecord::Migrations.with_low_card_support(table_name, options) do |new_options|
+          add_column_without_low_card_support(table_name, column_name, type, options)
+        end
+      end
+
+      # Overrides ::ActiveRecord::Migrations#remove_column with low-cardinality support, as described in the comment
+      # for LowCardTables::ActiveRecord::Migrations.
+      def remove_column_with_low_card_support(table_name, *column_names)
+        options = column_names.pop if column_names[-1] && column_names[-1].kind_of?(Hash)
+        ::LowCardTables::ActiveRecord::Migrations.with_low_card_support(table_name, options) do |new_options|
+          args = [ table_name ]
+          args += column_names
+          args << new_options if new_options && new_options.size > 0
+          remove_column_without_low_card_support(*args)
+        end
+      end
+
+      # Overrides ::ActiveRecord::Migrations#change_table with low-cardinality support, as described in the comment
+      # for LowCardTables::ActiveRecord::Migrations.
+      def change_table_with_low_card_support(table_name, options = { }, &block)
+        ::LowCardTables::ActiveRecord::Migrations.with_low_card_support(table_name, options) do |new_options|
+          ar = method(:change_table_without_low_card_support).arity
+          if ar > 1 || ar < -2
+            change_table_without_low_card_support(table_name, new_options, &block)
+          else
+            change_table_without_low_card_support(table_name, &block)
+          end
+        end
+      end
+
+      # Given the name of a low-card table and a block:
+      #
+      # * Removes the all-columns unique index for that low-card table;
+      # * Calls the block;
+      # * Looks for any removed columns, and, if so, collapses now-duplicate rows and updates all referrers;
+      # * Creates the all-columns unique index for that table.
+      #
+      # While inside the block, none of the above checking will be performed against that table, as it otherwise would
+      # be if you call #add_column, #remove_column, #create_table, or #change_table. This thus gives you a scope in
+      # which to do what you need to do, without the all-columns index interfering.
+      def change_low_card_table(table_name, &block)
+        ::LowCardTables::ActiveRecord::Migrations.with_low_card_support(table_name, { :low_card => true }) do |new_options|
+          block.call
+        end
+      end
+
+      included do
+        alias_method_chain :create_table, :low_card_support
+        alias_method_chain :add_column, :low_card_support
+        alias_method_chain :remove_column, :low_card_support
+        alias_method_chain :change_table, :low_card_support
+      end
+
+      class << self
+        # Adds all the checking described in the comment on LowCardTables::ActiveRecord::Migrations for the given
+        # table name to the supplied block.
+        def with_low_card_support(table_name, options = { }, &block)
+          # Don't do this if we're already inside such a check -- this is needed because:
+          #
+          #    change_table :foo do |t|
+          #      t.remove :bar
+          #    end
+          #
+          # ...actually translates internally to a call to remove_column inside change_table, and, otherwise, we'll
+          # try to do our work twice, which is bad news.
+          (options, low_card_options) = partition_low_card_options(options)
+          return block.call(options) if inside_migrations_check?
+
+          low_card_model = low_card_model_to_use_for(table_name, low_card_options)
+          return block.call(options) if (! low_card_model)
+
+          with_migrations_check do
+            without_unique_index(low_card_model, low_card_options) do
+              with_removed_column_detection(low_card_model, low_card_options) do
+                block.call(options)
+              end
+            end
+          end
+        end
+
+        private
+        # Are we currently inside a call to #with_low_card_support?
+        def inside_migrations_check?
+          !! Thread.current[:_low_card_migrations_only_once]
+        end
+
+        # Wrap the given block in code notifying us that we're inside a call to #with_low_card_support.
+        def with_migrations_check(&block)
+          begin
+            Thread.current[:_low_card_migrations_only_once] = true
+            block.call
+          ensure
+            Thread.current[:_low_card_migrations_only_once] = false
+          end
+        end
+
+        # Wrap the given block in code that checks to see if we've removed any columns from the table that the given
+        # model is for, and, if so, calls low_card_collapse_rows_and_update_referrers! on that model.
+        def with_removed_column_detection(model, low_card_options, &block)
+          previous_columns = fresh_value_column_names(model)
+
+          begin
+            block.call
+          ensure
+            LowCardTables::VersionSupport.clear_schema_cache!(model)
+            model.reset_column_information
+            new_columns = fresh_value_column_names(model)
+
+            if (previous_columns - new_columns).length > 0
+              model.low_card_collapse_rows_and_update_referrers!(low_card_options)
+            end
+          end
+        end
+
+        # Wrap the given block in code that removes the all-columns unique index on the given model (which must be
+        # a low-card table) beforehand, and recreates it afterwards.
+        def without_unique_index(model, low_card_options, &block)
+          begin
+            model.low_card_remove_unique_index!
+            block.call
+          ensure
+            unless low_card_options.has_key?(:low_card_collapse_rows) && (! low_card_options[:low_card_collapse_rows])
+              model.low_card_ensure_has_unique_index!(true)
+            end
+          end
+        end
+
+        # Gets a fresh set of low_card_value_column_names from the given low-card model.
+        def fresh_value_column_names(model)
+          model.reset_column_information
+          model.low_card_value_column_names
+        end
+
+        # Splits an options Hash into two -- the first containing everything but low-card-related options, the second
+        # containing only low-card options.
+        def partition_low_card_options(options)
+          options = (options || { }).dup
+          low_card_options = { }
+
+          options.keys.each do |k|
+            if k.to_s =~ /^low_card/
+              low_card_options[k] = options.delete(k)
+            end
+          end
+
+          [ options, low_card_options ]
+        end
+
+        # Given a table name, looks to see if it's a low-card table -- either implicitly, because there's an existing
+        # model for that table that declares itself to be a low-card model, or explicitly, because we were passed
+        # :low_card => true in the options hash. If so, returns a model to use for that table -- either the existing
+        # model (implicit case) or a newly-created temporary model class (explicit case).
+        #
+        # Prefers an existing model over a temporary model, if there's both an existing model and we were passed
+        # :low_card => true.
+        def low_card_model_to_use_for(table_name, low_card_options)
+          out = existing_low_card_model_for(table_name)
+          out ||= temporary_model_class_for(table_name) if low_card_options[:low_card]
+          out
+        end
+
+        # Creates a temporary low-card model class for the given table_name. This is used only if we explicitly
+        # declare a model to be low-card in a migration, but there isn't currently a model for that table that
+        # declares itself to be low-card.
+        def temporary_model_class_for(table_name)
+          temporary_model_class = Class.new(::ActiveRecord::Base)
+          temporary_model_class.table_name = table_name
+          temporary_model_class.class_eval { is_low_card_table }
+          temporary_model_class.reset_column_information
+          temporary_model_class
+        end
+
+        # Looks at ::ActiveRecord::Base.descendants to see if there's an existing model class that references the given
+        # table_name and declares itself to be a low-card model class. If so, returns it.
+        #
+        # This method will attempt to eager-load all Rails code, so that we can detect the model class properly.
+        # (Otherwise, migrations typically don't end up loading most models, so, even if the model is there on disk,
+        # it will not be in memory and thus won't appear in ::ActiveRecord::Base.descendants.)
+        def existing_low_card_model_for(table_name)
+          # Make sure we load all models
+          ::Rails.application.eager_load! if defined?(::Rails) && ::Rails.respond_to?(:application) && ::Rails.application && ::Rails.application.respond_to?(:eager_load!)
+          out = ::ActiveRecord::Base.descendants.detect do |klass|
+            klass.table_name.strip.downcase == table_name.to_s.strip.downcase &&
+              klass.is_low_card_table? &&
+              klass.name && klass.name.strip.length > 0
+          end
+
+          out
+        end
+      end
+    end
+  end
+end