oid2name.c File Reference

#include "postgres_fe.h"
#include "catalog/pg_class_d.h"
#include "common/connect.h"
#include "common/logging.h"
#include "common/string.h"
#include "getopt_long.h"
#include "libpq-fe.h"
#include "pg_getopt.h"

Include dependency graph for oid2name.c:

Go to the source code of this file.

Data Structures
struct	eary
struct	options

Macros
#define	PARAMS_ARRAY_SIZE   7

Functions
static void	help (const char *progname)
void	get_opts (int argc, char **argv, struct options *my_opts)
void	add_one_elt (char *eltname, eary *eary)
char *	get_comma_elts (eary *eary)
PGconn *	sql_conn (struct options *my_opts)
int	sql_exec (PGconn *conn, const char *todo, bool quiet)
void	sql_exec_dumpalldbs (PGconn *conn, struct options *opts)
void	sql_exec_dumpalltables (PGconn *conn, struct options *opts)
void	sql_exec_searchtables (PGconn *conn, struct options *opts)
void	sql_exec_dumpalltbspc (PGconn *conn, struct options *opts)
int	main (int argc, char **argv)

Macro Definition Documentation

PARAMS_ARRAY_SIZE

#define PARAMS_ARRAY_SIZE   7

Function Documentation

add_one_elt()

void add_one_elt	(	char *	eltname,
		eary *	eary
	)

Definition at line 235 of file oid2name.c.

{
    if (eary->alloc == 0)
    {
        eary      ->alloc = 8;
        eary      ->array = (char **) pg_malloc(8 * sizeof(char *));
    }
    else if (eary->num >= eary->alloc)
    {
        eary      ->alloc *= 2;
        eary      ->array = (char **) pg_realloc(eary->array,
                                                 eary->alloc * sizeof(char *));
    }
 
    eary      ->array[eary->num] = pg_strdup(eltname);
    eary      ->num++;
}

References eary::alloc, eary::array, eary::num, pg_malloc(), pg_realloc(), and pg_strdup().

Referenced by get_opts().

get_comma_elts()

char * get_comma_elts

(

eary *

eary

)

Definition at line 261 of file oid2name.c.

{
    char       *ret,
               *ptr;
    int         i,
                length = 0;
 
    if (eary->num == 0)
        return pg_strdup("");
 
    /*
     * PQescapeString wants 2 * length + 1 bytes of breath space.  Add two
     * chars per element for the single quotes and one for the comma.
     */
    for (i = 0; i < eary->num; i++)
        length += strlen(eary->array[i]);
 
    ret = (char *) pg_malloc(length * 2 + 4 * eary->num);
    ptr = ret;
 
    for (i = 0; i < eary->num; i++)
    {
        if (i != 0)
            sprintf(ptr++, ",");
        sprintf(ptr++, "'");
        ptr += PQescapeString(ptr, eary->array[i], strlen(eary->array[i]));
        sprintf(ptr++, "'");
    }
 
    return ret;
}

References eary::array, i, eary::num, pg_malloc(), pg_strdup(), PQescapeString(), and sprintf.

Referenced by sql_exec_searchtables().

get_opts()

void get_opts	(	int	argc,
		char **	argv,
		struct options *	my_opts
	)

Definition at line 63 of file oid2name.c.

