yaml_db 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: acdb560a3395eccc63e09765a383c21a04989f16
-  data.tar.gz: d212a746810f53f432a0f0d0470a0786f69afeae
+  metadata.gz: 04f954464b2709f0799c94e237e9be6908fae386
+  data.tar.gz: 284dcf617e715dc8fac6359d987c96a6ec3968ea
 SHA512:
-  metadata.gz: 7b584320742d6e98d03dc8bc5d83a967a6386b938719d2a67343f6d6197203c0a8fe21dffdc51d1cdd5f1f3ff9fb1aeb161ddeeedb0d3b0a954f66258aa5415b
-  data.tar.gz: 6b9e694bd379f5c198316e366af098f3b7e9c94b9397926cc129911cb66182fa218b4586e72eff418909c1734eac04aada3ccda1d68c902569d87fc0c0b25014
+  metadata.gz: 88e48da7a8e781d54fbcfa6f88d08fb8103f5a39450c4d3226d475edd6a4129882b60fdc4af4c88a1321e9be54bb49f5b701a1be0091013518b22e4dda821bd9
+  data.tar.gz: e20c244eef8ae1d6b20bb63352910d3238fc251d379b6c023d1f13256f1976b32aa5a4b571baa4c1585b2956ff1c728fa89cdcb8c9fdafbae0b9a515ab98b63d

data/README.md

@@ -1,10 +1,12 @@
 # YamlDb
 
-YamlDb is a database-independent format for dumping and restoring data.  It complements the the database-independent schema format found in db/schema.rb.  The data is saved into db/data.yml.
+YamlDb is a database-independent format for dumping and restoring data.  It complements the database-independent schema format found in db/schema.rb.  The data is saved into db/data.yml.
 
 This can be used as a replacement for mysqldump or pg_dump, but only for the databases typically used by Rails apps.  Users, permissions, schemas, triggers, and other advanced database features are not supported - by design.
 
