activerecord-turntable 1.1.2 → 2.0.0.rc1

data/lib/active_record/turntable/rack/query_cache.rb

@@ -1,41 +1,38 @@
+require 'rack/body_proxy'
 require 'active_record/query_cache'
 
 module ActiveRecord
   module Turntable
     module Rack
       class QueryCache < ActiveRecord::QueryCache
-        class BodyProxy < ActiveRecord::QueryCache::BodyProxy
-          def close
-            @target.close if @target.respond_to?(:close)
-          ensure
-            klasses = [ActiveRecord::Base, *ActiveRecord::Base.turntable_connections.values]
-            ActiveRecord::Base.connection_id = @connection_id
-            klasses.each do |k|
-              k.connection.clear_query_cache
-              unless @original_cache_value
-                k.connection.disable_query_cache!
-              end
-            end
-          end
-        end
-
         def call(env)
-          old = ActiveRecord::Base.connection.query_cache_enabled
-          klasses = [ActiveRecord::Base, *ActiveRecord::Base.turntable_connections.values]
+          enabled       = ActiveRecord::Base.connection.query_cache_enabled
+          connection_id = ActiveRecord::Base.connection_id
+          klasses = ActiveRecord::Base.turntable_connections.values
           klasses.each do |k|
             k.connection.enable_query_cache!
           end
 
-          status, headers, body = @app.call(env)
-          [status, headers, BodyProxy.new(old, body, ActiveRecord::Base.connection_id)]
+          response = @app.call(env)
+          response[2] = ::Rack::BodyProxy.new(response[2]) do
+            restore_query_cache_settings(connection_id, enabled)
+          end
+
+          response
         rescue Exception => e
+          restore_query_cache_settings(connection_id, enabled)
+          raise e
+        end
+
+        private
+
+        def restore_query_cache_settings(connection_id, enabled)
+          klasses = ActiveRecord::Base.turntable_connections.values
           klasses.each do |k|
+            ActiveRecord::Base.connection_id = connection_id
             k.connection.clear_query_cache
-            unless old
-              k.connection.disable_query_cache!
-            end
+            k.connection.disable_query_cache! unless enabled
           end
-          raise e
         end
       end
     end

data/lib/active_record/turntable/rack.rb

@@ -1,6 +1,8 @@
 module ActiveRecord::Turntable
   module Rack
-    autoload :ConnectionManagement, 'active_record/turntable/rack/connection_management'
-    autoload :QueryCache, 'active_record/turntable/rack/query_cache'
+    extend ActiveSupport::Autoload
+
+    autoload :ConnectionManagement
+    autoload :QueryCache
   end
 end

data/lib/active_record/turntable/railtie.rb

@@ -1,6 +1,7 @@
 module ActiveRecord::Turntable
   class Railtie < Rails::Railtie
     rake_tasks do
+      require 'active_record/turntable/active_record_ext/database_tasks'
       load "active_record/turntable/railties/databases.rake"
     end
 
@@ -11,9 +12,9 @@ module ActiveRecord::Turntable
       end
     end
 
-    # Swap QueryCache Middleware
-    initializer "turntable.swap_query_cache_middleware" do |app|
-      app.middleware.swap ActiveRecord::QueryCache, ActiveRecord::Turntable::Rack::QueryCache
+    # QueryCache Middleware for turntable shards
+    initializer "turntable.insert_query_cache_middleware" do |app|
+      app.middleware.insert_after ActiveRecord::QueryCache, ActiveRecord::Turntable::Rack::QueryCache
     end
   end
 end

data/lib/active_record/turntable/railties/databases.rake

@@ -1,43 +1,69 @@
 require 'active_record/turntable'
 ActiveRecord::SchemaDumper.send(:include, ActiveRecord::Turntable::ActiveRecordExt::SchemaDumper)
 
+# TODO: implement schema:cache:xxxx
+
 db_namespace = namespace :db do
