if not is_literals:

        into = sql_gen.as_Table(into_table_name(out_table, in_tables0, mapping,

            is_function))

        # Set column sources

        in_cols = filter(sql_gen.is_table_col, mapping.values())

        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=None, limit=None, **kw_args):

        query = sql.mk_select(db, joins, cols, order_by=None, limit=limit)

        if pkeys_table_exists_ref[0]:

        else:

            sql.run_query_into(db, query, into=into, add_pkey_=True, **kw_args)

            pkeys_table_exists_ref[0] = True

    def mk_func_call():

        args = dict(((k.name, v) for k, v in mapping.iteritems()))

    if is_function and not is_literals:

        log_debug('Defining wrapper function')

        func_call, args = mk_func_call()

        # Create empty pkeys table so its row type can be used

        insert_into_pkeys(input_joins, [in_pkey_col, func_call], limit=0,

            recover=True)

        ## Create error handling wrapper function

    elif has_joins:

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

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

    else:

        sql.add_row_num(db, insert_out_pkeys) # for joining with input pkeys

        log_debug('Combining output and input pkeys in inserted order')

        pkey_joins = [insert_in_pkeys, sql_gen.Join(insert_out_pkeys,

            {sql.row_num_col: sql_gen.join_same_not_null})]

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

            # must use join_same_not_null or query will take forever

        insert_into_pkeys(missing_rows_joins,

            [sql_gen.Col(in_pkey, full_in_table),

    # otherwise, there is already an entry for every row

    assert (sql.table_row_count(db, into)

    srcs = []

    if is_function: srcs = sql_gen.cols_srcs(in_cols)