function.c File Reference

#include "postgres_fe.h"
#include "access/transam.h"
#include "catalog/pg_language_d.h"
#include "pg_upgrade.h"

Include dependency graph for function.c:

Go to the source code of this file.

Functions
static int	library_name_compare (const void *p1, const void *p2)
void	get_loadable_libraries (void)
void	check_loadable_libraries (void)

Function Documentation

check_loadable_libraries()

void check_loadable_libraries

(

void

)

Definition at line 146 of file function.c.

{
    PGconn     *conn = connectToServer(&new_cluster, "template1");
    int         libnum;
    int         was_load_failure = false;
    FILE       *script = NULL;
    char        output_path[MAXPGPATH];
 
    prep_status("Checking for presence of required libraries");
 
    snprintf(output_path, sizeof(output_path), "%s/%s",
             log_opts.basedir, "loadable_libraries.txt");
 
    /*
     * Now we want to sort the library names into order.  This avoids multiple
     * probes of the same library, and ensures that libraries are probed in a
     * consistent order, which is important for reproducible behavior if one
     * library depends on another.
     */
    qsort(os_info.libraries, os_info.num_libraries,
          sizeof(LibraryInfo), library_name_compare);
 
    for (libnum = 0; libnum < os_info.num_libraries; libnum++)
    {
        char       *lib = os_info.libraries[libnum].name;
        int         llen = strlen(lib);
        char        cmd[7 + 2 * MAXPGPATH + 1];
        PGresult   *res;
 
        /* Did the library name change?  Probe it. */
        if (libnum == 0 || strcmp(lib, os_info.libraries[libnum - 1].name) != 0)
        {
            strcpy(cmd, "LOAD '");
            PQescapeStringConn(conn, cmd + strlen(cmd), lib, llen, NULL);
            strcat(cmd, "'");
 
            res = PQexec(conn, cmd);
 
            if (PQresultStatus(res) != PGRES_COMMAND_OK)
            {
                was_load_failure = true;
 
                if (script == NULL && (script = fopen_priv(output_path, "w")) == NULL)
                    pg_fatal("could not open file \"%s\": %s",
                             output_path, strerror(errno));
                fprintf(script, _("could not load library \"%s\": %s"),
                        lib,
                        PQerrorMessage(conn));
            }
            else
                was_load_failure = false;
 
            PQclear(res);
        }
 
        if (was_load_failure)
            fprintf(script, _("In database: %s\n"),
                    old_cluster.dbarr.dbs[os_info.libraries[libnum].dbnum].db_name);
    }
 
    PQfinish(conn);
 
    if (script)
    {
        fclose(script);
        pg_log(PG_REPORT, "fatal");
        pg_fatal("Your installation references loadable libraries that are missing from the\n"
                 "new installation.  You can add these libraries to the new installation,\n"
                 "or remove the functions using them from the old installation.  A list of\n"
                 "problem libraries is in the file:\n"
                 "    %s", output_path);
    }
    else
        check_ok();
}

References _, LogOpts::basedir, check_ok(), conn, connectToServer(), DbInfo::db_name, ClusterInfo::dbarr, LibraryInfo::dbnum, DbInfoArr::dbs, fopen_priv, fprintf, OSInfo::libraries, library_name_compare(), log_opts, MAXPGPATH, LibraryInfo::name, new_cluster, OSInfo::num_libraries, old_cluster, os_info, pg_fatal, pg_log(), PG_REPORT, PGRES_COMMAND_OK, PQclear(), PQerrorMessage(), PQescapeStringConn(), PQexec(), PQfinish(), PQresultStatus(), prep_status(), qsort, res, snprintf, and strerror.

Referenced by check_new_cluster().

get_loadable_libraries()

void get_loadable_libraries

(

void

)

Definition at line 55 of file function.c.