-  task :create do
-    if Rails.env.development? && ActiveRecord::Base.configurations['test'] && ActiveRecord::Base.configurations["test"]["shards"]
-      dbs = ActiveRecord::Base.configurations["test"]["shards"].values
-      dbs += ActiveRecord::Base.configurations["test"]["seq"].values if ActiveRecord::Base.configurations["test"]["seq"]
-      dbs.each do |shard_config|
-        create_database(shard_config)
-      end
+  namespace :create do
+    task :all => :load_config do
+      ActiveRecord::Tasks::DatabaseTasks.create_all_turntable_cluster
     end
-    if shard_configs = ActiveRecord::Base.configurations[Rails.env || 'development']["shards"]
-      dbs = shard_configs.values
-      dbs += ActiveRecord::Base.configurations[Rails.env || 'development']["seq"].values if ActiveRecord::Base.configurations[Rails.env || 'development']["seq"]
-      dbs.each do |shard_config|
-        create_database(shard_config)
-      end
+  end
+
+  desc 'Create current turntable databases config/database.yml for the current Rails.env'
+  task :create => [:load_config] do
+    unless ENV['DATABASE_URL']
+      ActiveRecord::Tasks::DatabaseTasks.create_current_turntable_cluster
     end
-    config = ActiveRecord::Base.configurations[Rails.env || 'development']
-    ActiveRecord::Base.establish_connection(config)
   end
 
-  task :drop do
-    config = ActiveRecord::Base.configurations[Rails.env || 'development']
-    shard_configs = config["shards"]
-    if shard_configs
-      dbs = shard_configs.values
-      dbs += ActiveRecord::Base.configurations[Rails.env || 'development']["seq"].values if ActiveRecord::Base.configurations[Rails.env || 'development']["seq"]
-      dbs.each do |shard_config|
-        begin
-          drop_database(shard_config)
-        rescue Exception => e
-          $stderr.puts "Couldn't drop #{ config['database']} : #{e.inspect}"
-        end
-      end
+  namespace :drop do
+    task :all => :load_config do
+      ActiveRecord::Tasks::DatabaseTasks.drop_all_turntable_cluster
+    end
+  end
+
+  desc 'Drops current turntable databases for the current Rails.env'
+  task :drop => [:load_config] do
+    unless ENV['DATABASE_URL']
+      ActiveRecord::Tasks::DatabaseTasks.drop_current_turntable_cluster
+    end
+  end
+
+  desc "Migrate turntable databases (options: VERSION=x, VERBOSE=false, SCOPE=blog)."
+  task :migrate => [:environment, :load_config] do
+    ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+
+    ActiveRecord::Tasks::DatabaseTasks.each_current_turntable_cluster_connected do |name, configuration|
+      puts "[turntable] *** Migrating database: #{configuration['database']}(Shard: #{name})"
+      ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths, ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+      db_namespace['_dump'].invoke
     end
-    ActiveRecord::Base.establish_connection(config)
   end
 
+  desc 'Rolls the turntable cluster schema back to the previous version (specify steps w/ STEP=n).'
+  task :rollback => [:environment, :load_config] do
+    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+
+    ActiveRecord::Tasks::DatabaseTasks.each_current_turntable_cluster_connected do |name, configuration|
+      puts "[turntable] *** Migrating database: #{configuration['database']}(Shard: #{name})"
+      ActiveRecord::Migrator.rollback(ActiveRecord::Migrator.migrations_paths, step)
+    end
+    db_namespace['_dump'].invoke
+  end
+
+  # desc 'Pushes the turntable cluster schema to the next version (specify steps w/ STEP=n).'
+  task :forward => [:environment, :load_config] do
+    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+
+    ActiveRecord::Tasks::DatabaseTasks.each_current_turntable_cluster_connected do |name, configuration|
+      puts "[turntable] *** Migrating database: #{configuration['database']}(Shard: #{name})"
+      ActiveRecord::Migrator.forward(ActiveRecord::Migrator.migrations_paths, step)
+    end
+    db_namespace['_dump'].invoke
+  end
+
+
   namespace :schema do
     task :dump do
       require 'active_record/schema_dumper'
