version = int(version)+1

    return sql_gen.add_suffix(name, '#'+str(version))

    '''Outputs a query to a temp table.

    For params, see run_query().

    '''

        * compare_right_side: sql_gen.ValueCond|literal value

    @param distinct_on The columns to SELECT DISTINCT ON, or distinct_on_all to

        use all columns

    '''

    # Parse tables param

    if not lists.is_seq(tables): tables = [tables]

    if missing: warnings.warn(DbWarning(

        'SELECT statement missing a WHERE, LIMIT, or OFFSET clause: '+query))

def select(db, *args, **kw_args):

    '''For params, see mk_select() and run_query()'''

    cacheable = kw_args.pop('cacheable', True)

    log_level = kw_args.pop('log_level', 2)

def mk_insert_select(db, table, cols=None, select_query=None, params=None,

    returning=None, embeddable=False):

        # Return query that uses function

        func_table = sql_gen.NamedTable('f', sql_gen.FunctionCall(function),

            [returning]) # AS clause requires function alias

    return (query, params)

    '''

    items = mk_flatten_mapping(db, into, cols, as_items=True, **kw_args)

    cols = [sql_gen.NamedCol(new.name, old) for old, new in items]

        into=into)

    return dict(items)

        sql_gen.filter_out)]

    return mk_insert_select(db, errors_table, name_only_cols,

def track_data_error(db, errors_table, *args, **kw_args):

    '''

##### Database structure queries

def table_row_count(db, table, recover=None):

        order_by=None, start=0), recover=recover, log_level=3))

def table_cols(db, table, recover=None):

    pkeys_table_exists_ref = [False]

    def insert_into_pkeys(joins, cols):

        if pkeys_table_exists_ref[0]:

        else:

            pkeys_table_exists_ref[0] = True

    limit_ref = [None]

    while True:

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

            log_debug('Creating an empty pkeys table')

                limit=limit_ref[0]), into=insert_out_pkeys)

            break # don't do main case

                sql_gen.filter_out))

        else:

            insert_args.update(dict(returning=out_pkey, into=insert_out_pkeys))

        log_debug('Trying to insert new rows')

        try:

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

        log_debug('Getting input table pkeys of inserted rows')

            into=insert_in_pkeys)

        add_row_num(db, insert_in_pkeys) # for joining with output pkeys

        full_in_table = in_table

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

        in_table.set_srcs([full_in_table])

            start=start), into=in_table)

            # in_table will be shadowed (hidden) by the created temp table

        sql.add_pkey(db, in_table)