Class: Masamune::Schema::Table

Inherits:
Object
  • Object
show all
Includes:
LastElement
Defined in:
lib/masamune/schema/table.rb

Direct Known Subclasses

Dimension, Fact

Constant Summary collapse

DEFAULT_ATTRIBUTES = 
{
  id:              nil,
  name:            nil,
  type:            :table,
  store:           nil,
  parent:          nil,
  suffix:          nil,
  implicit:        false,
  references:      {},
  columns:         {},
  rows:            [],
  inherit:         false,
  debug:           false,
  properties:      {}
}.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from LastElement

#last_element

Constructor Details

#initialize(opts = {}) ⇒ Table

Returns a new instance of Table.

Raises:

  • (ArgumentError) 


52
53
54
55
56
57
58
59
 
# File 'lib/masamune/schema/table.rb', line 52

def initialize(opts = {})
  opts.symbolize_keys!
  raise ArgumentError, 'required parameter id: missing' unless opts.key?(:id)
  DEFAULT_ATTRIBUTES.merge(opts).each do |name, value|
    public_send("#{name}=", value)
  end
  @children = Set.new
end

Instance Attribute Details

#children ⇒ Object (readonly)

Returns the value of attribute children.



29
30
31
 
# File 'lib/masamune/schema/table.rb', line 29

def children
  @children
end

Instance Method Details

#aliased_rows ⇒ Object 



168
169
170
 
# File 'lib/masamune/schema/table.rb', line 168

def aliased_rows
  rows.select(&:name)
end

#auto_surrogate_keys ⇒ Object 



263
264
265
 
# File 'lib/masamune/schema/table.rb', line 263

def auto_surrogate_keys
  columns.values.select { |column| column.reference && column.reference.surrogate_key.auto }.uniq.compact
end

#columns=(instance) ⇒ Object

Raises:

  • (ArgumentError) 


74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/masamune/schema/table.rb', line 74

def columns=(instance)
  @columns = {}
  columns = (instance.is_a?(Hash) ? instance.values : instance).compact
  raise ArgumentError, "table #{name} contains reserved columns" if columns.any? { |column| reserved_column_ids.include?(column.id) }

  initialize_surrogate_key_column! unless columns.any?(&:surrogate_key)
  initialize_reference_columns! unless columns.any?(&:reference)
  columns.each do |column|
    initialize_column!(column)
  end
end

#defined_columns ⇒ Object 



118
119
120
 
# File 'lib/masamune/schema/table.rb', line 118

def defined_columns
  columns.values.reject(&:partition)
end

#denormalized_column_names ⇒ Object 



203
204
205
206
207
208
209
210
211
212
213
214
 
# File 'lib/masamune/schema/table.rb', line 203

def denormalized_column_names
  return to_enum(__method__).to_a unless block_given?
  denormalized_columns do |reference, column|
    if column.parent == self
      yield column.name.to_s
    elsif reference
      yield [reference.id, column.name].compact.join('.')
    else
      yield [column.parent.id, column.name].compact.join('.')
    end
  end
end

#denormalized_columns ⇒ Object 



184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
 
# File 'lib/masamune/schema/table.rb', line 184

def denormalized_columns
  return to_enum(__method__).to_a.flatten.compact unless block_given?
  columns.map do |_, column|
    next if column.surrogate_key || column.ignore
    if column.reference && column.reference.natural_keys.any?
      column.reference.natural_keys.each do |join_column|
        next if join_column.reference && join_column.natural_key
        yield [column.reference, join_column]
      end
    elsif column.reference && column.reference.denormalized_columns.any?
      column.reference.denormalized_columns.each do |join_column|
        yield [column.reference, join_column]
      end
    else
      yield [nil, column]
    end
  end
end

#dereference_column(column, reference) ⇒ Object 



248
249
250
251
252
 
# File 'lib/masamune/schema/table.rb', line 248