@@ -46,6 +72,7 @@ db_namespace = namespace :db do
       shard_configs.merge!(config["seq"]) if config["seq"]
       if shard_configs
         shard_configs.each do |name, config|
+          next unless config["database"]
           filename = ENV['SCHEMA'] || "#{Rails.root}/db/schema-#{name}.rb"
           File.open(filename, "w:utf-8") do |file|
             ActiveRecord::Base.establish_connection(config)
@@ -64,6 +91,7 @@ db_namespace = namespace :db do
       shard_configs.merge!(config["seq"]) if config["seq"]
       if shard_configs
         shard_configs.each do |name, config|
+          next unless config["database"]
           ActiveRecord::Base.establish_connection(config)
           file = ENV['SCHEMA'] || "#{Rails.root}/db/schema-#{name}.rb"
           if File.exists?(file)
@@ -80,90 +108,45 @@ db_namespace = namespace :db do
   namespace :structure do
     desc 'Dump the database structure to an SQL file'
     task :dump => :environment do
-      config = ActiveRecord::Base.configurations[Rails.env]
-      shard_configs = config["shards"]
+      current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
+      shard_configs = current_config["shards"]
       shard_configs.merge!(config["seq"]) if config["seq"]
       if shard_configs
         shard_configs.each do |name, config|
-          case config['adapter']
-          when /mysql/, 'oci', 'oracle'
-            ActiveRecord::Base.establish_connection(config)
-            File.open("#{Rails.root}/db/#{Rails.env}_#{name}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
-          when /postgresql/
-            ENV['PGHOST']     = config['host'] if config['host']
-            ENV['PGPORT']     = config["port"].to_s if config['port']
-            ENV['PGPASSWORD'] = config['password'].to_s if config['password']
-            search_path = config['schema_search_path']
-            unless search_path.blank?
-              search_path = search_path.split(",").map{|search_path| "--schema=#{search_path.strip}" }.join(" ")
-            end
-            `pg_dump -i -U "#{config['username']}" -s -x -O -f db/#{Rails.env}_#{name}_structure.sql #{search_path} #{config['database']}`
-            raise 'Error dumping database' if $?.exitstatus == 1
-          when /sqlite/
-            dbfile = config['database'] || config['dbfile']
-            `sqlite3 #{dbfile} .schema > db/#{Rails.env}_#{name}_structure.sql`
-          when 'sqlserver'
-            `smoscript -s #{config['host']} -d #{config['database']} -u #{config['username']} -p #{config['password']} -f db\\#{Rails.env}_#{name}_structure.sql -A -U`
-          when "firebird"
-            set_firebird_env(config)
-            db_string = firebird_db_string(config)
-            sh "isql -a #{db_string} > #{Rails.root}/db/#{Rails.env}_#{name}_structure.sql"
-          else
-            raise "Task not supported by '#{config["adapter"]}'"
-          end
+          next unless config["database"]
+          ActiveRecord::Base.establish_connection(config)
+          filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "structure_#{name}.sql")
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(config, filename)
 
           if ActiveRecord::Base.connection.supports_migrations?
