1
|
# XML-database conversion
|
2
|
|
3
|
import re
|
4
|
import traceback
|
5
|
from xml.dom import Node
|
6
|
|
7
|
import exc
|
8
|
import sql
|
9
|
import strings
|
10
|
import util
|
11
|
import xml_dom
|
12
|
|
13
|
def name_of(node): return re.sub(r'^.*\.', r'', node.tagName)
|
14
|
|
15
|
ptr_suffix = '_id'
|
16
|
|
17
|
def is_ptr(node_name): return node_name.lower().endswith(ptr_suffix)
|
18
|
|
19
|
def ptr_type_guess(node_name):
|
20
|
assert is_ptr(node_name)
|
21
|
return node_name[:-len(ptr_suffix)]
|
22
|
|
23
|
def ptr_target(node):
|
24
|
assert is_ptr(name_of(node))
|
25
|
return xml_dom.first_elem(node)
|
26
|
|
27
|
def find_by_name(node, name):
|
28
|
for parent in xml_dom.NodeParentIter(node):
|
29
|
if name_of(parent) == name: return parent
|
30
|
else:
|
31
|
for child in xml_dom.NodeElemIter(parent):
|
32
|
child_name = name_of(child)
|
33
|
if is_ptr(child_name):
|
34
|
target = ptr_target(child)
|
35
|
if target.tagName == name: return target
|
36
|
elif child_name == name: return child
|
37
|
return None
|
38
|
|
39
|
def get(db, node, pkeys=None, limit=None):
|
40
|
if pkeys == None: pkeys = {}
|
41
|
def pkey(table): return sql.pkey(db, pkeys, table)
|
42
|
|
43
|
node = node.firstChild
|
44
|
table = name_of(node)
|
45
|
pkey_ = pkey(table)
|
46
|
|
47
|
fields = []
|
48
|
conds = {}
|
49
|
for child in xml_dom.NodeElemIter(node):
|
50
|
child_name = name_of(child)
|
51
|
if xml_dom.is_empty(child): fields.append(child_name)
|
52
|
elif xml_dom.is_text(child): conds[child_name] = xml_dom.value(child)
|
53
|
else: raise Exception('Joins not supported yet')
|
54
|
id_ = xml_dom.get_id(node)
|
55
|
if id_ != '': conds[pkey(table)] = id_ # replace any existing pkey value
|
56
|
if fields == []: fields.append(pkey_)
|
57
|
|
58
|
return sql.select(db, table, fields, conds, limit)
|
59
|
|
60
|
def put(db, node, pkeys=None, row_ct_ref=None, on_error=exc.raise_,
|
61
|
store_ids=False, parent_id=None):
|
62
|
'''store_ids enables searching the tree for missing fields'''
|
63
|
if pkeys == None: pkeys = {}
|
64
|
def pkey(table): return sql.pkey(db, pkeys, table)
|
65
|
|
66
|
def put_(node, parent_id=None):
|
67
|
return put(db, node, pkeys, row_ct_ref, on_error, store_ids, parent_id)
|
68
|
|
69
|
def on_error_(e):
|
70
|
exc.add_msg(e, 'node:\n'+str(node))
|
71
|
on_error(e)
|
72
|
|
73
|
table = name_of(node)
|
74
|
try: pkey_ = pkey(table)
|
75
|
except sql.DatabaseErrors, e: on_error_(e); return None
|
76
|
row = {}
|
77
|
children = []
|
78
|
|
79
|
# Divide children into fields and children with fkeys to parent
|
80
|
for child in xml_dom.NodeElemIter(node):
|
81
|
child_name = name_of(child)
|
82
|
if xml_dom.is_empty(child): row[child_name] = None
|
83
|
elif xml_dom.is_text(child):
|
84
|
row[child_name] = strings.to_unicode(xml_dom.value(child))
|
85
|
elif is_ptr(child_name): row[child_name] = put_(ptr_target(child))
|
86
|
else: children.append(child)
|
87
|
try: del row[pkey_]
|
88
|
except KeyError: pass
|
89
|
|
90
|
# Add fkey to parent
|
91
|
if parent_id != None:
|
92
|
parent_ptr = node.getAttribute('fkey')
|
93
|
if parent_ptr == '': parent_ptr = pkey(name_of(node.parentNode))
|
94
|
row[parent_ptr] = parent_id
|
95
|
|
96
|
# Insert node
|
97
|
try:
|
98
|
for try_num in xrange(2):
|
99
|
try:
|
100
|
id_ = sql.get(db, table, row, pkey_, True, row_ct_ref)
|
101
|
if store_ids: xml_dom.set_id(node, id_)
|
102
|
break
|
103
|
except sql.NullValueException, e:
|
104
|
col = e.cols[0]
|
105
|
if try_num > 0: raise # exception still raised after retry
|
106
|
if store_ids and is_ptr(col):
|
107
|
# Search for required column in ancestors and their children
|
108
|
target = find_by_name(node, ptr_type_guess(col))
|
109
|
if target == None: raise
|
110
|
row[col] = xml_dom.get_id(target)
|
111
|
else: raise
|
112
|
except sql.DatabaseErrors, e: on_error_(e); return None
|
113
|
|
114
|
# Insert children with fkeys to parent
|
115
|
for child in children: put_(child, id_)
|
116
|
|
117
|
return id_
|