for (i = 0; i < dim; i++)
{
if (i > 0)
- appendStringInfo(&buf, ", ");
+ appendStringInfoString(&buf, ", ");
appendStringInfo(&buf, "%.*g", ndig, LL_COORD(cube, i));
}
appendStringInfoChar(&buf, ')');
if (!cube_is_point_internal(cube))
{
- appendStringInfo(&buf, ",(");
+ appendStringInfoString(&buf, ",(");
for (i = 0; i < dim; i++)
{
if (i > 0)
- appendStringInfo(&buf, ", ");
+ appendStringInfoString(&buf, ", ");
appendStringInfo(&buf, "%.*g", ndig, UR_COORD(cube, i));
}
appendStringInfoChar(&buf, ')');
continue;
if (needComma)
- appendStringInfo(&buf, ",");
+ appendStringInfoChar(&buf, ',');
appendStringInfoString(&buf,
quote_ident_cstr(NameStr(tupdesc->attrs[i]->attname)));
needComma = true;
}
- appendStringInfo(&buf, ") VALUES(");
+ appendStringInfoString(&buf, ") VALUES(");
/*
* Note: i is physical column number (counting from 0).
continue;
if (needComma)
- appendStringInfo(&buf, ",");
+ appendStringInfoChar(&buf, ',');
key = get_attnum_pk_pos(pkattnums, pknumatts, i);
pfree(val);
}
else
- appendStringInfo(&buf, "NULL");
+ appendStringInfoString(&buf, "NULL");
needComma = true;
}
- appendStringInfo(&buf, ")");
+ appendStringInfoChar(&buf, ')');
return (buf.data);
}
int pkattnum = pkattnums[i];
if (i > 0)
- appendStringInfo(&buf, " AND ");
+ appendStringInfoString(&buf, " AND ");
appendStringInfoString(&buf,
quote_ident_cstr(NameStr(tupdesc->attrs[pkattnum]->attname)));
appendStringInfo(&buf, " = %s",
quote_literal_cstr(tgt_pkattvals[i]));
else
- appendStringInfo(&buf, " IS NULL");
+ appendStringInfoString(&buf, " IS NULL");
}
return (buf.data);
continue;
if (needComma)
- appendStringInfo(&buf, ", ");
+ appendStringInfoString(&buf, ", ");
appendStringInfo(&buf, "%s = ",
quote_ident_cstr(NameStr(tupdesc->attrs[i]->attname)));
needComma = true;
}
- appendStringInfo(&buf, " WHERE ");
+ appendStringInfoString(&buf, " WHERE ");
for (i = 0; i < pknumatts; i++)
{
int pkattnum = pkattnums[i];
if (i > 0)
- appendStringInfo(&buf, " AND ");
+ appendStringInfoString(&buf, " AND ");
- appendStringInfo(&buf, "%s",
+ appendStringInfoString(&buf,
quote_ident_cstr(NameStr(tupdesc->attrs[pkattnum]->attname)));
val = tgt_pkattvals[i];
if (val != NULL)
appendStringInfo(&buf, " = %s", quote_literal_cstr(val));
else
- appendStringInfo(&buf, " IS NULL");
+ appendStringInfoString(&buf, " IS NULL");
}
return (buf.data);
int pkattnum = pkattnums[i];
if (i > 0)
- appendStringInfo(&buf, " AND ");
+ appendStringInfoString(&buf, " AND ");
appendStringInfoString(&buf,
quote_ident_cstr(NameStr(tupdesc->attrs[pkattnum]->attname)));
appendStringInfo(&buf, " = %s",
quote_literal_cstr(src_pkattvals[i]));
else
- appendStringInfo(&buf, " IS NULL");
+ appendStringInfoString(&buf, " IS NULL");
}
/*
initStringInfo(&buf);
- appendStringInfo(&buf, "\ndigraph sourceNFA {\n");
+ appendStringInfoString(&buf, "\ndigraph sourceNFA {\n");
for (state = 0; state < nstates; state++)
{
appendStringInfo(&buf, "s%d", state);
if (pg_reg_getfinalstate(regex) == state)
- appendStringInfo(&buf, " [shape = doublecircle]");
- appendStringInfo(&buf, ";\n");
+ appendStringInfoString(&buf, " [shape = doublecircle]");
+ appendStringInfoString(&buf, ";\n");
arcsCount = pg_reg_getnumoutarcs(regex, state);
arcs = (regex_arc_t *) palloc(sizeof(regex_arc_t) * arcsCount);
pfree(arcs);
}
- appendStringInfo(&buf, " node [shape = point ]; initial;\n");
+ appendStringInfoString(&buf, " node [shape = point ]; initial;\n");
appendStringInfo(&buf, " initial -> s%d;\n",
pg_reg_getinitialstate(regex));
/* Print colors */
- appendStringInfo(&buf, " { rank = sink;\n");
- appendStringInfo(&buf, " Colors [shape = none, margin=0, label=<\n");
+ appendStringInfoString(&buf, " { rank = sink;\n");
+ appendStringInfoString(&buf, " Colors [shape = none, margin=0, label=<\n");
for (i = 0; i < ncolors; i++)
{
memcpy(s, color->wordChars[j].bytes, MAX_MULTIBYTE_CHAR_LEN);
s[MAX_MULTIBYTE_CHAR_LEN] = '\0';
- appendStringInfo(&buf, "%s", s);
+ appendStringInfoString(&buf, s);
}
}
else
- appendStringInfo(&buf, "not expandable");
- appendStringInfo(&buf, "\n");
+ appendStringInfoString(&buf, "not expandable");
+ appendStringInfoChar(&buf, '\n');
}
- appendStringInfo(&buf, " >];\n");
- appendStringInfo(&buf, " }\n");
- appendStringInfo(&buf, "}\n");
+ appendStringInfoString(&buf, " >];\n");
+ appendStringInfoString(&buf, " }\n");
+ appendStringInfoString(&buf, "}\n");
{
/* dot -Tpng -o /tmp/source.png < /tmp/source.dot */
initStringInfo(&buf);
- appendStringInfo(&buf, "\ndigraph transformedNFA {\n");
+ appendStringInfoString(&buf, "\ndigraph transformedNFA {\n");
hash_seq_init(&scan_status, trgmNFA->states);
while ((state = (TrgmState *) hash_seq_search(&scan_status)) != NULL)
appendStringInfo(&buf, "s%p", (void *) state);
if (state->fin)
- appendStringInfo(&buf, " [shape = doublecircle]");
+ appendStringInfoString(&buf, " [shape = doublecircle]");
if (state->init)
initstate = state;
appendStringInfo(&buf, " [label = \"%d\"]", state->stateKey.nstate);
- appendStringInfo(&buf, ";\n");
+ appendStringInfoString(&buf, ";\n");
foreach(cell, state->arcs)
{
appendStringInfo(&buf, " s%p -> s%p [label = \"",
(void *) state, (void *) arc->target);
printTrgmColor(&buf, arc->ctrgm.colors[0]);
- appendStringInfo(&buf, " ");
+ appendStringInfoChar(&buf, ' ');
printTrgmColor(&buf, arc->ctrgm.colors[1]);
- appendStringInfo(&buf, " ");
+ appendStringInfoChar(&buf, ' ');
printTrgmColor(&buf, arc->ctrgm.colors[2]);
- appendStringInfo(&buf, "\"];\n");
+ appendStringInfoString(&buf, "\"];\n");
}
}
if (initstate)
{
- appendStringInfo(&buf, " node [shape = point ]; initial;\n");
+ appendStringInfoString(&buf, " node [shape = point ]; initial;\n");
appendStringInfo(&buf, " initial -> s%p;\n", (void *) initstate);
}
- appendStringInfo(&buf, "}\n");
+ appendStringInfoString(&buf, "}\n");
{
/* dot -Tpng -o /tmp/transformed.png < /tmp/transformed.dot */
printTrgmColor(StringInfo buf, TrgmColor co)
{
if (co == COLOR_UNKNOWN)
- appendStringInfo(buf, "u");
+ appendStringInfoChar(buf, 'u');
else if (co == COLOR_BLANK)
- appendStringInfo(buf, "b");
+ appendStringInfoChar(buf, 'b');
else
appendStringInfo(buf, "%d", (int) co);
}
initStringInfo(&buf);
- appendStringInfo(&buf, "\ndigraph packedGraph {\n");
+ appendStringInfoString(&buf, "\ndigraph packedGraph {\n");
for (i = 0; i < packedGraph->statesCount; i++)
{
appendStringInfo(&buf, " s%d", i);
if (i == 1)
- appendStringInfo(&buf, " [shape = doublecircle]");
+ appendStringInfoString(&buf, " [shape = doublecircle]");
appendStringInfo(&buf, " [label = <s%d>];\n", i);
}
}
- appendStringInfo(&buf, " node [shape = point ]; initial;\n");
+ appendStringInfoString(&buf, " node [shape = point ]; initial;\n");
appendStringInfo(&buf, " initial -> s%d;\n", 0);
/* Print trigrams */
- appendStringInfo(&buf, " { rank = sink;\n");
- appendStringInfo(&buf, " Trigrams [shape = none, margin=0, label=<\n");
+ appendStringInfoString(&buf, " { rank = sink;\n");
+ appendStringInfoString(&buf, " Trigrams [shape = none, margin=0, label=<\n");
p = GETARR(trigrams);
for (i = 0; i < packedGraph->colorTrigramsCount; i++)
for (j = 0; j < count; j++)
{
if (j > 0)
- appendStringInfo(&buf, ", ");
+ appendStringInfoString(&buf, ", ");
/*
* XXX This representation is nice only for all-ASCII trigrams.
}
}
- appendStringInfo(&buf, " >];\n");
- appendStringInfo(&buf, " }\n");
- appendStringInfo(&buf, "}\n");
+ appendStringInfoString(&buf, " >];\n");
+ appendStringInfoString(&buf, " }\n");
+ appendStringInfoString(&buf, "}\n");
{
/* dot -Tpng -o /tmp/packed.png < /tmp/packed.dot */
if (targetAttrs)
{
- appendStringInfoString(buf, "(");
+ appendStringInfoChar(buf, '(');
first = true;
foreach(lc, targetAttrs)
pindex++;
}
- appendStringInfoString(buf, ")");
+ appendStringInfoChar(buf, ')');
}
else
appendStringInfoString(buf, " DEFAULT VALUES");
initStringInfo(&relname);
deparseRelation(&relname, rel);
- appendStringInfo(buf, "SELECT pg_catalog.pg_relation_size(");
+ appendStringInfoString(buf, "SELECT pg_catalog.pg_relation_size(");
deparseStringLiteral(buf, relname.data);
appendStringInfo(buf, "::pg_catalog.regclass) / %d", BLCKSZ);
}
if (node->constisnull)
{
- appendStringInfo(buf, "NULL");
+ appendStringInfoString(buf, "NULL");
appendStringInfo(buf, "::%s",
format_type_with_typemod(node->consttype,
node->consttypmod));
else
{
/* Just print operator name. */
- appendStringInfo(buf, "%s", opname);
+ appendStringInfoString(buf, opname);
}
}
root->parse->commandType == CMD_DELETE))
{
/* Relation is UPDATE/DELETE target, so use FOR UPDATE */
- appendStringInfo(&sql, " FOR UPDATE");
+ appendStringInfoString(&sql, " FOR UPDATE");
}
else
{
{
case LCS_FORKEYSHARE:
case LCS_FORSHARE:
- appendStringInfo(&sql, " FOR SHARE");
+ appendStringInfoString(&sql, " FOR SHARE");
break;
case LCS_FORNOKEYUPDATE:
case LCS_FORUPDATE:
- appendStringInfo(&sql, " FOR UPDATE");
+ appendStringInfoString(&sql, " FOR UPDATE");
break;
}
}
for (i = 0; i < proc; i++)
{
/* initialize branch for this pass */
- appendStringInfo(&branchstr, "%s", branch);
+ appendStringInfoString(&branchstr, branch);
appendStringInfo(&chk_branchstr, "%s%s%s", branch_delim, branch, branch_delim);
/* get the next sql result tuple */
appendStringInfo(buf, "truncate before: %d", pageno);
}
else
- appendStringInfo(buf, "UNKNOWN");
+ appendStringInfoString(buf, "UNKNOWN");
}
xlrec->db_id, xlrec->tablespace_id);
}
else
- appendStringInfo(buf, "UNKNOWN");
+ appendStringInfoString(buf, "UNKNOWN");
}
switch (info)
{
case XLOG_GIN_CREATE_INDEX:
- appendStringInfo(buf, "Create index, ");
+ appendStringInfoString(buf, "Create index, ");
desc_node(buf, *(RelFileNode *) rec, GIN_ROOT_BLKNO);
break;
case XLOG_GIN_CREATE_PTREE:
- appendStringInfo(buf, "Create posting tree, ");
+ appendStringInfoString(buf, "Create posting tree, ");
desc_node(buf, ((ginxlogCreatePostingTree *) rec)->node, ((ginxlogCreatePostingTree *) rec)->blkno);
break;
case XLOG_GIN_INSERT:
- appendStringInfo(buf, "Insert item, ");
+ appendStringInfoString(buf, "Insert item, ");
desc_node(buf, ((ginxlogInsert *) rec)->node, ((ginxlogInsert *) rec)->blkno);
appendStringInfo(buf, " offset: %u nitem: %u isdata: %c isleaf %c isdelete %c updateBlkno:%u",
((ginxlogInsert *) rec)->offset,
((ginxlogInsert *) rec)->updateBlkno);
break;
case XLOG_GIN_SPLIT:
- appendStringInfo(buf, "Page split, ");
+ appendStringInfoString(buf, "Page split, ");
desc_node(buf, ((ginxlogSplit *) rec)->node, ((ginxlogSplit *) rec)->lblkno);
appendStringInfo(buf, " isrootsplit: %c", (((ginxlogSplit *) rec)->isRootSplit) ? 'T' : 'F');
break;
case XLOG_GIN_VACUUM_PAGE:
- appendStringInfo(buf, "Vacuum page, ");
+ appendStringInfoString(buf, "Vacuum page, ");
desc_node(buf, ((ginxlogVacuumPage *) rec)->node, ((ginxlogVacuumPage *) rec)->blkno);
break;
case XLOG_GIN_DELETE_PAGE:
- appendStringInfo(buf, "Delete page, ");
+ appendStringInfoString(buf, "Delete page, ");
desc_node(buf, ((ginxlogDeletePage *) rec)->node, ((ginxlogDeletePage *) rec)->blkno);
break;
case XLOG_GIN_UPDATE_META_PAGE:
- appendStringInfo(buf, "Update metapage, ");
+ appendStringInfoString(buf, "Update metapage, ");
desc_node(buf, ((ginxlogUpdateMeta *) rec)->node, GIN_METAPAGE_BLKNO);
break;
case XLOG_GIN_INSERT_LISTPAGE:
- appendStringInfo(buf, "Insert new list page, ");
+ appendStringInfoString(buf, "Insert new list page, ");
desc_node(buf, ((ginxlogInsertListPage *) rec)->node, ((ginxlogInsertListPage *) rec)->blkno);
break;
case XLOG_GIN_DELETE_LISTPAGE:
static void
out_gistxlogPageSplit(StringInfo buf, gistxlogPageSplit *xlrec)
{
- appendStringInfo(buf, "page_split: ");
+ appendStringInfoString(buf, "page_split: ");
out_target(buf, xlrec->node);
appendStringInfo(buf, "; block number %u splits to %d pages",
xlrec->origblkno, xlrec->npage);
switch (info)
{
case XLOG_GIST_PAGE_UPDATE:
- appendStringInfo(buf, "page_update: ");
+ appendStringInfoString(buf, "page_update: ");
out_gistxlogPageUpdate(buf, (gistxlogPageUpdate *) rec);
break;
case XLOG_GIST_PAGE_SPLIT:
out_infobits(StringInfo buf, uint8 infobits)
{
if (infobits & XLHL_XMAX_IS_MULTI)
- appendStringInfo(buf, "IS_MULTI ");
+ appendStringInfoString(buf, "IS_MULTI ");
if (infobits & XLHL_XMAX_LOCK_ONLY)
- appendStringInfo(buf, "LOCK_ONLY ");
+ appendStringInfoString(buf, "LOCK_ONLY ");
if (infobits & XLHL_XMAX_EXCL_LOCK)
- appendStringInfo(buf, "EXCL_LOCK ");
+ appendStringInfoString(buf, "EXCL_LOCK ");
if (infobits & XLHL_XMAX_KEYSHR_LOCK)
- appendStringInfo(buf, "KEYSHR_LOCK ");
+ appendStringInfoString(buf, "KEYSHR_LOCK ");
if (infobits & XLHL_KEYS_UPDATED)
- appendStringInfo(buf, "KEYS_UPDATED ");
+ appendStringInfoString(buf, "KEYS_UPDATED ");
}
void
xl_heap_insert *xlrec = (xl_heap_insert *) rec;
if (xl_info & XLOG_HEAP_INIT_PAGE)
- appendStringInfo(buf, "insert(init): ");
+ appendStringInfoString(buf, "insert(init): ");
else
- appendStringInfo(buf, "insert: ");
+ appendStringInfoString(buf, "insert: ");
out_target(buf, &(xlrec->target));
}
else if (info == XLOG_HEAP_DELETE)
{
xl_heap_delete *xlrec = (xl_heap_delete *) rec;
- appendStringInfo(buf, "delete: ");
+ appendStringInfoString(buf, "delete: ");
out_target(buf, &(xlrec->target));
appendStringInfoChar(buf, ' ');
out_infobits(buf, xlrec->infobits_set);
xl_heap_update *xlrec = (xl_heap_update *) rec;
if (xl_info & XLOG_HEAP_INIT_PAGE)
- appendStringInfo(buf, "update(init): ");
+ appendStringInfoString(buf, "update(init): ");
else
- appendStringInfo(buf, "update: ");
+ appendStringInfoString(buf, "update: ");
out_target(buf, &(xlrec->target));
appendStringInfo(buf, " xmax %u ", xlrec->old_xmax);
out_infobits(buf, xlrec->old_infobits_set);
xl_heap_update *xlrec = (xl_heap_update *) rec;
if (xl_info & XLOG_HEAP_INIT_PAGE) /* can this case happen? */
- appendStringInfo(buf, "hot_update(init): ");
+ appendStringInfoString(buf, "hot_update(init): ");
else
- appendStringInfo(buf, "hot_update: ");
+ appendStringInfoString(buf, "hot_update: ");
out_target(buf, &(xlrec->target));
appendStringInfo(buf, " xmax %u ", xlrec->old_xmax);
out_infobits(buf, xlrec->old_infobits_set);
{
xl_heap_inplace *xlrec = (xl_heap_inplace *) rec;
- appendStringInfo(buf, "inplace: ");
+ appendStringInfoString(buf, "inplace: ");
out_target(buf, &(xlrec->target));
}
else
- appendStringInfo(buf, "UNKNOWN");
+ appendStringInfoString(buf, "UNKNOWN");
}
void
heap2_desc(StringInfo buf, uint8 xl_info, char *rec)
xl_heap_multi_insert *xlrec = (xl_heap_multi_insert *) rec;
if (xl_info & XLOG_HEAP_INIT_PAGE)
- appendStringInfo(buf, "multi-insert (init): ");
+ appendStringInfoString(buf, "multi-insert (init): ");
else
- appendStringInfo(buf, "multi-insert: ");
+ appendStringInfoString(buf, "multi-insert: ");
appendStringInfo(buf, "rel %u/%u/%u; blk %u; %d tuples",
xlrec->node.spcNode, xlrec->node.dbNode, xlrec->node.relNode,
xlrec->blkno, xlrec->ntuples);
out_target(buf, &(xlrec->target));
}
else
- appendStringInfo(buf, "UNKNOWN");
+ appendStringInfoString(buf, "UNKNOWN");
}
out_member(buf, &xlrec->members[i]);
}
else
- appendStringInfo(buf, "UNKNOWN");
+ appendStringInfoString(buf, "UNKNOWN");
}
{
xl_btree_insert *xlrec = (xl_btree_insert *) rec;
- appendStringInfo(buf, "insert: ");
+ appendStringInfoString(buf, "insert: ");
out_target(buf, &(xlrec->target));
break;
}
{
xl_btree_insert *xlrec = (xl_btree_insert *) rec;
- appendStringInfo(buf, "insert_upper: ");
+ appendStringInfoString(buf, "insert_upper: ");
out_target(buf, &(xlrec->target));
break;
}
{
xl_btree_insert *xlrec = (xl_btree_insert *) rec;
- appendStringInfo(buf, "insert_meta: ");
+ appendStringInfoString(buf, "insert_meta: ");
out_target(buf, &(xlrec->target));
break;
}
{
xl_btree_delete_page *xlrec = (xl_btree_delete_page *) rec;
- appendStringInfo(buf, "delete_page: ");
+ appendStringInfoString(buf, "delete_page: ");
out_target(buf, &(xlrec->target));
appendStringInfo(buf, "; dead %u; left %u; right %u",
xlrec->deadblk, xlrec->leftblk, xlrec->rightblk);
break;
}
default:
- appendStringInfo(buf, "UNKNOWN");
+ appendStringInfoString(buf, "UNKNOWN");
break;
}
}
xlrec->dbid, xlrec->tsid, xlrec->nbytes);
}
else
- appendStringInfo(buf, "UNKNOWN");
+ appendStringInfoString(buf, "UNKNOWN");
}
xl_seq_rec *xlrec = (xl_seq_rec *) rec;
if (info == XLOG_SEQ_LOG)
- appendStringInfo(buf, "log: ");
+ appendStringInfoString(buf, "log: ");
else
{
- appendStringInfo(buf, "UNKNOWN");
+ appendStringInfoString(buf, "UNKNOWN");
return;
}
pfree(path);
}
else
- appendStringInfo(buf, "UNKNOWN");
+ appendStringInfoString(buf, "UNKNOWN");
}
break;
case XLOG_SPGIST_PICKSPLIT:
out_target(buf, ((spgxlogPickSplit *) rec)->node);
- appendStringInfo(buf, "split leaf page");
+ appendStringInfoString(buf, "split leaf page");
break;
case XLOG_SPGIST_VACUUM_LEAF:
out_target(buf, ((spgxlogVacuumLeaf *) rec)->node);
}
if (xlrec->subxid_overflow)
- appendStringInfo(buf, "; subxid ovf");
+ appendStringInfoString(buf, "; subxid ovf");
}
void
xl_standby_locks *xlrec = (xl_standby_locks *) rec;
int i;
- appendStringInfo(buf, "AccessExclusive locks:");
+ appendStringInfoString(buf, "AccessExclusive locks:");
for (i = 0; i < xlrec->nlocks; i++)
appendStringInfo(buf, " xid %u db %u rel %u",
{
xl_running_xacts *xlrec = (xl_running_xacts *) rec;
- appendStringInfo(buf, "running xacts:");
+ appendStringInfoString(buf, "running xacts:");
standby_desc_running_xacts(buf, xlrec);
}
else
- appendStringInfo(buf, "UNKNOWN");
+ appendStringInfoString(buf, "UNKNOWN");
}
appendStringInfo(buf, "drop tablespace: %u", xlrec->ts_id);
}
else
- appendStringInfo(buf, "UNKNOWN");
+ appendStringInfoString(buf, "UNKNOWN");
}
if (xlrec->nrels > 0)
{
- appendStringInfo(buf, "; rels:");
+ appendStringInfoString(buf, "; rels:");
for (i = 0; i < xlrec->nrels; i++)
{
char *path = relpathperm(xlrec->xnodes[i], MAIN_FORKNUM);
}
if (xlrec->nsubxacts > 0)
{
- appendStringInfo(buf, "; subxacts:");
+ appendStringInfoString(buf, "; subxacts:");
for (i = 0; i < xlrec->nsubxacts; i++)
appendStringInfo(buf, " %u", subxacts[i]);
}
appendStringInfo(buf, "; relcache init file inval dbid %u tsid %u",
xlrec->dbId, xlrec->tsId);
- appendStringInfo(buf, "; inval msgs:");
+ appendStringInfoString(buf, "; inval msgs:");
for (i = 0; i < xlrec->nmsgs; i++)
{
SharedInvalidationMessage *msg = &msgs[i];
appendStringInfo(buf, " relcache %u", msg->rc.relId);
/* not expected, but print something anyway */
else if (msg->id == SHAREDINVALSMGR_ID)
- appendStringInfo(buf, " smgr");
+ appendStringInfoString(buf, " smgr");
/* not expected, but print something anyway */
else if (msg->id == SHAREDINVALRELMAP_ID)
- appendStringInfo(buf, " relmap");
+ appendStringInfoString(buf, " relmap");
else if (msg->id == SHAREDINVALSNAPSHOT_ID)
appendStringInfo(buf, " snapshot %u", msg->sn.relId);
else
if (xlrec->nsubxacts > 0)
{
- appendStringInfo(buf, "; subxacts:");
+ appendStringInfoString(buf, "; subxacts:");
for (i = 0; i < xlrec->nsubxacts; i++)
appendStringInfo(buf, " %u", xlrec->subxacts[i]);
}
appendStringInfoString(buf, timestamptz_to_str(xlrec->xact_time));
if (xlrec->nrels > 0)
{
- appendStringInfo(buf, "; rels:");
+ appendStringInfoString(buf, "; rels:");
for (i = 0; i < xlrec->nrels; i++)
{
char *path = relpathperm(xlrec->xnodes[i], MAIN_FORKNUM);
TransactionId *xacts = (TransactionId *)
&xlrec->xnodes[xlrec->nrels];
- appendStringInfo(buf, "; subxacts:");
+ appendStringInfoString(buf, "; subxacts:");
for (i = 0; i < xlrec->nsubxacts; i++)
appendStringInfo(buf, " %u", xacts[i]);
}
{
int i;
- appendStringInfo(buf, "subxacts:");
+ appendStringInfoString(buf, "subxacts:");
for (i = 0; i < xlrec->nsubxacts; i++)
appendStringInfo(buf, " %u", xlrec->xsub[i]);
{
xl_xact_commit_compact *xlrec = (xl_xact_commit_compact *) rec;
- appendStringInfo(buf, "commit: ");
+ appendStringInfoString(buf, "commit: ");
xact_desc_commit_compact(buf, xlrec);
}
else if (info == XLOG_XACT_COMMIT)
{
xl_xact_commit *xlrec = (xl_xact_commit *) rec;
- appendStringInfo(buf, "commit: ");
+ appendStringInfoString(buf, "commit: ");
xact_desc_commit(buf, xlrec);
}
else if (info == XLOG_XACT_ABORT)
{
xl_xact_abort *xlrec = (xl_xact_abort *) rec;
- appendStringInfo(buf, "abort: ");
+ appendStringInfoString(buf, "abort: ");
xact_desc_abort(buf, xlrec);
}
else if (info == XLOG_XACT_PREPARE)
{
- appendStringInfo(buf, "prepare");
+ appendStringInfoString(buf, "prepare");
}
else if (info == XLOG_XACT_COMMIT_PREPARED)
{
xact_desc_assignment(buf, xlrec);
}
else
- appendStringInfo(buf, "UNKNOWN");
+ appendStringInfoString(buf, "UNKNOWN");
}
}
else if (info == XLOG_NOOP)
{
- appendStringInfo(buf, "xlog no-op");
+ appendStringInfoString(buf, "xlog no-op");
}
else if (info == XLOG_NEXTOID)
{
}
else if (info == XLOG_SWITCH)
{
- appendStringInfo(buf, "xlog switch");
+ appendStringInfoString(buf, "xlog switch");
}
else if (info == XLOG_RESTORE_POINT)
{
timestamptz_to_str(xlrec.end_time));
}
else
- appendStringInfo(buf, "UNKNOWN");
+ appendStringInfoString(buf, "UNKNOWN");
}
xlog_outrec(&buf, rechdr);
if (rdata->data != NULL)
{
- appendStringInfo(&buf, " - ");
+ appendStringInfoString(&buf, " - ");
RmgrTable[rechdr->xl_rmid].rm_desc(&buf, rechdr->xl_info, rdata->data);
}
elog(LOG, "%s", buf.data);
(uint32) (ReadRecPtr >> 32), (uint32) ReadRecPtr,
(uint32) (EndRecPtr >> 32), (uint32) EndRecPtr);
xlog_outrec(&buf, record);
- appendStringInfo(&buf, " - ");
+ appendStringInfoString(&buf, " - ");
RmgrTable[record->xl_rmid].rm_desc(&buf,
record->xl_info,
XLogRecGetData(record));
break;
case OCLASS_TYPE:
- appendStringInfo(&buffer, "type");
+ appendStringInfoString(&buffer, "type");
break;
case OCLASS_CAST:
- appendStringInfo(&buffer, "cast");
+ appendStringInfoString(&buffer, "cast");
break;
case OCLASS_COLLATION:
- appendStringInfo(&buffer, "collation");
+ appendStringInfoString(&buffer, "collation");
break;
case OCLASS_CONSTRAINT:
break;
case OCLASS_CONVERSION:
- appendStringInfo(&buffer, "conversion");
+ appendStringInfoString(&buffer, "conversion");
break;
case OCLASS_DEFAULT:
- appendStringInfo(&buffer, "default value");
+ appendStringInfoString(&buffer, "default value");
break;
case OCLASS_LANGUAGE:
- appendStringInfo(&buffer, "language");
+ appendStringInfoString(&buffer, "language");
break;
case OCLASS_LARGEOBJECT:
- appendStringInfo(&buffer, "large object");
+ appendStringInfoString(&buffer, "large object");
break;
case OCLASS_OPERATOR:
- appendStringInfo(&buffer, "operator");
+ appendStringInfoString(&buffer, "operator");
break;
case OCLASS_OPCLASS:
- appendStringInfo(&buffer, "operator class");
+ appendStringInfoString(&buffer, "operator class");
break;
case OCLASS_OPFAMILY:
- appendStringInfo(&buffer, "operator family");
+ appendStringInfoString(&buffer, "operator family");
break;
case OCLASS_AMOP:
- appendStringInfo(&buffer, "operator of access method");
+ appendStringInfoString(&buffer, "operator of access method");
break;
case OCLASS_AMPROC:
- appendStringInfo(&buffer, "function of access method");
+ appendStringInfoString(&buffer, "function of access method");
break;
case OCLASS_REWRITE:
- appendStringInfo(&buffer, "rule");
+ appendStringInfoString(&buffer, "rule");
break;
case OCLASS_TRIGGER:
- appendStringInfo(&buffer, "trigger");
+ appendStringInfoString(&buffer, "trigger");
break;
case OCLASS_SCHEMA:
- appendStringInfo(&buffer, "schema");
+ appendStringInfoString(&buffer, "schema");
break;
case OCLASS_TSPARSER:
- appendStringInfo(&buffer, "text search parser");
+ appendStringInfoString(&buffer, "text search parser");
break;
case OCLASS_TSDICT:
- appendStringInfo(&buffer, "text search dictionary");
+ appendStringInfoString(&buffer, "text search dictionary");
break;
case OCLASS_TSTEMPLATE:
- appendStringInfo(&buffer, "text search template");
+ appendStringInfoString(&buffer, "text search template");
break;
case OCLASS_TSCONFIG:
- appendStringInfo(&buffer, "text search configuration");
+ appendStringInfoString(&buffer, "text search configuration");
break;
case OCLASS_ROLE:
- appendStringInfo(&buffer, "role");
+ appendStringInfoString(&buffer, "role");
break;
case OCLASS_DATABASE:
- appendStringInfo(&buffer, "database");
+ appendStringInfoString(&buffer, "database");
break;
case OCLASS_TBLSPACE:
- appendStringInfo(&buffer, "tablespace");
+ appendStringInfoString(&buffer, "tablespace");
break;
case OCLASS_FDW:
- appendStringInfo(&buffer, "foreign-data wrapper");
+ appendStringInfoString(&buffer, "foreign-data wrapper");
break;
case OCLASS_FOREIGN_SERVER:
- appendStringInfo(&buffer, "server");
+ appendStringInfoString(&buffer, "server");
break;
case OCLASS_USER_MAPPING:
- appendStringInfo(&buffer, "user mapping");
+ appendStringInfoString(&buffer, "user mapping");
break;
case OCLASS_DEFACL:
- appendStringInfo(&buffer, "default acl");
+ appendStringInfoString(&buffer, "default acl");
break;
case OCLASS_EXTENSION:
- appendStringInfo(&buffer, "extension");
+ appendStringInfoString(&buffer, "extension");
break;
case OCLASS_EVENT_TRIGGER:
- appendStringInfo(&buffer, "event trigger");
+ appendStringInfoString(&buffer, "event trigger");
break;
default:
switch (relForm->relkind)
{
case RELKIND_RELATION:
- appendStringInfo(buffer, "table");
+ appendStringInfoString(buffer, "table");
break;
case RELKIND_INDEX:
- appendStringInfo(buffer, "index");
+ appendStringInfoString(buffer, "index");
break;
case RELKIND_SEQUENCE:
- appendStringInfo(buffer, "sequence");
+ appendStringInfoString(buffer, "sequence");
break;
case RELKIND_TOASTVALUE:
- appendStringInfo(buffer, "toast table");
+ appendStringInfoString(buffer, "toast table");
break;
case RELKIND_VIEW:
- appendStringInfo(buffer, "view");
+ appendStringInfoString(buffer, "view");
break;
case RELKIND_MATVIEW:
- appendStringInfo(buffer, "materialized view");
+ appendStringInfoString(buffer, "materialized view");
break;
case RELKIND_COMPOSITE_TYPE:
- appendStringInfo(buffer, "composite type");
+ appendStringInfoString(buffer, "composite type");
break;
case RELKIND_FOREIGN_TABLE:
- appendStringInfo(buffer, "foreign table");
+ appendStringInfoString(buffer, "foreign table");
break;
default:
/* shouldn't get here */
- appendStringInfo(buffer, "relation");
+ appendStringInfoString(buffer, "relation");
break;
}
if (objectSubId != 0)
- appendStringInfo(buffer, " column");
+ appendStringInfoString(buffer, " column");
ReleaseSysCache(relTup);
}
procForm = (Form_pg_proc) GETSTRUCT(procTup);
if (procForm->proisagg)
- appendStringInfo(buffer, "aggregate");
+ appendStringInfoString(buffer, "aggregate");
else
- appendStringInfo(buffer, "function");
+ appendStringInfoString(buffer, "function");
ReleaseSysCache(procTup);
}
break;
case OCLASS_PROC:
- appendStringInfo(&buffer, "%s",
+ appendStringInfoString(&buffer,
format_procedure_qualified(object->objectId));
break;
case OCLASS_TYPE:
- appendStringInfo(&buffer, "%s",
+ appendStringInfoString(&buffer,
format_type_be_qualified(object->objectId));
break;
elog(ERROR, "cache lookup failed for conversion %u",
object->objectId);
conForm = (Form_pg_conversion) GETSTRUCT(conTup);
- appendStringInfo(&buffer, "%s",
+ appendStringInfoString(&buffer,
quote_identifier(NameStr(conForm->conname)));
ReleaseSysCache(conTup);
break;
elog(ERROR, "cache lookup failed for language %u",
object->objectId);
langForm = (Form_pg_language) GETSTRUCT(langTup);
- appendStringInfo(&buffer, "%s",
+ appendStringInfoString(&buffer,
quote_identifier(NameStr(langForm->lanname)));
ReleaseSysCache(langTup);
break;
break;
case OCLASS_OPERATOR:
- appendStringInfo(&buffer, "%s",
+ appendStringInfoString(&buffer,
format_operator_qualified(object->objectId));
break;
opcForm->opcmethod);
amForm = (Form_pg_am) GETSTRUCT(amTup);
- appendStringInfo(&buffer,
- "%s",
+ appendStringInfoString(&buffer,
quote_qualified_identifier(schema,
NameStr(opcForm->opcname)));
appendStringInfo(&buffer, " for %s",
if (!nspname)
elog(ERROR, "cache lookup failed for namespace %u",
object->objectId);
- appendStringInfo(&buffer, "%s",
+ appendStringInfoString(&buffer,
quote_identifier(nspname));
break;
}
elog(ERROR, "cache lookup failed for text search parser %u",
object->objectId);
formParser = (Form_pg_ts_parser) GETSTRUCT(tup);
- appendStringInfo(&buffer, "%s",
+ appendStringInfoString(&buffer,
quote_identifier(NameStr(formParser->prsname)));
ReleaseSysCache(tup);
break;
elog(ERROR, "cache lookup failed for text search dictionary %u",
object->objectId);
formDict = (Form_pg_ts_dict) GETSTRUCT(tup);
- appendStringInfo(&buffer, "%s",
+ appendStringInfoString(&buffer,
quote_identifier(NameStr(formDict->dictname)));
ReleaseSysCache(tup);
break;
elog(ERROR, "cache lookup failed for text search template %u",
object->objectId);
formTmpl = (Form_pg_ts_template) GETSTRUCT(tup);
- appendStringInfo(&buffer, "%s",
+ appendStringInfoString(&buffer,
quote_identifier(NameStr(formTmpl->tmplname)));
ReleaseSysCache(tup);
break;
elog(ERROR, "cache lookup failed for text search configuration %u",
object->objectId);
formCfg = (Form_pg_ts_config) GETSTRUCT(tup);
- appendStringInfo(&buffer, "%s",
+ appendStringInfoString(&buffer,
quote_identifier(NameStr(formCfg->cfgname)));
ReleaseSysCache(tup);
break;
char *username;
username = GetUserNameFromId(object->objectId);
- appendStringInfo(&buffer, "%s",
+ appendStringInfoString(&buffer,
quote_identifier(username));
break;
}
if (!datname)
elog(ERROR, "cache lookup failed for database %u",
object->objectId);
- appendStringInfo(&buffer, "%s",
+ appendStringInfoString(&buffer,
quote_identifier(datname));
break;
}
if (!tblspace)
elog(ERROR, "cache lookup failed for tablespace %u",
object->objectId);
- appendStringInfo(&buffer, "%s",
+ appendStringInfoString(&buffer,
quote_identifier(tblspace));
break;
}
ForeignDataWrapper *fdw;
fdw = GetForeignDataWrapper(object->objectId);
- appendStringInfo(&buffer, "%s",
- quote_identifier(fdw->fdwname));
+ appendStringInfoString(&buffer, quote_identifier(fdw->fdwname));
break;
}
ForeignServer *srv;
srv = GetForeignServer(object->objectId);
- appendStringInfo(&buffer, "%s",
+ appendStringInfoString(&buffer,
quote_identifier(srv->servername));
break;
}
else
usename = "public";
- appendStringInfo(&buffer, "%s", usename);
+ appendStringInfoString(&buffer, usename);
break;
}
if (!extname)
elog(ERROR, "cache lookup failed for extension %u",
object->objectId);
- appendStringInfo(&buffer, "%s",
- quote_identifier(extname));
+ appendStringInfoString(&buffer, quote_identifier(extname));
break;
}
elog(ERROR, "cache lookup failed for event trigger %u",
object->objectId);
trigForm = (Form_pg_event_trigger) GETSTRUCT(tup);
- appendStringInfo(&buffer, "%s",
+ appendStringInfoString(&buffer,
quote_identifier(NameStr(trigForm->evtname)));
ReleaseSysCache(tup);
break;
relForm = (Form_pg_class) GETSTRUCT(relTup);
schema = get_namespace_name(relForm->relnamespace);
- appendStringInfo(buffer, "%s",
+ appendStringInfoString(buffer,
quote_qualified_identifier(schema,
NameStr(relForm->relname)));
if (((Join *) plan)->jointype != JOIN_INNER)
appendStringInfo(es->str, " %s Join", jointype);
else if (!IsA(plan, NestLoop))
- appendStringInfo(es->str, " Join");
+ appendStringInfoString(es->str, " Join");
}
else
ExplainPropertyText("Join Type", jointype, es);
{
if (es->format == EXPLAIN_FORMAT_TEXT)
- appendStringInfo(es->str, " (never executed)");
+ appendStringInfoString(es->str, " (never executed)");
else if (planstate->instrument->need_timer)
{
ExplainPropertyFloat("Actual Startup Time", 0.0, 3, es);
}
appendStringInfoChar(&buf, '\'');
if (lnext(l) != NULL)
- appendStringInfo(&buf, ", ");
+ appendStringInfoString(&buf, ", ");
}
result = cstring_to_text_with_len(buf.data, buf.len);
{
if (s == NULL || *s == '\0')
{
- appendStringInfo(str, "<>");
+ appendStringInfoString(str, "<>");
return;
}
appendStringInfo(str, "%u [ ", (unsigned int) length);
for (i = 0; i < (Size) sizeof(Datum); i++)
appendStringInfo(str, "%d ", (int) (s[i]));
- appendStringInfo(str, "]");
+ appendStringInfoChar(str, ']');
}
else
{
s = (char *) DatumGetPointer(value);
if (!PointerIsValid(s))
- appendStringInfo(str, "0 [ ]");
+ appendStringInfoString(str, "0 [ ]");
else
{
appendStringInfo(str, "%u [ ", (unsigned int) length);
for (i = 0; i < length; i++)
appendStringInfo(str, "%d ", (int) (s[i]));
- appendStringInfo(str, "]");
+ appendStringInfoChar(str, ']');
}
}
}
WRITE_INT_FIELD(numCols);
- appendStringInfo(str, " :sortColIdx");
+ appendStringInfoString(str, " :sortColIdx");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %d", node->sortColIdx[i]);
- appendStringInfo(str, " :sortOperators");
+ appendStringInfoString(str, " :sortOperators");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %u", node->sortOperators[i]);
- appendStringInfo(str, " :collations");
+ appendStringInfoString(str, " :collations");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %u", node->collations[i]);
- appendStringInfo(str, " :nullsFirst");
+ appendStringInfoString(str, " :nullsFirst");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %s", booltostr(node->nullsFirst[i]));
}
WRITE_INT_FIELD(wtParam);
WRITE_INT_FIELD(numCols);
- appendStringInfo(str, " :dupColIdx");
+ appendStringInfoString(str, " :dupColIdx");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %d", node->dupColIdx[i]);
- appendStringInfo(str, " :dupOperators");
+ appendStringInfoString(str, " :dupOperators");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %u", node->dupOperators[i]);
numCols = list_length(node->mergeclauses);
- appendStringInfo(str, " :mergeFamilies");
+ appendStringInfoString(str, " :mergeFamilies");
for (i = 0; i < numCols; i++)
appendStringInfo(str, " %u", node->mergeFamilies[i]);
- appendStringInfo(str, " :mergeCollations");
+ appendStringInfoString(str, " :mergeCollations");
for (i = 0; i < numCols; i++)
appendStringInfo(str, " %u", node->mergeCollations[i]);
- appendStringInfo(str, " :mergeStrategies");
+ appendStringInfoString(str, " :mergeStrategies");
for (i = 0; i < numCols; i++)
appendStringInfo(str, " %d", node->mergeStrategies[i]);
- appendStringInfo(str, " :mergeNullsFirst");
+ appendStringInfoString(str, " :mergeNullsFirst");
for (i = 0; i < numCols; i++)
appendStringInfo(str, " %d", (int) node->mergeNullsFirst[i]);
}
WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
WRITE_INT_FIELD(numCols);
- appendStringInfo(str, " :grpColIdx");
+ appendStringInfoString(str, " :grpColIdx");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %d", node->grpColIdx[i]);
- appendStringInfo(str, " :grpOperators");
+ appendStringInfoString(str, " :grpOperators");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %u", node->grpOperators[i]);
WRITE_UINT_FIELD(winref);
WRITE_INT_FIELD(partNumCols);
- appendStringInfo(str, " :partColIdx");
+ appendStringInfoString(str, " :partColIdx");
for (i = 0; i < node->partNumCols; i++)
appendStringInfo(str, " %d", node->partColIdx[i]);
- appendStringInfo(str, " :partOperations");
+ appendStringInfoString(str, " :partOperations");
for (i = 0; i < node->partNumCols; i++)
appendStringInfo(str, " %u", node->partOperators[i]);
WRITE_INT_FIELD(ordNumCols);
- appendStringInfo(str, " :ordColIdx");
+ appendStringInfoString(str, " :ordColIdx");
for (i = 0; i < node->ordNumCols; i++)
appendStringInfo(str, " %d", node->ordColIdx[i]);
- appendStringInfo(str, " :ordOperations");
+ appendStringInfoString(str, " :ordOperations");
for (i = 0; i < node->ordNumCols; i++)
appendStringInfo(str, " %u", node->ordOperators[i]);
WRITE_INT_FIELD(numCols);
- appendStringInfo(str, " :grpColIdx");
+ appendStringInfoString(str, " :grpColIdx");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %d", node->grpColIdx[i]);
- appendStringInfo(str, " :grpOperators");
+ appendStringInfoString(str, " :grpOperators");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %u", node->grpOperators[i]);
}
WRITE_INT_FIELD(numCols);
- appendStringInfo(str, " :sortColIdx");
+ appendStringInfoString(str, " :sortColIdx");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %d", node->sortColIdx[i]);
- appendStringInfo(str, " :sortOperators");
+ appendStringInfoString(str, " :sortOperators");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %u", node->sortOperators[i]);
- appendStringInfo(str, " :collations");
+ appendStringInfoString(str, " :collations");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %u", node->collations[i]);
- appendStringInfo(str, " :nullsFirst");
+ appendStringInfoString(str, " :nullsFirst");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %s", booltostr(node->nullsFirst[i]));
}
WRITE_INT_FIELD(numCols);
- appendStringInfo(str, " :uniqColIdx");
+ appendStringInfoString(str, " :uniqColIdx");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %d", node->uniqColIdx[i]);
- appendStringInfo(str, " :uniqOperators");
+ appendStringInfoString(str, " :uniqOperators");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %u", node->uniqOperators[i]);
}
WRITE_ENUM_FIELD(strategy, SetOpStrategy);
WRITE_INT_FIELD(numCols);
- appendStringInfo(str, " :dupColIdx");
+ appendStringInfoString(str, " :dupColIdx");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %d", node->dupColIdx[i]);
- appendStringInfo(str, " :dupOperators");
+ appendStringInfoString(str, " :dupOperators");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %u", node->dupOperators[i]);
WRITE_BOOL_FIELD(constisnull);
WRITE_LOCATION_FIELD(location);
- appendStringInfo(str, " :constvalue ");
+ appendStringInfoString(str, " :constvalue ");
if (node->constisnull)
- appendStringInfo(str, "<>");
+ appendStringInfoString(str, "<>");
else
_outDatum(str, node->constvalue, node->constlen, node->constbyval);
}
opstr = "not";
break;
}
- appendStringInfo(str, " :boolop ");
+ appendStringInfoString(str, " :boolop ");
_outToken(str, opstr);
WRITE_NODE_FIELD(args);
_outPathInfo(StringInfo str, const Path *node)
{
WRITE_ENUM_FIELD(pathtype, NodeTag);
- appendStringInfo(str, " :parent_relids ");
+ appendStringInfoString(str, " :parent_relids ");
_outBitmapset(str, node->parent->relids);
- appendStringInfo(str, " :required_outer ");
+ appendStringInfoString(str, " :required_outer ");
if (node->param_info)
_outBitmapset(str, node->param_info->ppi_req_outer);
else
WRITE_NODE_FIELD(utilityStmt);
break;
default:
- appendStringInfo(str, " :utilityStmt ?");
+ appendStringInfoString(str, " :utilityStmt ?");
break;
}
}
else
- appendStringInfo(str, " :utilityStmt <>");
+ appendStringInfoString(str, " :utilityStmt <>");
WRITE_INT_FIELD(resultRelation);
WRITE_BOOL_FIELD(hasAggs);
switch (node->kind)
{
case AEXPR_OP:
- appendStringInfo(str, " ");
+ appendStringInfoChar(str, ' ');
WRITE_NODE_FIELD(name);
break;
case AEXPR_AND:
- appendStringInfo(str, " AND");
+ appendStringInfoString(str, " AND");
break;
case AEXPR_OR:
- appendStringInfo(str, " OR");
+ appendStringInfoString(str, " OR");
break;
case AEXPR_NOT:
- appendStringInfo(str, " NOT");
+ appendStringInfoString(str, " NOT");
break;
case AEXPR_OP_ANY:
- appendStringInfo(str, " ");
+ appendStringInfoChar(str, ' ');
WRITE_NODE_FIELD(name);
- appendStringInfo(str, " ANY ");
+ appendStringInfoString(str, " ANY ");
break;
case AEXPR_OP_ALL:
- appendStringInfo(str, " ");
+ appendStringInfoChar(str, ' ');
WRITE_NODE_FIELD(name);
- appendStringInfo(str, " ALL ");
+ appendStringInfoString(str, " ALL ");
break;
case AEXPR_DISTINCT:
- appendStringInfo(str, " DISTINCT ");
+ appendStringInfoString(str, " DISTINCT ");
WRITE_NODE_FIELD(name);
break;
case AEXPR_NULLIF:
- appendStringInfo(str, " NULLIF ");
+ appendStringInfoString(str, " NULLIF ");
WRITE_NODE_FIELD(name);
break;
case AEXPR_OF:
- appendStringInfo(str, " OF ");
+ appendStringInfoString(str, " OF ");
WRITE_NODE_FIELD(name);
break;
case AEXPR_IN:
- appendStringInfo(str, " IN ");
+ appendStringInfoString(str, " IN ");
WRITE_NODE_FIELD(name);
break;
default:
- appendStringInfo(str, " ??");
+ appendStringInfoString(str, " ??");
break;
}
{
WRITE_NODE_TYPE("A_CONST");
- appendStringInfo(str, " :val ");
+ appendStringInfoString(str, " :val ");
_outValue(str, &(node->val));
WRITE_LOCATION_FIELD(location);
}
WRITE_BOOL_FIELD(initdeferred);
WRITE_LOCATION_FIELD(location);
- appendStringInfo(str, " :contype ");
+ appendStringInfoString(str, " :contype ");
switch (node->contype)
{
case CONSTR_NULL:
- appendStringInfo(str, "NULL");
+ appendStringInfoString(str, "NULL");
break;
case CONSTR_NOTNULL:
- appendStringInfo(str, "NOT_NULL");
+ appendStringInfoString(str, "NOT_NULL");
break;
case CONSTR_DEFAULT:
- appendStringInfo(str, "DEFAULT");
+ appendStringInfoString(str, "DEFAULT");
WRITE_NODE_FIELD(raw_expr);
WRITE_STRING_FIELD(cooked_expr);
break;
case CONSTR_CHECK:
- appendStringInfo(str, "CHECK");
+ appendStringInfoString(str, "CHECK");
WRITE_BOOL_FIELD(is_no_inherit);
WRITE_NODE_FIELD(raw_expr);
WRITE_STRING_FIELD(cooked_expr);
break;
case CONSTR_PRIMARY:
- appendStringInfo(str, "PRIMARY_KEY");
+ appendStringInfoString(str, "PRIMARY_KEY");
WRITE_NODE_FIELD(keys);
WRITE_NODE_FIELD(options);
WRITE_STRING_FIELD(indexname);
break;
case CONSTR_UNIQUE:
- appendStringInfo(str, "UNIQUE");
+ appendStringInfoString(str, "UNIQUE");
WRITE_NODE_FIELD(keys);
WRITE_NODE_FIELD(options);
WRITE_STRING_FIELD(indexname);
break;
case CONSTR_EXCLUSION:
- appendStringInfo(str, "EXCLUSION");
+ appendStringInfoString(str, "EXCLUSION");
WRITE_NODE_FIELD(exclusions);
WRITE_NODE_FIELD(options);
WRITE_STRING_FIELD(indexname);
break;
case CONSTR_FOREIGN:
- appendStringInfo(str, "FOREIGN_KEY");
+ appendStringInfoString(str, "FOREIGN_KEY");
WRITE_NODE_FIELD(pktable);
WRITE_NODE_FIELD(fk_attrs);
WRITE_NODE_FIELD(pk_attrs);
break;
case CONSTR_ATTR_DEFERRABLE:
- appendStringInfo(str, "ATTR_DEFERRABLE");
+ appendStringInfoString(str, "ATTR_DEFERRABLE");
break;
case CONSTR_ATTR_NOT_DEFERRABLE:
- appendStringInfo(str, "ATTR_NOT_DEFERRABLE");
+ appendStringInfoString(str, "ATTR_NOT_DEFERRABLE");
break;
case CONSTR_ATTR_DEFERRED:
- appendStringInfo(str, "ATTR_DEFERRED");
+ appendStringInfoString(str, "ATTR_DEFERRED");
break;
case CONSTR_ATTR_IMMEDIATE:
- appendStringInfo(str, "ATTR_IMMEDIATE");
+ appendStringInfoString(str, "ATTR_IMMEDIATE");
break;
default:
_outNode(StringInfo str, const void *obj)
{
if (obj == NULL)
- appendStringInfo(str, "<>");
+ appendStringInfoString(str, "<>");
else if (IsA(obj, List) ||IsA(obj, IntList) || IsA(obj, OidList))
_outList(str, obj);
else if (IsA(obj, Integer) ||
*/
initStringInfo(&str);
- appendStringInfo(&str, "! system usage stats:\n");
+ appendStringInfoString(&str, "! system usage stats:\n");
appendStringInfo(&str,
"!\t%ld.%06ld elapsed %ld.%06ld user %ld.%06ld system sec\n",
(long) (elapse_t.tv_sec - Save_t.tv_sec),
format_type_be_qualified(operform->oprleft) :
format_type_be(operform->oprleft));
else
- appendStringInfo(&buf, "NONE,");
+ appendStringInfoString(&buf, "NONE,");
if (operform->oprright)
appendStringInfo(&buf, "%s)",
format_type_be_qualified(operform->oprright) :
format_type_be(operform->oprright));
else
- appendStringInfo(&buf, "NONE)");
+ appendStringInfoString(&buf, "NONE)");
result = buf.data;
querysep = "AND";
queryoids[i] = fk_type;
}
- appendStringInfo(&querybuf, " FOR KEY SHARE OF x");
+ appendStringInfoString(&querybuf, " FOR KEY SHARE OF x");
/* Prepare and save the plan */
qplan = ri_PlanCheck(querybuf.data, riinfo->nkeys, queryoids,
querysep = "AND";
queryoids[i] = pk_type;
}
- appendStringInfo(&querybuf, " FOR KEY SHARE OF x");
+ appendStringInfoString(&querybuf, " FOR KEY SHARE OF x");
/* Prepare and save the plan */
qplan = ri_PlanCheck(querybuf.data, riinfo->nkeys, queryoids,
querysep = "AND";
queryoids[i] = pk_type;
}
- appendStringInfo(&querybuf, " FOR KEY SHARE OF x");
+ appendStringInfoString(&querybuf, " FOR KEY SHARE OF x");
/* Prepare and save the plan */
qplan = ri_PlanCheck(querybuf.data, riinfo->nkeys, queryoids,
querysep = "AND";
queryoids[i] = pk_type;
}
- appendStringInfo(&querybuf, " FOR KEY SHARE OF x");
+ appendStringInfoString(&querybuf, " FOR KEY SHARE OF x");
/* Prepare and save the plan */
qplan = ri_PlanCheck(querybuf.data, riinfo->nkeys, queryoids,
*----------
*/
initStringInfo(&querybuf);
- appendStringInfo(&querybuf, "SELECT ");
+ appendStringInfoString(&querybuf, "SELECT ");
sep = "";
for (i = 0; i < riinfo->nkeys; i++)
{
break;
}
}
- appendStringInfo(&querybuf, ")");
+ appendStringInfoChar(&querybuf, ')');
/*
* Temporarily increase work_mem so that the check query can be executed
if (spirc != SPI_OK_SELECT)
elog(ERROR, "failed to get pg_rewrite tuple for rule %u", ruleoid);
if (SPI_processed != 1)
- appendStringInfo(&buf, "-");
+ appendStringInfoChar(&buf, '-');
else
{
/*
if (spirc != SPI_OK_SELECT)
elog(ERROR, "failed to get pg_rewrite tuple for view %u", viewoid);
if (SPI_processed != 1)
- appendStringInfo(&buf, "Not a view");
+ appendStringInfoString(&buf, "Not a view");
else
{
/*
quote_identifier(tgname));
if (TRIGGER_FOR_BEFORE(trigrec->tgtype))
- appendStringInfo(&buf, "BEFORE");
+ appendStringInfoString(&buf, "BEFORE");
else if (TRIGGER_FOR_AFTER(trigrec->tgtype))
- appendStringInfo(&buf, "AFTER");
+ appendStringInfoString(&buf, "AFTER");
else if (TRIGGER_FOR_INSTEAD(trigrec->tgtype))
- appendStringInfo(&buf, "INSTEAD OF");
+ appendStringInfoString(&buf, "INSTEAD OF");
else
elog(ERROR, "unexpected tgtype value: %d", trigrec->tgtype);
if (TRIGGER_FOR_INSERT(trigrec->tgtype))
{
- appendStringInfo(&buf, " INSERT");
+ appendStringInfoString(&buf, " INSERT");
findx++;
}
if (TRIGGER_FOR_DELETE(trigrec->tgtype))
{
if (findx > 0)
- appendStringInfo(&buf, " OR DELETE");
+ appendStringInfoString(&buf, " OR DELETE");
else
- appendStringInfo(&buf, " DELETE");
+ appendStringInfoString(&buf, " DELETE");
findx++;
}
if (TRIGGER_FOR_UPDATE(trigrec->tgtype))
{
if (findx > 0)
- appendStringInfo(&buf, " OR UPDATE");
+ appendStringInfoString(&buf, " OR UPDATE");
else
- appendStringInfo(&buf, " UPDATE");
+ appendStringInfoString(&buf, " UPDATE");
findx++;
/* tgattr is first var-width field, so OK to access directly */
if (trigrec->tgattr.dim1 > 0)
if (TRIGGER_FOR_TRUNCATE(trigrec->tgtype))
{
if (findx > 0)
- appendStringInfo(&buf, " OR TRUNCATE");
+ appendStringInfoString(&buf, " OR TRUNCATE");
else
- appendStringInfo(&buf, " TRUNCATE");
+ appendStringInfoString(&buf, " TRUNCATE");
findx++;
}
appendStringInfo(&buf, " ON %s ",
appendStringInfo(&buf, "FROM %s ",
generate_relation_name(trigrec->tgconstrrelid, NIL));
if (!trigrec->tgdeferrable)
- appendStringInfo(&buf, "NOT ");
- appendStringInfo(&buf, "DEFERRABLE INITIALLY ");
+ appendStringInfoString(&buf, "NOT ");
+ appendStringInfoString(&buf, "DEFERRABLE INITIALLY ");
if (trigrec->tginitdeferred)
- appendStringInfo(&buf, "DEFERRED ");
+ appendStringInfoString(&buf, "DEFERRED ");
else
- appendStringInfo(&buf, "IMMEDIATE ");
+ appendStringInfoString(&buf, "IMMEDIATE ");
}
if (TRIGGER_FOR_ROW(trigrec->tgtype))
- appendStringInfo(&buf, "FOR EACH ROW ");
+ appendStringInfoString(&buf, "FOR EACH ROW ");
else
- appendStringInfo(&buf, "FOR EACH STATEMENT ");
+ appendStringInfoString(&buf, "FOR EACH STATEMENT ");
/* If the trigger has a WHEN qualification, add that */
value = fastgetattr(ht_trig, Anum_pg_trigger_tgqual,
get_rule_expr(qual, &context, false);
- appendStringInfo(&buf, ") ");
+ appendStringInfoString(&buf, ") ");
}
appendStringInfo(&buf, "EXECUTE PROCEDURE %s(",
for (i = 0; i < trigrec->tgnargs; i++)
{
if (i > 0)
- appendStringInfo(&buf, ", ");
+ appendStringInfoString(&buf, ", ");
simple_quote_literal(&buf, p);
/* advance p to next string embedded in tgargs */
while (*p)
}
/* We deliberately do not put semi-colon at end */
- appendStringInfo(&buf, ")");
+ appendStringInfoChar(&buf, ')');
/* Clean up */
systable_endscan(tgscan);
/* if it supports sort ordering, report DESC and NULLS opts */
if (opt & INDOPTION_DESC)
{
- appendStringInfo(&buf, " DESC");
+ appendStringInfoString(&buf, " DESC");
/* NULLS FIRST is the default in this case */
if (!(opt & INDOPTION_NULLS_FIRST))
- appendStringInfo(&buf, " NULLS LAST");
+ appendStringInfoString(&buf, " NULLS LAST");
}
else
{
if (opt & INDOPTION_NULLS_FIRST)
- appendStringInfo(&buf, " NULLS FIRST");
+ appendStringInfoString(&buf, " NULLS FIRST");
}
}
const char *string;
/* Start off the constraint definition */
- appendStringInfo(&buf, "FOREIGN KEY (");
+ appendStringInfoString(&buf, "FOREIGN KEY (");
/* Fetch and build referencing-column list */
val = SysCacheGetAttr(CONSTROID, tup,
decompile_column_index_array(val, conForm->confrelid, &buf);
- appendStringInfo(&buf, ")");
+ appendStringInfoChar(&buf, ')');
/* Add match type */
switch (conForm->confmatchtype)
/* Start off the constraint definition */
if (conForm->contype == CONSTRAINT_PRIMARY)
- appendStringInfo(&buf, "PRIMARY KEY (");
+ appendStringInfoString(&buf, "PRIMARY KEY (");
else
- appendStringInfo(&buf, "UNIQUE (");
+ appendStringInfoString(&buf, "UNIQUE (");
/* Fetch and build target column list */
val = SysCacheGetAttr(CONSTROID, tup,
decompile_column_index_array(val, conForm->conrelid, &buf);
- appendStringInfo(&buf, ")");
+ appendStringInfoChar(&buf, ')');
indexId = get_constraint_index(constraintId);
* throw an error; if we throw error then this function couldn't
* safely be applied to all rows of pg_constraint.
*/
- appendStringInfo(&buf, "TRIGGER");
+ appendStringInfoString(&buf, "TRIGGER");
break;
case CONSTRAINT_EXCLUSION:
{
}
if (conForm->condeferrable)
- appendStringInfo(&buf, " DEFERRABLE");
+ appendStringInfoString(&buf, " DEFERRABLE");
if (conForm->condeferred)
- appendStringInfo(&buf, " INITIALLY DEFERRED");
+ appendStringInfoString(&buf, " INITIALLY DEFERRED");
if (!conForm->convalidated)
appendStringInfoString(&buf, " NOT VALID");
appendStringInfoString(&buf, prosrc);
appendStringInfoString(&buf, dq.data);
- appendStringInfoString(&buf, "\n");
+ appendStringInfoChar(&buf, '\n');
ReleaseSysCache(langtup);
ReleaseSysCache(proctup);
switch (ev_type)
{
case '1':
- appendStringInfo(buf, "SELECT");
+ appendStringInfoString(buf, "SELECT");
break;
case '2':
- appendStringInfo(buf, "UPDATE");
+ appendStringInfoString(buf, "UPDATE");
break;
case '3':
- appendStringInfo(buf, "INSERT");
+ appendStringInfoString(buf, "INSERT");
break;
case '4':
- appendStringInfo(buf, "DELETE");
+ appendStringInfoString(buf, "DELETE");
break;
default:
if (prettyFlags & PRETTYFLAG_INDENT)
appendStringInfoString(buf, "\n ");
- appendStringInfo(buf, " WHERE ");
+ appendStringInfoString(buf, " WHERE ");
qual = stringToNode(ev_qual);
get_rule_expr(qual, &context, false);
}
- appendStringInfo(buf, " DO ");
+ appendStringInfoString(buf, " DO ");
/* The INSTEAD keyword (if so) */
if (is_instead)
- appendStringInfo(buf, "INSTEAD ");
+ appendStringInfoString(buf, "INSTEAD ");
/* Finally the rules actions */
if (list_length(actions) > 1)
ListCell *action;
Query *query;
- appendStringInfo(buf, "(");
+ appendStringInfoChar(buf, '(');
foreach(action, actions)
{
query = (Query *) lfirst(action);
get_query_def(query, buf, NIL, NULL,
prettyFlags, WRAP_COLUMN_DEFAULT, 0);
if (prettyFlags)
- appendStringInfo(buf, ";\n");
+ appendStringInfoString(buf, ";\n");
else
- appendStringInfo(buf, "; ");
+ appendStringInfoString(buf, "; ");
}
- appendStringInfo(buf, ");");
+ appendStringInfoString(buf, ");");
}
else if (list_length(actions) == 0)
{
- appendStringInfo(buf, "NOTHING;");
+ appendStringInfoString(buf, "NOTHING;");
}
else
{
query = (Query *) linitial(actions);
get_query_def(query, buf, NIL, NULL,
prettyFlags, WRAP_COLUMN_DEFAULT, 0);
- appendStringInfo(buf, ";");
+ appendStringInfoChar(buf, ';');
}
}
if (list_length(actions) != 1)
{
- appendStringInfo(buf, "Not a view");
+ appendStringInfoString(buf, "Not a view");
return;
}
if (ev_type != '1' || !is_instead ||
strcmp(ev_qual, "<>") != 0 || query->commandType != CMD_SELECT)
{
- appendStringInfo(buf, "Not a view");
+ appendStringInfoString(buf, "Not a view");
return;
}
get_query_def(query, buf, NIL, RelationGetDescr(ev_relation),
prettyFlags, wrapColumn, 0);
- appendStringInfo(buf, ";");
+ appendStringInfoChar(buf, ';');
heap_close(ev_relation, AccessShareLock);
}
break;
case CMD_NOTHING:
- appendStringInfo(buf, "NOTHING");
+ appendStringInfoString(buf, "NOTHING");
break;
case CMD_UTILITY:
-PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
if (IsA(query->limitCount, Const) &&
((Const *) query->limitCount)->constisnull)
- appendStringInfo(buf, "ALL");
+ appendStringInfoString(buf, "ALL");
else
get_rule_expr(query->limitCount, context, false);
}
quote_identifier(get_rtable_name(rc->rti,
context)));
if (rc->noWait)
- appendStringInfo(buf, " NOWAIT");
+ appendStringInfoString(buf, " NOWAIT");
}
}
/*
* Build up the query string - first we say SELECT
*/
- appendStringInfo(buf, "SELECT");
+ appendStringInfoString(buf, "SELECT");
/* Add the DISTINCT clause if given */
if (query->distinctClause != NIL)
{
if (query->hasDistinctOn)
{
- appendStringInfo(buf, " DISTINCT ON (");
+ appendStringInfoString(buf, " DISTINCT ON (");
sep = "";
foreach(l, query->distinctClause)
{
false, context);
sep = ", ";
}
- appendStringInfo(buf, ")");
+ appendStringInfoChar(buf, ')');
}
else
- appendStringInfo(buf, " DISTINCT");
+ appendStringInfoString(buf, " DISTINCT");
}
/* Then we tell what to select (the targetlist) */
(int) op->op);
}
if (op->all)
- appendStringInfo(buf, "ALL ");
+ appendStringInfoString(buf, "ALL ");
if (PRETTY_INDENT(context))
appendContextKeyword(context, "", 0, 0, 0);
{
/* ASC is default, so emit nothing for it */
if (srt->nulls_first)
- appendStringInfo(buf, " NULLS FIRST");
+ appendStringInfoString(buf, " NULLS FIRST");
}
else if (srt->sortop == typentry->gt_opr)
{
- appendStringInfo(buf, " DESC");
+ appendStringInfoString(buf, " DESC");
/* DESC defaults to NULLS FIRST */
if (!srt->nulls_first)
- appendStringInfo(buf, " NULLS LAST");
+ appendStringInfoString(buf, " NULLS LAST");
}
else
{
sortcoltype));
/* be specific to eliminate ambiguity */
if (srt->nulls_first)
- appendStringInfo(buf, " NULLS FIRST");
+ appendStringInfoString(buf, " NULLS FIRST");
else
- appendStringInfo(buf, " NULLS LAST");
+ appendStringInfoString(buf, " NULLS LAST");
}
sep = ", ";
}
}
}
if (query->targetList)
- appendStringInfo(buf, ") ");
+ appendStringInfoString(buf, ") ");
if (select_rte)
{
else
{
/* No expressions, so it must be DEFAULT VALUES */
- appendStringInfo(buf, "DEFAULT VALUES");
+ appendStringInfoString(buf, "DEFAULT VALUES");
}
/* Add RETURNING if present */
*/
expr = processIndirection((Node *) tle->expr, context, true);
- appendStringInfo(buf, " = ");
+ appendStringInfoString(buf, " = ");
get_rule_expr(expr, context, false);
}
if (!PRETTY_PAREN(context))
appendStringInfoChar(buf, '(');
get_rule_expr_paren(arg1, context, true, node);
- appendStringInfo(buf, " IS DISTINCT FROM ");
+ appendStringInfoString(buf, " IS DISTINCT FROM ");
get_rule_expr_paren(arg2, context, true, node);
if (!PRETTY_PAREN(context))
appendStringInfoChar(buf, ')');
{
NullIfExpr *nullifexpr = (NullIfExpr *) node;
- appendStringInfo(buf, "NULLIF(");
+ appendStringInfoString(buf, "NULLIF(");
get_rule_expr((Node *) nullifexpr->args, context, true);
appendStringInfoChar(buf, ')');
}
false, node);
while (arg)
{
- appendStringInfo(buf, " AND ");
+ appendStringInfoString(buf, " AND ");
get_rule_expr_paren((Node *) lfirst(arg), context,
false, node);
arg = lnext(arg);
false, node);
while (arg)
{
- appendStringInfo(buf, " OR ");
+ appendStringInfoString(buf, " OR ");
get_rule_expr_paren((Node *) lfirst(arg), context,
false, node);
arg = lnext(arg);
case NOT_EXPR:
if (!PRETTY_PAREN(context))
appendStringInfoChar(buf, '(');
- appendStringInfo(buf, "NOT ");
+ appendStringInfoString(buf, "NOT ");
get_rule_expr_paren(first_arg, context,
false, node);
if (!PRETTY_PAREN(context))
ListCell *lc;
/* As above, this can only happen during EXPLAIN */
- appendStringInfo(buf, "(alternatives: ");
+ appendStringInfoString(buf, "(alternatives: ");
foreach(lc, asplan->subplans)
{
SubPlan *splan = (SubPlan *) lfirst(lc);
if (splan->useHashTable)
appendStringInfo(buf, "hashed %s", splan->plan_name);
else
- appendStringInfo(buf, "%s", splan->plan_name);
+ appendStringInfoString(buf, splan->plan_name);
if (lnext(lc))
- appendStringInfo(buf, " or ");
+ appendStringInfoString(buf, " or ");
}
- appendStringInfo(buf, ")");
+ appendStringInfoChar(buf, ')');
}
break;
appendContextKeyword(context, "WHEN ",
0, 0, 0);
get_rule_expr(w, context, false);
- appendStringInfo(buf, " THEN ");
+ appendStringInfoString(buf, " THEN ");
get_rule_expr((Node *) when->result, context, true);
}
if (!PRETTY_INDENT(context))
* be unable to avoid that (see comments for CaseExpr). If we
* do see one, print it as CASE_TEST_EXPR.
*/
- appendStringInfo(buf, "CASE_TEST_EXPR");
+ appendStringInfoString(buf, "CASE_TEST_EXPR");
}
break;
{
ArrayExpr *arrayexpr = (ArrayExpr *) node;
- appendStringInfo(buf, "ARRAY[");
+ appendStringInfoString(buf, "ARRAY[");
get_rule_expr((Node *) arrayexpr->elements, context, true);
appendStringInfoChar(buf, ']');
* SQL99 allows "ROW" to be omitted when there is more than
* one column, but for simplicity we always print it.
*/
- appendStringInfo(buf, "ROW(");
+ appendStringInfoString(buf, "ROW(");
sep = "";
i = 0;
foreach(arg, rowexpr->args)
if (!tupdesc->attrs[i]->attisdropped)
{
appendStringInfoString(buf, sep);
- appendStringInfo(buf, "NULL");
+ appendStringInfoString(buf, "NULL");
sep = ", ";
}
i++;
ReleaseTupleDesc(tupdesc);
}
- appendStringInfo(buf, ")");
+ appendStringInfoChar(buf, ')');
if (rowexpr->row_format == COERCE_EXPLICIT_CAST)
appendStringInfo(buf, "::%s",
format_type_with_typemod(rowexpr->row_typeid, -1));
* SQL99 allows "ROW" to be omitted when there is more than
* one column, but for simplicity we always print it.
*/
- appendStringInfo(buf, "(ROW(");
+ appendStringInfoString(buf, "(ROW(");
sep = "";
foreach(arg, rcexpr->largs)
{
get_rule_expr(e, context, true);
sep = ", ";
}
- appendStringInfo(buf, "))");
+ appendStringInfoString(buf, "))");
}
break;
{
CoalesceExpr *coalesceexpr = (CoalesceExpr *) node;
- appendStringInfo(buf, "COALESCE(");
+ appendStringInfoString(buf, "COALESCE(");
get_rule_expr((Node *) coalesceexpr->args, context, true);
appendStringInfoChar(buf, ')');
}
switch (minmaxexpr->op)
{
case IS_GREATEST:
- appendStringInfo(buf, "GREATEST(");
+ appendStringInfoString(buf, "GREATEST(");
break;
case IS_LEAST:
- appendStringInfo(buf, "LEAST(");
+ appendStringInfoString(buf, "LEAST(");
break;
}
get_rule_expr((Node *) minmaxexpr->args, context, true);
switch (ntest->nulltesttype)
{
case IS_NULL:
- appendStringInfo(buf, " IS NULL");
+ appendStringInfoString(buf, " IS NULL");
break;
case IS_NOT_NULL:
- appendStringInfo(buf, " IS NOT NULL");
+ appendStringInfoString(buf, " IS NOT NULL");
break;
default:
elog(ERROR, "unrecognized nulltesttype: %d",
switch (btest->booltesttype)
{
case IS_TRUE:
- appendStringInfo(buf, " IS TRUE");
+ appendStringInfoString(buf, " IS TRUE");
break;
case IS_NOT_TRUE:
- appendStringInfo(buf, " IS NOT TRUE");
+ appendStringInfoString(buf, " IS NOT TRUE");
break;
case IS_FALSE:
- appendStringInfo(buf, " IS FALSE");
+ appendStringInfoString(buf, " IS FALSE");
break;
case IS_NOT_FALSE:
- appendStringInfo(buf, " IS NOT FALSE");
+ appendStringInfoString(buf, " IS NOT FALSE");
break;
case IS_UNKNOWN:
- appendStringInfo(buf, " IS UNKNOWN");
+ appendStringInfoString(buf, " IS UNKNOWN");
break;
case IS_NOT_UNKNOWN:
- appendStringInfo(buf, " IS NOT UNKNOWN");
+ appendStringInfoString(buf, " IS NOT UNKNOWN");
break;
default:
elog(ERROR, "unrecognized booltesttype: %d",
break;
case T_CoerceToDomainValue:
- appendStringInfo(buf, "VALUE");
+ appendStringInfoString(buf, "VALUE");
break;
case T_SetToDefault:
- appendStringInfo(buf, "DEFAULT");
+ appendStringInfoString(buf, "DEFAULT");
break;
case T_CurrentOfExpr:
* Always label the type of a NULL constant to prevent misdecisions
* about type when reparsing.
*/
- appendStringInfo(buf, "NULL");
+ appendStringInfoString(buf, "NULL");
if (showtype >= 0)
{
appendStringInfo(buf, "::%s",
case BOOLOID:
if (strcmp(extval, "t") == 0)
- appendStringInfo(buf, "true");
+ appendStringInfoString(buf, "true");
else
- appendStringInfo(buf, "false");
+ appendStringInfoString(buf, "false");
break;
default:
bool need_paren;
if (sublink->subLinkType == ARRAY_SUBLINK)
- appendStringInfo(buf, "ARRAY(");
+ appendStringInfoString(buf, "ARRAY(");
else
appendStringInfoChar(buf, '(');
switch (sublink->subLinkType)
{
case EXISTS_SUBLINK:
- appendStringInfo(buf, "EXISTS ");
+ appendStringInfoString(buf, "EXISTS ");
break;
case ANY_SUBLINK:
if (strcmp(opname, "=") == 0) /* Represent = ANY as IN */
- appendStringInfo(buf, " IN ");
+ appendStringInfoString(buf, " IN ");
else
appendStringInfo(buf, " %s ANY ", opname);
break;
context->indentLevel);
if (need_paren)
- appendStringInfo(buf, "))");
+ appendStringInfoString(buf, "))");
else
appendStringInfoChar(buf, ')');
}
ListCell *lc;
bool first = true;
- appendStringInfo(buf, " USING (");
+ appendStringInfoString(buf, " USING (");
/* Use the assigned names, not what's in usingClause */
foreach(lc, colinfo->usingNames)
{
if (first)
first = false;
else
- appendStringInfo(buf, ", ");
+ appendStringInfoString(buf, ", ");
appendStringInfoString(buf, quote_identifier(colname));
}
appendStringInfoChar(buf, ')');
}
else if (j->quals)
{
- appendStringInfo(buf, " ON ");
+ appendStringInfoString(buf, " ON ");
if (!PRETTY_PAREN(context))
appendStringInfoChar(buf, '(');
get_rule_expr(j->quals, context, false);
first = false;
}
else
- appendStringInfo(buf, ", ");
+ appendStringInfoString(buf, ", ");
appendStringInfoString(buf, quote_identifier(colname));
}
if (!first)
Assert(attname); /* shouldn't be any dropped columns here */
if (i > 0)
- appendStringInfo(buf, ", ");
+ appendStringInfoString(buf, ", ");
appendStringInfo(buf, "%s %s",
quote_identifier(attname),
format_type_with_typemod(atttypid, atttypmod));
errmsg("invalid XML comment")));
initStringInfo(&buf);
- appendStringInfo(&buf, "<!--");
+ appendStringInfoString(&buf, "<!--");
appendStringInfoText(&buf, arg);
- appendStringInfo(&buf, "-->");
+ appendStringInfoString(&buf, "-->");
PG_RETURN_XML_P(stringinfo_to_xmltype(&buf));
#else
for (p = ident; *p; p += pg_mblen(p))
{
if (*p == ':' && (p == ident || fully_escaped))
- appendStringInfo(&buf, "_x003A_");
+ appendStringInfoString(&buf, "_x003A_");
else if (*p == '_' && *(p + 1) == 'x')
- appendStringInfo(&buf, "_x005F_");
+ appendStringInfoString(&buf, "_x005F_");
else if (fully_escaped && p == ident &&
pg_strncasecmp(p, "xml", 3) == 0)
{
if (*p == 'x')
- appendStringInfo(&buf, "_x0078_");
+ appendStringInfoString(&buf, "_x0078_");
else
- appendStringInfo(&buf, "_x0058_");
+ appendStringInfoString(&buf, "_x0058_");
}
else if (escape_period && *p == '.')
- appendStringInfo(&buf, "_x002E_");
+ appendStringInfoString(&buf, "_x002E_");
else
{
pg_wchar u = sqlchar_to_unicode(p);
if (strlen(targetns) > 0)
appendStringInfo(result, " xsi:schemaLocation=\"%s #\"", targetns);
else
- appendStringInfo(result, " xsi:noNamespaceSchemaLocation=\"#\"");
+ appendStringInfoString(result, " xsi:noNamespaceSchemaLocation=\"#\"");
}
- appendStringInfo(result, ">\n");
+ appendStringInfoString(result, ">\n");
}
initStringInfo(&result);
if (a)
- appendStringInfo(&result, "%s",
+ appendStringInfoString(&result,
map_sql_identifier_to_xml_name(a, true, true));
if (b)
appendStringInfo(&result, ".%s",
{
case BPCHAROID:
if (typmod == -1)
- appendStringInfo(&result, "CHAR");
+ appendStringInfoString(&result, "CHAR");
else
appendStringInfo(&result, "CHAR_%d", typmod - VARHDRSZ);
break;
case VARCHAROID:
if (typmod == -1)
- appendStringInfo(&result, "VARCHAR");
+ appendStringInfoString(&result, "VARCHAR");
else
appendStringInfo(&result, "VARCHAR_%d", typmod - VARHDRSZ);
break;
case NUMERICOID:
if (typmod == -1)
- appendStringInfo(&result, "NUMERIC");
+ appendStringInfoString(&result, "NUMERIC");
else
appendStringInfo(&result, "NUMERIC_%d_%d",
((typmod - VARHDRSZ) >> 16) & 0xffff,
(typmod - VARHDRSZ) & 0xffff);
break;
case INT4OID:
- appendStringInfo(&result, "INTEGER");
+ appendStringInfoString(&result, "INTEGER");
break;
case INT2OID:
- appendStringInfo(&result, "SMALLINT");
+ appendStringInfoString(&result, "SMALLINT");
break;
case INT8OID:
- appendStringInfo(&result, "BIGINT");
+ appendStringInfoString(&result, "BIGINT");
break;
case FLOAT4OID:
- appendStringInfo(&result, "REAL");
+ appendStringInfoString(&result, "REAL");
break;
case FLOAT8OID:
- appendStringInfo(&result, "DOUBLE");
+ appendStringInfoString(&result, "DOUBLE");
break;
case BOOLOID:
- appendStringInfo(&result, "BOOLEAN");
+ appendStringInfoString(&result, "BOOLEAN");
break;
case TIMEOID:
if (typmod == -1)
- appendStringInfo(&result, "TIME");
+ appendStringInfoString(&result, "TIME");
else
appendStringInfo(&result, "TIME_%d", typmod);
break;
case TIMETZOID:
if (typmod == -1)
- appendStringInfo(&result, "TIME_WTZ");
+ appendStringInfoString(&result, "TIME_WTZ");
else
appendStringInfo(&result, "TIME_WTZ_%d", typmod);
break;
case TIMESTAMPOID:
if (typmod == -1)
- appendStringInfo(&result, "TIMESTAMP");
+ appendStringInfoString(&result, "TIMESTAMP");
else
appendStringInfo(&result, "TIMESTAMP_%d", typmod);
break;
case TIMESTAMPTZOID:
if (typmod == -1)
- appendStringInfo(&result, "TIMESTAMP_WTZ");
+ appendStringInfoString(&result, "TIMESTAMP_WTZ");
else
appendStringInfo(&result, "TIMESTAMP_WTZ_%d", typmod);
break;
case DATEOID:
- appendStringInfo(&result, "DATE");
+ appendStringInfoString(&result, "DATE");
break;
case XMLOID:
- appendStringInfo(&result, "XML");
+ appendStringInfoString(&result, "XML");
break;
default:
{
if (typeoid == XMLOID)
{
- appendStringInfo(&result,
+ appendStringInfoString(&result,
"<xsd:complexType mixed=\"true\">\n"
" <xsd:sequence>\n"
" <xsd:any name=\"element\" minOccurs=\"0\" maxOccurs=\"unbounded\" processContents=\"skip\"/>\n"
appendStringInfo(&result,
" <xsd:maxLength value=\"%d\"/>\n",
typmod - VARHDRSZ);
- appendStringInfo(&result,
- " </xsd:restriction>\n");
+ appendStringInfoString(&result, " </xsd:restriction>\n");
break;
case BYTEAOID:
break;
case FLOAT4OID:
- appendStringInfo(&result,
+ appendStringInfoString(&result,
" <xsd:restriction base=\"xsd:float\"></xsd:restriction>\n");
break;
case FLOAT8OID:
- appendStringInfo(&result,
+ appendStringInfoString(&result,
" <xsd:restriction base=\"xsd:double\"></xsd:restriction>\n");
break;
case BOOLOID:
- appendStringInfo(&result,
+ appendStringInfoString(&result,
" <xsd:restriction base=\"xsd:boolean\"></xsd:restriction>\n");
break;
}
case DATEOID:
- appendStringInfo(&result,
+ appendStringInfoString(&result,
" <xsd:restriction base=\"xsd:date\">\n"
" <xsd:pattern value=\"\\p{Nd}{4}-\\p{Nd}{2}-\\p{Nd}{2}\"/>\n"
" </xsd:restriction>\n");
}
break;
}
- appendStringInfo(&result,
- "</xsd:simpleType>\n");
+ appendStringInfoString(&result, "</xsd:simpleType>\n");
}
return result.data;
}
if (details.len == 0)
- appendStringInfo(&details,
+ appendStringInfoString(&details,
_("Magic block has unexpected length or padding difference."));
ereport(ERROR,
A_Const *con;
if (l != list_head(args))
- appendStringInfo(&buf, ", ");
+ appendStringInfoString(&buf, ", ");
if (IsA(arg, TypeCast))
{
projects / postgresql.git / commitdiff