char *curname = NULL;
char *sql = NULL;
char *conname = NULL;
- StringInfo str = makeStringInfo();
+ StringInfoData buf;
remoteConn *rconn = NULL;
bool fail = true; /* default to backward compatible behavior */
DBLINK_INIT;
+ initStringInfo(&buf);
if (PG_NARGS() == 2)
{
if (rconn->newXactForCursor)
(rconn->openCursorCount)++;
- appendStringInfo(str, "DECLARE %s CURSOR FOR %s", curname, sql);
- res = PQexec(conn, str->data);
+ appendStringInfo(&buf, "DECLARE %s CURSOR FOR %s", curname, sql);
+ res = PQexec(conn, buf.data);
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
{
if (fail)
PGresult *res = NULL;
char *curname = NULL;
char *conname = NULL;
- StringInfo str = makeStringInfo();
+ StringInfoData buf;
char *msg;
remoteConn *rconn = NULL;
bool fail = true; /* default to backward compatible behavior */
DBLINK_INIT;
+ initStringInfo(&buf);
if (PG_NARGS() == 1)
{
else
conn = rconn->conn;
- appendStringInfo(str, "CLOSE %s", curname);
+ appendStringInfo(&buf, "CLOSE %s", curname);
/* close the cursor */
- res = PQexec(conn, str->data);
+ res = PQexec(conn, buf.data);
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
{
if (fail)
if (SRF_IS_FIRSTCALL())
{
PGconn *conn = NULL;
- StringInfo str = makeStringInfo();
+ StringInfoData buf;
char *curname = NULL;
int howmany = 0;
bool fail = true; /* default to backward compatible */
if (!conn)
DBLINK_CONN_NOT_AVAIL;
+ initStringInfo(&buf);
+ appendStringInfo(&buf, "FETCH %d FROM %s", howmany, curname);
+
/* create a function context for cross-call persistence */
funcctx = SRF_FIRSTCALL_INIT();
*/
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
- appendStringInfo(str, "FETCH %d FROM %s", howmany, curname);
-
- res = PQexec(conn, str->data);
+ res = PQexec(conn, buf.data);
if (!res ||
(PQresultStatus(res) != PGRES_COMMAND_OK &&
PQresultStatus(res) != PGRES_TUPLES_OK))
HeapTuple tuple;
TupleDesc tupdesc;
int natts;
- StringInfo str = makeStringInfo();
- char *sql;
+ StringInfoData buf;
char *val;
int16 key;
int i;
bool needComma;
+ initStringInfo(&buf);
+
/* get relation name including any needed schema prefix and quoting */
relname = generate_relation_name(relid);
(errcode(ERRCODE_CARDINALITY_VIOLATION),
errmsg("source row not found")));
- appendStringInfo(str, "INSERT INTO %s(", relname);
+ appendStringInfo(&buf, "INSERT INTO %s(", relname);
needComma = false;
for (i = 0; i < natts; i++)
continue;
if (needComma)
- appendStringInfo(str, ",");
+ appendStringInfo(&buf, ",");
- appendStringInfo(str, "%s",
+ appendStringInfoString(&buf,
quote_ident_cstr(NameStr(tupdesc->attrs[i]->attname)));
needComma = true;
}
- appendStringInfo(str, ") VALUES(");
+ appendStringInfo(&buf, ") VALUES(");
/*
* remember attvals are 1 based
continue;
if (needComma)
- appendStringInfo(str, ",");
+ appendStringInfo(&buf, ",");
if (tgt_pkattvals != NULL)
key = get_attnum_pk_pos(pkattnums, pknumatts, i + 1);
if (val != NULL)
{
- appendStringInfo(str, "%s", quote_literal_cstr(val));
+ appendStringInfoString(&buf, quote_literal_cstr(val));
pfree(val);
}
else
- appendStringInfo(str, "NULL");
+ appendStringInfo(&buf, "NULL");
needComma = true;
}
- appendStringInfo(str, ")");
+ appendStringInfo(&buf, ")");
- sql = pstrdup(str->data);
- pfree(str->data);
- pfree(str);
relation_close(rel, AccessShareLock);
-
- return (sql);
+ return (buf.data);
}
static char *
char *relname;
TupleDesc tupdesc;
int natts;
- StringInfo str = makeStringInfo();
- char *sql;
+ StringInfoData buf;
int i;
+ initStringInfo(&buf);
+
/* get relation name including any needed schema prefix and quoting */
relname = generate_relation_name(relid);
tupdesc = rel->rd_att;
natts = tupdesc->natts;
- appendStringInfo(str, "DELETE FROM %s WHERE ", relname);
+ appendStringInfo(&buf, "DELETE FROM %s WHERE ", relname);
for (i = 0; i < pknumatts; i++)
{
int16 pkattnum = pkattnums->values[i];
if (i > 0)
- appendStringInfo(str, " AND ");
+ appendStringInfo(&buf, " AND ");
- appendStringInfo(str, "%s",
+ appendStringInfoString(&buf,
quote_ident_cstr(NameStr(tupdesc->attrs[pkattnum - 1]->attname)));
if (tgt_pkattvals == NULL)
elog(ERROR, "target key array must not be NULL");
if (tgt_pkattvals[i] != NULL)
- appendStringInfo(str, " = %s",
+ appendStringInfo(&buf, " = %s",
quote_literal_cstr(tgt_pkattvals[i]));
else
- appendStringInfo(str, " IS NULL");
+ appendStringInfo(&buf, " IS NULL");
}
- sql = pstrdup(str->data);
- pfree(str->data);
- pfree(str);
relation_close(rel, AccessShareLock);
-
- return (sql);
+ return (buf.data);
}
static char *
HeapTuple tuple;
TupleDesc tupdesc;
int natts;
- StringInfo str = makeStringInfo();
- char *sql;
+ StringInfoData buf;
char *val;
int16 key;
int i;
bool needComma;
+ initStringInfo(&buf);
+
/* get relation name including any needed schema prefix and quoting */
relname = generate_relation_name(relid);
(errcode(ERRCODE_CARDINALITY_VIOLATION),
errmsg("source row not found")));
- appendStringInfo(str, "UPDATE %s SET ", relname);
+ appendStringInfo(&buf, "UPDATE %s SET ", relname);
needComma = false;
for (i = 0; i < natts; i++)
continue;
if (needComma)
- appendStringInfo(str, ", ");
+ appendStringInfo(&buf, ", ");
- appendStringInfo(str, "%s = ",
+ appendStringInfo(&buf, "%s = ",
quote_ident_cstr(NameStr(tupdesc->attrs[i]->attname)));
if (tgt_pkattvals != NULL)
if (val != NULL)
{
- appendStringInfo(str, "%s", quote_literal_cstr(val));
+ appendStringInfoString(&buf, quote_literal_cstr(val));
pfree(val);
}
else
- appendStringInfo(str, "NULL");
+ appendStringInfoString(&buf, "NULL");
needComma = true;
}
- appendStringInfo(str, " WHERE ");
+ appendStringInfo(&buf, " WHERE ");
for (i = 0; i < pknumatts; i++)
{
int16 pkattnum = pkattnums->values[i];
if (i > 0)
- appendStringInfo(str, " AND ");
+ appendStringInfo(&buf, " AND ");
- appendStringInfo(str, "%s",
+ appendStringInfo(&buf, "%s",
quote_ident_cstr(NameStr(tupdesc->attrs[pkattnum - 1]->attname)));
if (tgt_pkattvals != NULL)
if (val != NULL)
{
- appendStringInfo(str, " = %s", quote_literal_cstr(val));
+ appendStringInfo(&buf, " = %s", quote_literal_cstr(val));
pfree(val);
}
else
- appendStringInfo(str, " IS NULL");
+ appendStringInfo(&buf, " IS NULL");
}
- sql = pstrdup(str->data);
- pfree(str->data);
- pfree(str);
relation_close(rel, AccessShareLock);
-
- return (sql);
+ return (buf.data);
}
/*
Relation rel;
char *relname;
TupleDesc tupdesc;
- StringInfo str = makeStringInfo();
- char *sql = NULL;
+ StringInfoData buf;
int ret;
HeapTuple tuple;
int i;
+ initStringInfo(&buf);
+
/* get relation name including any needed schema prefix and quoting */
relname = generate_relation_name(relid);
* Build sql statement to look up tuple of interest Use src_pkattvals as
* the criteria.
*/
- appendStringInfo(str, "SELECT * FROM %s WHERE ", relname);
+ appendStringInfo(&buf, "SELECT * FROM %s WHERE ", relname);
for (i = 0; i < pknumatts; i++)
{
int16 pkattnum = pkattnums->values[i];
if (i > 0)
- appendStringInfo(str, " AND ");
+ appendStringInfo(&buf, " AND ");
- appendStringInfo(str, "%s",
+ appendStringInfoString(&buf,
quote_ident_cstr(NameStr(tupdesc->attrs[pkattnum - 1]->attname)));
if (src_pkattvals[i] != NULL)
- appendStringInfo(str, " = %s",
+ appendStringInfo(&buf, " = %s",
quote_literal_cstr(src_pkattvals[i]));
else
- appendStringInfo(str, " IS NULL");
+ appendStringInfo(&buf, " IS NULL");
}
- sql = pstrdup(str->data);
- pfree(str->data);
- pfree(str);
-
/*
* Retrieve the desired tuple
*/
- ret = SPI_exec(sql, 0);
- pfree(sql);
+ ret = SPI_exec(buf.data, 0);
+ pfree(buf.data);
/*
* Only allow one qualifying tuple
{
TupleDesc tupdesc = attinmeta->tupdesc;
MemoryContext oldcontext;
- StringInfo sql = makeStringInfo();
int ret;
int proc;
int serial_column;
- StringInfo branchstr = NULL;
- StringInfo chk_branchstr = NULL;
- StringInfo chk_current_key = NULL;
+ StringInfoData sql;
char **values;
char *current_key;
char *current_key_parent;
if (max_depth > 0 && level > max_depth)
return tupstore;
- /* start a new branch */
- branchstr = makeStringInfo();
-
- /* need these to check for recursion */
- chk_branchstr = makeStringInfo();
- chk_current_key = makeStringInfo();
+ initStringInfo(&sql);
/* Build initial sql statement */
if (!show_serial)
{
- appendStringInfo(sql, "SELECT %s, %s FROM %s WHERE %s = %s AND %s IS NOT NULL AND %s <> %s",
+ appendStringInfo(&sql, "SELECT %s, %s FROM %s WHERE %s = %s AND %s IS NOT NULL AND %s <> %s",
key_fld,
parent_key_fld,
relname,
}
else
{
- appendStringInfo(sql, "SELECT %s, %s FROM %s WHERE %s = %s AND %s IS NOT NULL AND %s <> %s ORDER BY %s",
+ appendStringInfo(&sql, "SELECT %s, %s FROM %s WHERE %s = %s AND %s IS NOT NULL AND %s <> %s ORDER BY %s",
key_fld,
parent_key_fld,
relname,
}
/* Retrieve the desired rows */
- ret = SPI_execute(sql->data, true, 0);
+ ret = SPI_execute(sql.data, true, 0);
proc = SPI_processed;
/* Check for qualifying tuples */
SPITupleTable *tuptable = SPI_tuptable;
TupleDesc spi_tupdesc = tuptable->tupdesc;
int i;
+ StringInfoData branchstr;
+ StringInfoData chk_branchstr;
+ StringInfoData chk_current_key;
/* First time through, do a little more setup */
if (level == 0)
for (i = 0; i < proc; i++)
{
+ /* start a new branch */
+ initStringInfo(&branchstr);
+
+ /* need these to check for recursion */
+ initStringInfo(&chk_branchstr);
+ initStringInfo(&chk_current_key);
+
/* initialize branch for this pass */
- appendStringInfo(branchstr, "%s", branch);
- appendStringInfo(chk_branchstr, "%s%s%s", branch_delim, branch, branch_delim);
+ appendStringInfo(&branchstr, "%s", branch);
+ appendStringInfo(&chk_branchstr, "%s%s%s", branch_delim, branch, branch_delim);
/* get the next sql result tuple */
spi_tuple = tuptable->vals[i];
/* get the current key and parent */
current_key = SPI_getvalue(spi_tuple, spi_tupdesc, 1);
- appendStringInfo(chk_current_key, "%s%s%s", branch_delim, current_key, branch_delim);
+ appendStringInfo(&chk_current_key, "%s%s%s", branch_delim, current_key, branch_delim);
current_key_parent = pstrdup(SPI_getvalue(spi_tuple, spi_tupdesc, 2));
/* get the current level */
sprintf(current_level, "%d", level);
/* check to see if this key is also an ancestor */
- if (strstr(chk_branchstr->data, chk_current_key->data))
+ if (strstr(chk_branchstr.data, chk_current_key.data))
elog(ERROR, "infinite recursion detected");
/* OK, extend the branch */
- appendStringInfo(branchstr, "%s%s", branch_delim, current_key);
- current_branch = branchstr->data;
+ appendStringInfo(&branchstr, "%s%s", branch_delim, current_key);
+ current_branch = branchstr.data;
/* build a tuple */
values[0] = pstrdup(current_key);
tupstore);
/* reset branch for next pass */
- xpfree(branchstr->data);
- initStringInfo(branchstr);
-
- xpfree(chk_branchstr->data);
- initStringInfo(chk_branchstr);
-
- xpfree(chk_current_key->data);
- initStringInfo(chk_current_key);
+ xpfree(branchstr.data);
+ xpfree(chk_branchstr.data);
+ xpfree(chk_current_key.data);
}
}
* document */
int had_values; /* To determine end of nodeset results */
- StringInfo querysql;
+ StringInfoData query_buf;
/* We only have a valid tuple description in table function mode */
if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
} while ((pos != NULL) && (numpaths < (ret_tupdesc->natts - 1)));
/* Now build query */
-
- querysql = makeStringInfo();
+ initStringInfo(&query_buf);
/* Build initial sql statement */
- appendStringInfo(querysql, "SELECT %s, %s FROM %s WHERE %s",
+ appendStringInfo(&query_buf, "SELECT %s, %s FROM %s WHERE %s",
pkeyfield,
xmlfield,
relname,
if ((ret = SPI_connect()) < 0)
elog(ERROR, "xpath_table: SPI_connect returned %d", ret);
- if ((ret = SPI_exec(querysql->data, 0)) != SPI_OK_SELECT)
- elog(ERROR, "xpath_table: SPI execution failed for query %s", querysql->data);
+ if ((ret = SPI_exec(query_buf.data, 0)) != SPI_OK_SELECT)
+ elog(ERROR, "xpath_table: SPI execution failed for query %s", query_buf.data);
proc = SPI_processed;
/* elog(DEBUG1,"xpath_table: SPI returned %d rows",proc); */
* Portions Copyright (c) 1994-5, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/explain.c,v 1.144 2006/02/28 04:10:27 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/explain.c,v 1.145 2006/03/01 06:51:01 neilc Exp $
*
*-------------------------------------------------------------------------
*/
instr_time starttime;
double totaltime = 0;
ExplainState *es;
- StringInfo str;
+ StringInfoData buf;
int eflags;
INSTR_TIME_SET_CURRENT(starttime);
}
}
- str = makeStringInfo();
-
- explain_outNode(str, queryDesc->plantree, queryDesc->planstate,
+ initStringInfo(&buf);
+ explain_outNode(&buf, queryDesc->plantree, queryDesc->planstate,
NULL, 0, es);
/*
if (trig->tgisconstraint &&
(conname = GetConstraintNameForTrigger(trig->tgoid)) != NULL)
{
- appendStringInfo(str, "Trigger for constraint %s",
+ appendStringInfo(&buf, "Trigger for constraint %s",
conname);
pfree(conname);
}
else
- appendStringInfo(str, "Trigger %s", trig->tgname);
+ appendStringInfo(&buf, "Trigger %s", trig->tgname);
if (numrels > 1)
- appendStringInfo(str, " on %s",
+ appendStringInfo(&buf, " on %s",
RelationGetRelationName(rInfo->ri_RelationDesc));
- appendStringInfo(str, ": time=%.3f calls=%.0f\n",
+ appendStringInfo(&buf, ": time=%.3f calls=%.0f\n",
1000.0 * instr->total,
instr->ntuples);
}
totaltime += elapsed_time(&starttime);
if (stmt->analyze)
- appendStringInfo(str, "Total runtime: %.3f ms\n",
+ appendStringInfo(&buf, "Total runtime: %.3f ms\n",
1000.0 * totaltime);
- do_text_output_multiline(tstate, str->data);
+ do_text_output_multiline(tstate, buf.data);
- pfree(str->data);
- pfree(str);
+ pfree(buf.data);
pfree(es);
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/varlena.c,v 1.143 2006/02/26 02:23:41 neilc Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/varlena.c,v 1.144 2006/03/01 06:51:01 neilc Exp $
*
*-------------------------------------------------------------------------
*/
text *buf_text;
text *ret_text;
int curr_posn;
- StringInfo str;
+ StringInfoData str;
if (src_text_len == 0 || from_sub_text_len == 0)
PG_RETURN_TEXT_P(src_text);
if (curr_posn == 0)
PG_RETURN_TEXT_P(src_text);
- str = makeStringInfo();
+ initStringInfo(&str);
buf_text = src_text;
while (curr_posn > 0)
right_text = text_substring(PointerGetDatum(buf_text),
curr_posn + from_sub_text_len, -1, true);
- appendStringInfoText(str, left_text);
- appendStringInfoText(str, to_sub_text);
+ appendStringInfoText(&str, left_text);
+ appendStringInfoText(&str, to_sub_text);
if (buf_text != src_text)
pfree(buf_text);
curr_posn = TEXTPOS(buf_text, from_sub_text);
}
- appendStringInfoText(str, buf_text);
+ appendStringInfoText(&str, buf_text);
if (buf_text != src_text)
pfree(buf_text);
- ret_text = PG_STR_GET_TEXT(str->data);
- pfree(str->data);
- pfree(str);
+ ret_text = PG_STR_GET_TEXT(str.data);
+ pfree(str.data);
PG_RETURN_TEXT_P(ret_text);
}
text *ret_text;
regex_t *re = (regex_t *) regexp;
int src_text_len = VARSIZE(src_text) - VARHDRSZ;
- StringInfo str = makeStringInfo();
- int regexec_result;
+ StringInfoData buf;
regmatch_t pmatch[REGEXP_REPLACE_BACKREF_CNT];
pg_wchar *data;
size_t data_len;
int data_pos;
bool have_escape;
+ initStringInfo(&buf);
+
/* Convert data string to wide characters. */
data = (pg_wchar *) palloc((src_text_len + 1) * sizeof(pg_wchar));
data_len = pg_mb2wchar_with_len(VARDATA(src_text), data, src_text_len);
for (search_start = data_pos = 0; search_start <= data_len;)
{
+ int regexec_result;
+
regexec_result = pg_regexec(re,
data,
data_len,
pmatch,
0);
- if (regexec_result != REG_OKAY && regexec_result != REG_NOMATCH)
+ if (regexec_result == REG_NOMATCH)
+ break;
+
+ if (regexec_result != REG_OKAY)
{
char errMsg[100];
- /* re failed??? */
pg_regerror(regexec_result, re, errMsg, sizeof(errMsg));
ereport(ERROR,
(errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
errmsg("regular expression failed: %s", errMsg)));
}
- if (regexec_result == REG_NOMATCH)
- break;
-
/*
* Copy the text to the left of the match position. Because we are
* working with character not byte indexes, it's easiest to use
data_pos + 1,
pmatch[0].rm_so - data_pos,
false);
- appendStringInfoText(str, left_text);
+ appendStringInfoText(&buf, left_text);
pfree(left_text);
}
* replace_text has escape characters.
*/
if (have_escape)
- appendStringInfoRegexpSubstr(str, replace_text, pmatch, src_text);
+ appendStringInfoRegexpSubstr(&buf, replace_text, pmatch, src_text);
else
- appendStringInfoText(str, replace_text);
+ appendStringInfoText(&buf, replace_text);
search_start = data_pos = pmatch[0].rm_eo;
right_text = text_substring(PointerGetDatum(src_text),
data_pos + 1, -1, true);
- appendStringInfoText(str, right_text);
+ appendStringInfoText(&buf, right_text);
pfree(right_text);
}
- ret_text = PG_STR_GET_TEXT(str->data);
- pfree(str->data);
- pfree(str);
+ ret_text = PG_STR_GET_TEXT(buf.data);
+ pfree(buf.data);
pfree(data);
return ret_text;
int typlen;
bool typbyval;
char typalign;
- StringInfo result_str = makeStringInfo();
+ StringInfoData buf;
bool printed = false;
char *p;
bits8 *bitmap;
PG_RETURN_TEXT_P(PG_STR_GET_TEXT(""));
element_type = ARR_ELEMTYPE(v);
+ initStringInfo(&buf);
/*
* We arrange to look up info about element type, including its output
itemvalue));
if (printed)
- appendStringInfo(result_str, "%s%s", fldsep, value);
+ appendStringInfo(&buf, "%s%s", fldsep, value);
else
- appendStringInfoString(result_str, value);
+ appendStringInfoString(&buf, value);
printed = true;
p = att_addlength(p, typlen, PointerGetDatum(p));
}
}
- PG_RETURN_TEXT_P(PG_STR_GET_TEXT(result_str->data));
+ PG_RETURN_TEXT_P(PG_STR_GET_TEXT(buf.data));
}
#define HEXBASE 16