Module: ConnectionManager::ConnectionHandling

Defined in:
lib/connection_manager/connection_handling.rb

Constant Summary collapse

@@managed_connections = 
ThreadSafe::Cache.new

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.extended(base) ⇒ Object 



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

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

.included(base) ⇒ Object 



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

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

Instance Method Details

#establish_connection_with_managed_connections(spec = nil) ⇒ Object 



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

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



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

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 



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

def managed_connection_classes
  managed_connections.values.flatten
end

#managed_connections ⇒ Object

A place to store managed connections



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

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



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

def schema_name
  return self.table_name.split('.')[0] if self.table_name && self.table_name.match(/\./)
  return self.table_name_prefix.to_s.gsub(/\./,'') if self.table_name_prefix && self.table_name_prefix.match(/\./)
  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'



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

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