Project

General

Profile

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
(9-9/35)