{
    static const struct option long_options[] = {
        {"dbname", required_argument, NULL, 'd'},
        {"host", required_argument, NULL, 'h'},
        {"host", required_argument, NULL, 'H'}, /* deprecated */
        {"filenode", required_argument, NULL, 'f'},
        {"indexes", no_argument, NULL, 'i'},
        {"oid", required_argument, NULL, 'o'},
        {"port", required_argument, NULL, 'p'},
        {"quiet", no_argument, NULL, 'q'},
        {"tablespaces", no_argument, NULL, 's'},
        {"system-objects", no_argument, NULL, 'S'},
        {"table", required_argument, NULL, 't'},
        {"username", required_argument, NULL, 'U'},
        {"version", no_argument, NULL, 'V'},
        {"extended", no_argument, NULL, 'x'},
        {"help", no_argument, NULL, '?'},
        {NULL, 0, NULL, 0}
    };
 
    int         c;
    const char *progname;
    int         optindex;
 
    pg_logging_init(argv[0]);
    progname = get_progname(argv[0]);
 
    /* set the defaults */
    my_opts->quiet = false;
    my_opts->systables = false;
    my_opts->indexes = false;
    my_opts->nodb = false;
    my_opts->extended = false;
    my_opts->tablespaces = false;
    my_opts->dbname = NULL;
    my_opts->hostname = NULL;
    my_opts->port = NULL;
    my_opts->username = NULL;
    my_opts->progname = progname;
 
    if (argc > 1)
    {
        if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
        {
            help(progname);
            exit(0);
        }
        if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
        {
            puts("oid2name (PostgreSQL) " PG_VERSION);
            exit(0);
        }
    }
 
    /* get opts */
    while ((c = getopt_long(argc, argv, "d:f:h:H:io:p:qsSt:U:x", long_options, &optindex)) != -1)
    {
        switch (c)
        {
                /* specify the database */
            case 'd':
                my_opts->dbname = pg_strdup(optarg);
                break;
 
                /* specify one filenumber to show */
            case 'f':
                add_one_elt(optarg, my_opts->filenumbers);
                break;
 
                /* host to connect to */
            case 'H':           /* deprecated */
            case 'h':
                my_opts->hostname = pg_strdup(optarg);
                break;
 
                /* also display indexes */
            case 'i':
                my_opts->indexes = true;
                break;
 
                /* specify one Oid to show */
            case 'o':
                add_one_elt(optarg, my_opts->oids);
                break;
 
                /* port to connect to on remote host */
            case 'p':
                my_opts->port = pg_strdup(optarg);
                break;
 
                /* don't show headers */
            case 'q':
                my_opts->quiet = true;
                break;
 
                /* dump tablespaces only */
            case 's':
                my_opts->tablespaces = true;
                break;
 
                /* display system tables */
            case 'S':
                my_opts->systables = true;
                break;
 
                /* specify one tablename to show */
            case 't':
                add_one_elt(optarg, my_opts->tables);
                break;
 
                /* username */
            case 'U':
                my_opts->username = pg_strdup(optarg);
                break;
 
                /* display extra columns */
            case 'x':
                my_opts->extended = true;
                break;
 
            default:
                /* getopt_long already emitted a complaint */
                pg_log_error_hint("Try \"%s --help\" for more information.", progname);
                exit(1);
        }
    }
 
    if (optind < argc)
    {
        pg_log_error("too many command-line arguments (first is \"%s\")",
                     argv[optind]);
        pg_log_error_hint("Try \"%s --help\" for more information.", progname);
        exit(1);
    }
}

References add_one_elt(), options::dbname, exit(), options::extended, options::filenumbers, get_progname(), getopt_long(), help(), options::hostname, options::indexes, no_argument, options::nodb, options::oids, optarg, optind, pg_log_error, pg_log_error_hint, pg_logging_init(), pg_strdup(), options::port, options::progname, progname, options::quiet, required_argument, options::systables, options::tables, options::tablespaces, and options::username.

Referenced by main().

help()

static void help ( const char *  progname )

static

Definition at line 201 of file oid2name.c.

{
    printf("%s helps examining the file structure used by PostgreSQL.\n\n"
           "Usage:\n"
           "  %s [OPTION]...\n"
           "\nOptions:\n"
           "  -f, --filenode=FILENODE    show info for table with given file node\n"
           "  -i, --indexes              show indexes and sequences too\n"
           "  -o, --oid=OID              show info for table with given OID\n"
           "  -q, --quiet                quiet (don't show headers)\n"
           "  -s, --tablespaces          show all tablespaces\n"
           "  -S, --system-objects       show system objects too\n"
           "  -t, --table=TABLE          show info for named table\n"
           "  -V, --version              output version information, then exit\n"
           "  -x, --extended             extended (show additional columns)\n"
           "  -?, --help                 show this help, then exit\n"
           "\nConnection options:\n"
           "  -d, --dbname=DBNAME        database to connect to\n"
           "  -h, --host=HOSTNAME        database server host or socket directory\n"
           "  -H                         (same as -h, deprecated)\n"
           "  -p, --port=PORT            database server port number\n"
           "  -U, --username=USERNAME    connect as specified database user\n"
           "\nThe default action is to show all database OIDs.\n\n"
           "Report bugs to <%s>.\n"
           "%s home page: <%s>\n",
           progname, progname, PACKAGE_BUGREPORT, PACKAGE_NAME, PACKAGE_URL);
}

References printf, and progname.

Referenced by get_opts().

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 583 of file oid2name.c.

