# XML-database conversion

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 node_name[:-len(ptr_suffix)]

def ptr_target(node):

    assert is_ptr(name_of(node))

    return xml_dom.value_node(node)

def find_by_name(node, name):

    for parent in xml_dom.NodeParentIter(node):

        if name_of(parent) == name: return parent

        else:

            for child in xml_dom.NodeElemIter(parent):

                child_name = name_of(child)

                if is_ptr(child_name):

                    target = ptr_target(child)

                    if target.tagName == name: return target

                elif child_name == name: return child

    return None

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

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

    node = node.firstChild

    table = name_of(node)

    pkey_ = pkey(table)

    fields = []

    conds = {}

    for child in xml_dom.NodeElemIter(node):

        child_name = name_of(child)

        if xml_dom.is_empty(child): fields.append(child_name)

        elif xml_dom.is_text(child): conds[child_name] = xml_dom.value(child)

        else: raise Exception('Joins not supported yet')

    id_ = xml_dom.get_id(node)

    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=False, parent_id=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)

        if parent_id != None and pool != None: pool.apply_async(put, args)

        else: return put(*args)

    def on_error_(e):

        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 = {}

    children = []

    # Divide children into fields and children with fkeys to parent

    for child in xml_dom.NodeElemIter(node):

        child_name = name_of(child)

        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)

    # Add fkey to parent

    if parent_id != None:

        parent_ptr = node.getAttribute('fkey')

        if parent_ptr == '': parent_ptr = pkey(name_of(node.parentNode))

        row[parent_ptr] = parent_id

    # Insert node

    try:

        for try_num in xrange(2):

            try:

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

                if store_ids: xml_dom.set_id(node, id_)

                break

            except sql.NullValueException, e:

                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

    # Insert children with fkeys to parent

    for child in children: put_(child, id_)

    return id_

class ColRef:

    '''A reference to a table column'''

    def __init__(self, name, idx):

        self.name = name

        self.idx = idx

    def __str__(self): return self.name

# 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,

    limit=None, start=0, on_error=exc.raise_, col_defaults={}):

    '''

    @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

        input_col_prefix in place of the column value.

    @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

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

    full_in_table = in_table

    # Subset and partition in_table

    # OK to do even if table already the right size because it takes <1 sec.

    total = 0

    while limit == None or total < limit:

        # Adjust partition size if last partition

        this_limit = partition_size

        if limit != None: this_limit = min(this_limit, limit - total)

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

        db.log_debug('********** Partition: rows '+str(start+1)+'-'

            +str(start+this_limit)+' **********', level=1.2)

        # Subset in_table

        in_table = copy.copy(full_in_table) # don't modify input!

        in_table.name = str(in_table) # prepend schema

        cur = sql.run_query_into(db, sql.mk_select(db, full_in_table,

            limit=this_limit, start=start), into=in_table, add_pkey_=True)

            # full_in_table will be shadowed (hidden) by created temp table

        this_ct = cur.rowcount

        total += this_ct

        start += this_ct # advance start to fetch next set

        if this_ct == 0: break # in_table size is multiple of partition_size

        # Recurse

        pkeys_loc = _put_table_part(db, node, in_table, row_ins_ct_ref,

            on_error, col_defaults)

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

        sql.empty_temp(db, in_table)

        if this_ct < partition_size: break # partial partition = last

        # Work around PostgreSQL's temp table disk space leak

        db.reconnect()

    return pkeys_loc

def _put_table_part(db, node, in_table, row_ins_ct_ref, on_error, col_defaults,

    parent_ids_loc=None, next=None):

    '''Helper function for put_table() only; should not be called directly'''

    def put_table_(node, in_row_ct_ref=None):

        return _put_table_part(db, node, in_table, row_ins_ct_ref, on_error,

            col_defaults, parent_ids_loc, next)

    is_func = xml_func.is_func(node)

    out_table = name_of(node)

    # Divide children into fields and children with fkeys to parent

    row = {}

    children = []

    for child in xml_dom.NodeElemIter(node):

        child_name = name_of(child)

        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))

        else:

            child_value = xml_dom.value_node(child)

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

                row[child_name] = child_value

            else: children.append(child)

    # Special handling for structural XML functions

    if out_table == '_simplifyPath':

        # Parse args

        def wrap_e(e): raise xml_func.SyntaxError(e)

        try:

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

            require = row['require']

            path = row['path']

        except KeyError, e: wrap_e(e)

        try: next = xpath.parse(next)

        except Parser.SyntaxError, e: wrap_e(e)

        try: next = next[0].name

        except IndexError, e: wrap_e(e)

        return put_table_(path)

    no_empty = set([in_table])

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

    # Add fkey to parent

    if parent_ids_loc != None:

        if sql_gen.is_table_col(parent_ids_loc):

            no_empty.add(parent_ids_loc.table)

        parent_ptr = node.getAttribute('fkey')

        if parent_ptr == '': parent_ptr = pkey(name_of(node.parentNode))

        row[parent_ptr] = parent_ids_loc

    # Divide fields into input columns and literal values

    parent_ids_loc = None # applies to this section

    in_tables = [in_table]

    for out_col, value in row.iteritems():

        # Handle forward pointers

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

        # Translate values

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

            in_tables.append(value.table)

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

            # value is input column

            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)

    # Insert node

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

        None, 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_table_(child)

    return pkeys_loc