-            File.open("#{Rails.root}/db/#{Rails.env}_#{name}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+            File.open(filename, "a") do |f|
+              f.puts ActiveRecord::Base.connection.dump_schema_information
+            end
           end
         end
+        ActiveRecord::Base.establish_connection(current_config)
       end
-      ActiveRecord::Base.establish_connection(config)
+      db_namespace['structure:dump'].reenable
     end
-  end
-
 
-  namespace :test do
-    # desc "Recreate the test databases from the development structure"
-    task :clone_structure do
-      config = ActiveRecord::Base.configurations[Rails.env]
-      shard_configs = config["shards"]
+    # desc "Recreate the databases from the structure.sql file"
+    task :load => [:environment, :load_config] do
+      current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
+      shard_configs = current_config["shards"]
       shard_configs.merge!(config["seq"]) if config["seq"]
       if shard_configs
         shard_configs.each do |name, config|
-          case config['adapter']
-          when /mysql/
-            ActiveRecord::Base.establish_connection(config)
-            ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
-            IO.readlines("#{Rails.root}/db/#{Rails.env}_#{name}_structure.sql").join.split("\n\n").each do |table|
-              ActiveRecord::Base.connection.execute(table)
-            end
-          when /postgresql/
-            ENV['PGHOST']     = config['host'] if config['host']
-            ENV['PGPORT']     = config['port'].to_s if config['port']
-            ENV['PGPASSWORD'] = config['password'].to_s if config['password']
-            `psql -U "#{config['username']}" -f "#{Rails.root}/db/#{Rails.env}#{name}_structure.sql" #{config['database']} #{config['template']}`
-          when /sqlite/
-            dbfile = config['database'] || config['dbfile']
-            `sqlite3 #{dbfile} < "#{Rails.root}/db/#{Rails.env}#{name}_structure.sql"`
-          when 'sqlserver'
-            `sqlcmd -S #{config['host']} -d #{config['database']} -U #{config['username']} -P #{config['password']} -i db\\#{Rails.env}#{name}_structure.sql`
-          when 'oci', 'oracle'
-            ActiveRecord::Base.establish_connection(config)
-            IO.readlines("#{Rails.root}/db/#{Rails.env}#{name}_structure.sql").join.split(";\n\n").each do |ddl|
-              ActiveRecord::Base.connection.execute(ddl)
-            end
-          when 'firebird'
-            set_firebird_env(config)
-            db_string = firebird_db_string(config)
-            sh "isql -i #{Rails.root}/db/#{Rails.env}#{name}_structure.sql #{db_string}"
-          else
-            raise "Task not supported by '#{config['adapter']}'"
-          end
+          next unless config["database"]
+          ActiveRecord::Base.establish_connection(config)
+          filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "structure_#{name}.sql")
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(config, filename)
         end
+        ActiveRecord::Base.establish_connection(current_config)
       end
-      ActiveRecord::Base.establish_connection(config)
     end
+  end
 
+  namespace :test do
     # desc "Empty the test database"
     task :purge => :environment do
       config = ActiveRecord::Base.configurations[Rails.env]
@@ -171,35 +154,11 @@ db_namespace = namespace :db do
       shard_configs.merge!(config["seq"]) if config["seq"]
       if shard_configs
         shard_configs.each do |name, config|
-          case config['adapter']
-          when /mysql/
-            ActiveRecord::Base.establish_connection(config)
-            ActiveRecord::Base.connection.recreate_database(config['database'], mysql_creation_options(config))
-          when /postgresql/
-            ActiveRecord::Base.clear_active_connections!
-            drop_database(config)
-            create_database(config)
-          when /sqlite/
-            dbfile = config['database'] || config['dbfile']
-            File.delete(dbfile) if File.exist?(dbfile)
-          when 'sqlserver'
-            # TODO
-          when "oci", "oracle"
-            ActiveRecord::Base.establish_connection(config)
-            ActiveRecord::Base.connection.structure_drop.split(";\n\n").each do |ddl|
-              ActiveRecord::Base.connection.execute(ddl)
-            end
-          when 'firebird'
-            ActiveRecord::Base.establish_connection(config)
-            ActiveRecord::Base.connection.recreate_database!
-          else
-            raise "Task not supported by '#{config['adapter']}'"
-          end
+          next unless config["database"]
+          ActiveRecord::Tasks::DatabaseTasks.purge config
         end
       end
       ActiveRecord::Base.establish_connection(config)
     end
   end
-
 end
-

data/lib/active_record/turntable/seq_shard.rb

@@ -1,6 +1,7 @@
 module ActiveRecord::Turntable
   class SeqShard < Shard
     private
+
     def retrieve_connection_pool
       ActiveRecord::Base.turntable_connections[name] ||=
         begin
@@ -11,4 +12,3 @@ module ActiveRecord::Turntable
     end
   end
 end
-