{
    struct options *my_opts;
    PGconn     *pgconn;
 
    my_opts = (struct options *) pg_malloc(sizeof(struct options));
 
    my_opts->oids = (eary *) pg_malloc(sizeof(eary));
    my_opts->tables = (eary *) pg_malloc(sizeof(eary));
    my_opts->filenumbers = (eary *) pg_malloc(sizeof(eary));
 
    my_opts->oids->num = my_opts->oids->alloc = 0;
    my_opts->tables->num = my_opts->tables->alloc = 0;
    my_opts->filenumbers->num = my_opts->filenumbers->alloc = 0;
 
    /* parse the opts */
    get_opts(argc, argv, my_opts);
 
    if (my_opts->dbname == NULL)
    {
        my_opts->dbname = "postgres";
        my_opts->nodb = true;
    }
    pgconn = sql_conn(my_opts);
 
    /* display only tablespaces */
    if (my_opts->tablespaces)
    {
        if (!my_opts->quiet)
            printf("All tablespaces:\n");
        sql_exec_dumpalltbspc(pgconn, my_opts);
 
        PQfinish(pgconn);
        exit(0);
    }
 
    /* display the given elements in the database */
    if (my_opts->oids->num > 0 ||
        my_opts->tables->num > 0 ||
        my_opts->filenumbers->num > 0)
    {
        if (!my_opts->quiet)
            printf("From database \"%s\":\n", my_opts->dbname);
        sql_exec_searchtables(pgconn, my_opts);
 
        PQfinish(pgconn);
        exit(0);
    }
 
    /* no elements given; dump the given database */
    if (my_opts->dbname && !my_opts->nodb)
    {
        if (!my_opts->quiet)
            printf("From database \"%s\":\n", my_opts->dbname);
        sql_exec_dumpalltables(pgconn, my_opts);
 
        PQfinish(pgconn);
        exit(0);
    }
 
    /* no database either; dump all databases */
    if (!my_opts->quiet)
        printf("All databases:\n");
    sql_exec_dumpalldbs(pgconn, my_opts);
 
    PQfinish(pgconn);
    return 0;
}

References eary::alloc, options::dbname, exit(), options::filenumbers, get_opts(), options::nodb, eary::num, options::oids, pg_malloc(), PQfinish(), printf, options::quiet, sql_conn(), sql_exec_dumpalldbs(), sql_exec_dumpalltables(), sql_exec_dumpalltbspc(), sql_exec_searchtables(), options::tables, and options::tablespaces.

sql_conn()

PGconn * sql_conn

(

struct options *

my_opts

)

Definition at line 295 of file oid2name.c.

{
    PGconn     *conn;
    char       *password = NULL;
    bool        new_pass;
    PGresult   *res;
 
    /*
     * Start the connection.  Loop until we have a password if requested by
     * backend.
     */
    do
    {
#define PARAMS_ARRAY_SIZE   7
 
        const char *keywords[PARAMS_ARRAY_SIZE];
        const char *values[PARAMS_ARRAY_SIZE];
 
        keywords[0] = "host";
        values[0] = my_opts->hostname;
        keywords[1] = "port";
        values[1] = my_opts->port;
        keywords[2] = "user";
        values[2] = my_opts->username;
        keywords[3] = "password";
        values[3] = password;
        keywords[4] = "dbname";
        values[4] = my_opts->dbname;
        keywords[5] = "fallback_application_name";
        values[5] = my_opts->progname;
        keywords[6] = NULL;
        values[6] = NULL;
 
        new_pass = false;
        conn = PQconnectdbParams(keywords, values, true);
 
        if (!conn)
            pg_fatal("could not connect to database %s",
                     my_opts->dbname);
 
        if (PQstatus(conn) == CONNECTION_BAD &&
            PQconnectionNeedsPassword(conn) &&
            !password)
        {
            PQfinish(conn);
            password = simple_prompt("Password: ", false);
            new_pass = true;
        }
    } while (new_pass);
 
    /* check to see that the backend connection was successfully made */
    if (PQstatus(conn) == CONNECTION_BAD)
    {
        pg_log_error("%s", PQerrorMessage(conn));
        PQfinish(conn);
        exit(1);
    }
 
    res = PQexec(conn, ALWAYS_SECURE_SEARCH_PATH_SQL);
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        pg_log_error("could not clear \"search_path\": %s",
                     PQerrorMessage(conn));
        PQclear(res);
        PQfinish(conn);
        exit(1);
    }
    PQclear(res);
 
    /* return the conn if good */
    return conn;
}

