# Database import/export

import exc

import dicts

import sql

    if mapping == {}: # need at least one column for INSERT SELECT

        mapping = {out_pkey: None} # ColDict will replace with default value

    in_tables_ = in_tables[:] # don't modify input!

    in_tables0 = in_tables_.pop(0) # first table is separate

    in_pkey = sql.pkey(db, in_tables0, recover=True)

    in_pkey_col = sql_gen.as_Col(in_pkey, in_tables0)

    input_joins = [in_tables0]+[sql_gen.Join(v,

        {in_pkey: sql_gen.join_same_not_null}) for v in in_tables_]

    mapping = sql_gen.ColDict(db, out_table, mapping)

        # after applying dicts.join() because that returns a plain dict

            default = None

    # Save default values for all rows since in_table may have rows deleted

    else:

        full_in_table = sql_gen.suffixed_table(in_table, '_full')

        full_in_table_cols = [in_pkey_col]

        sql.run_query_into(db, sql.mk_select(db, in_table, full_in_table_cols,

            order_by=None), into=full_in_table, add_pkey_=True)

    pkeys_table_exists_ref = [False]

    def insert_into_pkeys(joins, cols, **kw_args):

    def mk_main_select(joins, cols):

        return sql.mk_select(db, joins, cols, limit=limit_ref[0], order_by=None)

    join_cols = sql_gen.ColDict(db, out_table)

    exc_strs = set()

            sql.delete(db, insert_in_table, sql_gen.ColValueCond(in_col, value))

            if value == None: not_null_cols.add(in_col)

    # Do inserts and selects

    while True:

        if limit_ref[0] == 0: # special case

            log_debug('Creating an empty pkeys table')

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

                [out_pkey], order_by=None, limit=0), into=insert_out_pkeys)

            if has_joins:

                insert_args.update(dict(ignore=True))

            else:

            main_select = mk_main_select([insert_in_table], [sql_gen.with_table(

                c, insert_in_table) for c in mapping.values()])

        try:

            cur = None

            if is_function:

            else:

                cur = sql.insert_select(db, out_table, mapping.keys(),

                    main_select, **insert_args)

            log_debug('Ignoring existing rows, comparing on these columns:\n'

                +strings.as_inline_table(join_cols, ustr=col_ustr))

            # Uniquify input table to avoid internal duplicate keys

            insert_in_table = sql.distinct_table(db, insert_in_table,

                join_cols.values())

    if cur != None and row_ct_ref != None and cur.rowcount >= 0:

        row_ct_ref[0] += cur.rowcount

    elif has_joins:

        select_joins = input_joins+[sql_gen.Join(out_table, join_cols)]

        log_debug('Getting output table pkeys of existing/inserted rows')

        sql.empty_temp(db, [insert_out_pkeys, insert_in_pkeys])

        log_debug('Setting pkeys of missing rows to '

            +strings.as_tt(repr(default)))

        missing_rows_joins = [full_in_table, sql_gen.Join(into,

            sql_gen.NamedCol(out_pkey, default)])

    # otherwise, there is already an entry for every row