# XML-database conversion

    return node_name[:-len(ptr_suffix)]

def ptr_target(node):

    assert is_ptr(name_of(node))

def find_by_name(node, name):

        else:

                    if target.tagName == name: return target

    return None

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

    def __init__(self, name, idx):

        self.name = name

        self.idx = idx

    def __str__(self): return self.name

    @param node To use an entire XML document, pass root.firstChild.

    '''

    if node == None: return None # when no rows, root.firstChild == None

        return put(db, node, row_ins_ct_ref, on_error, col_defaults, in_table,

            parent_ids_loc, next)

        augment_error(e)

        raise xml_func.SyntaxError(e)

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

            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)

    except dicts.KeyExistsError, e: wrap_e(e)

    # Special handling for structural XML functions

    if out_table == '_simplifyPath':

        try: next = xpath.parse(next)

        except Parser.SyntaxError, e: wrap_e(e)

        try: next = next[0].name

        except IndexError, e: wrap_e(e)

    no_empty = set()

        no_empty.add(in_table)

    if parent_ids_loc != None:

            no_empty.add(parent_ids_loc.table)

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

        row[parent_ptr] = parent_ids_loc

            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)

    if out_table == '_alt': # return first arg if non-NULL

        args = row.items()

        args.sort()

        out_col, value = min(args) # first arg

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

        if not sql_gen.is_nullable(db, value): return value

    parent_ids_loc = None # applies to this section

    for out_col, value in row.iteritems():

        # Translate values

    # Insert node

        row_ins_ct_ref, next, col_defaults, on_error_)

    except Exception, e:

        raise

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)

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

partition_size = 500000 # rows

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

    partition_size=partition_size):

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

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

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

    # Subset and partition in_table

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

    full_in_table = in_table

    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

            srcs=full_in_table.srcs, is_temp=True) # prepend schema to name

        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

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

            in_table)

        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