Class: Spider::Model::Storage::Db::DbSchema

Inherits:
Schema show all
Defined in:
lib/spiderfw/model/storage/db/db_schema.rb

Overview

The class describind the DB table(s) associated to a model.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ DbSchema

Returns a new instance of DbSchema.



19
20
21
22
23
24
25
26
27
28
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 19

def initialize()
    super
    @columns = {}
    @foreign_keys = {}
    @junction_tables = {}
    @sequences = {}
    @pass = {}
    @foreign_key_constraints = []
    @order = []
end

Instance Attribute Details

#columns ⇒ Object (readonly)

An Hash of column definitions for each element: => {:name => ‘COLUMN_NAME’, :attributes => {…}}



12
13
14
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 12

def columns
  @columns
end

#foreign_keys ⇒ Object (readonly)

An Hash of column definitions for foreign keys: => {:primary_key_name => {:name => ‘FOREIGN_COLUMN’, :attributes => {…}}}



15
16
17
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 15

def foreign_keys
  @foreign_keys
end

#pass ⇒ Object (readonly)

An Hash of elements without primary columns.



17
18
19
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 17

def pass
  @pass
end

#sequences ⇒ Object (readonly)

An Hash of db names for each named sequence.



9
10
11
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 9

def sequences
  @sequences
end

Instance Method Details

#attributes(element_name) ⇒ Object

Returns column attributes for given element name.



58
59
60
61
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 58

def attributes(element_name)
    return nil if (!@columns[element_name])
    return @columns[element_name].attributes
end

#column(element_name) ⇒ Object

Returns the column name for an element.



94
95
96
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 94

def column(element_name)
    return @columns[element_name]
end

#field(element_name) ⇒ Object

Returns the db column defined for the element.



43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 43

def field(element_name)
    if (@columns[element_name])
        return @columns[element_name]
    elsif (@foreign_keys[element_name])
        unless @foreign_keys[element_name].length == 1 # FIXME!!
            raise SchemaException, "No single field for element #{element_name}" 
        end
        @foreign_keys[element_name].each do |key, val|
            return val
        end
    end
    return nil
end

#foreign_key_field(element_name, key_name) ⇒ Object

Returns the defined foreign key column for given element and primary key



71
72
73
74
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 71

def foreign_key_field(element_name, key_name)
    return nil unless @foreign_keys[element_name]
    return @foreign_keys[element_name][key_name]
end

#get_schemas ⇒ Object

Returns a description of all the tables used by the model. Returns a struct in the form

{table_name => :columns => {
  'column_name' => {:type => 'column_type', :attributes => {:attr => true, :attr2 => 'some_val, ...}}
}, :attributes => {
  :primary_key => 'primary_key_column', ...
}}



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 158

def get_schemas
    schemas = {}
    schemas[@table.name] = {:columns => {}, :attributes => {}, :fields_order => @order}
    @columns.each do |element, column|
        schemas[@table.name][:columns][column.name] = {:type => column.type, :attributes => column.attributes}
    end
    @foreign_keys.each_key do |element|
        @foreign_keys[element].each do |key, column|
            schemas[@table.name][:columns][column.name] = {:type => column.type, :attributes => column.attributes}
        end
    end
    schemas[@table.name][:attributes][:primary_keys] = primary_keys.map{ |k| k.name }
    schemas[@table.name][:attributes][:foreign_key_constraints] = @foreign_key_constraints
    return schemas
end

#has_fields?(element_name) ⇒ Boolean

True if element_name has a defined column or foreign key.

Returns:

  • (Boolean) 


85
86
87
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 85

def has_fields?(element_name)
    return (@columns[element_name] || @foreign_keys[element_name]) ? true : false
end

#has_foreign_fields?(element_name) ⇒ Boolean

Returns:

  • (Boolean) 


89
90
91
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 89

def has_foreign_fields?(element_name)
    return @foreign_keys[element_name] ? true : false
end

#primary_keys ⇒ Object

Primary key column(s)



175
176
177
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 175

def primary_keys
    @table.fields.select{ |f| f.primary_key? }
end

#qualified_field(element_name, qualifier = nil) ⇒ Object

Returns the column for element_name, prefixed with the table name.

Raises:



64
65
66
67
68
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 64

def qualified_field(element_name, qualifier=nil)
    raise SchemaException, "No DB field defined in table #{@table} for element #{element_name}" unless f = field(element_name)
    qualifier ||= @table.name
    return qualifier + '.' + f.name
end

#qualified_foreign_key_field(element_name, key_name) ⇒ Object

Returns table_name + ‘.’ + #foreign_key_field



77
78
79
80
81
82
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 77

def qualified_foreign_key_field(element_name, key_name)
    f = foreign_key_field(element_name, key_name)
    return f.expression if f.is_a?(FieldExpression)
    raise "No foreign key field for #{element_name} #{key_name} in #{@table}" unless f
    return @table.name + '.' + f.name
end

#sequence(name) ⇒ Object

Returns the db name of a named sequence.



147
148
149
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 147

def sequence(name)
    @sequences[name]
end

#set_column(element_name, field) ⇒ Object

Sets the column name for an element.



99
100
101
102
103
104
105
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 99

def set_column(element_name, field)
    field = {:name => field} if field.is_a?(String)
    field = Field.new(@table, field[:name], field[:type], field[:attributes] || {}) if field.is_a?(Hash)
    had_column = @columns[element_name]
    @columns[element_name] = field
    @order << field unless had_column
end

#set_foreign_key(element_name, element_key, field) ⇒ Object

Sets a foreign key to the primary key of an element.



108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 108

def set_foreign_key(element_name, element_key, field)
    field = {:name => field} if field.is_a?(String)
    if field.is_a?(Hash)
        field[:attributes] ||= {}
        field[:attributes][:expression] ||= field[:expression]
        field[:attributes][:fixed] ||= field[:fixed]
        if field[:attributes][:expression] || field[:attributes][:fixed]
            field[:name] = "#{@table}_#{element_name}_#{element_key}".upcase
            if field[:attributes][:fixed]
                field = FixedExpression.new(@table, field[:name], field[:type], field[:attributes][:fixed], field[:attributes])
            else
                field = FieldExpression.new(@table, field[:name], field[:type], field[:attributes] || {})
            end
        else
            field = Field.new(@table, field[:name], field[:type], field[:attributes] || {}) 
        end
    end
    @foreign_keys[element_name] ||= {}
    had_fk = @foreign_keys[element_name][element_key]
    @foreign_keys[element_name][element_key] = field
    @order << field unless had_fk
end

#set_foreign_key_constraint(name, table, keys, options = {}) ⇒ Object 



131
132
133
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 131

def set_foreign_key_constraint(name, table, keys, options={})
    @foreign_key_constraints << ForeignKeyConstraint.new(name, table, keys, options)
end

#set_nil(name) ⇒ Object

Sets that given element has no associated db field.



142
143
144
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 142

def set_nil(name)
    @pass[name] = true
end

#set_sequence(name, db_name) ⇒ Object

Sets the db name for a named sequence.



137
138
139
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 137

def set_sequence(name, db_name)
    @sequences[name] = db_name
end

#table ⇒ Object

Returns the main table name.



31
32
33
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 31

def table
    return @table
end

#table=(table) ⇒ Object Also known as: set_table

Sets the main table name.



36
37
38
39
 
# File 'lib/spiderfw/model/storage/db/db_schema.rb', line 36

def table=(table)
    table = Table.new(table) unless table.is_a?(Table)
    @table = table
end