References ALWAYS_SECURE_SEARCH_PATH_SQL, conn, CONNECTION_BAD, options::dbname, exit(), options::hostname, keywords, PARAMS_ARRAY_SIZE, password, pg_fatal, pg_log_error, PGRES_TUPLES_OK, options::port, PQclear(), PQconnectdbParams(), PQconnectionNeedsPassword(), PQerrorMessage(), PQexec(), PQfinish(), PQresultStatus(), PQstatus(), options::progname, res, simple_prompt(), options::username, and values.

Referenced by main().

sql_exec()

int sql_exec	(	PGconn *	conn,
		const char *	todo,
		bool	quiet
	)

Definition at line 372 of file oid2name.c.

{
    PGresult   *res;
 
    int         nfields;
    int         nrows;
    int         i,
                j,
                l;
    int        *length;
    char       *pad;
 
    /* make the call */
    res = PQexec(conn, todo);
 
    /* check and deal with errors */
    if (!res || PQresultStatus(res) > 2)
    {
        pg_log_error("query failed: %s", PQerrorMessage(conn));
        pg_log_error_detail("Query was: %s", todo);
 
        PQclear(res);
        PQfinish(conn);
        exit(1);
    }
 
    /* get the number of fields */
    nrows = PQntuples(res);
    nfields = PQnfields(res);
 
    /* for each field, get the needed width */
    length = (int *) pg_malloc(sizeof(int) * nfields);
    for (j = 0; j < nfields; j++)
        length[j] = strlen(PQfname(res, j));
 
    for (i = 0; i < nrows; i++)
    {
        for (j = 0; j < nfields; j++)
        {
            l = strlen(PQgetvalue(res, i, j));
            if (l > length[j])
                length[j] = strlen(PQgetvalue(res, i, j));
        }
    }
 
    /* print a header */
    if (!quiet)
    {
        for (j = 0, l = 0; j < nfields; j++)
        {
            fprintf(stdout, "%*s", length[j] + 2, PQfname(res, j));
            l += length[j] + 2;
        }
        fprintf(stdout, "\n");
        pad = (char *) pg_malloc(l + 1);
        memset(pad, '-', l);
        pad[l] = '\0';
        fprintf(stdout, "%s\n", pad);
        free(pad);
    }
 
    /* for each row, dump the information */
    for (i = 0; i < nrows; i++)
    {
        for (j = 0; j < nfields; j++)
            fprintf(stdout, "%*s", length[j] + 2, PQgetvalue(res, i, j));
        fprintf(stdout, "\n");
    }
 
    /* cleanup */
    PQclear(res);
    free(length);
 
    return 0;
}

References conn, exit(), fprintf, free, i, j, pg_log_error, pg_log_error_detail, pg_malloc(), PQclear(), PQerrorMessage(), PQexec(), PQfinish(), PQfname(), PQgetvalue(), PQnfields(), PQntuples(), PQresultStatus(), res, and generate_unaccent_rules::stdout.

Referenced by sql_exec_dumpalldbs(), sql_exec_dumpalltables(), sql_exec_dumpalltbspc(), and sql_exec_searchtables().

sql_exec_dumpalldbs()

void sql_exec_dumpalldbs	(	PGconn *	conn,
		struct options *	opts
	)

Definition at line 452 of file oid2name.c.

{
    char        todo[1024];
 
    /* get the oid and database name from the system pg_database table */
    snprintf(todo, sizeof(todo),
             "SELECT d.oid AS \"Oid\", datname AS \"Database Name\", "
             "spcname AS \"Tablespace\" FROM pg_catalog.pg_database d JOIN pg_catalog.pg_tablespace t ON "
             "(dattablespace = t.oid) ORDER BY 2");
 
    sql_exec(conn, todo, opts->quiet);
}

References conn, opts, snprintf, and sql_exec().

Referenced by main().

sql_exec_dumpalltables()

void sql_exec_dumpalltables	(	PGconn *	conn,
		struct options *	opts
	)

Definition at line 469 of file oid2name.c.

