parallel_slot.h File Reference

#include "fe_utils/connect_utils.h"
#include "libpq-fe.h"

Include dependency graph for parallel_slot.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ParallelSlot
struct	ParallelSlotArray

Typedefs
typedef bool(*	ParallelSlotResultHandler) (PGresult *res, PGconn *conn, void *context)
typedef struct ParallelSlot	ParallelSlot
typedef struct ParallelSlotArray	ParallelSlotArray

Functions
static void	ParallelSlotSetHandler (ParallelSlot *slot, ParallelSlotResultHandler handler, void *context)
static void	ParallelSlotClearHandler (ParallelSlot *slot)
ParallelSlot *	ParallelSlotsGetIdle (ParallelSlotArray *sa, const char *dbname)
ParallelSlotArray *	ParallelSlotsSetup (int numslots, ConnParams *cparams, const char *progname, bool echo, const char *initcmd)
void	ParallelSlotsAdoptConn (ParallelSlotArray *sa, PGconn *conn)
void	ParallelSlotsTerminate (ParallelSlotArray *sa)
bool	ParallelSlotsWaitCompletion (ParallelSlotArray *sa)
bool	TableCommandResultHandler (PGresult *res, PGconn *conn, void *context)

Typedef Documentation

ParallelSlot

typedef struct ParallelSlot ParallelSlot

ParallelSlotArray

typedef struct ParallelSlotArray ParallelSlotArray

ParallelSlotResultHandler

typedef bool(* ParallelSlotResultHandler) (PGresult *res, PGconn *conn, void *context)

Definition at line 18 of file parallel_slot.h.

Function Documentation

ParallelSlotClearHandler()

static void ParallelSlotClearHandler ( ParallelSlot *  slot )

inlinestatic

Definition at line 55 of file parallel_slot.h.

{
    slot->handler = NULL;
    slot->handler_context = NULL;
}

References ParallelSlot::handler, and ParallelSlot::handler_context.

Referenced by ParallelSlotsWaitCompletion(), and wait_on_slots().

ParallelSlotsAdoptConn()

void ParallelSlotsAdoptConn	(	ParallelSlotArray *	sa,
		PGconn *	conn
	)

Definition at line 460 of file parallel_slot.c.

{
    int         offset;
 
    offset = find_unconnected_slot(sa);
    if (offset >= 0)
        sa->slots[offset].connection = conn;
    else
        disconnectDatabase(conn);
}

References conn, disconnectDatabase(), and find_unconnected_slot().

Referenced by main(), reindex_one_database(), and vacuum_one_database().

ParallelSlotSetHandler()

static void ParallelSlotSetHandler ( ParallelSlot *  slot, ParallelSlotResultHandler  handler, void *  context  )

inlinestatic

Definition at line 47 of file parallel_slot.h.

{
    slot->handler = handler;
    slot->handler_context = context;
}

References context, ParallelSlot::handler, and ParallelSlot::handler_context.

Referenced by main(), reindex_one_database(), and vacuum_one_database().

ParallelSlotsGetIdle()

ParallelSlot* ParallelSlotsGetIdle	(	ParallelSlotArray *	sa,
		const char *	dbname
	)

Definition at line 371 of file parallel_slot.c.

{
    int         offset;
 
    Assert(sa);
    Assert(sa->numslots > 0);
 
    while (1)
    {
        /* First choice: a slot already connected to the desired database. */
        offset = find_matching_idle_slot(sa, dbname);
        if (offset >= 0)
        {
            sa->slots[offset].inUse = true;
            return &sa->slots[offset];
        }
 
        /* Second choice: a slot not connected to any database. */
        offset = find_unconnected_slot(sa);
        if (offset >= 0)
        {
            connect_slot(sa, offset, dbname);
            sa->slots[offset].inUse = true;
            return &sa->slots[offset];
        }
 
        /* Third choice: a slot connected to the wrong database. */
        offset = find_any_idle_slot(sa);
        if (offset >= 0)
        {
            disconnectDatabase(sa->slots[offset].connection);
            sa->slots[offset].connection = NULL;
            connect_slot(sa, offset, dbname);
            sa->slots[offset].inUse = true;
            return &sa->slots[offset];
        }
 
        /*
         * Fourth choice: block until one or more slots become available. If
         * any slots hit a fatal error, we'll find out about that here and
         * return NULL.
         */
        if (!wait_on_slots(sa))
            return NULL;
    }
}