-Any database that has an ActiveRecord adapter should work.  This gem is now Rails 3 only.  For Rails 2, clone and checkout the Rails2 branch.
+Any database that has an ActiveRecord adapter should work.
+
+This gem supports Rails 3.x, 4.x, and 5.0.
 
 [![Build Status](https://travis-ci.org/yamldb/yaml_db.svg?branch=master)](https://travis-ci.org/yamldb/yaml_db)
 
@@ -42,6 +44,4 @@ One common use would be to switch your data from one database backend to another
 
 ## Credits
 
-Created by Orion Henry and Adam Wiggins.  Major updates by Ricardo Chimal, Jr.
-
-Patches contributed by Michael Irwin, Tom Locke, and Tim Galeckas.
+Created by Orion Henry and Adam Wiggins. Major updates by Ricardo Chimal Jr. and Nate Kidwell.

data/lib/tasks/yaml_db_tasks.rake

@@ -6,40 +6,24 @@ namespace :db do
   task(:load => [ "db:schema:load", "db:data:load" ])
 
   namespace :data do
-    def db_dump_data_file (extension = "yml")
-      "#{dump_dir}/data.#{extension}"
-    end
-
-    def dump_dir(dir = "")
-      "#{Rails.root}/db#{dir}"
-    end
-
     desc "Dump contents of database to db/data.extension (defaults to yaml)"
     task :dump => :environment do
-      format_class = ENV['class'] || "YamlDb::Helper"
-      helper = format_class.constantize
-      SerializationHelper::Base.new(helper).dump db_dump_data_file helper.extension
+      YamlDb::RakeTasks.data_dump_task
     end
 
     desc "Dump contents of database to curr_dir_name/tablename.extension (defaults to yaml)"
     task :dump_dir => :environment do
-      format_class = ENV['class'] || "YamlDb::Helper"
-      dir = ENV['dir'] || "#{Time.now.to_s.gsub(/ /, '_')}"
-      SerializationHelper::Base.new(format_class.constantize).dump_to_dir dump_dir("/#{dir}")
+      YamlDb::RakeTasks.data_dump_dir_task
     end
 
     desc "Load contents of db/data.extension (defaults to yaml) into database"
     task :load => :environment do
-      format_class = ENV['class'] || "YamlDb::Helper"
-      helper = format_class.constantize
-      SerializationHelper::Base.new(helper).load(db_dump_data_file helper.extension)
+      YamlDb::RakeTasks.data_load_task
     end
 
     desc "Load contents of db/data_dir into database"
     task :load_dir  => :environment do
-      dir = ENV['dir'] || "base"
-      format_class = ENV['class'] || "YamlDb::Helper"
-      SerializationHelper::Base.new(format_class.constantize).load_from_dir dump_dir("/#{dir}")
+      YamlDb::RakeTasks.data_load_dir_task
     end
   end
 end

data/lib/yaml_db.rb

@@ -1,19 +1,20 @@
 require 'rubygems'
 require 'yaml'
 require 'active_record'
-require 'serialization_helper'
 require 'active_support/core_ext/kernel/reporting'
 require 'rails/railtie'
+require 'yaml_db/rake_tasks'
 require 'yaml_db/version'
+require 'yaml_db/serialization_helper'
 
 module YamlDb
   module Helper
     def self.loader
-      YamlDb::Load
+      Load
     end
 
     def self.dumper
-      YamlDb::Dump
+      Dump
     end
 
     def self.extension
@@ -46,7 +47,7 @@ module YamlDb
 
       each_table_page(table) do |records|
         rows = SerializationHelper::Utils.unhash_records(records.to_a, column_names)
-        io.write(YamlDb::Utils.chunk_records(rows))
+        io.write(Utils.chunk_records(rows))
       end
     end
 

data/lib/yaml_db/csv_db.rb

@@ -0,0 +1,77 @@
+module YamlDb
+  module CsvDb
+    module Helper
+      def self.loader
+        Load
+      end
+
+      def self.dumper
+        Dump
+      end
+
+      def self.extension
+        "csv"
+      end
+    end
+
+    class Load < SerializationHelper::Load
+      def self.load_documents(io, truncate = true)
+        tables = {}
+        curr_table = nil
+        io.each do |line|
+          if /BEGIN_CSV_TABLE_DECLARATION(.+)END_CSV_TABLE_DECLARATION/ =~ line
+            curr_table = $1
+            tables[curr_table] = {}
+          else
+            if tables[curr_table]["columns"]
+              tables[curr_table]["records"] << FasterCSV.parse(line)[0]
+            else
+              tables[curr_table]["columns"] = FasterCSV.parse(line)[0]
+              tables[curr_table]["records"] = []
+            end
+          end
+        end
+
+        tables.each_pair do |table_name, contents|
+          load_table(table_name, contents, truncate)
+        end
+      end
+    end
+
+    class Dump < SerializationHelper::Dump
+
+      def self.before_table(io,table)
+        io.write "BEGIN_CSV_TABLE_DECLARATION#{table}END_CSV_TABLE_DECLARATION\n"
+      end
+
+      def self.dump(io)
+        tables.each do |table|
+          before_table(io, table)
+          dump_table(io, table)
+          after_table(io, table)
+        end
+      end
+
+      def self.after_table(io,table)
+        io.write ""
+      end
+
+      def self.dump_table_columns(io, table)
+        io.write(table_column_names(table).to_csv)
+      end
+
+      def self.dump_table_records(io, table)
+
+        column_names = table_column_names(table)
+
+        each_table_page(table) do |records|
+          rows = SerializationHelper::Utils.unhash_records(records, column_names)
+          records.each do |record|
+            io.write(record.to_csv)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/yaml_db/rake_tasks.rb

@@ -0,0 +1,36 @@
+module YamlDb
+  module RakeTasks
+    def self.data_dump_task
+      SerializationHelper::Base.new(helper).dump(db_dump_data_file(helper.extension))
+    end
+
+    def self.data_dump_dir_task
+      dir = ENV['dir'] || "#{Time.now.strftime('%F_%T')}"
+      SerializationHelper::Base.new(helper).dump_to_dir(dump_dir("/#{dir}"))
+    end
+
+    def self.data_load_task
+      SerializationHelper::Base.new(helper).load(db_dump_data_file(helper.extension))
+    end
+
+    def self.data_load_dir_task
+      dir = ENV['dir'] || 'base'
+      SerializationHelper::Base.new(helper).load_from_dir(dump_dir("/#{dir}"))
+    end
+
+    private
+
+    def self.db_dump_data_file(extension = 'yml')
+      "#{dump_dir}/data.#{extension}"
+    end
+
+    def self.dump_dir(dir = '')
+      "#{Rails.root}/db#{dir}"
+    end
+
+    def self.helper
+      format_class = ENV['class'] || 'YamlDb::Helper'
+      format_class.constantize
+    end
+  end
+end

data/lib/yaml_db/serialization_helper.rb

@@ -0,0 +1,201 @@
+module YamlDb
+  module SerializationHelper
+
+    class Base
+      attr_reader :extension
+
+      def initialize(helper)
+        @dumper    = helper.dumper
+        @loader    = helper.loader
+        @extension = helper.extension
+      end
+
+      def dump(filename)
+        disable_logger
+        File.open(filename, "w") do |file|
+          @dumper.dump(file)
+        end
+        reenable_logger
+      end
+
+      def dump_to_dir(dirname)
+        Dir.mkdir(dirname)
+        tables = @dumper.tables
+        tables.each do |table|
+          File.open("#{dirname}/#{table}.#{@extension}", "w") do |io|
+            @dumper.before_table(io, table)
+            @dumper.dump_table io, table
+            @dumper.after_table(io, table)
+          end
+        end
+      end
+
+      def load(filename, truncate = true)
+        disable_logger
+        @loader.load(File.new(filename, "r"), truncate)
+        reenable_logger
+      end
+
+      def load_from_dir(dirname, truncate = true)
+        Dir.entries(dirname).each do |filename|
+          if filename =~ /^[.]/
+            next
+          end
+          @loader.load(File.new("#{dirname}/#{filename}", "r"), truncate)
+        end
+      end
+
+      def disable_logger
+        @@old_logger = ActiveRecord::Base.logger
+        ActiveRecord::Base.logger = nil
+      end
+
+      def reenable_logger
+        ActiveRecord::Base.logger = @@old_logger
+      end
+    end
+
+    class Load
+      def self.load(io, truncate = true)
+        ActiveRecord::Base.connection.transaction do
+          load_documents(io, truncate)
+        end
+      end
+
+      def self.truncate_table(table)
+        begin
+          ActiveRecord::Base.connection.execute("TRUNCATE #{Utils.quote_table(table)}")
+        rescue Exception
+          ActiveRecord::Base.connection.execute("DELETE FROM #{Utils.quote_table(table)}")
+        end
+      end
+
+      def self.load_table(table, data, truncate = true)
+        column_names = data['columns']
+        if truncate
+          truncate_table(table)
+        end
+        load_records(table, column_names, data['records'])
+        reset_pk_sequence!(table)
+      end
+
+      def self.load_records(table, column_names, records)
+        if column_names.nil?
+          return
+        end
+        columns = column_names.map{|cn| ActiveRecord::Base.connection.columns(table).detect{|c| c.name == cn}}
+        quoted_column_names = column_names.map { |column| ActiveRecord::Base.connection.quote_column_name(column) }.join(',')
+        quoted_table_name = Utils.quote_table(table)
+        records.each do |record|
+          quoted_values = record.zip(columns).map{|c| ActiveRecord::Base.connection.quote(c.first, c.last)}.join(',')
+          ActiveRecord::Base.connection.execute("INSERT INTO #{quoted_table_name} (#{quoted_column_names}) VALUES (#{quoted_values})")
+        end
+      end
+
+      def self.reset_pk_sequence!(table_name)
+        if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!)
+          ActiveRecord::Base.connection.reset_pk_sequence!(table_name)
+        end
+      end
+
+    end
+
+    module Utils
+
+      def self.unhash(hash, keys)
+        keys.map { |key| hash[key] }
+      end
+
+      def self.unhash_records(records, keys)
+        records.each_with_index do |record, index|
+          records[index] = unhash(record, keys)
+        end
+
+        records
+      end
+
+      def self.convert_booleans(records, columns)
+        records.each do |record|
+          columns.each do |column|
+            next if is_boolean(record[column])
+            record[column] = convert_boolean(record[column])
+          end
+        end
+        records
+      end
+
+      def self.convert_boolean(value)
+        ['t', '1', true, 1].include?(value)
+      end
+
+      def self.boolean_columns(table)
+        columns = ActiveRecord::Base.connection.columns(table).reject { |c| silence_warnings { c.type != :boolean } }
+        columns.map { |c| c.name }
+      end
+
+      def self.is_boolean(value)
+        value.kind_of?(TrueClass) or value.kind_of?(FalseClass)
+      end
+
+      def self.quote_table(table)
+        ActiveRecord::Base.connection.quote_table_name(table)
+      end
+
+    end
+
+    class Dump
+      def self.before_table(io, table)
+
+      end
+
+      def self.dump(io)
+        tables.each do |table|
+          before_table(io, table)
+          dump_table(io, table)
+          after_table(io, table)
+        end
+      end
+
+      def self.after_table(io, table)
+
+      end
+
+      def self.tables
+        ActiveRecord::Base.connection.tables.reject { |table| ['schema_info', 'schema_migrations'].include?(table) }
+      end
+
+      def self.dump_table(io, table)
+        return if table_record_count(table).zero?
+
+        dump_table_columns(io, table)
+        dump_table_records(io, table)
+      end
+
+      def self.table_column_names(table)
+        ActiveRecord::Base.connection.columns(table).map { |c| c.name }
+      end
+
+
+      def self.each_table_page(table, records_per_page=1000)
+        total_count = table_record_count(table)
+        pages = (total_count.to_f / records_per_page).ceil - 1
+        id = table_column_names(table).first
+        boolean_columns = Utils.boolean_columns(table)
+        quoted_table_name = Utils.quote_table(table)
+
+        (0..pages).to_a.each do |page|
+          query = Arel::Table.new(table).order(id).skip(records_per_page*page).take(records_per_page).project(Arel.sql('*'))
+          records = ActiveRecord::Base.connection.select_all(query.to_sql)
+          records = Utils.convert_booleans(records, boolean_columns)
+          yield records
+        end
+      end
+
+      def self.table_record_count(table)
+        ActiveRecord::Base.connection.select_one("SELECT COUNT(*) FROM #{Utils.quote_table(table)}").values.first.to_i
+      end
+
+    end
+
+  end
+end

data/lib/yaml_db/version.rb

@@ -1,3 +1,3 @@
 module YamlDb
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yaml_db
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Adam Wiggins
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-02 00:00:00.000000000 Z
+date: 2016-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -20,7 +20,7 @@ dependencies:
         version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '5.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -30,7 +30,7 @@ dependencies:
         version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '5.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -89,7 +89,7 @@ dependencies:
         version: '1.3'
 description: |2
 
-  YamlDb is a database-independent format for dumping and restoring data.  It complements the the database-independent schema format found in db/schema.rb.  The data is saved into db/data.yml.
+  YamlDb is a database-independent format for dumping and restoring data.  It complements the database-independent schema format found in db/schema.rb.  The data is saved into db/data.yml.
   This can be used as a replacement for mysqldump or pg_dump, but only for the databases typically used by Rails apps.  Users, permissions, schemas, triggers, and other advanced database features are not supported - by design.
   Any database that has an ActiveRecord adapter should work.
 email: 
@@ -99,11 +99,11 @@ extra_rdoc_files:
 - README.md
 files:
 - README.md
-- init.rb
-- lib/csv_db.rb
-- lib/serialization_helper.rb
 - lib/tasks/yaml_db_tasks.rake
 - lib/yaml_db.rb
+- lib/yaml_db/csv_db.rb
+- lib/yaml_db/rake_tasks.rb
+- lib/yaml_db/serialization_helper.rb
 - lib/yaml_db/version.rb
 homepage: https://github.com/yamldb/yaml_db
 licenses:
@@ -125,8 +125,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: yaml_db allows export/import of database into/from yaml files
 test_files: []
+has_rdoc: 

data/init.rb

@@ -1 +0,0 @@
-require 'yaml_db'

data/lib/csv_db.rb

@@ -1,78 +0,0 @@
-#require 'FasterCSV'
-module CsvDb
-  module Helper
-    def self.loader
-      Load
-    end
-
-    def self.dumper
-      Dump
-    end
-
-    def self.extension
-      "csv"
-    end
-  end
-
-  class Load < SerializationHelper::Load
-    def self.load_documents(io, truncate = true)
-      tables = {}
-      curr_table = nil
-      io.each do |line|
-        if /BEGIN_CSV_TABLE_DECLARATION(.+)END_CSV_TABLE_DECLARATION/ =~ line
-          curr_table = $1
-          tables[curr_table] = {}
-        else
-          if tables[curr_table]["columns"]
-            tables[curr_table]["records"] << FasterCSV.parse(line)[0]
-          else
-            tables[curr_table]["columns"] = FasterCSV.parse(line)[0]
-            tables[curr_table]["records"] = []
-          end
-        end
-      end
-
-      tables.each_pair do |table_name, contents|
-        load_table(table_name, contents, truncate)
-      end
-    end
-  end
-
-  class Dump < SerializationHelper::Dump
-
-    def self.before_table(io,table)
-      io.write "BEGIN_CSV_TABLE_DECLARATION#{table}END_CSV_TABLE_DECLARATION\n"
-    end
-
-    def self.dump(io)
-      tables.each do |table|
-        before_table(io, table)
-        dump_table(io, table)
-        after_table(io, table)
-      end
-    end
-
-    def self.after_table(io,table)
-      io.write ""
-    end
-
-    def self.dump_table_columns(io, table)
-      io.write(table_column_names(table).to_csv)
-    end
-
-    def self.dump_table_records(io, table)
-
-      column_names = table_column_names(table)
-
-      each_table_page(table) do |records|
-        rows = SerializationHelper::Utils.unhash_records(records, column_names)
-        records.each do |record|
-          io.write(record.to_csv)
-        end
-      end
-    end
-    
-  end
-
-
-end

data/lib/serialization_helper.rb

@@ -1,196 +0,0 @@
-module SerializationHelper
-
-  class Base
-    attr_reader :extension
-
-    def initialize(helper)
-      @dumper    = helper.dumper
-      @loader    = helper.loader
-      @extension = helper.extension
-    end
-
-    def dump(filename)
-      disable_logger
-      @dumper.dump(File.new(filename, "w"))
-      reenable_logger
-    end
-
-    def dump_to_dir(dirname)
-      Dir.mkdir(dirname)
-      tables = @dumper.tables
-      tables.each do |table|
-        io = File.new "#{dirname}/#{table}.#{@extension}", "w"
-        @dumper.before_table(io, table)
-        @dumper.dump_table io, table
-        @dumper.after_table(io, table)
-      end
-    end
-
-    def load(filename, truncate = true)
-      disable_logger
-      @loader.load(File.new(filename, "r"), truncate)
-      reenable_logger
-    end
-
-    def load_from_dir(dirname, truncate = true)
-      Dir.entries(dirname).each do |filename|
-        if filename =~ /^[.]/
-          next
-        end
-        @loader.load(File.new("#{dirname}/#{filename}", "r"), truncate)
-      end
-    end
-
-    def disable_logger
-      @@old_logger = ActiveRecord::Base.logger
-      ActiveRecord::Base.logger = nil
-    end
-
-    def reenable_logger
-      ActiveRecord::Base.logger = @@old_logger
-    end
-  end
-
-  class Load
-    def self.load(io, truncate = true)
-      ActiveRecord::Base.connection.transaction do
-        load_documents(io, truncate)
-      end
-    end
-
-    def self.truncate_table(table)
-      begin
-        ActiveRecord::Base.connection.execute("TRUNCATE #{SerializationHelper::Utils.quote_table(table)}")
-      rescue Exception
-        ActiveRecord::Base.connection.execute("DELETE FROM #{SerializationHelper::Utils.quote_table(table)}")
-      end
-    end
-
-    def self.load_table(table, data, truncate = true)
-      column_names = data['columns']
-      if truncate
-        truncate_table(table)
-      end
-      load_records(table, column_names, data['records'])
-      reset_pk_sequence!(table)
-    end
-
-    def self.load_records(table, column_names, records)
-      if column_names.nil?
-        return
-      end
-      columns = column_names.map{|cn| ActiveRecord::Base.connection.columns(table).detect{|c| c.name == cn}}
-      quoted_column_names = column_names.map { |column| ActiveRecord::Base.connection.quote_column_name(column) }.join(',')
-      quoted_table_name = SerializationHelper::Utils.quote_table(table)
-      records.each do |record|
-        quoted_values = record.zip(columns).map{|c| ActiveRecord::Base.connection.quote(c.first, c.last)}.join(',')
-        ActiveRecord::Base.connection.execute("INSERT INTO #{quoted_table_name} (#{quoted_column_names}) VALUES (#{quoted_values})")
-      end
-    end
-
-    def self.reset_pk_sequence!(table_name)
-      if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!)
-        ActiveRecord::Base.connection.reset_pk_sequence!(table_name)
-      end
-    end
-
-  end
-
-  module Utils
-
-    def self.unhash(hash, keys)
-      keys.map { |key| hash[key] }
-    end
-
-    def self.unhash_records(records, keys)
-      records.each_with_index do |record, index|
-        records[index] = unhash(record, keys)
-      end
-
-      records
-    end
-
-    def self.convert_booleans(records, columns)
-      records.each do |record|
-        columns.each do |column|
-          next if is_boolean(record[column])
-          record[column] = convert_boolean(record[column])
-        end
-      end
-      records
-    end
-
-    def self.convert_boolean(value)
-      ['t', '1', true, 1].include?(value)
-    end
-
-    def self.boolean_columns(table)
-      columns = ActiveRecord::Base.connection.columns(table).reject { |c| silence_warnings { c.type != :boolean } }
-      columns.map { |c| c.name }
-    end
-
-    def self.is_boolean(value)
-      value.kind_of?(TrueClass) or value.kind_of?(FalseClass)
-    end
-
-    def self.quote_table(table)
-      ActiveRecord::Base.connection.quote_table_name(table)
-    end
-
-  end
-
-  class Dump
-    def self.before_table(io, table)
-
-    end
-
-    def self.dump(io)
-      tables.each do |table|
-        before_table(io, table)
-        dump_table(io, table)
-        after_table(io, table)
-      end
-    end
-
-    def self.after_table(io, table)
-
-    end
-
-    def self.tables
-      ActiveRecord::Base.connection.tables.reject { |table| ['schema_info', 'schema_migrations'].include?(table) }
-    end
-
-    def self.dump_table(io, table)
-      return if table_record_count(table).zero?
-
-      dump_table_columns(io, table)
-      dump_table_records(io, table)
-    end
-
-    def self.table_column_names(table)
-      ActiveRecord::Base.connection.columns(table).map { |c| c.name }
-    end
-
-
-    def self.each_table_page(table, records_per_page=1000)
-      total_count = table_record_count(table)
-      pages = (total_count.to_f / records_per_page).ceil - 1
-      id = table_column_names(table).first
-      boolean_columns = SerializationHelper::Utils.boolean_columns(table)
-      quoted_table_name = SerializationHelper::Utils.quote_table(table)
-
-      (0..pages).to_a.each do |page|
-        query = Arel::Table.new(table, ActiveRecord::Base).order(id).skip(records_per_page*page).take(records_per_page).project(Arel.sql('*'))
-        records = ActiveRecord::Base.connection.select_all(query.to_sql)
-        records = SerializationHelper::Utils.convert_booleans(records, boolean_columns)
-        yield records
-      end
-    end
-
-    def self.table_record_count(table)
-      ActiveRecord::Base.connection.select_one("SELECT COUNT(*) FROM #{SerializationHelper::Utils.quote_table(table)}").values.first.to_i
-    end
-
-  end
-
-end