echo "Password can also be specified with: export password=..."

class ExceptionWithCause(Exception):

    def __init__(self, msg, cause=None):

        Exception.__init__(self, msg)

        if cause != None: add_msg(self, 'cause: '+str(cause))

def name_of(node): return node.tagName.lower()

def get_id(node): return node.getAttribute('id')

def set_id(node, id_): node.setAttribute('id', id_)

class NodeParentIter:

    def __init__(self, node): self.node = node

    def __iter__(self): return self

    def curr(self):

        if self.node != None and self.node.nodeType == Node.ELEMENT_NODE:

            return self.node

        raise StopIteration

    def next(self):

        node = self.curr()

        self.node = self.node.parentNode

        return node

import xml_db

        print 'Inserted '+str(xml_db.xml2db(doc.documentElement, db))+' rows'

class ExceptionWithColumn(ex_util.ExceptionWithCause):

    def __init__(self, col, cause=None):

        ex_util.ExceptionWithCause.__init__(self, 'column: '+col, cause)

        self.col = col

class DuplicateKeyException(ExceptionWithColumn): pass

class NullValueException(ExceptionWithColumn): pass

    for col in conds.keys(): check_name(col)

        col, value = entry

        cond_ = col+' '

def insert(db, table, row):

    cols = row.keys()

    for col in cols: check_name(col)

    return run_query(db, 'INSERT INTO '+table+' ('+', '.join(cols)

        +') VALUES ('+', '.join(['%s']*len(cols))+')', row.values())

def last_insert_id(db): return value(run_query(db, 'SELECT lastval()'))

def insert_ignore(db, table, row):

    try: return with_savepoint(db, lambda: insert(db, table, row))

        msg = str(ex)

            +table+'_(\w+)_index"', msg)

        if match: raise DuplicateKeyException(match.group(1), ex)

        match = re.search(r'null value in column "(\w+)" violates not-null '

            'constraint', msg)

        if match: raise NullValueException(match.group(1), ex)

        raise # no specific exception raised

def insert_or_get(db, table, row, pkey, row_ct_ref=None):

    try:

        row_ct = insert_ignore(db, table, row).rowcount

        if row_ct_ref != None and row_ct >= 0: row_ct_ref[0] += row_ct

        return last_insert_id(db)

        return value(select(db, table, [pkey], {ex.col: row[ex.col]}))

-- Modifications

ALTER TABLE aux_role RENAME role_id  TO aux_role_id;

ALTER TABLE place RENAME plotplace_id  TO place_id;

# XML-database conversion

from xml.dom import Node

import db_util

import xml_util

from xml_util import name_of

ptr_suffix = '_id'

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

def ptr_type(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_util.first_elem(node)

def pkey_name(node_name): return node_name+ptr_suffix

def is_field(node_name): return node_name.find('.') >= 0

def field_name(node_name):

    if is_field(node_name): return node_name.partition('.')[2]

    else: return node_name

def is_db_export(node_name): return node_name.find('.') >= 1 # has prefix

def find_by_name(node, name):

    for parent in xml_util.NodeParentIter(node):

        if name_of(parent) == name: return parent

        else:

            for child in xml_util.NodeElemIter(parent):

                child_name = field_name(name_of(child))

                if is_ptr(child_name):

                    if ptr_type(child_name) == name: return ptr_target(child)

                elif child_name == name: return child

    return None

def xml2db(node, db):

    def _main(node):

        for child in xml_util.NodeElemIter(node):

            if not xml_util.is_text(child): _obj(child) # not XML metadata

    def _obj(node):

        table = name_of(node)

        db_util.check_name(table)

        pkey = pkey_name(table)

        row = {}

        children = []

        iter_ = xml_util.NodeElemIter(node)

        # Skip any pkey

        child_name = name_of(iter_.curr()) # first child

        if is_db_export(child_name) and is_ptr(child_name)\

        or field_name(child_name) == pkey: iter_.next()

        # Divide children into fields and children with fkeys to parent

        for child in iter_:

            if is_field(name_of(child)): row.update([_field(child)])

            else: children.append(child)

        # Add fkey to parent

        parent_id = xml_util.get_id(node.parentNode)

        if parent_id != '': row[pkey_name(name_of(node.parentNode))] = parent_id

        # Insert node

        for try_num in range(2):

            try:

                xml_util.set_id(node, db_util.insert_or_get(db, table, row,

                    pkey, row_ct_ref))

                break

            except db_util.NullValueException, ex:

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

                target = find_by_name(node, ptr_type(ex.col))

                if target == None: raise

                row[ex.col] = xml_util.get_id(target)

        # Insert children with fkeys to parent

        for child in children: _obj(child)

    def _field(node):

        if xml_util.is_text(node): value = xml_util.value(node)

        else:

            child = xml_util.first_elem(node)

            _obj(child)

            value = xml_util.get_id(child)

        return (field_name(name_of(node)), value)

    row_ct_ref = [0]

    _main(node)

    return row_ct_ref[0]