oid2name.c

Go to the documentation of this file.

/*
 * oid2name, a PostgreSQL app to map OIDs on the filesystem
 * to table and database names.
 *
 * Originally by
 * B. Palmer, bpalmer@crimelabs.net 1-17-2001
 *
 * contrib/oid2name/oid2name.c
 */
#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"
 
/* an extensible array to keep track of elements to show */
typedef struct
{
    char      **array;
    int         num;
    int         alloc;
} eary;
 
/* these are the opts structures for command line params */
struct options
{
    eary       *tables;
    eary       *oids;
    eary       *filenumbers;
 
    bool        quiet;
    bool        systables;
    bool        indexes;
    bool        nodb;
    bool        extended;
    bool        tablespaces;
 
    char       *dbname;
    char       *hostname;
    char       *port;
    char       *username;
    const char *progname;
};
 
/* function prototypes */
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);
 
/* function to parse command line options and check for some usage errors. */
void
get_opts(int argc, char **argv, struct options *my_opts)
{
    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);
    }
}
 
static void
help(const char *progname)
{
    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);
}
 
/*
 * add_one_elt
 *
 * Add one element to a (possibly empty) eary struct.
 */
void
add_one_elt(char *eltname, eary *eary)
{
    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++;
}
 
/*
 * get_comma_elts
 *
 * Return the elements of an eary as a (freshly allocated) single string, in
 * single quotes, separated by commas and properly escaped for insertion in an
 * SQL statement.
 */
char *
get_comma_elts(eary *eary)
{
    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;
}
 
/* establish connection with database. */
PGconn *
sql_conn(struct options *my_opts)
{
    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;
}
 
/*
 * Actual code to make call to the database and print the output data.
 */
int
sql_exec(PGconn *conn, const char *todo, bool quiet)
{
    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;
}
 
/*
 * Dump all databases.  There are no system objects to worry about.
 */
void
sql_exec_dumpalldbs(PGconn *conn, struct options *opts)
{
    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);
}
 
/*
 * Dump all tables, indexes and sequences in the current database.
 */
void
sql_exec_dumpalltables(PGconn *conn, struct options *opts)
{
    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);
}
 
/*
 * Show oid, filenumber, name, schema and tablespace for each of the
 * given objects in the current database.
 */
void
sql_exec_searchtables(PGconn *conn, struct options *opts)
{
    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);
}
 
void
sql_exec_dumpalltbspc(PGconn *conn, struct options *opts)
{
    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);
}
 
int
main(int argc, char **argv)
{
    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;
}