import re

import traceback

from xml.dom import Node

import exc

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, limit=None, start=None):

    node = node.firstChild

    table = name_of(node)

    for child in xml_dom.NodeElemIter(node):

        child_name = name_of(child)

    if id_ != None: conds[pkey(table)] = id_ # replace any existing pkey value

    if fields == []: fields.append(pkey_)

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

def put(db, node, row_ct_ref=None, on_error=exc.raise_, pool=None,

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

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

    def put_(node, parent_id=None):

        args = (db, node, row_ct_ref, on_error, pool, store_ids, parent_id)

        exc.add_msg(e, 'node:\n'+str(node))

        on_error(e)

    table = name_of(node)

    try: pkey_ = pkey(table)

    except sql.DatabaseErrors, e: on_error_(e); return None

    row = {}

    # Divide children into fields and children with fkeys to parent

        if xml_dom.is_empty(child): row[child_name] = None

        elif xml_dom.is_text(child):

            row[child_name] = strings.to_unicode(xml_dom.value(child))

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

        else: children.append(child)

    if parent_id != None:

    try:

                id_ = sql.put(db, table, row, pkey_, row_ct_ref)

                if store_ids: xml_dom.set_id(node, id_)

                col = e.cols[0]

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

                if store_ids and is_ptr(col):

                    # Search for required column in ancestors and their children

                    target = find_by_name(node, ptr_type_guess(col))

                    if target == None: raise

                    row[col] = xml_dom.get_id(target)

                else: raise

    except sql.DatabaseErrors, e: on_error_(e); return None

    for child in children: put_(child, id_)

class ColRef:

def put_table(db, node, in_table, in_schema=None, commit=False,

    '''

    @param node The XML tree that transforms the input to the output. Similar to

    @return tuple(table, col) Where the pkeys (from INSERT RETURNING) are made

    '''

    def esc_name(name): return sql.esc_name(db, name)

    def qual_name(table): return sql.qual_name(db, in_schema, table)

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

    def put_table_(node):

    out_table = name_of(node)

    in_tables = []

        elif is_ptr(child_name):

        else: children.append(child)

    # Divide fields into input columns and literal values

    in_tables.append(qual_name(in_table))

    pkeys_table = sql.put_table(db, esc_name(out_table), row.keys(),

        in_tables, row.values(), pkey_, row_ct_ref, table_is_esc=True)

    if commit: db.db.commit()

    return (pkeys_table, pkey_)