class ExceptionWithName(DbException):

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

        self.name = name

class ExceptionWithValue(DbException):

class ExceptionWithNameType(DbException):

    def __init__(self, type_, name, cause=None):

        self.type = type_

        self.name = name

                ## Log or return query

                # Put the src comment on a separate line in the log file

                query = query.replace('\t', '\n', 1)

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

            parent_ids_loc, next)

    def on_error_(e):

        augment_error(e)

        on_error(e)

    in_table = sql_gen.as_Table(in_table)

    sql_io.mk_errors_table(db, in_table)

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

    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 in_table

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

        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

import dicts

import objects

#### Function wrappers for statements

class ConstraintError(ValueError):

    def __init__(self, check_func, value):

def cast(type_, val):

    '''Passes None through. Does not cast a subclass to a superclass (which

    def __getitem__(self, key): return self.list[self.key_idxs[key]]

#### Named tuples

    return ''.join(get_traceback_str(t) for t in tracebacks)

def e_msg(e):

    assert util.is_str(e.args[0])

    return strings.ustr(e.args[0]).rstrip()

        if target != None: value_ = xml_dom.value(target)

        else:

            warnings.warn(UserWarning('XPath reference target missing: '

            value_ = None

    # Check each match

    def __str__(self): return util.class_name(self)+repr(self.__dict__)

    def __eq__(self, other):

        return (other != None and other.__class__ == self.__class__

def only_child(node):

    if not has_one_child(node):

    return node.firstChild

def is_simple(node):

def __Element_write_opening(self, writer, indent='', addindent='', newl=''):

    writer.write(indent+'<'+escape(self.tagName))

    for attr_idx in xrange(self.attributes.length):

    writer.write('>'+newl)

minidom.Element.write_opening = __Element_write_opening

            elif is_func_result(in_col): in_col = table # omit col name

        return strings.ustr(in_col)

    if is_func:

        str_ += '('

        try: value_in_col = mapping['value']

        except KeyError:

                for k, v in mapping.iteritems()))

        else: str_ += in_col_str(value_in_col)

        try: in_col = mapping[out_col]

        except KeyError: str_ += '_pkeys'

        else: # has a rank column, so hierarchical

    return str_

def put_table(db, out_table, in_tables, mapping, row_ct_ref=None, default=None,

                    in_, out = mapping

                    # All put_obj()s should return the same id_node

                    nodes, id_node = xpath.put_obj(root, out, '-1', has_types,

                    mappings[i] = [in_, nodes]

                if id_node == None:

                    warnings.warn(UserWarning('Map warning: No mappings'))

                xml_func.simplify(root)

                sys.stdout.flush()

            def process_row(row, i):

                row_id = str(i)

                if id_node != None: xml_dom.set_value(id_node, row_id)

                for in_, out in mappings:

                    value = metadata_value(in_)

                    if value == None: value = cleanup(get_value(in_, row))

                    if out_is_db: # out is list of XML nodes

                        for node in out: xml_dom.set_value(node, value)

                    elif value != None: # out is XPath

                # Strip XML functions not in the DB

                xml_func.process(root, is_rel_func=is_rel_func)

                    # only calc if debug

                # Import rows

                    if row_str_[0] == None:

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

                        row_str_[0] = (term.emph('row #:')+' '+str(row_num+1)

                        if verbose_errors: row_str_[0] += ('\n'

                    return row_str_[0]

                if debug: log_debug(row_str()) # only calc if debug

                row_root = root.cloneNode(True) # deep copy so don't modify root

                xml_func.process(row_root, on_error, is_rel_func, out_db)

                if not xml_dom.is_empty(row_root):

                    assert xml_dom.has_one_child(row_root)

                    try:

def main():

    try: main_()

if __name__ == '__main__':

    profile_to = opts.get_env_var('profile_to', None)