References Assert, connect_slot(), dbname, disconnectDatabase(), find_any_idle_slot(), find_matching_idle_slot(), find_unconnected_slot(), and wait_on_slots().

Referenced by main(), reindex_one_database(), and vacuum_one_database().

ParallelSlotsSetup()

ParallelSlotArray* ParallelSlotsSetup	(	int	numslots,
		ConnParams *	cparams,
		const char *	progname,
		bool	echo,
		const char *	initcmd
	)

Definition at line 428 of file parallel_slot.c.

{
    ParallelSlotArray *sa;
 
    Assert(numslots > 0);
    Assert(cparams != NULL);
    Assert(progname != NULL);
 
    sa = (ParallelSlotArray *) palloc0(offsetof(ParallelSlotArray, slots) +
                                       numslots * sizeof(ParallelSlot));
 
    sa->numslots = numslots;
    sa->cparams = cparams;
    sa->progname = progname;
    sa->echo = echo;
    sa->initcmd = initcmd;
 
    return sa;
}

References Assert, palloc0(), and progname.

Referenced by main(), reindex_one_database(), and vacuum_one_database().

ParallelSlotsTerminate()

void ParallelSlotsTerminate

(

ParallelSlotArray *

sa

)

Definition at line 479 of file parallel_slot.c.

{
    int         i;
 
    for (i = 0; i < sa->numslots; i++)
    {
        PGconn     *conn = sa->slots[i].connection;
 
        if (conn == NULL)
            continue;
 
        disconnectDatabase(conn);
    }
}

References conn, disconnectDatabase(), and i.

Referenced by main(), reindex_one_database(), and vacuum_one_database().

ParallelSlotsWaitCompletion()

bool ParallelSlotsWaitCompletion

(

ParallelSlotArray *

sa

)

Definition at line 501 of file parallel_slot.c.

{
    int         i;
 
    for (i = 0; i < sa->numslots; i++)
    {
        if (sa->slots[i].connection == NULL)
            continue;
        if (!consumeQueryResult(&sa->slots[i]))
            return false;
        /* Mark connection as idle */
        sa->slots[i].inUse = false;
        ParallelSlotClearHandler(&sa->slots[i]);
    }
 
    return true;
}

References consumeQueryResult(), i, and ParallelSlotClearHandler().

Referenced by main(), reindex_one_database(), and vacuum_one_database().

TableCommandResultHandler()

bool TableCommandResultHandler	(	PGresult *	res,
		PGconn *	conn,
		void *	context
	)

Definition at line 540 of file parallel_slot.c.

{
    Assert(res != NULL);
    Assert(conn != NULL);
 
    /*
     * If it's an error, report it.  Errors about a missing table are harmless
     * so we continue processing; but die for other errors.
     */
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
    {
        char       *sqlState = PQresultErrorField(res, PG_DIAG_SQLSTATE);
 
        pg_log_error("processing of database \"%s\" failed: %s",
                     PQdb(conn), PQerrorMessage(conn));
 
        if (sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) != 0)
        {
            PQclear(res);
            return false;
        }
    }
 
    return true;
}

References Assert, conn, ERRCODE_UNDEFINED_TABLE, PG_DIAG_SQLSTATE, pg_log_error, PGRES_COMMAND_OK, PQclear(), PQdb(), PQerrorMessage(), PQresultErrorField(), PQresultStatus(), and res.

Referenced by reindex_one_database(), and vacuum_one_database().