def dereference_column(column, reference)
  column.surrogate_key = false
  column.reference = reference
  column
end

#dereference_column_name(name) ⇒ Object 



237
238
239
240
241
242
243
244
245
246
 
# File 'lib/masamune/schema/table.rb', line 237

def dereference_column_name(name)
  reference_name, column_name = Column.dereference_column_name(name)
  reference = references[reference_name]
  if reference
    column = reference.columns[column_name]
    dereference_column(column.dup, reference) if column
  elsif columns[column_name]
    columns[column_name]
  end
end

#enum_columns ⇒ Object 



142
143
144
145
 
# File 'lib/masamune/schema/table.rb', line 142

def enum_columns
  return {} if temporary?
  columns.select { |_, column| column.type == :enum }
end

#foreign_key_columns ⇒ Object 



156
157
158
 
# File 'lib/masamune/schema/table.rb', line 156

def foreign_key_columns
  columns.values.select { |column| !column.degenerate? && column.reference && column.reference.foreign_key }
end

#foreign_key_constraints ⇒ Object 



267
268
269
270
271
272
273
274
275
276
277
278
279
 
# File 'lib/masamune/schema/table.rb', line 267

def foreign_key_constraints
  return [] if temporary?
  foreign_key_columns.map do |column|
    if column.reference.auto_surrogate_keys == auto_surrogate_keys
      column_names = [*column.reference.auto_surrogate_keys.map(&:name), column.name].compact
      reference_column_names = [*column.reference.auto_surrogate_keys.map(&:name), column.reference.surrogate_key.name].compact
    else
      column_names = [column.name]
      reference_column_names = [column.reference.surrogate_key.name]
    end
    [short_md5(column_names), column_names, column.reference.name, reference_column_names]
  end.compact
end

#id=(id) ⇒ Object 



61
62
63
 
# File 'lib/masamune/schema/table.rb', line 61

def id=(id)
  @id = id.to_sym
end

#index_columns ⇒ Object 



130
131
132
133
134
135
 
# File 'lib/masamune/schema/table.rb', line 130

def index_columns
  index_column_map.map do |_, column_names|
    unique_index = reverse_unique_constraints_map.key?(column_names.sort)
    [column_names, unique_index, short_md5(column_names.to_a)]
  end.uniq
end

#insert_references ⇒ Object 



172
173
174
 
# File 'lib/masamune/schema/table.rb', line 172

def insert_references
  references.select { |_, reference| reference.insert }
end

#insert_rows ⇒ Object 



164
165
166
 
# File 'lib/masamune/schema/table.rb', line 164

def insert_rows
  rows.select { |row| row.insert_values.any? }
end

#lock_id ⇒ Object

NOTE: postgres bigint is 8 bytes long



259
260
261
 
# File 'lib/masamune/schema/table.rb', line 259

def lock_id
  Integer('0x' + Digest::MD5.hexdigest(name)) % (1 << 63)
end

#name ⇒ Object 



94
95
96
 
# File 'lib/masamune/schema/table.rb', line 94

def name
  @name || [id, suffix].compact.join('_')
end

#natural_keys ⇒ Object 



114
115
116
 
# File 'lib/masamune/schema/table.rb', line 114

def natural_keys
  columns.values.select(&:natural_key)
end

#partitions ⇒ Object 



160
161
162
 
# File 'lib/masamune/schema/table.rb', line 160

def partitions
  columns.select { |_, column| column.partition }
end

#primary_keys ⇒ Object 



110
111
112
 
# File 'lib/masamune/schema/table.rb', line 110

def primary_keys
  [*auto_surrogate_keys, surrogate_key].compact
end

#reference_columns ⇒ Object 



152
153
154
 
# File 'lib/masamune/schema/table.rb', line 152

def reference_columns
  columns.values.select(&:reference)
end

#references=(instance) ⇒ Object 



65
66
67
68
69
70
71
72
 
