# XML-database conversion

import re

from xml.dom import Node

import db_util

import xml_util

def name_of(node): return re.sub(r'^.*\.', r'', xml_util.name_of(node))

ptr_suffix = '_id'

def is_ptr(node_name): return node_name.endswith(ptr_suffix)

def ptr_type(node_name):

    assert is_ptr(node_name)

    return node_name[:-len(ptr_suffix)]

def ptr_target(node):

    assert is_ptr(name_of(node))

    return xml_util.first_elem(node)

def find_by_name(node, name):

    for parent in xml_util.NodeParentIter(node):

        if name_of(parent) == name: return parent

        else:

            for child in xml_util.NodeElemIter(parent):

                child_name = name_of(child)

                if is_ptr(child_name):

                    if ptr_type(child_name) == name: return ptr_target(child)

                elif child_name == name: return child

    return None

def get(db, node, create=False, store_ids=False, row_ct_ref=None, pkeys=None):

    # store_ids enables searching the tree for missing fields

    if pkeys == None: pkeys = {}

    def pkey(table):

        if table not in pkeys: pkeys[table] = db_util.pkey(db, table)

        return pkeys[table]

    def main(node):

        for child in xml_util.NodeElemIter(node):

            if not xml_util.is_text(child): obj(child) # not XML metadata

    def obj(node, parent_id=None):

        table = name_of(node)

        pkey_ = pkey(table)

        row = {}

        children = []

        # Divide children into fields and children with fkeys to parent

        for child in xml_util.NodeElemIter(node):

            child_name = name_of(child)

            if xml_util.is_text(child): row[child_name] = xml_util.value(child)

            elif is_ptr(child_name): row[child_name] = obj(ptr_target(child))

            else: children.append(child)

        try: del row[pkey_]

        except KeyError: pass

        # Add fkey to parent

        if parent_id != None: row[pkey(name_of(node.parentNode))] = parent_id

        # Insert node

        for try_num in range(2):

            try:

                id_ = db_util.get(db, table, row, pkey_, create, row_ct_ref)

                if store_ids: xml_util.set_id(node, id_)

                break

            except db_util.NullValueException, ex:

                if try_num > 0: raise # exception still raised after retry

                # Search for required column in ancestors and their children

                target = find_by_name(node, ptr_type(ex.col))

                if target == None: raise

                row[ex.col] = xml_util.get_id(target)

        # Insert children with fkeys to parent

        for child in children: obj(child, id_)

        return id_

    return main(node)

def xml2db(db, node, row_ct_ref=None):

    return get(db, node, True, True, row_ct_ref)