{
    PGresult  **ress;
    int         totaltups;
    int         dbnum;
    int         n_libinfos;
 
    ress = (PGresult **) pg_malloc(old_cluster.dbarr.ndbs * sizeof(PGresult *));
    totaltups = 0;
 
    /* Fetch all library names, removing duplicates within each DB */
    for (dbnum = 0; dbnum < old_cluster.dbarr.ndbs; dbnum++)
    {
        DbInfo     *active_db = &old_cluster.dbarr.dbs[dbnum];
        PGconn     *conn = connectToServer(&old_cluster, active_db->db_name);
 
        /*
         * Fetch all libraries containing non-built-in C functions in this DB.
         */
        ress[dbnum] = executeQueryOrDie(conn,
                                        "SELECT DISTINCT probin "
                                        "FROM pg_catalog.pg_proc "
                                        "WHERE prolang = %u AND "
                                        "probin IS NOT NULL AND "
                                        "oid >= %u;",
                                        ClanguageId,
                                        FirstNormalObjectId);
        totaltups += PQntuples(ress[dbnum]);
 
        PQfinish(conn);
    }
 
    /*
     * Allocate memory for required libraries and logical replication output
     * plugins.
     */
    n_libinfos = totaltups + count_old_cluster_logical_slots();
    os_info.libraries = (LibraryInfo *) pg_malloc(sizeof(LibraryInfo) * n_libinfos);
    totaltups = 0;
 
    for (dbnum = 0; dbnum < old_cluster.dbarr.ndbs; dbnum++)
    {
        PGresult   *res = ress[dbnum];
        int         ntups;
        int         rowno;
        LogicalSlotInfoArr *slot_arr = &old_cluster.dbarr.dbs[dbnum].slot_arr;
 
        ntups = PQntuples(res);
        for (rowno = 0; rowno < ntups; rowno++)
        {
            char       *lib = PQgetvalue(res, rowno, 0);
 
            os_info.libraries[totaltups].name = pg_strdup(lib);
            os_info.libraries[totaltups].dbnum = dbnum;
 
            totaltups++;
        }
        PQclear(res);
 
        /*
         * Store the names of output plugins as well. There is a possibility
         * that duplicated plugins are set, but the consumer function
         * check_loadable_libraries() will avoid checking the same library, so
         * we do not have to consider their uniqueness here.
         */
        for (int slotno = 0; slotno < slot_arr->nslots; slotno++)
        {
            if (slot_arr->slots[slotno].invalid)
                continue;
 
            os_info.libraries[totaltups].name = pg_strdup(slot_arr->slots[slotno].plugin);
            os_info.libraries[totaltups].dbnum = dbnum;
 
            totaltups++;
        }
    }
 
    pg_free(ress);
 
    os_info.num_libraries = totaltups;
}

References conn, connectToServer(), count_old_cluster_logical_slots(), DbInfo::db_name, ClusterInfo::dbarr, LibraryInfo::dbnum, DbInfoArr::dbs, executeQueryOrDie(), FirstNormalObjectId, LogicalSlotInfo::invalid, OSInfo::libraries, LibraryInfo::name, DbInfoArr::ndbs, LogicalSlotInfoArr::nslots, OSInfo::num_libraries, old_cluster, os_info, pg_free(), pg_malloc(), pg_strdup(), LogicalSlotInfo::plugin, PQclear(), PQfinish(), PQgetvalue(), PQntuples(), res, DbInfo::slot_arr, and LogicalSlotInfoArr::slots.

Referenced by check_and_dump_old_cluster().

library_name_compare()

static int library_name_compare ( const void *  p1, const void *  p2  )

static

Definition at line 28 of file function.c.

{
    const char *str1 = ((const LibraryInfo *) p1)->name;
    const char *str2 = ((const LibraryInfo *) p2)->name;
    int         slen1 = strlen(str1);
    int         slen2 = strlen(str2);
    int         cmp = strcmp(str1, str2);
 
    if (slen1 != slen2)
        return slen1 - slen2;
    if (cmp != 0)
        return cmp;
    else
        return ((const LibraryInfo *) p1)->dbnum -
            ((const LibraryInfo *) p2)->dbnum;
}

References cmp(), and p2.

Referenced by check_loadable_libraries().