# File 'lib/masamune/schema/table.rb', line 65

def references=(instance)
  @references = {}
  references = (instance.is_a?(Hash) ? instance.values : instance).compact
  references.each do |reference|
    raise ArgumentError, "table #{name} contains invalid table references" unless reference.is_a?(TableReference)
    @references[reference.id] = reference
  end
end

#reserved_column_ids ⇒ Object 



254
255
256
 
# File 'lib/masamune/schema/table.rb', line 254

def reserved_column_ids
  inherit ? parent.reserved_column_ids : []
end

#reserved_columns ⇒ Object 



176
177
178
 
# File 'lib/masamune/schema/table.rb', line 176

def reserved_columns
  columns.select { |_, column| reserved_column_ids.include?(column.id) }
end

#rows=(rows) ⇒ Object 



86
87
88
89
90
91
92
 
# File 'lib/masamune/schema/table.rb', line 86

def rows=(rows)
  @rows = []
  rows.each do |row|
    @rows << row.dup
    @rows.last.parent = self
  end
end

#sequence_columns ⇒ Object 



147
148
149
150
 
# File 'lib/masamune/schema/table.rb', line 147

def sequence_columns
  return {} if temporary?
  columns.select { |_, column| column.reference.nil? && column.type == :sequence }
end

#shared_columns(other) ⇒ Object 



227
228
229
230
231
232
233
234
235
 
# File 'lib/masamune/schema/table.rb', line 227

def shared_columns(other)
  Hash.new { |h, k| h[k] = [] }.tap do |shared|
    columns.each do |_, column|
      other.columns.each do |_, other_column|
        shared[column] << other_column if column.references?(other_column)
      end
    end
  end
end

#stage_table(options = {}) ⇒ Object 



216
217
218
219
220
221
222
223
224
225
 
# File 'lib/masamune/schema/table.rb', line 216

def stage_table(options = {})
  selected = options[:columns] if options[:columns]
  selected ||= options[:target].columns.values.map(&:compact_name) if options[:target]
  selected ||= []
  stage_id = [id, options[:suffix]].compact.join('_')
  parent = options[:table] ? options[:table] : self
  type = options[:type] ? options[:type] : :stage
  @stage_tables ||= {}
  @stage_tables[options] ||= parent.class.new id: stage_id, type: type, store: store, columns: stage_table_columns(parent, selected, options.fetch(:inherit, true)), references: stage_table_references(parent, selected), parent: parent, inherit: options.fetch(:inherit, true)
end

#suffix ⇒ Object 



98
99
100
 
# File 'lib/masamune/schema/table.rb', line 98

def suffix
  ((parent ? parent.suffix.split('_') : []) + [type.to_s, @suffix]).compact.uniq.join('_')
end

#surrogate_key ⇒ Object 



106
107
108
 
# File 'lib/masamune/schema/table.rb', line 106

def surrogate_key
  columns.values.detect(&:surrogate_key)
end

#temporary? ⇒ Boolean

Returns:

  • (Boolean) 


102
103
104
 
# File 'lib/masamune/schema/table.rb', line 102

def temporary?
  type == :stage
end

#unique_columns ⇒ Object 



137
138
139
140
 
# File 'lib/masamune/schema/table.rb', line 137

def unique_columns
  return {} if temporary?
  columns.select { |_, column| column.unique }
end

#unique_constraints ⇒ Object 



123
124
125
126
127
128
 
# File 'lib/masamune/schema/table.rb', line 123

def unique_constraints
  return [] if temporary?
  unique_constraints_map.map do |_, column_names|
    [column_names, short_md5(column_names.to_a)]
  end.uniq
end

#unreserved_columns ⇒ Object 



180
181
182
 
# File 'lib/masamune/schema/table.rb', line 180

def unreserved_columns
  columns.reject { |_, column| reserved_column_ids.include?(column.id) }
end