data/lib/active_record/turntable/sequencer/api.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# APIサーバを利用しての採番
+# Sequencer via HTTP API
 #
 require 'httpclient'
 

data/lib/active_record/turntable/sequencer/barrage.rb

@@ -0,0 +1,28 @@
+module ActiveRecord::Turntable
+  class Sequencer
+    class Barrage < Sequencer
+      @@unique_barrage_instance = {}
+
+      def initialize(klass, options = {})
+        require 'barrage'
+        @klass = klass
+        @options = options["options"]
+        @barrage = get_barrage_instance
+      end
+
+      def next_sequence_value(sequence_name)
+        @barrage.next
+      end
+
+      def current_sequence_value(sequence_name)
+        @barrage.current
+      end
+
+      private
+
+      def get_barrage_instance
+        @@unique_barrage_instance[@options] ||= ::Barrage.new(@options)
+      end
+    end
+  end
+end

data/lib/active_record/turntable/sequencer.rb

@@ -5,20 +5,27 @@
 
 module ActiveRecord::Turntable
   class Sequencer
-    autoload :Api, "active_record/turntable/sequencer/api"
-    autoload :Mysql, "active_record/turntable/sequencer/mysql"
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Api
+      autoload :Mysql
+      autoload :Barrage
+    end
+
     @@sequence_types = {
       :api => Api,
-      :mysql => Mysql
+      :mysql => Mysql,
+      :barrage => Barrage
     }
 
     @@sequences = {}
     @@tables = {}
     cattr_reader :sequences, :tables
 
-    def self.build(klass)
-      seq_config_name = ActiveRecord::Base.turntable_config["clusters"][klass.turntable_cluster_name.to_s]["seq"]["connection"]
-      seq_config = ActiveRecord::Base.configurations[Rails.env]["seq"][seq_config_name]
+    def self.build(klass, sequence_name = nil, cluster_name = nil)
+      sequence_name ||= current_cluster_config_for(cluster_name || klass)["seq"].keys.first
+      seq_config = current_cluster_config_for(cluster_name || klass)["seq"][sequence_name]
       seq_type = (seq_config["seq_type"] ? seq_config["seq_type"].to_sym : :mysql)
       @@tables[klass.table_name] ||= (@@sequences[sequence_name(klass.table_name, klass.primary_key)] ||= @@sequence_types[seq_type].new(klass, seq_config))
     end
@@ -28,7 +35,7 @@ module ActiveRecord::Turntable
     end
 
     def self.sequence_name(table_name, pk)
-      "#{ table_name}_#{pk || 'id'}_seq"
+      "#{table_name}_#{pk || 'id'}_seq"
     end
 
     def self.table_name(seq_name)
@@ -36,11 +43,22 @@ module ActiveRecord::Turntable
     end
 
     def next_sequence_value
-      raise ActiveRecord::Turntable::NotImplementedError
+      raise NotImplementedError
     end
 
     def current_sequence_value
-      raise ActiveRecord::Turntable::NotImplementedError
+      raise NotImplementedError
+    end
+
+    private
+
+    def self.current_cluster_config_for(klass_or_name)
+      cluster_name = if klass_or_name.is_a?(Symbol)
+                       klass_or_name
+                     else
+                       klass_or_name.turntable_cluster_name.to_s
+                     end
+      ActiveRecord::Base.turntable_config["clusters"][cluster_name]
     end
   end
 end

data/lib/active_record/turntable/shard.rb

@@ -41,8 +41,8 @@ module ActiveRecord::Turntable
         raise "Please install the #{config['adapter']} adapter: `gem install activerecord-#{config['adapter']}-adapter` (#{e})"
       end
       adapter_method = "#{config['adapter']}_connection"
-      ActiveRecord::Base::ConnectionSpecification.new(config, adapter_method)
+
+      ActiveRecord::ConnectionAdapters::ConnectionSpecification.new(config, adapter_method)
     end
   end
 end
-

data/lib/active_record/turntable/sql_tree_patch.rb

