1
|
# XML-database conversion
|
2
|
|
3
|
import copy
|
4
|
import re
|
5
|
from xml.dom import Node
|
6
|
|
7
|
import exc
|
8
|
import Parser
|
9
|
import sql
|
10
|
import sql_gen
|
11
|
import strings
|
12
|
import util
|
13
|
import xml_dom
|
14
|
import xml_func
|
15
|
import xpath
|
16
|
|
17
|
def name_of(node): return re.sub(r'^.*\.', r'', node.tagName)
|
18
|
|
19
|
ptr_suffix = '_id'
|
20
|
|
21
|
def is_ptr(node_name): return node_name.lower().endswith(ptr_suffix)
|
22
|
|
23
|
def ptr_type_guess(node_name):
|
24
|
assert is_ptr(node_name)
|
25
|
return node_name[:-len(ptr_suffix)]
|
26
|
|
27
|
def ptr_target(node):
|
28
|
assert is_ptr(name_of(node))
|
29
|
return xml_dom.value_node(node)
|
30
|
|
31
|
def find_by_name(node, name):
|
32
|
for parent in xml_dom.NodeParentIter(node):
|
33
|
if name_of(parent) == name: return parent
|
34
|
else:
|
35
|
for child in xml_dom.NodeElemIter(parent):
|
36
|
child_name = name_of(child)
|
37
|
if is_ptr(child_name):
|
38
|
target = ptr_target(child)
|
39
|
if target.tagName == name: return target
|
40
|
elif child_name == name: return child
|
41
|
return None
|
42
|
|
43
|
def get(db, node, limit=None, start=None):
|
44
|
def pkey(table): return sql.pkey(db, table)
|
45
|
|
46
|
node = node.firstChild
|
47
|
table = name_of(node)
|
48
|
pkey_ = pkey(table)
|
49
|
|
50
|
fields = []
|
51
|
conds = {}
|
52
|
for child in xml_dom.NodeElemIter(node):
|
53
|
child_name = name_of(child)
|
54
|
if xml_dom.is_empty(child): fields.append(child_name)
|
55
|
elif xml_dom.is_text(child): conds[child_name] = xml_dom.value(child)
|
56
|
else: raise Exception('Joins not supported yet')
|
57
|
id_ = xml_dom.get_id(node)
|
58
|
if id_ != None: conds[pkey(table)] = id_ # replace any existing pkey value
|
59
|
if fields == []: fields.append(pkey_)
|
60
|
|
61
|
return sql.select(db, table, fields, conds, limit, start)
|
62
|
|
63
|
def put(db, node, row_ct_ref=None, on_error=exc.raise_, pool=None,
|
64
|
store_ids=False, parent_id=None):
|
65
|
'''store_ids enables searching the tree for missing fields'''
|
66
|
def pkey(table): return sql.pkey(db, table, True)
|
67
|
|
68
|
def put_(node, parent_id=None):
|
69
|
args = (db, node, row_ct_ref, on_error, pool, store_ids, parent_id)
|
70
|
if parent_id != None and pool != None: pool.apply_async(put, args)
|
71
|
else: return put(*args)
|
72
|
|
73
|
def on_error_(e):
|
74
|
exc.add_msg(e, 'node:\n'+str(node))
|
75
|
on_error(e)
|
76
|
|
77
|
table = name_of(node)
|
78
|
try: pkey_ = pkey(table)
|
79
|
except sql.DatabaseErrors, e: on_error_(e); return None
|
80
|
row = {}
|
81
|
children = []
|
82
|
|
83
|
# Divide children into fields and children with fkeys to parent
|
84
|
for child in xml_dom.NodeElemIter(node):
|
85
|
child_name = name_of(child)
|
86
|
if xml_dom.is_empty(child): row[child_name] = None
|
87
|
elif xml_dom.is_text(child):
|
88
|
row[child_name] = strings.to_unicode(xml_dom.value(child))
|
89
|
elif is_ptr(child_name): row[child_name] = put_(ptr_target(child))
|
90
|
else: children.append(child)
|
91
|
try: del row[pkey_]
|
92
|
except KeyError: pass
|
93
|
|
94
|
# Add fkey to parent
|
95
|
if parent_id != None:
|
96
|
parent_ptr = node.getAttribute('fkey')
|
97
|
if parent_ptr == '': parent_ptr = pkey(name_of(node.parentNode))
|
98
|
row[parent_ptr] = parent_id
|
99
|
|
100
|
# Insert node
|
101
|
try:
|
102
|
for try_num in xrange(2):
|
103
|
try:
|
104
|
id_ = sql.put(db, table, row, pkey_, row_ct_ref)
|
105
|
if store_ids: xml_dom.set_id(node, id_)
|
106
|
break
|
107
|
except sql.NullValueException, e:
|
108
|
col = e.cols[0]
|
109
|
if try_num > 0: raise # exception still raised after retry
|
110
|
if store_ids and is_ptr(col):
|
111
|
# Search for required column in ancestors and their children
|
112
|
target = find_by_name(node, ptr_type_guess(col))
|
113
|
if target == None: raise
|
114
|
row[col] = xml_dom.get_id(target)
|
115
|
else: raise
|
116
|
except sql.DatabaseErrors, e: on_error_(e); return None
|
117
|
|
118
|
# Insert children with fkeys to parent
|
119
|
for child in children: put_(child, id_)
|
120
|
|
121
|
return id_
|
122
|
|
123
|
class ColRef:
|
124
|
'''A reference to a table column'''
|
125
|
def __init__(self, name, idx):
|
126
|
self.name = name
|
127
|
self.idx = idx
|
128
|
|
129
|
def __str__(self): return self.name
|
130
|
|
131
|
input_col_prefix = '$'
|
132
|
|
133
|
def put_table(db, node, in_table, commit=False, in_row_ct_ref=None,
|
134
|
row_ins_ct_ref=None, limit=None, start=0, parent_ids_loc=None):
|
135
|
'''
|
136
|
@param node The XML tree that transforms the input to the output. Similar to
|
137
|
put()'s node param, but with the input column name prefixed by
|
138
|
input_col_prefix in place of the column value.
|
139
|
@param commit Whether to commit after each query
|
140
|
@return (table, col) Where the pkeys (from INSERT RETURNING) are made
|
141
|
available
|
142
|
'''
|
143
|
in_table = sql_gen.as_Table(in_table)
|
144
|
|
145
|
# Subset in_table
|
146
|
if limit != None or start != 0:
|
147
|
in_table = copy.copy(in_table) # don't modify input!
|
148
|
sql.run_query_into(db, *sql.mk_select(db, in_table, limit=limit,
|
149
|
start=start, order_by=None), into=in_table)
|
150
|
# in_table won't be overwritten because of automatic versioning
|
151
|
|
152
|
def pkey(table): return sql.pkey(db, table, True)
|
153
|
|
154
|
def put_table_(node, parent_ids_loc=None):
|
155
|
return put_table(db, node, in_table, commit,
|
156
|
row_ins_ct_ref=row_ins_ct_ref, parent_ids_loc=parent_ids_loc)
|
157
|
|
158
|
out_table = name_of(node)
|
159
|
special_funcs = set(['_simplifyPath'])
|
160
|
is_func = out_table in special_funcs
|
161
|
|
162
|
# Divide children into fields and children with fkeys to parent
|
163
|
row = {}
|
164
|
children = []
|
165
|
for child in xml_dom.NodeElemIter(node):
|
166
|
child_name = name_of(child)
|
167
|
if xml_dom.is_empty(child): row[child_name] = None
|
168
|
elif xml_dom.is_text(child):
|
169
|
row[child_name] = strings.to_unicode(xml_dom.value(child))
|
170
|
else:
|
171
|
child_value = xml_dom.value_node(child)
|
172
|
if is_func or is_ptr(child_name) or xml_func.is_func(child_value):
|
173
|
row[child_name] = child_value
|
174
|
else: children.append(child)
|
175
|
|
176
|
# Special handling for structural XML functions
|
177
|
if out_table == '_simplifyPath':
|
178
|
# Parse args
|
179
|
def wrap_e(e): raise xml_func.SyntaxError(e)
|
180
|
try:
|
181
|
next = row['next']
|
182
|
require = row['require']
|
183
|
path = row['path']
|
184
|
except KeyError, e: wrap_e(e)
|
185
|
try: next = xpath.parse(next)
|
186
|
except Parser.SyntaxError, e: wrap_e(e)
|
187
|
try: next = next[0].name
|
188
|
except IndexError, e: wrap_e(e)
|
189
|
|
190
|
# For now, just skip XML func
|
191
|
return put_table_(path, parent_ids_loc)
|
192
|
|
193
|
# Remove any explicit pkey
|
194
|
try: del row[pkey(out_table)]
|
195
|
except KeyError: pass
|
196
|
|
197
|
# Add fkey to parent
|
198
|
if parent_ids_loc != None:
|
199
|
parent_ptr = node.getAttribute('fkey')
|
200
|
if parent_ptr == '': parent_ptr = pkey(name_of(node.parentNode))
|
201
|
row[parent_ptr] = parent_ids_loc
|
202
|
|
203
|
# Divide fields into input columns and literal values
|
204
|
in_tables = [in_table]
|
205
|
for out_col, value in row.iteritems():
|
206
|
# Handle forward pointers
|
207
|
if xml_dom.is_node(value): row[out_col] = value = put_table_(value)
|
208
|
|
209
|
# Translate values
|
210
|
if isinstance(value, sql_gen.Col): # value is temp table column
|
211
|
in_tables.append(value.table)
|
212
|
elif util.is_str(value) and value.startswith(input_col_prefix):
|
213
|
# value is input column
|
214
|
row[out_col] = sql_gen.Col(strings.remove_prefix(input_col_prefix,
|
215
|
value), in_table)
|
216
|
else: # value is literal value; should only be string or None
|
217
|
assert util.is_str(value) or value == None
|
218
|
row[out_col] = sql_gen.NamedCol(out_col, value)
|
219
|
|
220
|
# Insert node
|
221
|
db.log_debug('Putting columns: '+str(row), level=1.5)
|
222
|
pkeys_loc = sql.put_table(db, out_table, in_tables, row, row_ins_ct_ref)
|
223
|
if commit: db.db.commit()
|
224
|
|
225
|
# Insert children with fkeys to parent
|
226
|
for child in children: put_table_(child, pkeys_loc)
|
227
|
|
228
|
# Count # rows and update in_row_ct_ref once all columns have been processed
|
229
|
if in_row_ct_ref != None:
|
230
|
in_row_ct_ref[0] += sql.table_row_count(db, in_table)
|
231
|
|
232
|
return pkeys_loc
|