import copy

import re

from xml.dom import Node

import exc

import Parser

import sql

import sql_io

import sql_gen

import strings

import util

import xml_dom

import xml_func

import xpath

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.value_node(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)

class ColRef:

# Controls when and how put_table() will partition the input table

partition_size = 500000 # rows

input_col_prefix = '$'

put_table_special_funcs = set(['_simplifyPath'])

def put_table(db, node, in_table, in_row_ct_ref=None, row_ins_ct_ref=None,

    '''

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

        put()'s node param, but with the input column name prefixed by

    @return sql_gen.Col Where the pkeys (from INSERT RETURNING) are made

        available

    '''

    in_table = sql_gen.as_Table(in_table)

    in_table.set_srcs([in_table], overwrite=False)

    db.src = str(in_table)

    db.autoanalyze = True # but don't do this in row-based import

    # Import col_defaults

        col_defaults[col] = put(db, node_, row_ins_ct_ref, on_error)

    # Subset and partition in_table

    full_in_table = in_table

    total = 0

        # Row # is interally 0-based, but 1-based to the user

        # Subset in_table

        this_ct = cur.rowcount

        pkeys_loc = put(db, node, row_ins_ct_ref, on_error,

            col_defaults, in_table)

        if in_row_ct_ref != None: in_row_ct_ref[0] += this_ct

    return pkeys_loc

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

    col_defaults={}, in_table=None, parent_ids_loc=None, next=None):

    def put_(node, in_row_ct_ref=None):

            in_table, parent_ids_loc, next)

    def on_error_(e):

    is_func = xml_func.is_func(node)

    out_table = name_of(node)

    row = {}

        else:

            if is_func or is_ptr(child_name) or xml_func.is_func(child_value):

                row[child_name] = child_value

            else: children.append(child)

        # Parse args

        try:

            next = row['next'] # modifies outer next var used by put_()

            require = row['require']

        except KeyError, e: wrap_e(e)

        return put_(path)

    in_tables = []

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

    # Add fkey to parent

        if sql_gen.is_table_col(parent_ids_loc):

        parent_ptr = node.getAttribute('fkey')

    # Divide fields into input columns and literal values

    parent_ids_loc = None # applies to this section

    for out_col, value in row.iteritems():

        # Handle forward pointers

        if xml_dom.is_node(value): row[out_col] = value = put_(value)

        if isinstance(value, sql_gen.Col): # value is temp table column

        elif util.is_str(value) and value.startswith(input_col_prefix):

            row[out_col] = sql_gen.Col(strings.remove_prefix(input_col_prefix,

                value), in_table)

        else: # value is literal value

            row[out_col] = sql_gen.NamedCol(out_col, value)

    pkeys_loc = sql_io.put_table(db, out_table, in_tables, row, row_ins_ct_ref,

        next, col_defaults, on_error_)

    sql.empty_temp(db, set(in_tables) - no_empty)

    # Insert children with fkeys to parent

    parent_ids_loc = pkeys_loc # applies to this section

    for child in children: put_(child)

    return pkeys_loc