import re

import traceback

from xml.dom import Node

import sql

import strings

import util

import xml_dom

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

ptr_suffix = '_id'

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

def ptr_type_guess(node_name):

    assert is_ptr(node_name)

    return xml_dom.first_elem(node)

    for parent in xml_dom.NodeParentIter(node):

        if name_of(parent) == name: return parent

            for child in xml_dom.NodeElemIter(parent):

                child_name = name_of(child)

                if is_ptr(child_name):

                    target = ptr_target(child)

                elif child_name == name: return child

def get(db, node, pkeys=None, limit=None):

    if pkeys == None: pkeys = {}

    node = node.firstChild

    table = name_of(node)

    for child in xml_dom.NodeElemIter(node):

        child_name = name_of(child)

    return sql.select(db, table, fields, conds, limit)

def put(db, node, store_ids=False, row_ct_ref=None, pkeys=None, parent_id=None):

    '''store_ids enables searching the tree for missing fields'''

    if pkeys == None: pkeys = {}

    def pkey(table): return sql.pkey(db, pkeys, table)

    table = name_of(node)

    # Divide children into fields and children with fkeys to parent

        if xml_dom.is_text(child):

        elif is_ptr(child_name): row[child_name] = put(db, ptr_target(child),

    if parent_id != None:

    for try_num in xrange(2):

        try:

        except sql.NullValueException, e:

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

            if store_ids and is_ptr(e.col):

                # Search for required column in ancestors and their children

                target = find_by_name(node, ptr_type_guess(e.col))

                if target == None: raise

                row[e.col] = xml_dom.get_id(target)

            else: raise