{
    char        todo[1024];
    char       *addfields = ",c.oid AS \"Oid\", nspname AS \"Schema\", spcname as \"Tablespace\" ";
 
    snprintf(todo, sizeof(todo),
             "SELECT pg_catalog.pg_relation_filenode(c.oid) as \"Filenode\", relname as \"Table Name\" %s "
             "FROM pg_catalog.pg_class c "
             "  LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace "
             "  LEFT JOIN pg_catalog.pg_database d ON d.datname = pg_catalog.current_database(),"
             "  pg_catalog.pg_tablespace t "
             "WHERE relkind IN (" CppAsString2(RELKIND_RELATION) ","
             CppAsString2(RELKIND_MATVIEW) "%s%s) AND "
             "  %s"
             "      t.oid = CASE"
             "          WHEN reltablespace <> 0 THEN reltablespace"
             "          ELSE dattablespace"
             "      END "
             "ORDER BY relname",
             opts->extended ? addfields : "",
             opts->indexes ? "," CppAsString2(RELKIND_INDEX) "," CppAsString2(RELKIND_SEQUENCE) : "",
             opts->systables ? "," CppAsString2(RELKIND_TOASTVALUE) : "",
             opts->systables ? "" : "n.nspname NOT IN ('pg_catalog', 'information_schema') AND n.nspname !~ '^pg_toast' AND");
 
    sql_exec(conn, todo, opts->quiet);
}

References conn, CppAsString2, opts, snprintf, and sql_exec().

Referenced by main().

sql_exec_dumpalltbspc()

void sql_exec_dumpalltbspc	(	PGconn *	conn,
		struct options *	opts
	)

Definition at line 571 of file oid2name.c.

{
    char        todo[1024];
 
    snprintf(todo, sizeof(todo),
             "SELECT oid AS \"Oid\", spcname as \"Tablespace Name\"\n"
             "FROM pg_catalog.pg_tablespace");
 
    sql_exec(conn, todo, opts->quiet);
}

References conn, opts, snprintf, and sql_exec().

Referenced by main().

sql_exec_searchtables()

void sql_exec_searchtables	(	PGconn *	conn,
		struct options *	opts
	)

Definition at line 501 of file oid2name.c.

{
    char       *todo;
    char       *qualifiers,
               *ptr;
    char       *comma_oids,
               *comma_filenumbers,
               *comma_tables;
    bool        written = false;
    char       *addfields = ",c.oid AS \"Oid\", nspname AS \"Schema\", spcname as \"Tablespace\" ";
 
    /* get tables qualifiers, whether names, filenumbers, or OIDs */
    comma_oids = get_comma_elts(opts->oids);
    comma_tables = get_comma_elts(opts->tables);
    comma_filenumbers = get_comma_elts(opts->filenumbers);
 
    /* 80 extra chars for SQL expression */
    qualifiers = (char *) pg_malloc(strlen(comma_oids) + strlen(comma_tables) +
                                    strlen(comma_filenumbers) + 80);
    ptr = qualifiers;
 
    if (opts->oids->num > 0)
    {
        ptr += sprintf(ptr, "c.oid IN (%s)", comma_oids);
        written = true;
    }
    if (opts->filenumbers->num > 0)
    {
        if (written)
            ptr += sprintf(ptr, " OR ");
        ptr += sprintf(ptr, "pg_catalog.pg_relation_filenode(c.oid) IN (%s)",
                       comma_filenumbers);
        written = true;
    }
    if (opts->tables->num > 0)
    {
        if (written)
            ptr += sprintf(ptr, " OR ");
        sprintf(ptr, "c.relname ~~ ANY (ARRAY[%s])", comma_tables);
    }
    free(comma_oids);
    free(comma_tables);
    free(comma_filenumbers);
 
    /* now build the query */
    todo = psprintf("SELECT pg_catalog.pg_relation_filenode(c.oid) as \"Filenode\", relname as \"Table Name\" %s\n"
                    "FROM pg_catalog.pg_class c\n"
                    "   LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n"
                    "   LEFT JOIN pg_catalog.pg_database d ON d.datname = pg_catalog.current_database(),\n"
                    "   pg_catalog.pg_tablespace t\n"
                    "WHERE relkind IN (" CppAsString2(RELKIND_RELATION) ","
                    CppAsString2(RELKIND_MATVIEW) ","
                    CppAsString2(RELKIND_INDEX) ","
                    CppAsString2(RELKIND_SEQUENCE) ","
                    CppAsString2(RELKIND_TOASTVALUE) ") AND\n"
                    "       t.oid = CASE\n"
                    "           WHEN reltablespace <> 0 THEN reltablespace\n"
                    "           ELSE dattablespace\n"
                    "       END AND\n"
                    "  (%s)\n"
                    "ORDER BY relname\n",
                    opts->extended ? addfields : "",
                    qualifiers);
 
    free(qualifiers);
 
    sql_exec(conn, todo, opts->quiet);
}

References conn, CppAsString2, free, get_comma_elts(), opts, pg_malloc(), psprintf(), sprintf, and sql_exec().

Referenced by main().