Class: Partitioned::PartitionedBase

Inherits:

ActiveRecord::Base

• Object
• ActiveRecord::Base
• Partitioned::PartitionedBase

show all

Extended by:

BulkMethodsMixin, SingleForwardable

Includes:

ActiveRecordOverrides

Defined in:

lib/partitioned/partitioned_base.rb,
lib/partitioned/partitioned_base/sql_adapter.rb,
lib/partitioned/partitioned_base/configurator.rb,
lib/partitioned/partitioned_base/configurator/dsl.rb,
lib/partitioned/partitioned_base/configurator/data.rb,
lib/partitioned/partitioned_base/partition_manager.rb,
lib/partitioned/partitioned_base/configurator/reader.rb

Overview

Defined Under Namespace

Modules: Configurator Classes: PartitionManager, SqlAdapter

Class Method Summary (collapse)

• + ({Configurator::Reader}) configurator

  Return a object used to read configurator information.

• + ({Configurator::Dsl}) configurator_dsl

  Returns the configurator DSL object.

• + (Arel::Table) dynamic_arel_table(values, as = nil)

  In activerecord 3.0 we need to supply an Arel::Table for the key value(s) used to determine the specific child table to access.

• + (Hash) from_partition(*partition_field)

  Real scope (uses #from_partition_scope).

• + (Hash) from_partitioned_without_alias(*partition_field)

  Real scope (uses #from_partitioned_without_alias_scope).

• + (Enumerable) partition_generate_range(start_value, end_value, step = 1)

  Range generation provided for methods like created_infrastructure that need a set of partition key values to operate on.

• + (Object⁺) partition_key_values(values)

  The specific values for a partition of this active record's type which are defined by #self#self.partition_keys.

• + (String⁺) partition_keys

  Returns an array of attribute names (strings) used to fetch the key value(s) the determine this specific partition table.

• + ({PartitionManager}) partition_manager

  Return an instance of this partition table's table manager.

• + (Object) partition_normalize_key_value(value)

  Normalize the value to be used for partitioning.

• + ({Configurator::Dsl}) partitioned {|@configurator_dsl| ... }

  Yields an object used to configure the ActiveRecord class for partitioning using the Configurator Domain Specific Language.

• + ({SqlAdapter}) sql_adapter

  Return an instance of this partition table's sql_adapter (used by the partition manage to create SQL statements).

Instance Method Summary (collapse)

• - (Arel::Table) dynamic_arel_table(as = nil)

  Used by our active record hacks to supply an Arel::Table given this active record's current attributes.

• - (Hash) from_partition_scope

  :from_partition_scope is generally not used directly, use helper self.from_partition so that the derived class can be passed into :from_partition_scope.

• - (Hash) from_partitioned_without_alias_scope

  :from_partitioned_without_alias_scope is generally not used directly, use helper self.from_partitioned_without_alias so that the derived class can be passed into :from_partitioned_without_alias_scope.

• - (String) partition_table_name

  The name of the current partition table determined by this active records attributes that define the key value(s) for the constraint check.

Methods included from BulkMethodsMixin

create_many, update_many

Methods included from ActiveRecordOverrides

#arel_attributes_values, #delete

214
215
216
217
218
219

# File 'lib/partitioned/partitioned_base.rb', line 214

def self.configurator
  unless @configurator
    @configurator = self::Configurator::Reader.new(self)
  end
  return @configurator
end

242
243
244

# File 'lib/partitioned/partitioned_base.rb', line 242

def self.configurator_dsl
  return @configurator_dsl
end

115
116
117
118
119
120
121
122
123

# File 'lib/partitioned/partitioned_base.rb', line 115

def self.dynamic_arel_table(values, as = nil)
  @arel_tables ||= {}
  key_values = self.partition_key_values(values)
  new_arel_table = @arel_tables[key_values]
  arel_engine_hash = {:engine => self.arel_engine}
  arel_engine_hash[:as] = as unless as.blank?
  new_arel_table = Arel::Table.new(self.partition_name(*key_values), arel_engine_hash)
  return new_arel_table
end

Foo.from_partition(KEY).find(:first)

165
166
167

# File 'lib/partitioned/partitioned_base.rb', line 165

def self.from_partition(*partition_field)
  from_partition_scope(self, *partition_field)
end

Foo.from_partitioned_without_alias(KEY).find(:all, :select => "*")

SELECT foos.* FROM foos_partitions.pXXX

206
207
208

# File 'lib/partitioned/partitioned_base.rb', line 206

def self.from_partitioned_without_alias(*partition_field)
  from_partitioned_without_alias_scope(self, *partition_field)
end

85
86
87

# File 'lib/partitioned/partitioned_base.rb', line 85

def self.partition_generate_range(start_value, end_value, step = 1)
  return Range.new(start_value, end_value).step(step)
end

51
52
53
54

# File 'lib/partitioned/partitioned_base.rb', line 51

def self.partition_key_values(values)
  symbolized_values = values.symbolize_keys
  return self.partition_keys.map{|key| symbolized_values[key.to_sym]}
end

40
41
42

# File 'lib/partitioned/partitioned_base.rb', line 40

def self.partition_keys
  return configurator.on_fields
end

93
94
95
96

# File 'lib/partitioned/partitioned_base.rb', line 93

def self.partition_manager
  @partition_manager = self::PartitionManager.new(self) unless @partition_manager.present?
  return @partition_manager
end

73
74
75

# File 'lib/partitioned/partitioned_base.rb', line 73

def self.partition_normalize_key_value(value)
  return value
end

partitioned do |partition|
  partition.on    :company_id
  partition.index :id, :unique => true
  partition.foreign_key :company_id
end

233
234
235
236

# File 'lib/partitioned/partitioned_base.rb', line 233

def self.partitioned
  @configurator_dsl ||= self::Configurator::Dsl.new(self)
  yield @configurator_dsl
end

103
104
105
106

# File 'lib/partitioned/partitioned_base.rb', line 103

def self.sql_adapter
  @sql_adapter = self::SqlAdapter.new(self) unless @sql_adapter.present?
  return @sql_adapter
end

131
132
133
134
135

# File 'lib/partitioned/partitioned_base.rb', line 131

def dynamic_arel_table(as = nil)
  symbolized_attributes = attributes.symbolize_keys
  key_values = Hash[*self.class.partition_keys.map{|name| [name,symbolized_attributes[name]]}.flatten]
  return self.class.dynamic_arel_table(key_values, as)
end

142
143
144
145
146

# File 'lib/partitioned/partitioned_base.rb', line 142

scope :from_partition_scope, lambda { |target_class, *partition_field|
  {
    :from => "#{target_class.partition_name(*partition_field)} AS #{target_class.table_name}"
  }
}

174
175
176
177
178

# File 'lib/partitioned/partitioned_base.rb', line 174

scope :from_partitioned_without_alias_scope, lambda { |target_class, *partition_field|
  {
    :from => target_class.partition_name(*partition_field)
  }
}

61
62
63
64

# File 'lib/partitioned/partitioned_base.rb', line 61

def partition_table_name
  symbolized_attributes = attributes.symbolize_keys
  return self.class.partition_name(*self.class.partition_keys.map{|attribute_name| symbolized_attributes[attribute_name]})
end