@@ -46,7 +46,7 @@ module SQLTree::Node
       sql << " GROUP BY " << group_by.map { |g| g.to_sql(options) }.join(', ') if group_by
       sql << " ORDER BY " << order_by.map { |o| o.to_sql(options) }.join(', ') if order_by
       sql << " HAVING "   << having.to_sql(options) if having
-      sql << " LIMIT "    << limit.map {|f| f.to_sql(options) }.join(', ') if limit
+      sql << " LIMIT "    << Array(limit).map {|f| f.to_sql(options) }.join(', ') if limit
       sql << " OFFSET "   << offset.to_sql(options) if offset
       return sql
     end

data/lib/active_record/turntable/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Turntable
-    VERSION = "1.1.2"
+    VERSION = "2.0.0.rc1"
   end
 end

data/lib/active_record/turntable.rb

@@ -13,23 +13,25 @@ require 'singleton'
 
 module ActiveRecord::Turntable
   extend ActiveSupport::Concern
+  extend ActiveSupport::Autoload
 
-  autoload :ActiveRecordExt, 'active_record/turntable/active_record_ext'
-  autoload :Algorithm, 'active_record/turntable/algorithm'
-  autoload :Base, 'active_record/turntable/base'
-  autoload :Cluster, 'active_record/turntable/cluster'
-  autoload :Config, 'active_record/turntable/config'
-  autoload :Compatible, "active_record/turntable/compatible"
-  autoload :ConnectionProxy, 'active_record/turntable/connection_proxy'
-  autoload :Helpers, 'active_record/turntable/helpers'
-  autoload :MasterShard, 'active_record/turntable/master_shard'
-  autoload :Migration, 'active_record/turntable/migration'
-  autoload :Mixer, 'active_record/turntable/mixer'
-  autoload :PoolProxy, 'active_record/turntable/pool_proxy'
-  autoload :Rack, 'active_record/turntable/rack'
-  autoload :SeqShard, 'active_record/turntable/seq_shard'
-  autoload :Sequencer, 'active_record/turntable/sequencer'
-  autoload :Shard, 'active_record/turntable/shard'
+  eager_autoload do
+    autoload :ActiveRecordExt
+    autoload :Algorithm
+    autoload :Base
+    autoload :Cluster
+    autoload :Config
+    autoload :ConnectionProxy
+    autoload :MasterShard
+    autoload :Migration
+    autoload :Mixer
+    autoload :PoolProxy
+    autoload :Shard
+    autoload :SeqShard
+    autoload :Sequencer
+  end
+  autoload :Rack
+  autoload :Helpers
 
   included do
     include ActiveRecordExt
@@ -54,5 +56,13 @@ module ActiveRecord::Turntable
     end
   end
 
+  def self.rails4?
+    ActiveRecord::VERSION::MAJOR == 4
+  end
+
+  def self.rails41_later?
+    rails4? && ActiveRecord::VERSION::MINOR >= 1
+  end
+
   require "active_record/turntable/railtie" if defined?(Rails)
 end

data/lib/generators/templates/turntable.yml

@@ -5,9 +5,10 @@
 development:
   clusters:
     user_cluster:
-      algorithm: range
+      algorithm: range_bsearch
       seq:
-        connection: user_seq_1
+        user_seq:
+          connection: user_seq
       shards:
         - connection: user_shard_1
           less_than: 100
@@ -19,9 +20,10 @@ development:
 test:
   clusters:
     user_cluster:
-      algorithm: range
+      algorithm: range_bsearch
       seq:
-        connection: user_seq_1
+        user_seq:
+          connection: user_seq
       shards:
         - connection: user_shard_1
           less_than: 20000
@@ -33,9 +35,10 @@ test:
 production:
   clusters:
     user_cluster:
-      algorithm: range
+      algorithm: range_bsearch
       seq:
-        connection: user_seq_1
+        user_seq:
+          connection: user_seq
       shards:
         - connection: user_shard_1
           less_than: 20000
@@ -43,4 +46,3 @@ production:
           less_than: 40000
         - connection: user_shard_3
           less_than: 10000000
-