Module: ConnectionManager::ConnectionHandling

Defined in:
lib/connection_manager/connection_handling.rb

Constant Summary collapse

@@managed_connections = 
Concurrent::Map.new

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.extended(base) ⇒ Object 



66
67
68
69
70
 
# File 'lib/connection_manager/connection_handling.rb', line 66

def self.extended(base)
  class << base
    self.alias_method_chain :establish_connection, :managed_connections
  end
end

.included(base) ⇒ Object 



62
63
64
 
# File 'lib/connection_manager/connection_handling.rb', line 62

def self.included(base)
  base.alias_method_chain :establish_connection, :managed_connections
end

Instance Method Details

#establish_connection_with_managed_connections(spec = nil) ⇒ Object 



72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/connection_manager/connection_handling.rb', line 72

def establish_connection_with_managed_connections(spec = nil)
  result = establish_connection_without_managed_connections(spec)
  if spec && (spec.is_a?(Symbol) || spec.is_a?(String))
    self.managed_connections[spec.to_sym] = self.name
  elsif spec.nil? && ConnectionManager.env
    self.managed_connections[ConnectionManager.env.to_sym] = self.name
  else
    self.managed_connections[self.name] = self.name
  end
  result
end

#establish_managed_connection(yml_key, opts = {}) ⇒ Object

Establishes and checks in a connection, normally for abstract classes AKA connection classes.

Options:

  • :abstract_class - used the set #abstract_class, default is true

  • :schema_name - the unformatted schema name for connection, is inherited but child classes

  • :table_name - the table name for the model, should not be used on abstract classes

EX:

class MyConnection < ActiveRecord::Base
  establish_managed_connection :key_from_db_yml,{:readonly => true}
end



49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/connection_manager/connection_handling.rb', line 49

def establish_managed_connection(yml_key,opts={})
  opts = {:class_name => self.name,
          :abstract_class => true}.merge(opts)
  establish_connection(yml_key)
  self.abstract_class = opts[:abstract_class]
  self.table_name = opts[:table_name] if opts[:table_name]
  if (opts[:schema_name] || opts[:database_name])
    self.schema_name = (opts[:schema_name] || opts[:database_name])
  else
    self.schema_name = self.schema_name unless !self.connection.cross_schema_support?
  end
end

#managed_connection_classes ⇒ Object 



33
34
35
 
# File 'lib/connection_manager/connection_handling.rb', line 33

def managed_connection_classes
  managed_connections.values.flatten
end

#managed_connections ⇒ Object

A place to store managed connections



29
30
31
 
# File 'lib/connection_manager/connection_handling.rb', line 29

def managed_connections
  @@managed_connections
end

#schema_name ⇒ Object Also known as: database_name

Attempts to return the schema from table_name and table_name_prefix



7
8
9
10
11
 
# File 'lib/connection_manager/connection_handling.rb', line 7

def schema_name
  return self.table_name.split('.')[0] if self.table_name && self.table_name =~ /\./
  return self.table_name_prefix.to_s.gsub(/\./,'') if self.table_name_prefix && self.table_name_prefix =~ /\./
  return self.connection.config[:database] if self.connection.mysql?
end

#schema_name=(schema_name) ⇒ Object Also known as: database_name=

Set the unformatted schema name for the given model / connection class EX: class User < ActiveRecord::Base

  self.schema_name = 'users_db'
end

User.schema_name        # => 'users_db'
User.table_name_prefix  # => 'users_db.'
User.table_name         # => 'users_db.users'



22
23
24
25
 
# File 'lib/connection_manager/connection_handling.rb', line 22

def schema_name=schema_name
  self.table_name_prefix = "#{schema_name}." if schema_name && !schema_name.blank?
  self.table_name = "#{self.table_name_prefix}#{self.table_name}" unless self.abstract_class?
end