Module: Oinky::Model
- Defined in:
- lib/oinky/dsl.rb,
lib/oinky/compiler.rb,
lib/oinky/modelbase.rb,
lib/oinky/normalize.rb,
lib/oinky/rb_emitter.rb,
lib/oinky/cpp_emitter.rb
Defined Under Namespace
Modules: Internal, Schema, Table
Classes: Cpp, DerivedType, Ruby
Constant Summary
collapse
- DefaultsByType =
{
:string=>'',
:bit=>false,
:int8=>0,
:int16=>0,
:int32=>0,
:int64=>0,
:uint8=>0,
:uint16=>0,
:uint32=>0,
:uint64=>0,
:float32=>0.0,
:float64=>0.0,
:variant=>0,
:datetime=>DateTime.parse("0001-01-01T00:00:00 UTC")
}
Class Method Summary
collapse
-
.build_schema(name, base = {}, &b) ⇒ Object
-
.build_schema_adapter(name, base = {}, &b) ⇒ Object
Build an entire schema, generate a ruby adapter class, and evaluate it.
-
.build_table(name, base = {}) ⇒ Object
Someone may want to create an unbound table-def and then reuse it later in multiple schemas, or as a base definition for derived tables.
-
.generate(schema, ccls) ⇒ Object
-
.normalize_column_def(nm, v) ⇒ Object
-
.normalize_index_column_def(cd) ⇒ Object
-
.normalize_index_def(k, v) ⇒ Object
-
.normalize_schema(s) ⇒ Object
-
.normalize_table_schema(nm, h) ⇒ Object
-
.validate_keys(h, keys) ⇒ Object
-
.validate_type(t) ⇒ Object
Class Method Details
.build_schema(name, base = {}, &b) ⇒ Object
144
145
146
147
148
|
# File 'lib/oinky/dsl.rb', line 144
def self.build_schema(name, base = {}, &b)
s = Internal::SchemaBuilder.new(name, base)
s.instance_eval &b
return s.to_h
end
|
.build_schema_adapter(name, base = {}, &b) ⇒ Object
Build an entire schema, generate a ruby adapter class, and evaluate it
151
152
153
154
155
|
# File 'lib/oinky/dsl.rb', line 151
def self.build_schema_adapter(name, base = {}, &b)
s = build_schema(name, base, &b)
cls = eval Oinky::Model.generate(s, :ruby)
return cls
end
|
.build_table(name, base = {}) ⇒ Object
Someone may want to create an unbound table-def and then reuse it later in multiple schemas, or as a base definition for derived tables.
160
161
162
163
164
165
|
# File 'lib/oinky/dsl.rb', line 160
def self.build_table(name, base = {})
s = Internal::TableBuilder.new(base)
s.name(name)
s.instance_eval &Proc.new
s.to_h
end
|
.generate(schema, ccls) ⇒ Object
66
67
68
69
70
|
# File 'lib/oinky/compiler.rb', line 66
def self.generate(schema, ccls)
ccls = ({:cpp=>Cpp, :CPP=>Cpp, :ruby=>Ruby, :rb=>Ruby}[ccls] || ccls)
ccls.new(schema).emit
end
|
.normalize_column_def(nm, v) ⇒ Object
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
# File 'lib/oinky/normalize.rb', line 37
def self.normalize_column_def(nm, v)
if v.is_a? Symbol
validate_type(v)
return {:type=>v, :default=>DefaultsByType[v], :accessor=>nm}
end
validate_keys(v,[:type,:default,:accessor])
t = v[:type]
raise ArgumentError.new("No column type specified for column [#{nm}]") unless t
v[:default] = DefaultsByType[t] unless v.has_key?(:default)
v[:accessor] = nm unless v.has_key?(:accessor)
return v
end
|
.normalize_index_column_def(cd) ⇒ Object
52
53
54
55
56
57
58
59
60
61
62
63
|
# File 'lib/oinky/normalize.rb', line 52
def self.normalize_index_column_def(cd)
if cd.is_a?(Symbol)
cd = cd.to_s
end
if cd.is_a?(String)
return {:name=>cd, :ascending=>true}
end
cd[:ascending] = true unless cd.has_key?(:ascending)
validate_keys(cd,[:name,:ascending])
return cd
end
|
.normalize_index_def(k, v) ⇒ Object
65
66
67
68
69
70
71
72
73
74
75
76
77
|
# File 'lib/oinky/normalize.rb', line 65
def self.normalize_index_def(k,v)
validate_keys(v,[:unique,:columns,:accessor, :name])
if v.has_key?(:name) and (k.to_s != v[:name].to_s)
raise ArgumentError.new("Inconsistent names for index: [#{k}] and [#{v[:name]}].")
end
d = {}
d[:unique] = (v[:unique] or false)
d[:accessor] = (v[:accessor] or k.to_s)
d[:columns] = v[:columns].map{|cd|
normalize_index_column_def(cd)
}
return d
end
|
.normalize_schema(s) ⇒ Object
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
# File 'lib/oinky/normalize.rb', line 104
def self.normalize_schema(s)
validate_keys(s,[:name, :tables, :version, :classname])
raise ArgumentError.new("Invalid schema definition") unless
s[:name] and s[:name].size and s[:tables] and s[:version]
tbls = {}
if s[:tables].is_a? Hash
s[:tables].each{|k,v|
tbls[k.to_s] = normalize_table_schema(k.to_s, v)
}
else
s[:tables].each{|v|
nm = v[:name].to_s
tbls[nm] = normalize_table_schema(nm, v)
}
end
= {}
[:classname] = s[:classname] if s.has_key?(:classname)
return {
:name=>s[:name].to_s,
:tables=>tbls,
:version=>s[:version]
}.merge()
end
|
.normalize_table_schema(nm, h) ⇒ Object
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
# File 'lib/oinky/normalize.rb', line 79
def self.normalize_table_schema(nm, h)
cols = {}
h[:columns].each{|k,v|
cn = k.to_s
cols[cn] = normalize_column_def(cn, v)
}
ixs = {}
h[:indices].each{|k,v|
ixs[k.to_s] = normalize_index_def(k,v)
}
if h.has_key?(:name) and (nm.to_s != h[:name].to_s)
raise ArgumentError.new("Inconsistent names for table: [#{nm}] and [#{h[:name]}].")
end
return {
:name=>nm.to_s,
:accessor=>(h[:accessor] or nm).to_s,
:columns=>cols,
:indices=>ixs
}
end
|
.validate_keys(h, keys) ⇒ Object
23
24
25
26
27
28
29
30
|
# File 'lib/oinky/normalize.rb', line 23
def self.validate_keys(h, keys)
h.keys.each{|k,v|
unless keys.find_index(k)
raise ArgumentError.new("Unrecognized key in Oinky schema " +
"definition: #{k}")
end
}
end
|
.validate_type(t) ⇒ Object
31
32
33
34
35
|
# File 'lib/oinky/normalize.rb', line 31
def self.validate_type(t)
unless DefaultsByType.has_key?(t)
raise ArgumentError.new("Unrecognized type in Oinky schema definition: #{k}")
end
end
|