/*
* cdbdisp_dispatchCommand:
* Send the strCommand SQL statement to all segdbs in the cluster
* cancelOnError indicates whether an error
* occurring on one of the qExec segdbs should cause all still-executing commands to cancel
* on other qExecs. Normally this would be true. The commands are sent over the libpq
* connections that were established during gang creation. They are run inside of threads.
* The number of segdbs handled by any one thread is determined by the
* guc variable gp_connections_per_thread.
*
* The CdbDispatchResults objects allocated for the command
* are returned in *pPrimaryResults
* The caller, after calling CdbCheckDispatchResult(), can
* examine the CdbDispatchResults objects, can keep them as
* long as needed, and ultimately must free them with
* cdbdisp_destroyDispatcherState() prior to deallocation
* of the memory context from which they were allocated.
*
* NB: Callers should use PG_TRY()/PG_CATCH() if needed to make
* certain that the CdbDispatchResults objects are destroyed by
* cdbdisp_destroyDispatcherState() in case of error.
* To wait for completion, check for errors, and clean up, it is
* suggested that the caller use cdbdisp_finishCommand().
*/
void
cdbdisp_dispatchCommand(const char *strCommand,
char *serializedQuerytree,
int serializedQuerytreelen,
bool cancelOnError,
bool needTwoPhase,
bool withSnapshot, CdbDispatcherState * ds)
{
DispatchCommandQueryParms queryParms;
Gang *primaryGang;
int nsegdb = getgpsegmentCount();
CdbComponentDatabaseInfo *qdinfo;
if (log_dispatch_stats)
ResetUsage();
if (DEBUG5 >= log_min_messages)
elog(DEBUG3, "cdbdisp_dispatchCommand: %s (needTwoPhase = %s)",
strCommand, (needTwoPhase ? "true" : "false"));
else
elog((Debug_print_full_dtm ? LOG : DEBUG3),
"cdbdisp_dispatchCommand: %.50s (needTwoPhase = %s)", strCommand,
(needTwoPhase ? "true" : "false"));
MemSet(&queryParms, 0, sizeof(queryParms));
queryParms.strCommand = strCommand;
queryParms.serializedQuerytree = serializedQuerytree;
queryParms.serializedQuerytreelen = serializedQuerytreelen;
/*
* Allocate a primary QE for every available segDB in the system.
*/
primaryGang = allocateWriterGang();
Assert(primaryGang);
/*
* Serialize a version of our DTX Context Info
*/
queryParms.serializedDtxContextInfo =
qdSerializeDtxContextInfo(&queryParms.serializedDtxContextInfolen,
withSnapshot, false,
mppTxnOptions(needTwoPhase),
"cdbdisp_dispatchCommand");
/*
* sequence server info
*/
qdinfo = &(getComponentDatabases()->entry_db_info[0]);
Assert(qdinfo != NULL && qdinfo->hostip != NULL);
queryParms.seqServerHost = pstrdup(qdinfo->hostip);
queryParms.seqServerHostlen = strlen(qdinfo->hostip) + 1;
queryParms.seqServerPort = seqServerCtl->seqServerPort;
/*
* Dispatch the command.
*/
ds->primaryResults = NULL;
ds->dispatchThreads = NULL;
cdbdisp_makeDispatcherState(ds, nsegdb, 0, cancelOnError);
cdbdisp_queryParmsInit(ds, &queryParms);
ds->primaryResults->writer_gang = primaryGang;
cdbdisp_dispatchToGang(ds, primaryGang, -1, DEFAULT_DISP_DIRECT);
/*
* don't pfree serializedShapshot here, it will be pfree'd when
* the first thread is destroyed.
*/
}
/*
* Reads the GP catalog tables and build a CdbComponentDatabases structure.
* It then converts this to a Gang structure and initializes all the non-connection related fields.
*
* Call this function in GangContext.
* Returns a not-null pointer.
*/
Gang *
buildGangDefinition(GangType type, int gang_id, int size, int content)
{
Gang *newGangDefinition = NULL;
CdbComponentDatabaseInfo *cdbinfo = NULL;
CdbComponentDatabaseInfo *cdbInfoCopy = NULL;
SegmentDatabaseDescriptor *segdbDesc = NULL;
MemoryContext perGangContext = NULL;
int segCount = 0;
int i = 0;
ELOG_DISPATCHER_DEBUG("buildGangDefinition:Starting %d qExec processes for %s gang",
size, gangTypeToString(type));
Assert(CurrentMemoryContext == GangContext);
Assert(size == 1 || size == getgpsegmentCount());
/* read gp_segment_configuration and build CdbComponentDatabases */
cdb_component_dbs = getComponentDatabases();
if (cdb_component_dbs == NULL ||
cdb_component_dbs->total_segments <= 0 ||
cdb_component_dbs->total_segment_dbs <= 0)
insist_log(false, "schema not populated while building segworker group");
/* if mirroring is not configured */
if (cdb_component_dbs->total_segment_dbs == cdb_component_dbs->total_segments)
{
ELOG_DISPATCHER_DEBUG("building Gang: mirroring not configured");
disableFTS();
}
perGangContext = AllocSetContextCreate(GangContext, "Per Gang Context",
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
Assert(perGangContext != NULL);
MemoryContextSwitchTo(perGangContext);
/* allocate a gang */
newGangDefinition = (Gang *) palloc0(sizeof(Gang));
newGangDefinition->type = type;
newGangDefinition->size = size;
newGangDefinition->gang_id = gang_id;
newGangDefinition->allocated = false;
newGangDefinition->noReuse = false;
newGangDefinition->dispatcherActive = false;
newGangDefinition->portal_name = NULL;
newGangDefinition->perGangContext = perGangContext;
newGangDefinition->db_descriptors =
(SegmentDatabaseDescriptor *) palloc0(size * sizeof(SegmentDatabaseDescriptor));
/* initialize db_descriptors */
switch (type)
{
case GANGTYPE_ENTRYDB_READER:
cdbinfo = &cdb_component_dbs->entry_db_info[0];
cdbInfoCopy = copyCdbComponentDatabaseInfo(cdbinfo);
segdbDesc = &newGangDefinition->db_descriptors[0];
cdbconn_initSegmentDescriptor(segdbDesc, cdbInfoCopy);
setQEIdentifier(segdbDesc, -1, perGangContext);
break;
case GANGTYPE_SINGLETON_READER:
cdbinfo = findDatabaseInfoBySegIndex(cdb_component_dbs, content);
cdbInfoCopy = copyCdbComponentDatabaseInfo(cdbinfo);
segdbDesc = &newGangDefinition->db_descriptors[0];
cdbconn_initSegmentDescriptor(segdbDesc, cdbInfoCopy);
setQEIdentifier(segdbDesc, -1, perGangContext);
break;
case GANGTYPE_PRIMARY_READER:
case GANGTYPE_PRIMARY_WRITER:
/*
* We loop through the segment_db_info. Each item has a segindex.
* They are sorted by segindex, and there can be > 1 segment_db_info for
* a given segindex (currently, there can be 1 or 2)
*/
for (i = 0; i < cdb_component_dbs->total_segment_dbs; i++)
{
cdbinfo = &cdb_component_dbs->segment_db_info[i];
if (SEGMENT_IS_ACTIVE_PRIMARY(cdbinfo))
{
segdbDesc = &newGangDefinition->db_descriptors[segCount];
cdbInfoCopy = copyCdbComponentDatabaseInfo(cdbinfo);
cdbconn_initSegmentDescriptor(segdbDesc, cdbInfoCopy);
setQEIdentifier(segdbDesc, -1, perGangContext);
segCount++;
}
}
if (size != segCount)
{
FtsReConfigureMPP(false);
elog(ERROR, "Not all primary segment instances are active and connected");
}
break;
default:
Assert(false);
}
ELOG_DISPATCHER_DEBUG("buildGangDefinition done");
MemoryContextSwitchTo(GangContext);
return newGangDefinition;
}
/*
* Compose and dispatch the MPPEXEC commands corresponding to a plan tree
* within a complete parallel plan. (A plan tree will correspond either
* to an initPlan or to the main plan.)
*
* If cancelOnError is true, then any dispatching error, a cancellation
* request from the client, or an error from any of the associated QEs,
* may cause the unfinished portion of the plan to be abandoned or canceled;
* and in the event this occurs before all gangs have been dispatched, this
* function does not return, but waits for all QEs to stop and exits to
* the caller's error catcher via ereport(ERROR,...).Otherwise this
* function returns normally and errors are not reported until later.
*
* If cancelOnError is false, the plan is to be dispatched as fully as
* possible and the QEs allowed to proceed regardless of cancellation
* requests, errors or connection failures from other QEs, etc.
*
* The CdbDispatchResults objects allocated for the plan are returned
* in *pPrimaryResults. The caller, after calling
* CdbCheckDispatchResult(), can examine the CdbDispatchResults
* objects, can keep them as long as needed, and ultimately must free
* them with cdbdisp_destroyDispatcherState() prior to deallocation of
* the caller's memory context. Callers should use PG_TRY/PG_CATCH to
* ensure proper cleanup.
*
* To wait for completion, check for errors, and clean up, it is
* suggested that the caller use cdbdisp_finishCommand().
*
* Note that the slice tree dispatched is the one specified in the EState
* of the argument QueryDesc as es_cur__slice.
*
* Note that the QueryDesc params must include PARAM_EXEC_REMOTE parameters
* containing the values of any initplans required by the slice to be run.
* (This is handled by calls to addRemoteExecParamsToParamList() from the
* functions preprocess_initplans() and ExecutorRun().)
*
* Each QE receives its assignment as a message of type 'M' in PostgresMain().
* The message is deserialized and processed by exec_mpp_query() in postgres.c.
*/
void
cdbdisp_dispatchPlan(struct QueryDesc *queryDesc,
bool planRequiresTxn,
bool cancelOnError, struct CdbDispatcherState *ds)
{
char *splan,
*sddesc,
*sparams;
int splan_len,
splan_len_uncompressed,
sddesc_len,
sparams_len;
SliceTable *sliceTbl;
int rootIdx;
int oldLocalSlice;
PlannedStmt *stmt;
bool is_SRI;
DispatchCommandQueryParms queryParms;
CdbComponentDatabaseInfo *qdinfo;
ds->primaryResults = NULL;
ds->dispatchThreads = NULL;
Assert(Gp_role == GP_ROLE_DISPATCH);
Assert(queryDesc != NULL && queryDesc->estate != NULL);
/*
* Later we'll need to operate with the slice table provided via the
* EState structure in the argument QueryDesc. Cache this information
* locally and assert our expectations about it.
*/
sliceTbl = queryDesc->estate->es_sliceTable;
rootIdx = RootSliceIndex(queryDesc->estate);
Assert(sliceTbl != NULL);
Assert(rootIdx == 0 ||
(rootIdx > sliceTbl->nMotions
&& rootIdx <= sliceTbl->nMotions + sliceTbl->nInitPlans));
/*
* Keep old value so we can restore it. We use this field as a parameter.
*/
oldLocalSlice = sliceTbl->localSlice;
/*
* This function is called only for planned statements.
*/
stmt = queryDesc->plannedstmt;
Assert(stmt);
/*
* Let's evaluate STABLE functions now, so we get consistent values on the QEs
*
* Also, if this is a single-row INSERT statement, let's evaluate
* nextval() and currval() now, so that we get the QD's values, and a
* consistent value for everyone
*
*/
is_SRI = false;
if (queryDesc->operation == CMD_INSERT)
{
Assert(stmt->commandType == CMD_INSERT);
/*
* We might look for constant input relation (instead of SRI), but I'm afraid
* * that wouldn't scale.
*/
is_SRI = IsA(stmt->planTree, Result)
&& stmt->planTree->lefttree == NULL;
}
if (!is_SRI)
clear_relsize_cache();
if (queryDesc->operation == CMD_INSERT ||
queryDesc->operation == CMD_SELECT ||
queryDesc->operation == CMD_UPDATE ||
queryDesc->operation == CMD_DELETE)
{
MemoryContext oldContext;
oldContext = CurrentMemoryContext;
if (stmt->qdContext)
{
oldContext = MemoryContextSwitchTo(stmt->qdContext);
}
else
/*
* memory context of plan tree should not change
*/
{
MemoryContext mc = GetMemoryChunkContext(stmt->planTree);
oldContext = MemoryContextSwitchTo(mc);
}
stmt->planTree = (Plan *) exec_make_plan_constant(stmt, is_SRI);
MemoryContextSwitchTo(oldContext);
}
/*
* Cursor queries and bind/execute path queries don't run on the
* writer-gang QEs; but they require snapshot-synchronization to
* get started.
*
* initPlans, and other work (see the function pre-evaluation
* above) may advance the snapshot "segmateSync" value, so we're
* best off setting the shared-snapshot-ready value here. This
* will dispatch to the writer gang and force it to set its
* snapshot; we'll then be able to serialize the same snapshot
* version (see qdSerializeDtxContextInfo() below).
*/
if (queryDesc->extended_query)
{
verify_shared_snapshot_ready();
}
/*
* serialized plan tree. Note that we're called for a single
* slice tree (corresponding to an initPlan or the main plan), so the
* parameters are fixed and we can include them in the prefix.
*/
splan = serializeNode((Node *) queryDesc->plannedstmt,
&splan_len, &splan_len_uncompressed);
uint64 plan_size_in_kb = ((uint64) splan_len_uncompressed) / (uint64) 1024;
if (0 < gp_max_plan_size && plan_size_in_kb > gp_max_plan_size)
{
ereport(ERROR,
(errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
(errmsg("Query plan size limit exceeded, current size: "
UINT64_FORMAT "KB, max allowed size: %dKB",
plan_size_in_kb, gp_max_plan_size),
errhint("Size controlled by gp_max_plan_size"))));
}
Assert(splan != NULL && splan_len > 0 && splan_len_uncompressed > 0);
if (queryDesc->params != NULL && queryDesc->params->numParams > 0)
{
ParamListInfoData *pli;
ParamExternData *pxd;
StringInfoData parambuf;
Size length;
int plioff;
int32 iparam;
/*
* Allocate buffer for params
*/
initStringInfo(¶mbuf);
/*
* Copy ParamListInfoData header and ParamExternData array
*/
pli = queryDesc->params;
length = (char *) &pli->params[pli->numParams] - (char *) pli;
plioff = parambuf.len;
Assert(plioff == MAXALIGN(plioff));
appendBinaryStringInfo(¶mbuf, pli, length);
/*
* Copy pass-by-reference param values.
*/
for (iparam = 0; iparam < queryDesc->params->numParams; iparam++)
{
int16 typlen;
bool typbyval;
/*
* Recompute pli each time in case parambuf.data is repalloc'ed
*/
pli = (ParamListInfoData *) (parambuf.data + plioff);
pxd = &pli->params[iparam];
if (pxd->ptype == InvalidOid)
continue;
/*
* Does pxd->value contain the value itself, or a pointer?
*/
get_typlenbyval(pxd->ptype, &typlen, &typbyval);
if (!typbyval)
{
char *s = DatumGetPointer(pxd->value);
if (pxd->isnull || !PointerIsValid(s))
{
pxd->isnull = true;
pxd->value = 0;
}
else
{
length = datumGetSize(pxd->value, typbyval, typlen);
/*
* We *must* set this before we
* append. Appending may realloc, which will
* invalidate our pxd ptr. (obviously we could
* append first if we recalculate pxd from the new
* base address)
*/
pxd->value = Int32GetDatum(length);
appendBinaryStringInfo(¶mbuf, &iparam, sizeof(iparam));
appendBinaryStringInfo(¶mbuf, s, length);
}
}
}
sparams = parambuf.data;
sparams_len = parambuf.len;
}
else
{
sparams = NULL;
sparams_len = 0;
}
sddesc = serializeNode((Node *) queryDesc->ddesc, &sddesc_len, NULL /*uncompressed_size */ );
MemSet(&queryParms, 0, sizeof(queryParms));
queryParms.strCommand = queryDesc->sourceText;
queryParms.serializedQuerytree = NULL;
queryParms.serializedQuerytreelen = 0;
queryParms.serializedPlantree = splan;
queryParms.serializedPlantreelen = splan_len;
queryParms.serializedParams = sparams;
queryParms.serializedParamslen = sparams_len;
queryParms.serializedQueryDispatchDesc = sddesc;
queryParms.serializedQueryDispatchDesclen = sddesc_len;
queryParms.rootIdx = rootIdx;
/*
* sequence server info
*/
qdinfo = &(getComponentDatabases()->entry_db_info[0]);
Assert(qdinfo != NULL && qdinfo->hostip != NULL);
queryParms.seqServerHost = pstrdup(qdinfo->hostip);
queryParms.seqServerHostlen = strlen(qdinfo->hostip) + 1;
queryParms.seqServerPort = seqServerCtl->seqServerPort;
/*
* serialized a version of our snapshot
*/
/*
* Generate our transction isolations. We generally want Plan
* based dispatch to be in a global transaction. The executor gets
* to decide if the special circumstances exist which allow us to
* dispatch without starting a global xact.
*/
queryParms.serializedDtxContextInfo =
qdSerializeDtxContextInfo(&queryParms.serializedDtxContextInfolen,
true /* wantSnapshot */ ,
queryDesc->extended_query,
mppTxnOptions(planRequiresTxn),
"cdbdisp_dispatchPlan");
cdbdisp_dispatchX(&queryParms, cancelOnError, sliceTbl, ds);
sliceTbl->localSlice = oldLocalSlice;
}
