#include "miscadmin.h"
#include "postmaster/syslogger.h"
#include "storage/fd.h"
+#include "utils/builtins.h"
#include "utils/datetime.h"
static char *
convert_and_check_filename(text *arg, bool logAllowed)
{
- int input_len = VARSIZE(arg) - VARHDRSZ;
- char *filename = palloc(input_len + 1);
-
- memcpy(filename, VARDATA(arg), input_len);
- filename[input_len] = '\0';
+ char *filename = text_to_cstring(arg);
canonicalize_path(filename); /* filename can change length here */
#endif
#include "fmgr.h"
+#include "utils/builtins.h"
PG_MODULE_MAGIC;
chkpass_rout(PG_FUNCTION_ARGS)
{
chkpass *password = (chkpass *) PG_GETARG_POINTER(0);
- text *result;
- int slen;
- slen = strlen(password->password);
- result = (text *) palloc(VARHDRSZ + slen);
- SET_VARSIZE(result, VARHDRSZ + slen);
- memcpy(VARDATA(result), password->password, slen);
-
- PG_RETURN_TEXT_P(result);
+ PG_RETURN_TEXT_P(cstring_to_text(password->password));
}
chkpass_eq(PG_FUNCTION_ARGS)
{
chkpass *a1 = (chkpass *) PG_GETARG_POINTER(0);
- text *a2 = (text *) PG_GETARG_TEXT_P(1);
- char str[10];
- int sz;
+ text *a2 = PG_GETARG_TEXT_PP(1);
+ char str[9];
- sz = Min(VARSIZE(a2) - VARHDRSZ, 8);
- memcpy(str, VARDATA(a2), sz);
- str[sz] = '\0';
+ text_to_cstring_buffer(a2, str, sizeof(str));
PG_RETURN_BOOL(strcmp(a1->password, crypt(str, a1->password)) == 0);
}
chkpass_ne(PG_FUNCTION_ARGS)
{
chkpass *a1 = (chkpass *) PG_GETARG_POINTER(0);
- text *a2 = (text *) PG_GETARG_TEXT_P(1);
- char str[10];
- int sz;
+ text *a2 = PG_GETARG_TEXT_PP(1);
+ char str[9];
- sz = Min(VARSIZE(a2) - VARHDRSZ, 8);
- memcpy(str, VARDATA(a2), sz);
- str[sz] = '\0';
+ text_to_cstring_buffer(a2, str, sizeof(str));
PG_RETURN_BOOL(strcmp(a1->password, crypt(str, a1->password)) != 0);
}
#define NUMCONN 16
/* general utility */
-#define GET_TEXT(cstrp) DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(cstrp)))
-#define GET_STR(textp) DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(textp)))
#define xpfree(var_) \
do { \
if (var_ != NULL) \
#define DBLINK_GET_CONN \
do { \
- char *conname_or_str = GET_STR(PG_GETARG_TEXT_P(0)); \
+ char *conname_or_str = text_to_cstring(PG_GETARG_TEXT_PP(0)); \
rconn = getConnectionByName(conname_or_str); \
if(rconn) \
{ \
#define DBLINK_GET_NAMED_CONN \
do { \
- char *conname = GET_STR(PG_GETARG_TEXT_P(0)); \
+ char *conname = text_to_cstring(PG_GETARG_TEXT_PP(0)); \
rconn = getConnectionByName(conname); \
if(rconn) \
conn = rconn->conn; \
if (PG_NARGS() == 2)
{
- connstr = GET_STR(PG_GETARG_TEXT_P(1));
- connname = GET_STR(PG_GETARG_TEXT_P(0));
+ connstr = text_to_cstring(PG_GETARG_TEXT_PP(1));
+ connname = text_to_cstring(PG_GETARG_TEXT_PP(0));
}
else if (PG_NARGS() == 1)
- connstr = GET_STR(PG_GETARG_TEXT_P(0));
+ connstr = text_to_cstring(PG_GETARG_TEXT_PP(0));
oldcontext = MemoryContextSwitchTo(TopMemoryContext);
else
pconn->conn = conn;
- PG_RETURN_TEXT_P(GET_TEXT("OK"));
+ PG_RETURN_TEXT_P(cstring_to_text("OK"));
}
/*
if (PG_NARGS() == 1)
{
- conname = GET_STR(PG_GETARG_TEXT_P(0));
+ conname = text_to_cstring(PG_GETARG_TEXT_PP(0));
rconn = getConnectionByName(conname);
if (rconn)
conn = rconn->conn;
else
pconn->conn = NULL;
- PG_RETURN_TEXT_P(GET_TEXT("OK"));
+ PG_RETURN_TEXT_P(cstring_to_text("OK"));
}
/*
if (PG_NARGS() == 2)
{
/* text,text */
- curname = GET_STR(PG_GETARG_TEXT_P(0));
- sql = GET_STR(PG_GETARG_TEXT_P(1));
+ curname = text_to_cstring(PG_GETARG_TEXT_PP(0));
+ sql = text_to_cstring(PG_GETARG_TEXT_PP(1));
rconn = pconn;
}
else if (PG_NARGS() == 3)
/* might be text,text,text or text,text,bool */
if (get_fn_expr_argtype(fcinfo->flinfo, 2) == BOOLOID)
{
- curname = GET_STR(PG_GETARG_TEXT_P(0));
- sql = GET_STR(PG_GETARG_TEXT_P(1));
+ curname = text_to_cstring(PG_GETARG_TEXT_PP(0));
+ sql = text_to_cstring(PG_GETARG_TEXT_PP(1));
fail = PG_GETARG_BOOL(2);
rconn = pconn;
}
else
{
- conname = GET_STR(PG_GETARG_TEXT_P(0));
- curname = GET_STR(PG_GETARG_TEXT_P(1));
- sql = GET_STR(PG_GETARG_TEXT_P(2));
+ conname = text_to_cstring(PG_GETARG_TEXT_PP(0));
+ curname = text_to_cstring(PG_GETARG_TEXT_PP(1));
+ sql = text_to_cstring(PG_GETARG_TEXT_PP(2));
rconn = getConnectionByName(conname);
}
}
else if (PG_NARGS() == 4)
{
/* text,text,text,bool */
- conname = GET_STR(PG_GETARG_TEXT_P(0));
- curname = GET_STR(PG_GETARG_TEXT_P(1));
- sql = GET_STR(PG_GETARG_TEXT_P(2));
+ conname = text_to_cstring(PG_GETARG_TEXT_PP(0));
+ curname = text_to_cstring(PG_GETARG_TEXT_PP(1));
+ sql = text_to_cstring(PG_GETARG_TEXT_PP(2));
fail = PG_GETARG_BOOL(3);
rconn = getConnectionByName(conname);
}
else
{
DBLINK_RES_ERROR_AS_NOTICE("sql error");
- PG_RETURN_TEXT_P(GET_TEXT("ERROR"));
+ PG_RETURN_TEXT_P(cstring_to_text("ERROR"));
}
}
PQclear(res);
- PG_RETURN_TEXT_P(GET_TEXT("OK"));
+ PG_RETURN_TEXT_P(cstring_to_text("OK"));
}
/*
if (PG_NARGS() == 1)
{
/* text */
- curname = GET_STR(PG_GETARG_TEXT_P(0));
+ curname = text_to_cstring(PG_GETARG_TEXT_PP(0));
rconn = pconn;
}
else if (PG_NARGS() == 2)
/* might be text,text or text,bool */
if (get_fn_expr_argtype(fcinfo->flinfo, 1) == BOOLOID)
{
- curname = GET_STR(PG_GETARG_TEXT_P(0));
+ curname = text_to_cstring(PG_GETARG_TEXT_PP(0));
fail = PG_GETARG_BOOL(1);
rconn = pconn;
}
else
{
- conname = GET_STR(PG_GETARG_TEXT_P(0));
- curname = GET_STR(PG_GETARG_TEXT_P(1));
+ conname = text_to_cstring(PG_GETARG_TEXT_PP(0));
+ curname = text_to_cstring(PG_GETARG_TEXT_PP(1));
rconn = getConnectionByName(conname);
}
}
if (PG_NARGS() == 3)
{
/* text,text,bool */
- conname = GET_STR(PG_GETARG_TEXT_P(0));
- curname = GET_STR(PG_GETARG_TEXT_P(1));
+ conname = text_to_cstring(PG_GETARG_TEXT_PP(0));
+ curname = text_to_cstring(PG_GETARG_TEXT_PP(1));
fail = PG_GETARG_BOOL(2);
rconn = getConnectionByName(conname);
}
else
{
DBLINK_RES_ERROR_AS_NOTICE("sql error");
- PG_RETURN_TEXT_P(GET_TEXT("ERROR"));
+ PG_RETURN_TEXT_P(cstring_to_text("ERROR"));
}
}
}
}
- PG_RETURN_TEXT_P(GET_TEXT("OK"));
+ PG_RETURN_TEXT_P(cstring_to_text("OK"));
}
/*
if (PG_NARGS() == 4)
{
/* text,text,int,bool */
- conname = GET_STR(PG_GETARG_TEXT_P(0));
- curname = GET_STR(PG_GETARG_TEXT_P(1));
+ conname = text_to_cstring(PG_GETARG_TEXT_PP(0));
+ curname = text_to_cstring(PG_GETARG_TEXT_PP(1));
howmany = PG_GETARG_INT32(2);
fail = PG_GETARG_BOOL(3);
/* text,text,int or text,int,bool */
if (get_fn_expr_argtype(fcinfo->flinfo, 2) == BOOLOID)
{
- curname = GET_STR(PG_GETARG_TEXT_P(0));
+ curname = text_to_cstring(PG_GETARG_TEXT_PP(0));
howmany = PG_GETARG_INT32(1);
fail = PG_GETARG_BOOL(2);
conn = pconn->conn;
}
else
{
- conname = GET_STR(PG_GETARG_TEXT_P(0));
- curname = GET_STR(PG_GETARG_TEXT_P(1));
+ conname = text_to_cstring(PG_GETARG_TEXT_PP(0));
+ curname = text_to_cstring(PG_GETARG_TEXT_PP(1));
howmany = PG_GETARG_INT32(2);
rconn = getConnectionByName(conname);
else if (PG_NARGS() == 2)
{
/* text,int */
- curname = GET_STR(PG_GETARG_TEXT_P(0));
+ curname = text_to_cstring(PG_GETARG_TEXT_PP(0));
howmany = PG_GETARG_INT32(1);
conn = pconn->conn;
}
{
/* text,text,bool */
DBLINK_GET_CONN;
- sql = GET_STR(PG_GETARG_TEXT_P(1));
+ sql = text_to_cstring(PG_GETARG_TEXT_PP(1));
fail = PG_GETARG_BOOL(2);
}
else if (PG_NARGS() == 2)
if (get_fn_expr_argtype(fcinfo->flinfo, 1) == BOOLOID)
{
conn = pconn->conn;
- sql = GET_STR(PG_GETARG_TEXT_P(0));
+ sql = text_to_cstring(PG_GETARG_TEXT_PP(0));
fail = PG_GETARG_BOOL(1);
}
else
{
DBLINK_GET_CONN;
- sql = GET_STR(PG_GETARG_TEXT_P(1));
+ sql = text_to_cstring(PG_GETARG_TEXT_PP(1));
}
}
else if (PG_NARGS() == 1)
{
/* text */
conn = pconn->conn;
- sql = GET_STR(PG_GETARG_TEXT_P(0));
+ sql = text_to_cstring(PG_GETARG_TEXT_PP(0));
}
else
/* shouldn't happen */
if (PG_NARGS() == 2)
{
DBLINK_GET_CONN;
- sql = GET_STR(PG_GETARG_TEXT_P(1));
+ sql = text_to_cstring(PG_GETARG_TEXT_PP(1));
}
else
/* shouldn't happen */
{
/* stash away current value */
astate = accumArrayResult(astate,
- PointerGetDatum(GET_TEXT(hentry->name)),
+ CStringGetTextDatum(hentry->name),
false, TEXTOID, CurrentMemoryContext);
}
}
PQfreeCancel(cancel);
if (res == 1)
- PG_RETURN_TEXT_P(GET_TEXT("OK"));
+ PG_RETURN_TEXT_P(cstring_to_text("OK"));
else
- PG_RETURN_TEXT_P(GET_TEXT(errbuf));
+ PG_RETURN_TEXT_P(cstring_to_text(errbuf));
}
msg = PQerrorMessage(conn);
if (msg == NULL || msg[0] == '\0')
- PG_RETURN_TEXT_P(GET_TEXT("OK"));
+ PG_RETURN_TEXT_P(cstring_to_text("OK"));
else
- PG_RETURN_TEXT_P(GET_TEXT(msg));
+ PG_RETURN_TEXT_P(cstring_to_text(msg));
}
/*
{
/* must be text,text,bool */
DBLINK_GET_CONN;
- sql = GET_STR(PG_GETARG_TEXT_P(1));
+ sql = text_to_cstring(PG_GETARG_TEXT_PP(1));
fail = PG_GETARG_BOOL(2);
}
else if (PG_NARGS() == 2)
if (get_fn_expr_argtype(fcinfo->flinfo, 1) == BOOLOID)
{
conn = pconn->conn;
- sql = GET_STR(PG_GETARG_TEXT_P(0));
+ sql = text_to_cstring(PG_GETARG_TEXT_PP(0));
fail = PG_GETARG_BOOL(1);
}
else
{
DBLINK_GET_CONN;
- sql = GET_STR(PG_GETARG_TEXT_P(1));
+ sql = text_to_cstring(PG_GETARG_TEXT_PP(1));
}
}
else if (PG_NARGS() == 1)
{
/* must be single text argument */
conn = pconn->conn;
- sql = GET_STR(PG_GETARG_TEXT_P(0));
+ sql = text_to_cstring(PG_GETARG_TEXT_PP(0));
}
else
/* shouldn't happen */
* and save a copy of the command status string to return as our
* result tuple
*/
- sql_cmd_status = GET_TEXT("ERROR");
+ sql_cmd_status = cstring_to_text("ERROR");
}
else if (PQresultStatus(res) == PGRES_COMMAND_OK)
* and save a copy of the command status string to return as our
* result tuple
*/
- sql_cmd_status = GET_TEXT(PQcmdStatus(res));
+ sql_cmd_status = cstring_to_text(PQcmdStatus(res));
PQclear(res);
}
else
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_TABLE),
errmsg("relation \"%s\" does not exist",
- GET_STR(PG_GETARG_TEXT_P(0)))));
+ text_to_cstring(PG_GETARG_TEXT_PP(0)))));
/*
* need a tuple descriptor representing one INT and one TEXT column
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_TABLE),
errmsg("relation \"%s\" does not exist",
- GET_STR(relname_text))));
+ text_to_cstring(relname_text))));
/*
* There should be at least one key attribute
/*
* And send it
*/
- PG_RETURN_TEXT_P(GET_TEXT(sql));
+ PG_RETURN_TEXT_P(cstring_to_text(sql));
}
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_TABLE),
errmsg("relation \"%s\" does not exist",
- GET_STR(relname_text))));
+ text_to_cstring(relname_text))));
/*
* There should be at least one key attribute
/*
* And send it
*/
- PG_RETURN_TEXT_P(GET_TEXT(sql));
+ PG_RETURN_TEXT_P(cstring_to_text(sql));
}
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_TABLE),
errmsg("relation \"%s\" does not exist",
- GET_STR(relname_text))));
+ text_to_cstring(relname_text))));
/*
* There should be one source array key values for each key attnum
/*
* And send it
*/
- PG_RETURN_TEXT_P(GET_TEXT(sql));
+ PG_RETURN_TEXT_P(cstring_to_text(sql));
}
/*
dblink_current_query(PG_FUNCTION_ARGS)
{
if (debug_query_string)
- PG_RETURN_TEXT_P(GET_TEXT(debug_query_string));
+ PG_RETURN_TEXT_P(cstring_to_text(debug_query_string));
else
PG_RETURN_NULL();
}
}
else
{
- values[i] = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(ptr)));
+ values[i] = TextDatumGetCString(PointerGetDatum(ptr));
ptr = att_addlength_pointer(ptr, typlen, ptr);
ptr = (char *) att_align_nominal(ptr, typalign);
}
text *result_text;
char *result;
- rawstr_text = DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(rawstr)));
- result_text = DatumGetTextP(DirectFunctionCall1(quote_literal, PointerGetDatum(rawstr_text)));
- result = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(result_text)));
+ rawstr_text = cstring_to_text(rawstr);
+ result_text = DatumGetTextP(DirectFunctionCall1(quote_literal,
+ PointerGetDatum(rawstr_text)));
+ result = text_to_cstring(result_text);
return result;
}
text *result_text;
char *result;
- rawstr_text = DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(rawstr)));
- result_text = DatumGetTextP(DirectFunctionCall1(quote_ident, PointerGetDatum(rawstr_text)));
- result = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(result_text)));
+ rawstr_text = cstring_to_text(rawstr);
+ result_text = DatumGetTextP(DirectFunctionCall1(quote_ident,
+ PointerGetDatum(rawstr_text)));
+ result = text_to_cstring(result_text);
return result;
}
#include "postgres.h"
-#include "fmgr.h"
+#include "utils/builtins.h"
/* turn off assertions for embedded function */
#define NDEBUG
extern Datum dmetaphone_alt(PG_FUNCTION_ARGS);
/* prototype for the main function we got from the perl module */
-static void
- DoubleMetaphone(char *, char **);
+static void DoubleMetaphone(char *, char **);
#ifndef DMETAPHONE_MAIN
/*
* The PostgreSQL visible dmetaphone function.
- *
*/
PG_FUNCTION_INFO_V1(dmetaphone);
Datum
dmetaphone(PG_FUNCTION_ARGS)
{
- text *arg,
- *result;
- int alen,
- rsize;
+ text *arg;
char *aptr,
*codes[2],
- *code,
- *rptr;
+ *code;
#ifdef DMETAPHONE_NOSTRICT
if (PG_ARGISNULL(0))
- PG_RETURNNULL();
+ PG_RETURN_NULL();
#endif
arg = PG_GETARG_TEXT_P(0);
- alen = VARSIZE(arg) - VARHDRSZ;
-
- /*
- * Postgres' string values might not have trailing nuls. The VARSIZE will
- * not include the nul in any case so we copy things out and add a
- * trailing nul. When we copy back we ignore the nul (and we don't make
- * space for it).
- */
-
- aptr = palloc(alen + 1);
- memcpy(aptr, VARDATA(arg), alen);
- aptr[alen] = 0;
+ aptr = text_to_cstring(arg);
+
DoubleMetaphone(aptr, codes);
code = codes[0];
if (!code)
code = "";
- rsize = VARHDRSZ + strlen(code);
- result = (text *) palloc(rsize);
- rptr = VARDATA(result);
- memcpy(rptr, code, rsize - VARHDRSZ);
- SET_VARSIZE(result, rsize);
- PG_RETURN_TEXT_P(result);
+
+ PG_RETURN_TEXT_P(cstring_to_text(code));
}
/*
* The PostgreSQL visible dmetaphone_alt function.
- *
*/
PG_FUNCTION_INFO_V1(dmetaphone_alt);
Datum
dmetaphone_alt(PG_FUNCTION_ARGS)
{
- text *arg,
- *result;
- int alen,
- rsize;
+ text *arg;
char *aptr,
*codes[2],
- *code,
- *rptr;
+ *code;
#ifdef DMETAPHONE_NOSTRICT
if (PG_ARGISNULL(0))
- PG_RETURNNULL();
+ PG_RETURN_NULL();
#endif
arg = PG_GETARG_TEXT_P(0);
- alen = VARSIZE(arg) - VARHDRSZ;
- aptr = palloc(alen + 1);
- memcpy(aptr, VARDATA(arg), alen);
- aptr[alen] = 0;
+ aptr = text_to_cstring(arg);
+
DoubleMetaphone(aptr, codes);
code = codes[1];
if (!code)
code = "";
- rsize = VARHDRSZ + strlen(code);
- result = (text *) palloc(rsize);
- rptr = VARDATA(result);
- memcpy(rptr, code, rsize - VARHDRSZ);
- SET_VARSIZE(result, rsize);
- PG_RETURN_TEXT_P(result);
+
+ PG_RETURN_TEXT_P(cstring_to_text(code));
}
Datum
levenshtein(PG_FUNCTION_ARGS)
{
- char *str_s;
+ char *str_s = TextDatumGetCString(PG_GETARG_DATUM(0));
+ char *str_t = TextDatumGetCString(PG_GETARG_DATUM(1));
+ int cols = strlen(str_s) + 1;
+ int rows = strlen(str_t) + 1;
char *str_s0;
- char *str_t;
- int cols = 0;
- int rows = 0;
int *u_cells;
int *l_cells;
int *tmp;
int j;
/*
- * Fetch the arguments. str_s is referred to as the "source" cols = length
- * of source + 1 to allow for the initialization column str_t is referred
- * to as the "target", rows = length of target + 1 rows = length of target
- * + 1 to allow for the initialization row
+ * str_s is referred to as the "source", str_t is referred to as the
+ * "target", cols = length of source + 1 to allow for the initialization
+ * column, rows = length of target + 1 to allow for the initialization row
*/
- str_s = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0))));
- str_t = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(1))));
-
- cols = strlen(str_s) + 1;
- rows = strlen(str_t) + 1;
/*
* Restrict the length of the strings being compared to something
* Returns number of characters requested
* (suggested value is 4)
*/
-#define GET_TEXT(cstrp) DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(cstrp)))
-
PG_FUNCTION_INFO_V1(metaphone);
Datum
metaphone(PG_FUNCTION_ARGS)
{
+ char *str_i = TextDatumGetCString(PG_GETARG_DATUM(0));
+ size_t str_i_len = strlen(str_i);
int reqlen;
- char *str_i;
- size_t str_i_len;
char *metaph;
- text *result_text;
int retval;
- str_i = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0))));
- str_i_len = strlen(str_i);
-
/* return an empty string if we receive one */
if (!(str_i_len > 0))
- PG_RETURN_TEXT_P(GET_TEXT(""));
+ PG_RETURN_TEXT_P(cstring_to_text(""));
if (str_i_len > MAX_METAPHONE_STRLEN)
ereport(ERROR,
retval = _metaphone(str_i, reqlen, &metaph);
if (retval == META_SUCCESS)
- {
- result_text = DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(metaph)));
- PG_RETURN_TEXT_P(result_text);
- }
+ PG_RETURN_TEXT_P(cstring_to_text(metaph));
else
{
/* internal error */
elog(ERROR, "metaphone: failure");
-
- /*
- * Keep the compiler quiet
- */
+ /* keep the compiler quiet */
PG_RETURN_NULL();
}
}
char outstr[SOUNDEX_LEN + 1];
char *arg;
- arg = _textout(PG_GETARG_TEXT_P(0));
+ arg = text_to_cstring(PG_GETARG_TEXT_P(0));
_soundex(arg, outstr);
- PG_RETURN_TEXT_P(_textin(outstr));
+ PG_RETURN_TEXT_P(cstring_to_text(outstr));
}
static void
int i,
result;
- _soundex(_textout(PG_GETARG_TEXT_P(0)), sndx1);
- _soundex(_textout(PG_GETARG_TEXT_P(1)), sndx2);
+ _soundex(text_to_cstring(PG_GETARG_TEXT_P(0)), sndx1);
+ _soundex(text_to_cstring(PG_GETARG_TEXT_P(1)), sndx2);
result = 0;
for (i = 0; i < SOUNDEX_LEN; i++)
static void _soundex(const char *instr, char *outstr);
#define SOUNDEX_LEN 4
-#define _textin(str) DirectFunctionCall1(textin, CStringGetDatum(str))
-#define _textout(str) DatumGetPointer(DirectFunctionCall1(textout, PointerGetDatum(str)))
/* ABCDEFGHIJKLMNOPQRSTUVWXYZ */
static const char *soundex_table = "01230120022455012623010202";
PG_RETURN_NULL();
}
- out = palloc(VARHDRSZ + entry->vallen);
- memcpy(VARDATA(out), STRPTR(hs) + entry->pos + entry->keylen, entry->vallen);
- SET_VARSIZE(out, VARHDRSZ + entry->vallen);
+ out = cstring_to_text_with_len(STRPTR(hs) + entry->pos + entry->keylen,
+ entry->vallen);
PG_FREE_IF_COPY(hs, 0);
PG_FREE_IF_COPY(key, 1);
- PG_RETURN_POINTER(out);
+ PG_RETURN_TEXT_P(out);
}
PG_FUNCTION_INFO_V1(exists);
d = (Datum *) palloc(sizeof(Datum) * (hs->size + 1));
while (ptr - ARRPTR(hs) < hs->size)
{
- text *item = (text *) palloc(VARHDRSZ + ptr->keylen);
+ text *item;
- SET_VARSIZE(item, VARHDRSZ + ptr->keylen);
- memcpy(VARDATA(item), base + ptr->pos, ptr->keylen);
+ item = cstring_to_text_with_len(base + ptr->pos, ptr->keylen);
d[ptr - ARRPTR(hs)] = PointerGetDatum(item);
ptr++;
}
- a = construct_array(
- d,
+ a = construct_array(d,
hs->size,
TEXTOID,
-1,
false,
- 'i'
- );
+ 'i');
ptr = ARRPTR(hs);
while (ptr - ARRPTR(hs) < hs->size)
d = (Datum *) palloc(sizeof(Datum) * (hs->size + 1));
while (ptr - ARRPTR(hs) < hs->size)
{
- int vallen = (ptr->valisnull) ? 0 : ptr->vallen;
- text *item = (text *) palloc(VARHDRSZ + vallen);
+ text *item;
- SET_VARSIZE(item, VARHDRSZ + vallen);
- memcpy(VARDATA(item), base + ptr->pos + ptr->keylen, vallen);
+ item = cstring_to_text_with_len(base + ptr->pos + ptr->keylen,
+ (ptr->valisnull) ? 0 : ptr->vallen);
d[ptr - ARRPTR(hs)] = PointerGetDatum(item);
ptr++;
}
- a = construct_array(
- d,
+ a = construct_array(d,
hs->size,
TEXTOID,
-1,
false,
- 'i'
- );
+ 'i');
ptr = ARRPTR(hs);
while (ptr - ARRPTR(hs) < hs->size)
if (st->i < st->hs->size)
{
HEntry *ptr = &(ARRPTR(st->hs)[st->i]);
- text *item = (text *) palloc(VARHDRSZ + ptr->keylen);
+ text *item;
- SET_VARSIZE(item, VARHDRSZ + ptr->keylen);
- memcpy(VARDATA(item), STRPTR(st->hs) + ptr->pos, ptr->keylen);
+ item = cstring_to_text_with_len(STRPTR(st->hs) + ptr->pos,
+ ptr->keylen);
st->i++;
SRF_RETURN_NEXT(funcctx, PointerGetDatum(item));
}
else
{
- int vallen = ptr->vallen;
- text *item = (text *) palloc(VARHDRSZ + vallen);
+ text *item;
- SET_VARSIZE(item, VARHDRSZ + vallen);
- memcpy(VARDATA(item), STRPTR(st->hs) + ptr->pos + ptr->keylen, vallen);
+ item = cstring_to_text_with_len(STRPTR(st->hs) + ptr->pos + ptr->keylen,
+ ptr->vallen);
st->i++;
SRF_RETURN_NEXT(funcctx, PointerGetDatum(item));
text *item;
HeapTuple tuple;
- item = (text *) palloc(VARHDRSZ + ptr->keylen);
- SET_VARSIZE(item, VARHDRSZ + ptr->keylen);
- memcpy(VARDATA(item), STRPTR(st->hs) + ptr->pos, ptr->keylen);
+ item = cstring_to_text_with_len(STRPTR(st->hs) + ptr->pos, ptr->keylen);
dvalues[0] = PointerGetDatum(item);
if (ptr->valisnull)
}
else
{
- int vallen = ptr->vallen;
-
- item = (text *) palloc(VARHDRSZ + vallen);
- SET_VARSIZE(item, VARHDRSZ + vallen);
- memcpy(VARDATA(item), STRPTR(st->hs) + ptr->pos + ptr->keylen, vallen);
+ item = cstring_to_text_with_len(STRPTR(st->hs) + ptr->pos + ptr->keylen,
+ ptr->vallen);
dvalues[1] = PointerGetDatum(item);
}
st->i++;
if (len == 0)
{
- res = (text *) palloc(1 + VARHDRSZ);
- SET_VARSIZE(res, 1 + VARHDRSZ);
- *((char *) VARDATA(res)) = 'T';
+ res = cstring_to_text("T");
}
else
{
nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
*(nrm.cur) = '\0';
infix(&nrm, true);
-
- res = (text *) palloc(nrm.cur - nrm.buf + VARHDRSZ);
- SET_VARSIZE(res, nrm.cur - nrm.buf + VARHDRSZ);
- memcpy(VARDATA(res), nrm.buf, nrm.cur - nrm.buf);
+ res = cstring_to_text_with_len(nrm.buf, nrm.cur - nrm.buf);
}
pfree(q);
- PG_RETURN_POINTER(res);
+ PG_RETURN_TEXT_P(res);
}
ltree_addtext(PG_FUNCTION_ARGS)
{
ltree *a = PG_GETARG_LTREE(0);
- text *b = PG_GETARG_TEXT_P(1);
+ text *b = PG_GETARG_TEXT_PP(1);
char *s;
ltree *r,
*tmp;
- s = (char *) palloc(VARSIZE(b) - VARHDRSZ + 1);
- memcpy(s, VARDATA(b), VARSIZE(b) - VARHDRSZ);
- s[VARSIZE(b) - VARHDRSZ] = '\0';
+ s = text_to_cstring(b);
- tmp = (ltree *) DatumGetPointer(DirectFunctionCall1(
- ltree_in,
- PointerGetDatum(s)
- ));
+ tmp = (ltree *) DatumGetPointer(DirectFunctionCall1(ltree_in,
+ PointerGetDatum(s)));
pfree(s);
ltree_textadd(PG_FUNCTION_ARGS)
{
ltree *a = PG_GETARG_LTREE(1);
- text *b = PG_GETARG_TEXT_P(0);
+ text *b = PG_GETARG_TEXT_PP(0);
char *s;
ltree *r,
*tmp;
- s = (char *) palloc(VARSIZE(b) - VARHDRSZ + 1);
- memcpy(s, VARDATA(b), VARSIZE(b) - VARHDRSZ);
- s[VARSIZE(b) - VARHDRSZ] = '\0';
+ s = text_to_cstring(b);
- tmp = (ltree *) DatumGetPointer(DirectFunctionCall1(
- ltree_in,
- PointerGetDatum(s)
- ));
+ tmp = (ltree *) DatumGetPointer(DirectFunctionCall1(ltree_in,
+ PointerGetDatum(s)));
pfree(s);
Datum
text2ltree(PG_FUNCTION_ARGS)
{
- text *in = PG_GETARG_TEXT_P(0);
- char *s = (char *) palloc(VARSIZE(in) - VARHDRSZ + 1);
+ text *in = PG_GETARG_TEXT_PP(0);
+ char *s;
ltree *out;
- memcpy(s, VARDATA(in), VARSIZE(in) - VARHDRSZ);
- s[VARSIZE(in) - VARHDRSZ] = '\0';
+ s = text_to_cstring(in);
- out = (ltree *) DatumGetPointer(DirectFunctionCall1(
- ltree_in,
- PointerGetDatum(s)
- ));
+ out = (ltree *) DatumGetPointer(DirectFunctionCall1(ltree_in,
+ PointerGetDatum(s)));
pfree(s);
PG_FREE_IF_COPY(in, 0);
PG_RETURN_POINTER(out);
Datum heap_page_items(PG_FUNCTION_ARGS);
-#define GET_TEXT(str_) \
- DirectFunctionCall1(textin, CStringGetDatum(str_))
/*
* bits_to_text
bits_len = tuphdr->t_hoff -
(((char *) tuphdr->t_bits) -((char *) tuphdr));
- values[11] = GET_TEXT(
- bits_to_text(tuphdr->t_bits, bits_len * 8));
+ values[11] = CStringGetTextDatum(
+ bits_to_text(tuphdr->t_bits, bits_len * 8));
}
else
nulls[11] = true;
lsn = PageGetLSN(page);
snprintf(lsnchar, sizeof(lsnchar), "%X/%X", lsn.xlogid, lsn.xrecoff);
- values[0] = DirectFunctionCall1(textin, CStringGetDatum(lsnchar));
+ values[0] = CStringGetTextDatum(lsnchar);
values[1] = UInt16GetDatum(PageGetTLI(page));
values[2] = UInt16GetDatum(page->pd_flags);
values[3] = UInt16GetDatum(page->pd_lower);
#include "fmgr.h"
#include "parser/scansup.h"
+#include "utils/builtins.h"
#include "px.h"
#include "px-crypt.h"
Datum
pg_gen_salt(PG_FUNCTION_ARGS)
{
- text *arg0;
+ text *arg0 = PG_GETARG_TEXT_PP(0);
int len;
- text *res;
char buf[PX_MAX_SALT_LEN + 1];
- arg0 = PG_GETARG_TEXT_P(0);
-
- len = VARSIZE(arg0) - VARHDRSZ;
- len = len > PX_MAX_SALT_LEN ? PX_MAX_SALT_LEN : len;
- memcpy(buf, VARDATA(arg0), len);
- buf[len] = 0;
+ text_to_cstring_buffer(arg0, buf, sizeof(buf));
len = px_gen_salt(buf, buf, 0);
if (len < 0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("gen_salt: %s", px_strerror(len))));
- res = (text *) palloc(len + VARHDRSZ);
- SET_VARSIZE(res, len + VARHDRSZ);
- memcpy(VARDATA(res), buf, len);
-
PG_FREE_IF_COPY(arg0, 0);
- PG_RETURN_TEXT_P(res);
+ PG_RETURN_TEXT_P(cstring_to_text_with_len(buf, len));
}
/* SQL function: pg_gen_salt(text, int4) returns text */
Datum
pg_gen_salt_rounds(PG_FUNCTION_ARGS)
{
- text *arg0;
- int rounds;
+ text *arg0 = PG_GETARG_TEXT_PP(0);
+ int rounds = PG_GETARG_INT32(1);
int len;
- text *res;
char buf[PX_MAX_SALT_LEN + 1];
- arg0 = PG_GETARG_TEXT_P(0);
- rounds = PG_GETARG_INT32(1);
-
- len = VARSIZE(arg0) - VARHDRSZ;
- len = len > PX_MAX_SALT_LEN ? PX_MAX_SALT_LEN : len;
- memcpy(buf, VARDATA(arg0), len);
- buf[len] = 0;
+ text_to_cstring_buffer(arg0, buf, sizeof(buf));
len = px_gen_salt(buf, buf, rounds);
if (len < 0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("gen_salt: %s", px_strerror(len))));
- res = (text *) palloc(len + VARHDRSZ);
- SET_VARSIZE(res, len + VARHDRSZ);
- memcpy(VARDATA(res), buf, len);
-
PG_FREE_IF_COPY(arg0, 0);
- PG_RETURN_TEXT_P(res);
+ PG_RETURN_TEXT_P(cstring_to_text_with_len(buf, len));
}
/* SQL function: pg_crypt(psw:text, salt:text) returns text */
Datum
pg_crypt(PG_FUNCTION_ARGS)
{
- text *arg0;
- text *arg1;
- unsigned len0,
- len1,
- clen;
+ text *arg0 = PG_GETARG_TEXT_PP(0);
+ text *arg1 = PG_GETARG_TEXT_PP(1);
char *buf0,
*buf1,
*cres,
*resbuf;
text *res;
- arg0 = PG_GETARG_TEXT_P(0);
- arg1 = PG_GETARG_TEXT_P(1);
- len0 = VARSIZE(arg0) - VARHDRSZ;
- len1 = VARSIZE(arg1) - VARHDRSZ;
-
- buf0 = palloc(len0 + 1);
- buf1 = palloc(len1 + 1);
-
- memcpy(buf0, VARDATA(arg0), len0);
- memcpy(buf1, VARDATA(arg1), len1);
-
- buf0[len0] = '\0';
- buf1[len1] = '\0';
+ buf0 = text_to_cstring(arg0);
+ buf1 = text_to_cstring(arg1);
resbuf = palloc0(PX_MAX_CRYPT);
(errcode(ERRCODE_EXTERNAL_ROUTINE_INVOCATION_EXCEPTION),
errmsg("crypt(3) returned NULL")));
- clen = strlen(cres);
+ res = cstring_to_text(cres);
- res = (text *) palloc(clen + VARHDRSZ);
- SET_VARSIZE(res, clen + VARHDRSZ);
- memcpy(VARDATA(res), cres, clen);
pfree(resbuf);
PG_FREE_IF_COPY(arg0, 0);
i++;
chattrs[chnattrs] = attnum;
- seqname = DirectFunctionCall1(textin,
- CStringGetDatum(args[i]));
+ seqname = CStringGetTextDatum(args[i]);
newvals[chnattrs] = DirectFunctionCall1(nextval, seqname);
/* nextval now returns int64; coerce down to int32 */
newvals[chnattrs] = Int32GetDatum((int32) DatumGetInt64(newvals[chnattrs]));
args[0], relname)));
/* create fields containing name */
- newval = DirectFunctionCall1(textin,
- CStringGetDatum(GetUserNameFromId(GetUserId())));
+ newval = CStringGetTextDatum(GetUserNameFromId(GetUserId()));
/* construct new tuple */
rettuple = SPI_modifytuple(rel, rettuple, 1, &attnum, &newval, NULL);
}
/* create fields containing name */
- newuser = DirectFunctionCall1(textin, CStringGetDatum(GetUserNameFromId(GetUserId())));
+ newuser = CStringGetTextDatum(GetUserNameFromId(GetUserId()));
nulltext = (Datum) NULL;
size - 1,
PG_UTF8,
GetDatabaseEncoding());
- outlen = strlen(dp);
- result = palloc(VARHDRSZ + outlen);
- memcpy(VARDATA(result), dp, outlen);
- SET_VARSIZE(result, VARHDRSZ + outlen);
+ result = cstring_to_text(dp);
if (dp != sp)
pfree(dp);
Datum
X509_NAME_field_to_text(X509_NAME *name, text *fieldName)
{
- char *sp;
char *string_fieldname;
- char *dp;
- size_t name_len = VARSIZE(fieldName) - VARHDRSZ;
int nid,
- index,
- i;
+ index;
ASN1_STRING *data;
- string_fieldname = palloc(name_len + 1);
- sp = VARDATA(fieldName);
- dp = string_fieldname;
- for (i = 0; i < name_len; i++)
- *dp++ = *sp++;
- *dp = '\0';
+ string_fieldname = text_to_cstring(fieldName);
nid = OBJ_txt2nid(string_fieldname);
if (nid == NID_undef)
ereport(ERROR,
count = X509_NAME_entry_count(name);
X509_NAME_ENTRY *e;
ASN1_STRING *v;
-
const char *field_name;
- size_t size,
- outlen;
+ size_t size;
char *sp;
char *dp;
text *result;
GetDatabaseEncoding());
BIO_free(membuf);
- outlen = strlen(dp);
- result = palloc(VARHDRSZ + outlen);
- memcpy(VARDATA(result), dp, outlen);
- SET_VARSIZE(result, VARHDRSZ + outlen);
+ result = cstring_to_text(dp);
/*
* pg_do_encoding_conversion has annoying habit of returning source
char *lastrowid; /* rowid of the last tuple sent */
} crosstab_fctx;
-#define GET_TEXT(cstrp) DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(cstrp)))
-#define GET_STR(textp) DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(textp)))
#define xpfree(var_) \
do { \
if (var_ != NULL) \
/* stuff done only on the first call of the function */
if (SRF_IS_FIRSTCALL())
{
- char *sql = GET_STR(PG_GETARG_TEXT_P(0));
+ char *sql = text_to_cstring(PG_GETARG_TEXT_PP(0));
TupleDesc tupdesc;
int ret;
int proc;
Datum
crosstab_hash(PG_FUNCTION_ARGS)
{
- char *sql = GET_STR(PG_GETARG_TEXT_P(0));
- char *cats_sql = GET_STR(PG_GETARG_TEXT_P(1));
+ char *sql = text_to_cstring(PG_GETARG_TEXT_PP(0));
+ char *cats_sql = text_to_cstring(PG_GETARG_TEXT_PP(1));
ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
TupleDesc tupdesc;
MemoryContext per_query_ctx;
Datum
connectby_text(PG_FUNCTION_ARGS)
{
- char *relname = GET_STR(PG_GETARG_TEXT_P(0));
- char *key_fld = GET_STR(PG_GETARG_TEXT_P(1));
- char *parent_key_fld = GET_STR(PG_GETARG_TEXT_P(2));
- char *start_with = GET_STR(PG_GETARG_TEXT_P(3));
+ char *relname = text_to_cstring(PG_GETARG_TEXT_PP(0));
+ char *key_fld = text_to_cstring(PG_GETARG_TEXT_PP(1));
+ char *parent_key_fld = text_to_cstring(PG_GETARG_TEXT_PP(2));
+ char *start_with = text_to_cstring(PG_GETARG_TEXT_PP(3));
int max_depth = PG_GETARG_INT32(4);
char *branch_delim = NULL;
bool show_branch = false;
if (fcinfo->nargs == 6)
{
- branch_delim = GET_STR(PG_GETARG_TEXT_P(5));
+ branch_delim = text_to_cstring(PG_GETARG_TEXT_PP(5));
show_branch = true;
}
else
Datum
connectby_text_serial(PG_FUNCTION_ARGS)
{
- char *relname = GET_STR(PG_GETARG_TEXT_P(0));
- char *key_fld = GET_STR(PG_GETARG_TEXT_P(1));
- char *parent_key_fld = GET_STR(PG_GETARG_TEXT_P(2));
- char *orderby_fld = GET_STR(PG_GETARG_TEXT_P(3));
- char *start_with = GET_STR(PG_GETARG_TEXT_P(4));
+ char *relname = text_to_cstring(PG_GETARG_TEXT_PP(0));
+ char *key_fld = text_to_cstring(PG_GETARG_TEXT_PP(1));
+ char *parent_key_fld = text_to_cstring(PG_GETARG_TEXT_PP(2));
+ char *orderby_fld = text_to_cstring(PG_GETARG_TEXT_PP(3));
+ char *start_with = text_to_cstring(PG_GETARG_TEXT_PP(4));
int max_depth = PG_GETARG_INT32(5);
char *branch_delim = NULL;
bool show_branch = false;
if (fcinfo->nargs == 7)
{
- branch_delim = GET_STR(PG_GETARG_TEXT_P(6));
+ branch_delim = text_to_cstring(PG_GETARG_TEXT_PP(6));
show_branch = true;
}
else
text *result_text;
char *result;
- rawstr_text = DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(rawstr)));
- result_text = DatumGetTextP(DirectFunctionCall1(quote_literal, PointerGetDatum(rawstr_text)));
- result = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(result_text)));
+ rawstr_text = cstring_to_text(rawstr);
+ result_text = DatumGetTextP(DirectFunctionCall1(quote_literal,
+ PointerGetDatum(rawstr_text)));
+ result = text_to_cstring(result_text);
return result;
}
fcinfo->nargs++; \
} while (0)
-#define TextPGetCString(t) \
- DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(t)))
-#define CStringGetTextP(c) \
- DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(c)))
-
#define TextGetObjectId(infunction, text) \
DatumGetObjectId(DirectFunctionCall1(infunction, \
- DirectFunctionCall1(textout, PointerGetDatum(text))))
+ CStringGetDatum(text_to_cstring(text))))
#define UNSUPPORTED_FUNCTION(name) \
Datum name(PG_FUNCTION_ARGS); \
Datum
tsa_lexize_byname(PG_FUNCTION_ARGS)
{
- text *dictname = PG_GETARG_TEXT_P(0);
+ text *dictname = PG_GETARG_TEXT_PP(0);
Datum arg1 = PG_GETARG_DATUM(1);
return DirectFunctionCall2(ts_lexize,
Datum
tsa_set_curdict_byname(PG_FUNCTION_ARGS)
{
- text *name = PG_GETARG_TEXT_P(0);
+ text *name = PG_GETARG_TEXT_PP(0);
Oid dict_oid;
- dict_oid = TSDictionaryGetDictid(stringToQualifiedNameList(TextPGetCString(name)), false);
+ dict_oid = TSDictionaryGetDictid(stringToQualifiedNameList(text_to_cstring(name)), false);
current_dictionary_oid = dict_oid;
Datum
tsa_set_curprs_byname(PG_FUNCTION_ARGS)
{
- text *name = PG_GETARG_TEXT_P(0);
+ text *name = PG_GETARG_TEXT_PP(0);
Oid parser_oid;
- parser_oid = TSParserGetPrsid(stringToQualifiedNameList(TextPGetCString(name)), false);
+ parser_oid = TSParserGetPrsid(stringToQualifiedNameList(text_to_cstring(name)), false);
current_parser_oid = parser_oid;
Datum
tsa_set_curcfg_byname(PG_FUNCTION_ARGS)
{
- text *arg0 = PG_GETARG_TEXT_P(0);
+ text *arg0 = PG_GETARG_TEXT_PP(0);
char *name;
- name = TextPGetCString(arg0);
+ name = text_to_cstring(arg0);
set_config_option("default_text_search_config", name,
PGC_USERSET,
Datum
tsa_to_tsvector_name(PG_FUNCTION_ARGS)
{
- text *cfgname = PG_GETARG_TEXT_P(0);
+ text *cfgname = PG_GETARG_TEXT_PP(0);
Datum arg1 = PG_GETARG_DATUM(1);
Oid config_oid;
Datum
tsa_to_tsquery_name(PG_FUNCTION_ARGS)
{
- text *cfgname = PG_GETARG_TEXT_P(0);
+ text *cfgname = PG_GETARG_TEXT_PP(0);
Datum arg1 = PG_GETARG_DATUM(1);
Oid config_oid;
Datum
tsa_plainto_tsquery_name(PG_FUNCTION_ARGS)
{
- text *cfgname = PG_GETARG_TEXT_P(0);
+ text *cfgname = PG_GETARG_TEXT_PP(0);
Datum arg1 = PG_GETARG_DATUM(1);
Oid config_oid;
/* first parameter has to be converted to oid */
config_oid = DatumGetObjectId(DirectFunctionCall1(regconfigin,
- DirectFunctionCall1(textout, arg0)));
+ CStringGetDatum(TextDatumGetCString(arg0))));
if (PG_NARGS() == 3)
result = DirectFunctionCall3(ts_headline_byid,
result = uuid_generate_internal(mode,
ns_uuid,
- DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(name))));
+ text_to_cstring(name));
rc = uuid_destroy(ns_uuid);
if (rc != UUID_RC_OK)
char *errbuf; /* per line error buffer */
char *pgxml_errorMsg = NULL; /* overall error message */
-/* Convenience macros */
-
-#define GET_TEXT(cstrp) DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(cstrp)))
-#define GET_STR(textp) DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(textp)))
-
#define ERRBUF_SIZE 200
/* memory handling passthrough functions (e.g. palloc, pstrdup are
MemoryContext oldcontext;
/* Function parameters */
- char *pkeyfield = GET_STR(PG_GETARG_TEXT_P(0));
- char *xmlfield = GET_STR(PG_GETARG_TEXT_P(1));
- char *relname = GET_STR(PG_GETARG_TEXT_P(2));
- char *xpathset = GET_STR(PG_GETARG_TEXT_P(3));
- char *condition = GET_STR(PG_GETARG_TEXT_P(4));
+ char *pkeyfield = text_to_cstring(PG_GETARG_TEXT_PP(0));
+ char *xmlfield = text_to_cstring(PG_GETARG_TEXT_PP(1));
+ char *relname = text_to_cstring(PG_GETARG_TEXT_PP(2));
+ char *xpathset = text_to_cstring(PG_GETARG_TEXT_PP(3));
+ char *condition = text_to_cstring(PG_GETARG_TEXT_PP(4));
char **values;
xmlChar **xpaths;
/* declarations to come from xpath.c */
-
extern void elog_error(int level, char *explain, int force);
extern void pgxml_parser_init();
extern xmlChar *pgxml_texttoxmlchar(text *textstring);
-#define GET_STR(textp) DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(textp)))
-
/* local defs */
static void parse_params(const char **params, text *paramstr);
if (VARDATA(doct)[0] == '<')
doctree = xmlParseMemory((char *) VARDATA(doct), VARSIZE(doct) - VARHDRSZ);
else
- doctree = xmlParseFile(GET_STR(doct));
+ doctree = xmlParseFile(text_to_cstring(doct));
if (doctree == NULL)
{
stylesheet = xsltParseStylesheetDoc(ssdoc);
}
else
- stylesheet = xsltParseStylesheetFile((xmlChar *) GET_STR(ssheet));
+ stylesheet = xsltParseStylesheetFile((xmlChar *) text_to_cstring(ssheet));
if (stylesheet == NULL)
char *nvsep = "=";
char *itsep = ",";
- pstr = GET_STR(paramstr);
+ pstr = text_to_cstring(paramstr);
pos = pstr;
int proc;
/* Convert given text object to a C string */
- command = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(sql)));
+ command = text_to_cstring(sql);
SPI_connect();
char *p;
Node *val = NULL;
- s = DatumGetCString(DirectFunctionCall1(textout, optiondatums[i]));
+ s = TextDatumGetCString(optiondatums[i]);
p = strchr(s, '=');
if (p)
{
char *s;
char *p;
- s = DatumGetCString(DirectFunctionCall1(textout, optiondatums[i]));
+ s = TextDatumGetCString(optiondatums[i]);
p = strchr(s, '=');
if (p)
*p = '\0';
MemSet(nulls, 0, sizeof(nulls));
values[0] = TransactionIdGetDatum(gxact->proc.xid);
- values[1] = DirectFunctionCall1(textin, CStringGetDatum(gxact->gid));
+ values[1] = CStringGetTextDatum(gxact->gid);
values[2] = TimestampTzGetDatum(gxact->prepared_at);
values[3] = ObjectIdGetDatum(gxact->owner);
values[4] = ObjectIdGetDatum(gxact->proc.databaseId);
pg_start_backup(PG_FUNCTION_ARGS)
{
text *backupid = PG_GETARG_TEXT_P(0);
- text *result;
char *backupidstr;
XLogRecPtr checkpointloc;
XLogRecPtr startpoint;
errhint("archive_command must be defined before "
"online backups can be made safely.")));
- backupidstr = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(backupid)));
+ backupidstr = text_to_cstring(backupid);
/*
* Mark backup active in shared memory. We must do full-page WAL writes
*/
snprintf(xlogfilename, sizeof(xlogfilename), "%X/%X",
startpoint.xlogid, startpoint.xrecoff);
- result = DatumGetTextP(DirectFunctionCall1(textin,
- CStringGetDatum(xlogfilename)));
- PG_RETURN_TEXT_P(result);
+ PG_RETURN_TEXT_P(cstring_to_text(xlogfilename));
}
/*
Datum
pg_stop_backup(PG_FUNCTION_ARGS)
{
- text *result;
XLogRecPtr startpoint;
XLogRecPtr stoppoint;
pg_time_t stamp_time;
*/
snprintf(stopxlogfilename, sizeof(stopxlogfilename), "%X/%X",
stoppoint.xlogid, stoppoint.xrecoff);
- result = DatumGetTextP(DirectFunctionCall1(textin,
- CStringGetDatum(stopxlogfilename)));
- PG_RETURN_TEXT_P(result);
+ PG_RETURN_TEXT_P(cstring_to_text(stopxlogfilename));
}
/*
Datum
pg_switch_xlog(PG_FUNCTION_ARGS)
{
- text *result;
XLogRecPtr switchpoint;
char location[MAXFNAMELEN];
*/
snprintf(location, sizeof(location), "%X/%X",
switchpoint.xlogid, switchpoint.xrecoff);
- result = DatumGetTextP(DirectFunctionCall1(textin,
- CStringGetDatum(location)));
- PG_RETURN_TEXT_P(result);
+ PG_RETURN_TEXT_P(cstring_to_text(location));
}
/*
Datum
pg_current_xlog_location(PG_FUNCTION_ARGS)
{
- text *result;
char location[MAXFNAMELEN];
/* Make sure we have an up-to-date local LogwrtResult */
snprintf(location, sizeof(location), "%X/%X",
LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff);
-
- result = DatumGetTextP(DirectFunctionCall1(textin,
- CStringGetDatum(location)));
- PG_RETURN_TEXT_P(result);
+ PG_RETURN_TEXT_P(cstring_to_text(location));
}
/*
Datum
pg_current_xlog_insert_location(PG_FUNCTION_ARGS)
{
- text *result;
XLogCtlInsert *Insert = &XLogCtl->Insert;
XLogRecPtr current_recptr;
char location[MAXFNAMELEN];
snprintf(location, sizeof(location), "%X/%X",
current_recptr.xlogid, current_recptr.xrecoff);
-
- result = DatumGetTextP(DirectFunctionCall1(textin,
- CStringGetDatum(location)));
- PG_RETURN_TEXT_P(result);
+ PG_RETURN_TEXT_P(cstring_to_text(location));
}
/*
/*
* Read input and parse
*/
- locationstr = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(location)));
+ locationstr = text_to_cstring(location);
if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
ereport(ERROR,
XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
XLogFileName(xlogfilename, ThisTimeLineID, xlogid, xlogseg);
- values[0] = DirectFunctionCall1(textin,
- CStringGetDatum(xlogfilename));
+ values[0] = CStringGetTextDatum(xlogfilename);
isnull[0] = false;
/*
pg_xlogfile_name(PG_FUNCTION_ARGS)
{
text *location = PG_GETARG_TEXT_P(0);
- text *result;
char *locationstr;
unsigned int uxlogid;
unsigned int uxrecoff;
XLogRecPtr locationpoint;
char xlogfilename[MAXFNAMELEN];
- locationstr = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(location)));
+ locationstr = text_to_cstring(location);
if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
ereport(ERROR,
XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
XLogFileName(xlogfilename, ThisTimeLineID, xlogid, xlogseg);
- result = DatumGetTextP(DirectFunctionCall1(textin,
- CStringGetDatum(xlogfilename)));
- PG_RETURN_TEXT_P(result);
+ PG_RETURN_TEXT_P(cstring_to_text(xlogfilename));
}
/*
*/
values[Anum_pg_attrdef_adrelid - 1] = RelationGetRelid(rel);
values[Anum_pg_attrdef_adnum - 1] = attnum;
- values[Anum_pg_attrdef_adbin - 1] = DirectFunctionCall1(textin,
- CStringGetDatum(adbin));
- values[Anum_pg_attrdef_adsrc - 1] = DirectFunctionCall1(textin,
- CStringGetDatum(adsrc));
+ values[Anum_pg_attrdef_adbin - 1] = CStringGetTextDatum(adbin);
+ values[Anum_pg_attrdef_adsrc - 1] = CStringGetTextDatum(adsrc);
adrel = heap_open(AttrDefaultRelationId, RowExclusiveLock);
char *exprsString;
exprsString = nodeToString(indexInfo->ii_Expressions);
- exprsDatum = DirectFunctionCall1(textin,
- CStringGetDatum(exprsString));
+ exprsDatum = CStringGetTextDatum(exprsString);
pfree(exprsString);
}
else
char *predString;
predString = nodeToString(make_ands_explicit(indexInfo->ii_Predicate));
- predDatum = DirectFunctionCall1(textin,
- CStringGetDatum(predString));
+ predDatum = CStringGetTextDatum(predString);
pfree(predString);
}
else
values[Anum_pg_aggregate_aggsortop - 1] = ObjectIdGetDatum(sortop);
values[Anum_pg_aggregate_aggtranstype - 1] = ObjectIdGetDatum(aggTransType);
if (agginitval)
- values[Anum_pg_aggregate_agginitval - 1] =
- DirectFunctionCall1(textin, CStringGetDatum(agginitval));
+ values[Anum_pg_aggregate_agginitval - 1] = CStringGetTextDatum(agginitval);
else
nulls[Anum_pg_aggregate_agginitval - 1] = 'n';
* initialize the binary form of the check constraint.
*/
if (conBin)
- values[Anum_pg_constraint_conbin - 1] = DirectFunctionCall1(textin,
- CStringGetDatum(conBin));
+ values[Anum_pg_constraint_conbin - 1] = CStringGetTextDatum(conBin);
else
nulls[Anum_pg_constraint_conbin - 1] = 'n';
* initialize the text form of the check constraint
*/
if (conSrc)
- values[Anum_pg_constraint_consrc - 1] = DirectFunctionCall1(textin,
- CStringGetDatum(conSrc));
+ values[Anum_pg_constraint_consrc - 1] = CStringGetTextDatum(conSrc);
else
nulls[Anum_pg_constraint_consrc - 1] = 'n';
values[Anum_pg_proc_proargnames - 1] = parameterNames;
else
nulls[Anum_pg_proc_proargnames - 1] = 'n';
- values[Anum_pg_proc_prosrc - 1] = DirectFunctionCall1(textin,
- CStringGetDatum(prosrc));
- values[Anum_pg_proc_probin - 1] = DirectFunctionCall1(textin,
- CStringGetDatum(probin));
+ values[Anum_pg_proc_prosrc - 1] = CStringGetTextDatum(prosrc);
+ values[Anum_pg_proc_probin - 1] = CStringGetTextDatum(probin);
if (proconfig != PointerGetDatum(NULL))
values[Anum_pg_proc_proconfig - 1] = proconfig;
else
tmp = SysCacheGetAttr(PROCOID, tuple, Anum_pg_proc_prosrc, &isnull);
if (isnull)
elog(ERROR, "null prosrc");
- prosrc = DatumGetCString(DirectFunctionCall1(textout, tmp));
+ prosrc = TextDatumGetCString(tmp);
if (fmgr_internal_function(prosrc) == InvalidOid)
ereport(ERROR,
tmp = SysCacheGetAttr(PROCOID, tuple, Anum_pg_proc_prosrc, &isnull);
if (isnull)
elog(ERROR, "null prosrc");
- prosrc = DatumGetCString(DirectFunctionCall1(textout, tmp));
+ prosrc = TextDatumGetCString(tmp);
tmp = SysCacheGetAttr(PROCOID, tuple, Anum_pg_proc_probin, &isnull);
if (isnull)
elog(ERROR, "null probin");
- probin = DatumGetCString(DirectFunctionCall1(textout, tmp));
+ probin = TextDatumGetCString(tmp);
(void) load_external_function(probin, prosrc, true, &libraryhandle);
(void) fetch_finfo_record(libraryhandle, prosrc);
if (isnull)
elog(ERROR, "null prosrc");
- prosrc = DatumGetCString(DirectFunctionCall1(textout, tmp));
+ prosrc = TextDatumGetCString(tmp);
/*
* Setup error traceback support for ereport().
tmp = SysCacheGetAttr(PROCOID, tuple, Anum_pg_proc_prosrc, &isnull);
if (isnull)
elog(ERROR, "null prosrc");
- prosrc = DatumGetCString(DirectFunctionCall1(textout, tmp));
+ prosrc = TextDatumGetCString(tmp);
if (!function_parse_error_transpose(prosrc))
{
* course.
*/
if (defaultTypeBin)
- values[i] = DirectFunctionCall1(textin,
- CStringGetDatum(defaultTypeBin));
+ values[i] = CStringGetTextDatum(defaultTypeBin);
else
nulls[i] = 'n';
i++; /* typdefaultbin */
* initialize the default value for this type.
*/
if (defaultTypeValue)
- values[i] = DirectFunctionCall1(textin,
- CStringGetDatum(defaultTypeValue));
+ values[i] = CStringGetTextDatum(defaultTypeValue);
else
nulls[i] = 'n';
i++; /* typdefault */
values[i++] = ObjectIdGetDatum(oid);
values[i++] = ObjectIdGetDatum(classoid);
values[i++] = Int32GetDatum(subid);
- values[i++] = DirectFunctionCall1(textin, CStringGetDatum(comment));
+ values[i++] = CStringGetTextDatum(comment);
}
/* Use the index to search for a matching old tuple */
i = 0;
values[i++] = ObjectIdGetDatum(oid);
values[i++] = ObjectIdGetDatum(classoid);
- values[i++] = DirectFunctionCall1(textin, CStringGetDatum(comment));
+ values[i++] = CStringGetTextDatum(comment);
}
/* Use the index to search for a matching old tuple */
if (fp->name && fp->name[0])
{
- paramNames[i] = DirectFunctionCall1(textin,
- CStringGetDatum(fp->name));
+ paramNames[i] = CStringGetTextDatum(fp->name);
have_names = true;
}
for (i = 0; i < parameterCount; i++)
{
if (paramNames[i] == PointerGetDatum(NULL))
- paramNames[i] = DirectFunctionCall1(textin,
- CStringGetDatum(""));
+ paramNames[i] = CStringGetTextDatum("");
}
*parameterNames = construct_array(paramNames, parameterCount, TEXTOID,
-1, false, 'i');
MemSet(nulls, 0, sizeof(nulls));
- values[0] = DirectFunctionCall1(textin,
- CStringGetDatum(prep_stmt->stmt_name));
+ values[0] = CStringGetTextDatum(prep_stmt->stmt_name);
if (prep_stmt->plansource->query_string == NULL)
nulls[1] = true;
else
- values[1] = DirectFunctionCall1(textin,
- CStringGetDatum(prep_stmt->plansource->query_string));
+ values[1] = CStringGetTextDatum(prep_stmt->plansource->query_string);
values[2] = TimestampTzGetDatum(prep_stmt->prepare_time);
values[3] = build_regtype_array(prep_stmt->plansource->param_types,
datum = heap_getattr(tup, Anum_pg_pltemplate_tmplhandler,
RelationGetDescr(rel), &isnull);
if (!isnull)
- result->tmplhandler =
- DatumGetCString(DirectFunctionCall1(textout, datum));
+ result->tmplhandler = TextDatumGetCString(datum);
datum = heap_getattr(tup, Anum_pg_pltemplate_tmplvalidator,
RelationGetDescr(rel), &isnull);
if (!isnull)
- result->tmplvalidator =
- DatumGetCString(DirectFunctionCall1(textout, datum));
+ result->tmplvalidator = TextDatumGetCString(datum);
datum = heap_getattr(tup, Anum_pg_pltemplate_tmpllibrary,
RelationGetDescr(rel), &isnull);
if (!isnull)
- result->tmpllibrary =
- DatumGetCString(DirectFunctionCall1(textout, datum));
+ result->tmpllibrary = TextDatumGetCString(datum);
/* Ignore template if handler or library info is missing */
if (!result->tmplhandler || !result->tmpllibrary)
expr = DirectFunctionCall2(pg_get_expr, attr,
ObjectIdGetDatum(con->conrelid));
- return DatumGetCString(DirectFunctionCall1(textout, expr));
+ return TextDatumGetCString(expr);
}
/*
values[Anum_pg_tablespace_spcowner - 1] =
ObjectIdGetDatum(ownerId);
values[Anum_pg_tablespace_spclocation - 1] =
- DirectFunctionCall1(textin, CStringGetDatum(location));
+ CStringGetTextDatum(location);
nulls[Anum_pg_tablespace_spcacl - 1] = 'n';
tuple = heap_formtuple(rel->rd_att, values, nulls);
appendStringInfo(&buf, ", ");
}
- result = CStringGetTextP(buf.data);
+ result = cstring_to_text_with_len(buf.data, buf.len);
pfree(buf.data);
return result;
}
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("invalid parameter list format: \"%s\"",
- TextPGetCString(in))));
+ text_to_cstring(in))));
break;
case CS_WAITVALUE:
if (*ptr == '\'')
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("invalid parameter list format: \"%s\"",
- TextPGetCString(in))));
+ text_to_cstring(in))));
pfree(workspace);
datum = SysCacheGetAttr(TYPEOID, typeTup,
Anum_pg_type_typdefault, &isnull);
if (!isnull)
- defaultValue = DatumGetCString(DirectFunctionCall1(textout, datum));
+ defaultValue = TextDatumGetCString(datum);
/* Inherited default binary value */
datum = SysCacheGetAttr(TYPEOID, typeTup,
Anum_pg_type_typdefaultbin, &isnull);
if (!isnull)
- defaultValueBin = DatumGetCString(DirectFunctionCall1(textout, datum));
+ defaultValueBin = TextDatumGetCString(datum);
/*
* Run through constraints manually to avoid the additional processing
/*
* Form an updated tuple with the new default and write it back.
*/
- new_record[Anum_pg_type_typdefaultbin - 1] = DirectFunctionCall1(textin,
- CStringGetDatum(nodeToString(defaultExpr)));
+ new_record[Anum_pg_type_typdefaultbin - 1] = CStringGetTextDatum(nodeToString(defaultExpr));
new_record_repl[Anum_pg_type_typdefaultbin - 1] = 'r';
- new_record[Anum_pg_type_typdefault - 1] = DirectFunctionCall1(textin,
- CStringGetDatum(defaultValue));
+ new_record[Anum_pg_type_typdefault - 1] = CStringGetTextDatum(defaultValue);
new_record_repl[Anum_pg_type_typdefault - 1] = 'r';
}
}
elog(ERROR, "domain \"%s\" constraint \"%s\" has NULL conbin",
NameStr(typTup->typname), NameStr(c->conname));
- check_expr = (Expr *)
- stringToNode(DatumGetCString(DirectFunctionCall1(textout,
- val)));
+ check_expr = (Expr *) stringToNode(TextDatumGetCString(val));
/* ExecInitExpr assumes we already fixed opfuncids */
fix_opfuncids((Node *) check_expr);
{
if (!encrypt_password || isMD5(password))
new_record[Anum_pg_authid_rolpassword - 1] =
- DirectFunctionCall1(textin, CStringGetDatum(password));
+ CStringGetTextDatum(password);
else
{
if (!pg_md5_encrypt(password, stmt->role, strlen(stmt->role),
encrypted_password))
elog(ERROR, "password encryption failed");
new_record[Anum_pg_authid_rolpassword - 1] =
- DirectFunctionCall1(textin, CStringGetDatum(encrypted_password));
+ CStringGetTextDatum(encrypted_password);
}
}
else
{
if (!encrypt_password || isMD5(password))
new_record[Anum_pg_authid_rolpassword - 1] =
- DirectFunctionCall1(textin, CStringGetDatum(password));
+ CStringGetTextDatum(password);
else
{
if (!pg_md5_encrypt(password, stmt->role, strlen(stmt->role),
encrypted_password))
elog(ERROR, "password encryption failed");
new_record[Anum_pg_authid_rolpassword - 1] =
- DirectFunctionCall1(textin, CStringGetDatum(encrypted_password));
+ CStringGetTextDatum(encrypted_password);
}
new_record_repl[Anum_pg_authid_rolpassword - 1] = 'r';
}
datum = heap_getattr(oldtuple, Anum_pg_authid_rolpassword, dsc, &isnull);
- if (!isnull && isMD5(DatumGetCString(DirectFunctionCall1(textout, datum))))
+ if (!isnull && isMD5(TextDatumGetCString(datum)))
{
/* MD5 uses the username as salt, so just clear it on a rename */
repl_repl[Anum_pg_authid_rolpassword - 1] = 'r';
{
Assert(prm->ptype == REFCURSOROID);
/* We know that refcursor uses text's I/O routines */
- return DatumGetCString(DirectFunctionCall1(textout,
- prm->value));
+ return TextDatumGetCString(prm->value);
}
}
if (*isNull)
result = NULL;
else
- {
- int len = buf.len + VARHDRSZ;
-
- result = palloc(len);
- SET_VARSIZE(result, len);
- memcpy(VARDATA(result), buf.data, buf.len);
- }
+ result = cstring_to_text_with_len(buf.data, buf.len);
pfree(buf.data);
return PointerGetDatum(result);
&isNull);
if (isNull)
elog(ERROR, "null prosrc for function %u", foid);
- fcache->src = DatumGetCString(DirectFunctionCall1(textout, tmp));
+ fcache->src = TextDatumGetCString(tmp);
/*
* Parse and rewrite the queries in the function text.
&isnull);
if (isnull)
elog(ERROR, "null prosrc");
- prosrc = DatumGetCString(DirectFunctionCall1(textout, tmp));
+ prosrc = TextDatumGetCString(tmp);
errposition(0);
internalerrposition(syntaxerrposition);
internalerrquery(prosrc);
Datum initVal;
getTypeInputInfo(transtype, &typinput, &typioparam);
- strInitVal = DatumGetCString(DirectFunctionCall1(textout, textInitVal));
+ strInitVal = TextDatumGetCString(textInitVal);
initVal = OidInputFunctionCall(typinput, strInitVal,
typioparam, -1);
pfree(strInitVal);
#include "miscadmin.h"
#include "storage/fd.h"
#include "storage/large_object.h"
+#include "utils/builtins.h"
#include "utils/memutils.h"
Datum
lo_import(PG_FUNCTION_ARGS)
{
- text *filename = PG_GETARG_TEXT_P(0);
+ text *filename = PG_GETARG_TEXT_PP(0);
PG_RETURN_OID(lo_import_internal(filename, InvalidOid));
}
Datum
lo_import_with_oid(PG_FUNCTION_ARGS)
{
- text *filename = PG_GETARG_TEXT_P(0);
+ text *filename = PG_GETARG_TEXT_PP(0);
Oid oid = PG_GETARG_OID(1);
PG_RETURN_OID(lo_import_internal(filename, oid));
/*
* open the file to be read in
*/
- nbytes = VARSIZE(filename) - VARHDRSZ;
- if (nbytes >= MAXPGPATH)
- nbytes = MAXPGPATH - 1;
- memcpy(fnamebuf, VARDATA(filename), nbytes);
- fnamebuf[nbytes] = '\0';
+ text_to_cstring_buffer(filename, fnamebuf, sizeof(fnamebuf));
fd = PathNameOpenFile(fnamebuf, O_RDONLY | PG_BINARY, 0666);
if (fd < 0)
ereport(ERROR,
lo_export(PG_FUNCTION_ARGS)
{
Oid lobjId = PG_GETARG_OID(0);
- text *filename = PG_GETARG_TEXT_P(1);
+ text *filename = PG_GETARG_TEXT_PP(1);
File fd;
int nbytes,
tmp;
* 022. This code used to drop it all the way to 0, but creating
* world-writable export files doesn't seem wise.
*/
- nbytes = VARSIZE(filename) - VARHDRSZ;
- if (nbytes >= MAXPGPATH)
- nbytes = MAXPGPATH - 1;
- memcpy(fnamebuf, VARDATA(filename), nbytes);
- fnamebuf[nbytes] = '\0';
+ text_to_cstring_buffer(filename, fnamebuf, sizeof(fnamebuf));
oumask = umask((mode_t) 0022);
fd = PathNameOpenFile(fnamebuf, O_CREAT | O_WRONLY | O_TRUNC | PG_BINARY, 0666);
umask(oumask);
switch (prefix_const->consttype)
{
case TEXTOID:
- prefix = DatumGetCString(DirectFunctionCall1(textout,
- prefix_const->constvalue));
+ prefix = TextDatumGetCString(prefix_const->constvalue);
break;
case BYTEAOID:
prefix = DatumGetCString(DirectFunctionCall1(byteaout,
string_to_datum(const char *str, Oid datatype)
{
/*
- * We cheat a little by assuming that textin() will do for bpchar and
- * varchar constants too...
+ * We cheat a little by assuming that CStringGetTextDatum() will do for
+ * bpchar and varchar constants too...
*/
if (datatype == NAMEOID)
return DirectFunctionCall1(namein, CStringGetDatum(str));
else if (datatype == BYTEAOID)
return DirectFunctionCall1(byteain, CStringGetDatum(str));
else
- return DirectFunctionCall1(textin, CStringGetDatum(str));
+ return CStringGetTextDatum(str);
}
/*
&isNull);
if (isNull)
elog(ERROR, "null prosrc for function %u", funcid);
- src = DatumGetCString(DirectFunctionCall1(textout, tmp));
+ src = TextDatumGetCString(tmp);
/*
* We just do parsing and parse analysis, not rewriting, because rewriting
&isnull);
if (isnull)
elog(ERROR, "null prosrc");
- prosrc = DatumGetCString(DirectFunctionCall1(textout, tmp));
+ prosrc = TextDatumGetCString(tmp);
errposition(0);
internalerrposition(syntaxerrposition);
internalerrquery(prosrc);
&isNull);
if (isNull)
elog(ERROR, "null prosrc for function %u", fexpr->funcid);
- src = DatumGetCString(DirectFunctionCall1(textout, tmp));
+ src = TextDatumGetCString(tmp);
/*
* Parse, analyze, and rewrite (unlike inline_function(), we can't
{
char *exprsString;
- exprsString = DatumGetCString(DirectFunctionCall1(textout, datum));
+ exprsString = TextDatumGetCString(datum);
indexprs = (List *) stringToNode(exprsString);
}
else
char *pred_str;
/* Convert text string to node tree */
- pred_str = DatumGetCString(DirectFunctionCall1(textout, datum));
+ pred_str = TextDatumGetCString(datum);
index->whereClause = (Node *) stringToNode(pred_str);
/* Adjust attribute numbers */
change_varattnos_of_a_node(index->whereClause, attmap);
values[i++] = CharGetDatum(evtype + '0'); /* ev_type */
values[i++] = CharGetDatum(RULE_FIRES_ON_ORIGIN); /* ev_enabled */
values[i++] = BoolGetDatum(evinstead); /* is_instead */
- values[i++] = DirectFunctionCall1(textin, CStringGetDatum(evqual)); /* ev_qual */
- values[i++] = DirectFunctionCall1(textin, CStringGetDatum(actiontree)); /* ev_action */
+ values[i++] = CStringGetTextDatum(evqual); /* ev_qual */
+ values[i++] = CStringGetTextDatum(actiontree); /* ev_action */
/*
* Ready to store new pg_rewrite tuple
ptr = res;
while (ptr->lexeme)
{
- da[ptr - res] = DirectFunctionCall1(textin, CStringGetDatum(ptr->lexeme));
+ da[ptr - res] = CStringGetTextDatum(ptr->lexeme);
ptr++;
}
QueryItem *res;
int4 len;
- query = parse_tsquery(TextPGetCString(in), pushval_morph, ObjectIdGetDatum(cfgid), false);
+ query = parse_tsquery(text_to_cstring(in), pushval_morph, ObjectIdGetDatum(cfgid), false);
if (query->size == 0)
PG_RETURN_TSQUERY(query);
QueryItem *res;
int4 len;
- query = parse_tsquery(TextPGetCString(in), pushval_morph, ObjectIdGetDatum(cfgid), true);
+ query = parse_tsquery(text_to_cstring(in), pushval_morph, ObjectIdGetDatum(cfgid), true);
if (query->size == 0)
PG_RETURN_TSQUERY(query);
static AclMode
convert_priv_string(text *priv_type_text)
{
- char *priv_type;
-
- priv_type = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(priv_type_text)));
+ char *priv_type = text_to_cstring(priv_type_text);
if (pg_strcasecmp(priv_type, "SELECT") == 0)
return ACL_SELECT;
static AclMode
convert_table_priv_string(text *priv_type_text)
{
- char *priv_type;
-
- priv_type = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(priv_type_text)));
+ char *priv_type = text_to_cstring(priv_type_text);
/*
* Return mode from priv_type string
static Oid
convert_database_name(text *databasename)
{
- char *dbname;
+ char *dbname = text_to_cstring(databasename);
Oid oid;
- dbname = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(databasename)));
-
oid = get_database_oid(dbname);
if (!OidIsValid(oid))
ereport(ERROR,
static AclMode
convert_database_priv_string(text *priv_type_text)
{
- char *priv_type;
-
- priv_type = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(priv_type_text)));
+ char *priv_type = text_to_cstring(priv_type_text);
/*
* Return mode from priv_type string
static Oid
convert_function_name(text *functionname)
{
- char *funcname;
+ char *funcname = text_to_cstring(functionname);
Oid oid;
- funcname = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(functionname)));
-
oid = DatumGetObjectId(DirectFunctionCall1(regprocedurein,
CStringGetDatum(funcname)));
static AclMode
convert_function_priv_string(text *priv_type_text)
{
- char *priv_type;
-
- priv_type = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(priv_type_text)));
+ char *priv_type = text_to_cstring(priv_type_text);
/*
* Return mode from priv_type string
static Oid
convert_language_name(text *languagename)
{
- char *langname;
+ char *langname = text_to_cstring(languagename);
Oid oid;
- langname = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(languagename)));
-
oid = GetSysCacheOid(LANGNAME,
CStringGetDatum(langname),
0, 0, 0);
static AclMode
convert_language_priv_string(text *priv_type_text)
{
- char *priv_type;
-
- priv_type = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(priv_type_text)));
+ char *priv_type = text_to_cstring(priv_type_text);
/*
* Return mode from priv_type string
static Oid
convert_schema_name(text *schemaname)
{
- char *nspname;
+ char *nspname = text_to_cstring(schemaname);
Oid oid;
- nspname = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(schemaname)));
-
oid = GetSysCacheOid(NAMESPACENAME,
CStringGetDatum(nspname),
0, 0, 0);
static AclMode
convert_schema_priv_string(text *priv_type_text)
{
- char *priv_type;
-
- priv_type = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(priv_type_text)));
+ char *priv_type = text_to_cstring(priv_type_text);
/*
* Return mode from priv_type string
static Oid
convert_tablespace_name(text *tablespacename)
{
- char *spcname;
+ char *spcname = text_to_cstring(tablespacename);
Oid oid;
- spcname = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(tablespacename)));
oid = get_tablespace_oid(spcname);
if (!OidIsValid(oid))
static AclMode
convert_tablespace_priv_string(text *priv_type_text)
{
- char *priv_type;
-
- priv_type = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(priv_type_text)));
+ char *priv_type = text_to_cstring(priv_type_text);
/*
* Return mode from priv_type string
static AclMode
convert_role_priv_string(text *priv_type_text)
{
- char *priv_type;
-
- priv_type = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(priv_type_text)));
+ char *priv_type = text_to_cstring(priv_type_text);
/*
* Return mode from priv_type string
array_dims(PG_FUNCTION_ARGS)
{
ArrayType *v = PG_GETARG_ARRAYTYPE_P(0);
- text *result;
char *p;
- int nbytes,
- i;
+ int i;
int *dimv,
*lb;
- /* Sanity check: does it look like an array at all? */
- if (ARR_NDIM(v) <= 0 || ARR_NDIM(v) > MAXDIM)
- PG_RETURN_NULL();
-
- nbytes = ARR_NDIM(v) * 33 + 1;
-
/*
* 33 since we assume 15 digits per number + ':' +'[]'
*
- * +1 allows for temp trailing null
+ * +1 for trailing null
*/
+ char buf[MAXDIM * 33 + 1];
- result = (text *) palloc(nbytes + VARHDRSZ);
- p = VARDATA(result);
+ /* Sanity check: does it look like an array at all? */
+ if (ARR_NDIM(v) <= 0 || ARR_NDIM(v) > MAXDIM)
+ PG_RETURN_NULL();
dimv = ARR_DIMS(v);
lb = ARR_LBOUND(v);
+ p = buf;
for (i = 0; i < ARR_NDIM(v); i++)
{
sprintf(p, "[%d:%d]", lb[i], dimv[i] + lb[i] - 1);
p += strlen(p);
}
- SET_VARSIZE(result, strlen(VARDATA(result)) + VARHDRSZ);
- PG_RETURN_TEXT_P(result);
+ PG_RETURN_TEXT_P(cstring_to_text(buf));
}
/*
booltext(PG_FUNCTION_ARGS)
{
bool arg1 = PG_GETARG_BOOL(0);
- char *str;
+ const char *str;
if (arg1)
str = "true";
else
str = "false";
- PG_RETURN_DATUM(DirectFunctionCall1(textin, CStringGetDatum(str)));
+ PG_RETURN_TEXT_P(cstring_to_text(str));
}
#include <locale.h>
#include "libpq/pqformat.h"
+#include "utils/builtins.h"
#include "utils/cash.h"
#include "utils/pg_locale.h"
Cash m4;
Cash m5;
Cash m6;
- text *result;
/* work with positive numbers */
if (value < 0)
/* capitalize output */
buf[0] = pg_toupper((unsigned char) buf[0]);
- /* make a text type for output */
- result = (text *) palloc(strlen(buf) + VARHDRSZ);
- SET_VARSIZE(result, strlen(buf) + VARHDRSZ);
- memcpy(VARDATA(result), buf, strlen(buf));
-
- PG_RETURN_TEXT_P(result);
+ /* return as text datum */
+ PG_RETURN_TEXT_P(cstring_to_text(buf));
}
Datum
time_part(PG_FUNCTION_ARGS)
{
- text *units = PG_GETARG_TEXT_P(0);
+ text *units = PG_GETARG_TEXT_PP(0);
TimeADT time = PG_GETARG_TIMEADT(1);
float8 result;
int type,
val;
char *lowunits;
- lowunits = downcase_truncate_identifier(VARDATA(units),
- VARSIZE(units) - VARHDRSZ,
+ lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
+ VARSIZE_ANY_EXHDR(units),
false);
type = DecodeUnits(0, lowunits, &val);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("\"time\" units \"%s\" not recognized",
- DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(units))))));
-
+ lowunits)));
result = 0;
}
}
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("\"time\" units \"%s\" not recognized",
- DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(units))))));
+ lowunits)));
result = 0;
}
Datum
timetz_part(PG_FUNCTION_ARGS)
{
- text *units = PG_GETARG_TEXT_P(0);
+ text *units = PG_GETARG_TEXT_PP(0);
TimeTzADT *time = PG_GETARG_TIMETZADT_P(1);
float8 result;
int type,
val;
char *lowunits;
- lowunits = downcase_truncate_identifier(VARDATA(units),
- VARSIZE(units) - VARHDRSZ,
+ lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
+ VARSIZE_ANY_EXHDR(units),
false);
type = DecodeUnits(0, lowunits, &val);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("\"time with time zone\" units \"%s\" not recognized",
- DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(units))))));
-
+ lowunits)));
result = 0;
}
}
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("\"time with time zone\" units \"%s\" not recognized",
- DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(units))))));
-
+ lowunits)));
result = 0;
}
Datum
timetz_zone(PG_FUNCTION_ARGS)
{
- text *zone = PG_GETARG_TEXT_P(0);
+ text *zone = PG_GETARG_TEXT_PP(0);
TimeTzADT *t = PG_GETARG_TIMETZADT_P(1);
TimeTzADT *result;
int tz;
char tzname[TZ_STRLEN_MAX + 1];
- int len;
pg_tz *tzp;
/*
* (to handle cases like "America/New_York"), and if that fails, we look
* in the date token table (to handle cases like "EST").
*/
- len = Min(VARSIZE(zone) - VARHDRSZ, TZ_STRLEN_MAX);
- memcpy(tzname, VARDATA(zone), len);
- tzname[len] = '\0';
+ text_to_cstring_buffer(zone, tzname, sizeof(tzname));
tzp = pg_tzset(tzname);
if (tzp)
{
int type,
val;
- lowzone = downcase_truncate_identifier(VARDATA(zone),
- VARSIZE(zone) - VARHDRSZ,
+ lowzone = downcase_truncate_identifier(tzname,
+ strlen(tzname),
false);
type = DecodeSpecial(0, lowzone, &val);
for (p = (unsigned char *) buffer; *p; p++)
*p = pg_toupper(*p);
- values[0] = DirectFunctionCall1(textin, CStringGetDatum(buffer));
+ values[0] = CStringGetTextDatum(buffer);
MemSet(&tm, 0, sizeof(struct pg_tm));
tm.tm_min = (-1) * FROMVAL(&timezonetktbl[*pindex]);
MemSet(nulls, 0, sizeof(nulls));
- values[0] = DirectFunctionCall1(textin,
- CStringGetDatum(pg_get_timezone_name(tz)));
-
- values[1] = DirectFunctionCall1(textin,
- CStringGetDatum(tzn ? tzn : ""));
+ values[0] = CStringGetTextDatum(pg_get_timezone_name(tz));
+ values[1] = CStringGetTextDatum(tzn ? tzn : "");
MemSet(&itm, 0, sizeof(struct pg_tm));
itm.tm_sec = -tzoff;
pg_size_pretty(PG_FUNCTION_ARGS)
{
int64 size = PG_GETARG_INT64(0);
- char *result = palloc(50 + VARHDRSZ);
+ char buf[64];
int64 limit = 10 * 1024;
int64 mult = 1;
if (size < limit * mult)
- snprintf(VARDATA(result), 50, INT64_FORMAT " bytes", size);
+ snprintf(buf, sizeof(buf), INT64_FORMAT " bytes", size);
else
{
mult *= 1024;
if (size < limit * mult)
- snprintf(VARDATA(result), 50, INT64_FORMAT " kB",
+ snprintf(buf, sizeof(buf), INT64_FORMAT " kB",
(size + mult / 2) / mult);
else
{
mult *= 1024;
if (size < limit * mult)
- snprintf(VARDATA(result), 50, INT64_FORMAT " MB",
+ snprintf(buf, sizeof(buf), INT64_FORMAT " MB",
(size + mult / 2) / mult);
else
{
mult *= 1024;
if (size < limit * mult)
- snprintf(VARDATA(result), 50, INT64_FORMAT " GB",
+ snprintf(buf, sizeof(buf), INT64_FORMAT " GB",
(size + mult / 2) / mult);
else
{
mult *= 1024;
- snprintf(VARDATA(result), 50, INT64_FORMAT " TB",
+ snprintf(buf, sizeof(buf), INT64_FORMAT " TB",
(size + mult / 2) / mult);
}
}
}
}
- SET_VARSIZE(result, strlen(VARDATA(result)) + VARHDRSZ);
-
- PG_RETURN_TEXT_P(result);
+ PG_RETURN_TEXT_P(cstring_to_text(buf));
}
datalen = VARSIZE(data) - VARHDRSZ;
- namebuf = DatumGetCString(DirectFunctionCall1(textout, name));
+ namebuf = TextDatumGetCString(name);
enc = pg_find_encoding(namebuf);
if (enc == NULL)
datalen = VARSIZE(data) - VARHDRSZ;
- namebuf = DatumGetCString(DirectFunctionCall1(textout, name));
+ namebuf = TextDatumGetCString(name);
enc = pg_find_encoding(namebuf);
if (enc == NULL)
#include "mb/pg_wchar.h"
#define MAX_INT32_LEN 11
-#define _textin(str) DirectFunctionCall1(textin, CStringGetDatum(str))
static char *format_type_internal(Oid type_oid, int32 typemod,
bool typemod_given, bool allow_invalid);
result = format_type_internal(type_oid, typemod, true, true);
}
- PG_RETURN_DATUM(_textin(result));
+ PG_RETURN_TEXT_P(cstring_to_text(result));
}
/*
left -= slen;
}
- PG_RETURN_DATUM(_textin(result));
+ PG_RETURN_TEXT_P(cstring_to_text(result));
}
static void do_to_timestamp(text *date_txt, text *fmt,
struct pg_tm * tm, fsec_t *fsec);
static char *fill_str(char *str, int c, int max);
-static FormatNode *NUM_cache(int len, NUMDesc *Num, char *pars_str, bool *shouldFree);
+static FormatNode *NUM_cache(int len, NUMDesc *Num, text *pars_str, bool *shouldFree);
static char *int_to_roman(int number);
static void NUM_prepare_locale(NUMProc *Np);
static char *get_last_relevant_decnum(char *num);
char *fmt_str,
*result;
bool incache;
- int fmt_len = VARSIZE(fmt) - VARHDRSZ;
- int reslen;
+ int fmt_len;
text *res;
/*
* Convert fmt to C string
*/
- fmt_str = (char *) palloc(fmt_len + 1);
- memcpy(fmt_str, VARDATA(fmt), fmt_len);
- *(fmt_str + fmt_len) = '\0';
+ fmt_str = text_to_cstring(fmt);
+ fmt_len = strlen(fmt_str);
/*
* Allocate workspace for result as C string
pfree(fmt_str);
/* convert C-string result to TEXT format */
- reslen = strlen(result);
- res = (text *) palloc(reslen + VARHDRSZ);
- memcpy(VARDATA(res), result, reslen);
- SET_VARSIZE(res, reslen + VARHDRSZ);
+ res = cstring_to_text(result);
pfree(result);
return res;
ZERO_tm(tm);
*fsec = 0;
- fmt_len = VARSIZE(fmt) - VARHDRSZ;
+ fmt_len = VARSIZE_ANY_EXHDR(fmt);
if (fmt_len)
{
- int date_len;
char *fmt_str;
char *date_str;
bool incache;
- fmt_str = (char *) palloc(fmt_len + 1);
- memcpy(fmt_str, VARDATA(fmt), fmt_len);
- *(fmt_str + fmt_len) = '\0';
+ fmt_str = text_to_cstring(fmt);
/*
* Allocate new memory if format picture is bigger than static cache
/* dump_node(format, fmt_len); */
#endif
- /*
- * Convert date to C string
- */
- date_len = VARSIZE(date_txt) - VARHDRSZ;
- date_str = (char *) palloc(date_len + 1);
- memcpy(date_str, VARDATA(date_txt), date_len);
- *(date_str + date_len) = '\0';
+ date_str = text_to_cstring(date_txt);
DCH_from_char(format, date_str, &tmfc);
* ----------
*/
static FormatNode *
-NUM_cache(int len, NUMDesc *Num, char *pars_str, bool *shouldFree)
+NUM_cache(int len, NUMDesc *Num, text *pars_str, bool *shouldFree)
{
FormatNode *format = NULL;
char *str;
- /*
- * Convert VARDATA() to string
- */
- str = (char *) palloc(len + 1);
- memcpy(str, pars_str, len);
- *(str + len) = '\0';
+ str = text_to_cstring(pars_str);
/*
* Allocate new memory if format picture is bigger than static cache and
*/
#define NUM_TOCHAR_prepare \
do { \
- len = VARSIZE(fmt) - VARHDRSZ; \
+ len = VARSIZE_ANY_EXHDR(fmt); \
if (len <= 0 || len >= (INT_MAX-VARHDRSZ)/NUM_MAX_ITEM_SIZ) \
- return DirectFunctionCall1(textin, CStringGetDatum("")); \
+ PG_RETURN_TEXT_P(cstring_to_text("")); \
result = (text *) palloc0((len * NUM_MAX_ITEM_SIZ) + 1 + VARHDRSZ); \
- format = NUM_cache(len, &Num, VARDATA(fmt), &shouldFree); \
+ format = NUM_cache(len, &Num, fmt, &shouldFree); \
} while (0)
/* ----------
if (len <= 0 || len >= INT_MAX / NUM_MAX_ITEM_SIZ)
PG_RETURN_NULL();
- format = NUM_cache(len, &Num, VARDATA(fmt), &shouldFree);
+ format = NUM_cache(len, &Num, fmt, &shouldFree);
numstr = (char *) palloc((len * NUM_MAX_ITEM_SIZ) + 1);
static char *
convert_and_check_filename(text *arg)
{
- int input_len = VARSIZE(arg) - VARHDRSZ;
- char *filename = palloc(input_len + 1);
-
- memcpy(filename, VARDATA(arg), input_len);
- filename[input_len] = '\0';
+ char *filename;
+ filename = text_to_cstring(arg);
canonicalize_path(filename); /* filename can change length here */
/* Disallow ".." in the path */
while ((de = ReadDir(fctx->dirdesc, fctx->location)) != NULL)
{
- int len = strlen(de->d_name);
- text *result;
-
if (strcmp(de->d_name, ".") == 0 ||
strcmp(de->d_name, "..") == 0)
continue;
- result = palloc(len + VARHDRSZ);
- SET_VARSIZE(result, len + VARHDRSZ);
- memcpy(VARDATA(result), de->d_name, len);
-
- SRF_RETURN_NEXT(funcctx, PointerGetDatum(result));
+ SRF_RETURN_NEXT(funcctx, CStringGetTextDatum(de->d_name));
}
FreeDir(fctx->dirdesc);
snprintf(vxidstr, sizeof(vxidstr), "%d/%u", bid, lxid);
- return DirectFunctionCall1(textin, CStringGetDatum(vxidstr));
+ return CStringGetTextDatum(vxidstr);
}
(int) lock->tag.locktag_type);
locktypename = tnbuf;
}
- values[0] = DirectFunctionCall1(textin,
- CStringGetDatum(locktypename));
+ values[0] = CStringGetTextDatum(locktypename);
switch ((LockTagType) lock->tag.locktag_type)
{
values[11] = Int32GetDatum(proc->pid);
else
nulls[11] = 'n';
- values[12] = DirectFunctionCall1(textin,
- CStringGetDatum(GetLockmodeName(LOCK_LOCKMETHOD(*lock),
- mode)));
+ values[12] = CStringGetTextDatum(GetLockmodeName(LOCK_LOCKMETHOD(*lock), mode));
values[13] = BoolGetDatum(granted);
tuple = heap_formtuple(funcctx->tuple_desc, values, nulls);
struct timeval tp;
char templ[128];
char buf[128];
- text *result;
- int len;
pg_time_t tt;
gettimeofday(&tp, NULL);
pg_localtime(&tt, session_timezone));
snprintf(buf, sizeof(buf), templ, tp.tv_usec);
- len = VARHDRSZ + strlen(buf);
- result = (text *) palloc(len);
- SET_VARSIZE(result, len);
- memcpy(VARDATA(result), buf, len - VARHDRSZ);
- PG_RETURN_TEXT_P(result);
+ PG_RETURN_TEXT_P(cstring_to_text(buf));
}
network_host(PG_FUNCTION_ARGS)
{
inet *ip = PG_GETARG_INET_P(0);
- text *ret;
- int len;
char *ptr;
char tmp[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255/128")];
if ((ptr = strchr(tmp, '/')) != NULL)
*ptr = '\0';
- /* Return string as a text datum */
- len = strlen(tmp);
- ret = (text *) palloc(len + VARHDRSZ);
- SET_VARSIZE(ret, len + VARHDRSZ);
- memcpy(VARDATA(ret), tmp, len);
- PG_RETURN_TEXT_P(ret);
+ PG_RETURN_TEXT_P(cstring_to_text(tmp));
}
/*
network_show(PG_FUNCTION_ARGS)
{
inet *ip = PG_GETARG_INET_P(0);
- text *ret;
int len;
char tmp[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255/128")];
snprintf(tmp + len, sizeof(tmp) - len, "/%u", ip_bits(ip));
}
- /* Return string as a text datum */
- len = strlen(tmp);
- ret = (text *) palloc(len + VARHDRSZ);
- SET_VARSIZE(ret, len + VARHDRSZ);
- memcpy(VARDATA(ret), tmp, len);
- PG_RETURN_TEXT_P(ret);
+ PG_RETURN_TEXT_P(cstring_to_text(tmp));
}
Datum
inet_abbrev(PG_FUNCTION_ARGS)
{
inet *ip = PG_GETARG_INET_P(0);
- text *ret;
char *dst;
- int len;
char tmp[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255/128")];
dst = inet_net_ntop(ip_family(ip), ip_addr(ip),
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("could not format inet value: %m")));
- /* Return string as a text datum */
- len = strlen(tmp);
- ret = (text *) palloc(len + VARHDRSZ);
- SET_VARSIZE(ret, len + VARHDRSZ);
- memcpy(VARDATA(ret), tmp, len);
- PG_RETURN_TEXT_P(ret);
+ PG_RETURN_TEXT_P(cstring_to_text(tmp));
}
Datum
cidr_abbrev(PG_FUNCTION_ARGS)
{
inet *ip = PG_GETARG_INET_P(0);
- text *ret;
char *dst;
- int len;
char tmp[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255/128")];
dst = inet_cidr_ntop(ip_family(ip), ip_addr(ip),
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("could not format cidr value: %m")));
- /* Return string as a text datum */
- len = strlen(tmp);
- ret = (text *) palloc(len + VARHDRSZ);
- SET_VARSIZE(ret, len + VARHDRSZ);
- memcpy(VARDATA(ret), tmp, len);
- PG_RETURN_TEXT_P(ret);
+ PG_RETURN_TEXT_P(cstring_to_text(tmp));
}
Datum
errmsg("out of memory")));
/* Need a null-terminated version of the input */
- workstr = (char *) palloc(nbytes + 1);
- memcpy(workstr, VARDATA_ANY(txt), nbytes);
- workstr[nbytes] = '\0';
+ workstr = text_to_cstring(txt);
/* Output workspace cannot have more codes than input bytes */
result = (wchar_t *) palloc((nbytes + 1) * sizeof(wchar_t));
text *in_text;
text *out_text;
char *result;
- int nbytes = strlen(str);
int i;
- in_text = palloc(nbytes + VARHDRSZ);
- memcpy(VARDATA(in_text), str, nbytes);
- SET_VARSIZE(in_text, nbytes + VARHDRSZ);
-
+ in_text = cstring_to_text(str);
workspace = texttowcs(in_text);
for (i = 0; workspace[i] != 0; i++)
workspace[i] = towupper(workspace[i]);
out_text = wcstotext(workspace, i);
-
- nbytes = VARSIZE(out_text) - VARHDRSZ;
- result = palloc(nbytes + 1);
- memcpy(result, VARDATA(out_text), nbytes);
-
- result[nbytes] = '\0';
+ result = text_to_cstring(out_text);
pfree(workspace);
pfree(in_text);
text *in_text;
text *out_text;
char *result;
- int nbytes = strlen(str);
int i;
- in_text = palloc(nbytes + VARHDRSZ);
- memcpy(VARDATA(in_text), str, nbytes);
- SET_VARSIZE(in_text, nbytes + VARHDRSZ);
-
+ in_text = cstring_to_text(str);
workspace = texttowcs(in_text);
for (i = 0; workspace[i] != 0; i++)
workspace[i] = towlower(workspace[i]);
out_text = wcstotext(workspace, i);
-
- nbytes = VARSIZE(out_text) - VARHDRSZ;
- result = palloc(nbytes + 1);
- memcpy(result, VARDATA(out_text), nbytes);
-
- result[nbytes] = '\0';
+ result = text_to_cstring(out_text);
pfree(workspace);
pfree(in_text);
const char *set, int setlen,
bool doltrim, bool dortrim)
{
- text *result;
int i;
/* Nothing to do if either string or set is empty */
}
/* Return selected portion of string */
- result = (text *) palloc(VARHDRSZ + stringlen);
- SET_VARSIZE(result, VARHDRSZ + stringlen);
- memcpy(VARDATA(result), string, stringlen);
-
- return result;
+ return cstring_to_text_with_len(string, stringlen);
}
/********************************************************************
pg_stat_get_backend_activity(PG_FUNCTION_ARGS)
{
int32 beid = PG_GETARG_INT32(0);
- text *result;
PgBackendStatus *beentry;
- int len;
const char *activity;
if ((beentry = pgstat_fetch_stat_beentry(beid)) == NULL)
else
activity = beentry->st_activity;
- len = strlen(activity);
- result = palloc(VARHDRSZ + len);
- SET_VARSIZE(result, VARHDRSZ + len);
- memcpy(VARDATA(result), activity, len);
-
- PG_RETURN_TEXT_P(result);
+ PG_RETURN_TEXT_P(cstring_to_text(activity));
}
Datum
quote_ident(PG_FUNCTION_ARGS)
{
- text *t = PG_GETARG_TEXT_P(0);
- text *result;
+ text *t = PG_GETARG_TEXT_PP(0);
const char *qstr;
char *str;
- int len;
-
- /* We have to convert to a C string to use quote_identifier */
- len = VARSIZE(t) - VARHDRSZ;
- str = (char *) palloc(len + 1);
- memcpy(str, VARDATA(t), len);
- str[len] = '\0';
+ str = text_to_cstring(t);
qstr = quote_identifier(str);
-
- len = strlen(qstr);
- result = (text *) palloc(len + VARHDRSZ);
- SET_VARSIZE(result, len + VARHDRSZ);
- memcpy(VARDATA(result), qstr, len);
-
- PG_RETURN_TEXT_P(result);
+ PG_RETURN_TEXT_P(cstring_to_text(qstr));
}
/*
quote_nullable(PG_FUNCTION_ARGS)
{
if (PG_ARGISNULL(0))
- PG_RETURN_DATUM(DirectFunctionCall1(textin,
- CStringGetDatum("NULL")));
+ PG_RETURN_TEXT_P(cstring_to_text("NULL"));
else
PG_RETURN_DATUM(DirectFunctionCall1(quote_literal,
PG_GETARG_DATUM(0)));
exprsDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
Anum_pg_index_indexprs, &isnull);
Assert(!isnull);
- exprsString = DatumGetCString(DirectFunctionCall1(textout,
- exprsDatum));
+ exprsString = TextDatumGetCString(exprsDatum);
indexprs = (List *) stringToNode(exprsString);
pfree(exprsString);
}
predDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
Anum_pg_index_indpred, &isnull);
Assert(!isnull);
- predString = DatumGetCString(DirectFunctionCall1(textout,
- predDatum));
+ predString = TextDatumGetCString(predDatum);
node = (Node *) stringToNode(predString);
pfree(predString);
elog(ERROR, "null conbin for constraint %u",
constraintId);
- conbin = DatumGetCString(DirectFunctionCall1(textout, val));
+ conbin = TextDatumGetCString(val);
expr = stringToNode(conbin);
/* Set up deparsing context for Var nodes in constraint */
char *str;
/* Convert input TEXT object to C string */
- exprstr = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(expr)));
+ exprstr = text_to_cstring(expr);
/* Convert expression to node tree */
node = (Node *) stringToNode(exprstr);
str = deparse_expression_pretty(node, context, false, false,
prettyFlags, 0);
+ pfree(exprstr);
+
return str;
}
pg_get_serial_sequence(PG_FUNCTION_ARGS)
{
text *tablename = PG_GETARG_TEXT_P(0);
- text *columnname = PG_GETARG_TEXT_P(1);
+ text *columnname = PG_GETARG_TEXT_PP(1);
RangeVar *tablerv;
Oid tableOid;
char *column;
tableOid = RangeVarGetRelid(tablerv, false);
/* Get the number of the column */
- column = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(columnname)));
+ column = text_to_cstring(columnname);
attnum = get_attnum(tableOid, column);
if (attnum == InvalidAttrNumber)
string_to_text(char *str)
{
text *result;
- int slen = strlen(str);
- int tlen;
-
- tlen = slen + VARHDRSZ;
- result = (text *) palloc(tlen);
- SET_VARSIZE(result, tlen);
- memcpy(VARDATA(result), str, slen);
+ result = cstring_to_text(str);
pfree(str);
-
return result;
}
* array_to_text() relies on flinfo to be valid. So use
* OidFunctionCall2.
*/
- sep = DirectFunctionCall1(textin, CStringGetDatum(", "));
+ sep = CStringGetTextDatum(", ");
txt = OidFunctionCall2(F_ARRAY_TO_TEXT, reloptions, sep);
- result = DatumGetCString(DirectFunctionCall1(textout, txt));
+ result = TextDatumGetCString(txt);
}
ReleaseSysCache(tuple);
switch (prefix->consttype)
{
case TEXTOID:
- prefixstr = DatumGetCString(DirectFunctionCall1(textout,
- prefix->constvalue));
+ prefixstr = TextDatumGetCString(prefix->constvalue);
break;
case BYTEAOID:
prefixstr = DatumGetCString(DirectFunctionCall1(byteaout,
case BPCHAROID:
case VARCHAROID:
case TEXTOID:
- {
- char *str = (char *) VARDATA(DatumGetPointer(value));
- int strlength = VARSIZE(DatumGetPointer(value)) - VARHDRSZ;
-
- val = (char *) palloc(strlength + 1);
- memcpy(val, str, strlength);
- val[strlength] = '\0';
- break;
- }
+ val = TextDatumGetCString(value);
+ break;
case NAMEOID:
{
NameData *nm = (NameData *) DatumGetPointer(value);
if (typeid != BYTEAOID)
{
- patt = DatumGetCString(DirectFunctionCall1(textout, patt_const->constvalue));
+ patt = TextDatumGetCString(patt_const->constvalue);
pattlen = strlen(patt);
}
else
errmsg("regular-expression matching not supported on type bytea")));
/* the right-hand const is type text for all of these */
- patt = DatumGetCString(DirectFunctionCall1(textout, patt_const->constvalue));
+ patt = TextDatumGetCString(patt_const->constvalue);
/*
* Check for ARE director prefix. It's worth our trouble to recognize
if (typeid != BYTEAOID)
{
- patt = DatumGetCString(DirectFunctionCall1(textout, patt_const->constvalue));
+ patt = TextDatumGetCString(patt_const->constvalue);
pattlen = strlen(patt);
}
else
errmsg("regular-expression matching not supported on type bytea")));
/* the right-hand const is type text for all of these */
- patt = DatumGetCString(DirectFunctionCall1(textout, patt_const->constvalue));
+ patt = TextDatumGetCString(patt_const->constvalue);
pattlen = strlen(patt);
/* If patt doesn't end with $, consider it to have a trailing wildcard */
}
else
{
- workstr = DatumGetCString(DirectFunctionCall1(textout,
- str_const->constvalue));
+ workstr = TextDatumGetCString(str_const->constvalue);
len = strlen(workstr);
if (lc_collate_is_c() || len == 0)
cmpstr = str_const->constvalue;
Assert(str != NULL);
/*
- * We cheat a little by assuming that textin() will do for bpchar and
- * varchar constants too...
+ * We cheat a little by assuming that CStringGetTextDatum() will do for
+ * bpchar and varchar constants too...
*/
if (datatype == NAMEOID)
return DirectFunctionCall1(namein, CStringGetDatum(str));
else if (datatype == BYTEAOID)
return DirectFunctionCall1(byteain, CStringGetDatum(str));
else
- return DirectFunctionCall1(textin, CStringGetDatum(str));
+ return CStringGetTextDatum(str);
}
/*
Datum
timestamp_trunc(PG_FUNCTION_ARGS)
{
- text *units = PG_GETARG_TEXT_P(0);
+ text *units = PG_GETARG_TEXT_PP(0);
Timestamp timestamp = PG_GETARG_TIMESTAMP(1);
Timestamp result;
int type,
if (TIMESTAMP_NOT_FINITE(timestamp))
PG_RETURN_TIMESTAMP(timestamp);
- lowunits = downcase_truncate_identifier(VARDATA(units),
- VARSIZE(units) - VARHDRSZ,
+ lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
+ VARSIZE_ANY_EXHDR(units),
false);
type = DecodeUnits(0, lowunits, &val);
Datum
timestamptz_trunc(PG_FUNCTION_ARGS)
{
- text *units = PG_GETARG_TEXT_P(0);
+ text *units = PG_GETARG_TEXT_PP(0);
TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(1);
TimestampTz result;
int tz;
if (TIMESTAMP_NOT_FINITE(timestamp))
PG_RETURN_TIMESTAMPTZ(timestamp);
- lowunits = downcase_truncate_identifier(VARDATA(units),
- VARSIZE(units) - VARHDRSZ,
+ lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
+ VARSIZE_ANY_EXHDR(units),
false);
type = DecodeUnits(0, lowunits, &val);
Datum
interval_trunc(PG_FUNCTION_ARGS)
{
- text *units = PG_GETARG_TEXT_P(0);
+ text *units = PG_GETARG_TEXT_PP(0);
Interval *interval = PG_GETARG_INTERVAL_P(1);
Interval *result;
int type,
result = (Interval *) palloc(sizeof(Interval));
- lowunits = downcase_truncate_identifier(VARDATA(units),
- VARSIZE(units) - VARHDRSZ,
+ lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
+ VARSIZE_ANY_EXHDR(units),
false);
type = DecodeUnits(0, lowunits, &val);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("interval units \"%s\" not recognized",
- DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(units))))));
- *result = *interval;
+ lowunits)));
}
PG_RETURN_INTERVAL_P(result);
Datum
timestamp_part(PG_FUNCTION_ARGS)
{
- text *units = PG_GETARG_TEXT_P(0);
+ text *units = PG_GETARG_TEXT_PP(0);
Timestamp timestamp = PG_GETARG_TIMESTAMP(1);
float8 result;
int type,
PG_RETURN_FLOAT8(result);
}
- lowunits = downcase_truncate_identifier(VARDATA(units),
- VARSIZE(units) - VARHDRSZ,
+ lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
+ VARSIZE_ANY_EXHDR(units),
false);
type = DecodeUnits(0, lowunits, &val);
Datum
timestamptz_part(PG_FUNCTION_ARGS)
{
- text *units = PG_GETARG_TEXT_P(0);
+ text *units = PG_GETARG_TEXT_PP(0);
TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(1);
float8 result;
int tz;
PG_RETURN_FLOAT8(result);
}
- lowunits = downcase_truncate_identifier(VARDATA(units),
- VARSIZE(units) - VARHDRSZ,
+ lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
+ VARSIZE_ANY_EXHDR(units),
false);
type = DecodeUnits(0, lowunits, &val);
Datum
interval_part(PG_FUNCTION_ARGS)
{
- text *units = PG_GETARG_TEXT_P(0);
+ text *units = PG_GETARG_TEXT_PP(0);
Interval *interval = PG_GETARG_INTERVAL_P(1);
float8 result;
int type,
struct pg_tm tt,
*tm = &tt;
- lowunits = downcase_truncate_identifier(VARDATA(units),
- VARSIZE(units) - VARHDRSZ,
+ lowunits = downcase_truncate_identifier(VARDATA_ANY(units),
+ VARSIZE_ANY_EXHDR(units),
false);
type = DecodeUnits(0, lowunits, &val);
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("interval units \"%s\" not supported",
- DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(units))))));
+ lowunits)));
result = 0;
}
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("interval units \"%s\" not recognized",
- DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(units))))));
+ lowunits)));
result = 0;
}
Datum
timestamp_zone(PG_FUNCTION_ARGS)
{
- text *zone = PG_GETARG_TEXT_P(0);
+ text *zone = PG_GETARG_TEXT_PP(0);
Timestamp timestamp = PG_GETARG_TIMESTAMP(1);
TimestampTz result;
int tz;
pg_tz *tzp;
char tzname[TZ_STRLEN_MAX + 1];
- int len;
if (TIMESTAMP_NOT_FINITE(timestamp))
PG_RETURN_TIMESTAMPTZ(timestamp);
* (to handle cases like "America/New_York"), and if that fails, we look
* in the date token table (to handle cases like "EST").
*/
- len = Min(VARSIZE(zone) - VARHDRSZ, TZ_STRLEN_MAX);
- memcpy(tzname, VARDATA(zone), len);
- tzname[len] = '\0';
+ text_to_cstring_buffer(zone, tzname, sizeof(tzname));
tzp = pg_tzset(tzname);
if (tzp)
{
int type,
val;
- lowzone = downcase_truncate_identifier(VARDATA(zone),
- VARSIZE(zone) - VARHDRSZ,
+ lowzone = downcase_truncate_identifier(tzname,
+ strlen(tzname),
false);
type = DecodeSpecial(0, lowzone, &val);
Datum
timestamptz_zone(PG_FUNCTION_ARGS)
{
- text *zone = PG_GETARG_TEXT_P(0);
+ text *zone = PG_GETARG_TEXT_PP(0);
TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(1);
Timestamp result;
int tz;
pg_tz *tzp;
char tzname[TZ_STRLEN_MAX + 1];
- int len;
if (TIMESTAMP_NOT_FINITE(timestamp))
PG_RETURN_TIMESTAMP(timestamp);
* (to handle cases like "America/New_York"), and if that fails, we look
* in the date token table (to handle cases like "EST").
*/
- len = Min(VARSIZE(zone) - VARHDRSZ, TZ_STRLEN_MAX);
- memcpy(tzname, VARDATA(zone), len);
- tzname[len] = '\0';
+ text_to_cstring_buffer(zone, tzname, sizeof(tzname));
tzp = pg_tzset(tzname);
if (tzp)
{
int type,
val;
- lowzone = downcase_truncate_identifier(VARDATA(zone),
- VARSIZE(zone) - VARHDRSZ,
+ lowzone = downcase_truncate_identifier(tzname,
+ strlen(tzname),
false);
type = DecodeSpecial(0, lowzone, &val);
#include "access/skey.h"
#include "tsearch/ts_type.h"
#include "tsearch/ts_utils.h"
+#include "utils/builtins.h"
Datum
for (i = 0; i < vector->size; i++)
{
- text *txt = (text *) palloc(VARHDRSZ + we->len);
-
- SET_VARSIZE(txt, VARHDRSZ + we->len);
- memcpy(VARDATA(txt), STRPTR(vector) + we->pos, we->len);
+ text *txt;
+ txt = cstring_to_text_with_len(STRPTR(vector) + we->pos, we->len);
entries[i] = PointerGetDatum(txt);
we++;
text *txt;
QueryOperand *val = &item[i].operand;
- txt = (text *) palloc(VARHDRSZ + val->length);
-
- SET_VARSIZE(txt, VARHDRSZ + val->length);
- memcpy(VARDATA(txt), GETOPERAND(query) + val->distance, val->length);
-
+ txt = cstring_to_text_with_len(GETOPERAND(query) + val->distance,
+ val->length);
entries[j++] = PointerGetDatum(txt);
if (strategy != TSearchWithClassStrategyNumber && val->weight != 0)
#include "tsearch/ts_locale.h"
#include "tsearch/ts_type.h"
#include "tsearch/ts_utils.h"
+#include "utils/builtins.h"
#include "utils/memutils.h"
#include "utils/pg_crc.h"
if (!q)
{
- res = (text *) palloc(1 + VARHDRSZ);
- SET_VARSIZE(res, 1 + VARHDRSZ);
- *((char *) VARDATA(res)) = 'T';
+ res = cstring_to_text("T");
}
else
{
*(nrm.cur) = '\0';
nrm.op = GETOPERAND(query);
infix(&nrm, true);
-
- res = (text *) palloc(nrm.cur - nrm.buf + VARHDRSZ);
- SET_VARSIZE(res, nrm.cur - nrm.buf + VARHDRSZ);
- strncpy(VARDATA(res), nrm.buf, nrm.cur - nrm.buf);
+ res = cstring_to_text_with_len(nrm.buf, nrm.cur - nrm.buf);
pfree(q);
}
PG_FREE_IF_COPY(query, 0);
- PG_RETURN_POINTER(res);
+ PG_RETURN_TEXT_P(res);
}
QTNTernary(tree);
QTNSort(tree);
- buf = TextPGetCString(in);
+ buf = text_to_cstring(in);
SPI_connect();
static tsstat *
ts_stat_sql(text *txt, text *ws)
{
- char *query = TextPGetCString(txt);
+ char *query = text_to_cstring(txt);
int i;
tsstat *newstat,
*stat;
/*
* Convert a CHARACTER value to a C string.
+ *
+ * Uses the text conversion functions, which is only appropriate if BpChar
+ * and text are equivalent types.
*/
Datum
bpcharout(PG_FUNCTION_ARGS)
{
- BpChar *s = PG_GETARG_BPCHAR_PP(0);
- char *result;
- int len;
+ Datum txt = PG_GETARG_DATUM(0);
- /* copy and add null term */
- len = VARSIZE_ANY_EXHDR(s);
- result = (char *) palloc(len + 1);
- memcpy(result, VARDATA_ANY(s), len);
- result[len] = '\0';
-
- PG_RETURN_CSTRING(result);
+ PG_RETURN_CSTRING(TextDatumGetCString(txt));
}
/*
/* name_bpchar()
* Converts a NameData type to a bpchar type.
+ *
+ * Uses the text conversion functions, which is only appropriate if BpChar
+ * and text are equivalent types.
*/
Datum
name_bpchar(PG_FUNCTION_ARGS)
{
Name s = PG_GETARG_NAME(0);
BpChar *result;
- int len;
-
- len = strlen(NameStr(*s));
- result = (BpChar *) palloc(VARHDRSZ + len);
- memcpy(VARDATA(result), NameStr(*s), len);
- SET_VARSIZE(result, VARHDRSZ + len);
+ result = (BpChar *) cstring_to_text(NameStr(*s));
PG_RETURN_BPCHAR_P(result);
}
*
* If the input string is too long, raise an error, unless the extra
* characters are spaces, in which case they're truncated. (per SQL)
+ *
+ * Uses the C string to text conversion function, which is only appropriate
+ * if VarChar and text are equivalent types.
*/
static VarChar *
varchar_input(const char *s, size_t len, int32 atttypmod)
len = mbmaxlen;
}
- result = (VarChar *) palloc(len + VARHDRSZ);
- SET_VARSIZE(result, len + VARHDRSZ);
- memcpy(VARDATA(result), s, len);
-
+ result = (VarChar *) cstring_to_text_with_len(s, len);
return result;
}
/*
* Convert a VARCHAR value to a C string.
+ *
+ * Uses the text to C string conversion function, which is only appropriate
+ * if VarChar and text are equivalent types.
*/
Datum
varcharout(PG_FUNCTION_ARGS)
{
- VarChar *s = PG_GETARG_VARCHAR_PP(0);
- char *result;
- int32 len;
-
- /* copy and add null term */
- len = VARSIZE_ANY_EXHDR(s);
- result = palloc(len + 1);
- memcpy(result, VARDATA_ANY(s), len);
- result[len] = '\0';
+ Datum txt = PG_GETARG_DATUM(0);
- PG_RETURN_CSTRING(result);
+ PG_RETURN_CSTRING(TextDatumGetCString(txt));
}
/*
#define PG_GETARG_UNKNOWN_P_COPY(n) DatumGetUnknownPCopy(PG_GETARG_DATUM(n))
#define PG_RETURN_UNKNOWN_P(x) PG_RETURN_POINTER(x)
-#define PG_TEXTARG_GET_STR(arg_) \
- DatumGetCString(DirectFunctionCall1(textout, PG_GETARG_DATUM(arg_)))
-#define PG_TEXT_GET_STR(textp_) \
- DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(textp_)))
-#define PG_STR_GET_TEXT(str_) \
- DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(str_)))
-#define TEXTLEN(textp) \
- text_length(PointerGetDatum(textp))
-
static int text_cmp(text *arg1, text *arg2);
static int32 text_length(Datum str);
static int text_position(text *t1, text *t2);
int32 start,
int32 length,
bool length_not_specified);
-
static void appendStringInfoText(StringInfo str, const text *t);
+/*****************************************************************************
+ * CONVERSION ROUTINES EXPORTED FOR USE BY C CODE *
+ *****************************************************************************/
+
+/*
+ * cstring_to_text
+ *
+ * Create a text value from a null-terminated C string.
+ *
+ * The new text value is freshly palloc'd with a full-size VARHDR.
+ */
+text *
+cstring_to_text(const char *s)
+{
+ return cstring_to_text_with_len(s, strlen(s));
+}
+
+/*
+ * cstring_to_text_with_len
+ *
+ * Same as cstring_to_text except the caller specifies the string length;
+ * the string need not be null_terminated.
+ */
+text *
+cstring_to_text_with_len(const char *s, int len)
+{
+ text *result = (text *) palloc(len + VARHDRSZ);
+
+ SET_VARSIZE(result, len + VARHDRSZ);
+ memcpy(VARDATA(result), s, len);
+
+ return result;
+}
+
+/*
+ * text_to_cstring
+ *
+ * Create a palloc'd, null-terminated C string from a text value.
+ *
+ * We support being passed a compressed or toasted text value.
+ * This is a bit bogus since such values shouldn't really be referred to as
+ * "text *", but it seems useful for robustness. If we didn't handle that
+ * case here, we'd need another routine that did, anyway.
+ */
+char *
+text_to_cstring(const text *t)
+{
+ /* must cast away the const, unfortunately */
+ text *tunpacked = pg_detoast_datum_packed((struct varlena *) t);
+ int len = VARSIZE_ANY_EXHDR(tunpacked);
+ char *result;
+
+ result = (char *) palloc(len + 1);
+ memcpy(result, VARDATA_ANY(tunpacked), len);
+ result[len] = '\0';
+
+ if (tunpacked != t)
+ pfree(tunpacked);
+
+ return result;
+}
+
+/*
+ * text_to_cstring_buffer
+ *
+ * Copy a text value into a caller-supplied buffer of size dst_len.
+ *
+ * The text string is truncated if necessary to fit. The result is
+ * guaranteed null-terminated (unless dst_len == 0).
+ *
+ * We support being passed a compressed or toasted text value.
+ * This is a bit bogus since such values shouldn't really be referred to as
+ * "text *", but it seems useful for robustness. If we didn't handle that
+ * case here, we'd need another routine that did, anyway.
+ */
+void
+text_to_cstring_buffer(const text *src, char *dst, size_t dst_len)
+{
+ /* must cast away the const, unfortunately */
+ text *srcunpacked = pg_detoast_datum_packed((struct varlena *) src);
+ size_t src_len = VARSIZE_ANY_EXHDR(srcunpacked);
+
+ if (dst_len > 0)
+ {
+ dst_len--;
+ if (dst_len >= src_len)
+ dst_len = src_len;
+ else /* ensure truncation is encoding-safe */
+ dst_len = pg_mbcliplen(VARDATA_ANY(srcunpacked), src_len, dst_len);
+ memcpy(dst, VARDATA_ANY(srcunpacked), dst_len);
+ dst[dst_len] = '\0';
+ }
+
+ if (srcunpacked != src)
+ pfree(srcunpacked);
+}
+
+
/*****************************************************************************
* USER I/O ROUTINES *
*****************************************************************************/
textin(PG_FUNCTION_ARGS)
{
char *inputText = PG_GETARG_CSTRING(0);
- text *result;
- int len;
-
- len = strlen(inputText);
- result = (text *) palloc(len + VARHDRSZ);
- SET_VARSIZE(result, len + VARHDRSZ);
- memcpy(VARDATA(result), inputText, len);
-
- PG_RETURN_TEXT_P(result);
+ PG_RETURN_TEXT_P(cstring_to_text(inputText));
}
/*
Datum
textout(PG_FUNCTION_ARGS)
{
- text *t = PG_GETARG_TEXT_PP(0);
- int len;
- char *result;
+ Datum txt = PG_GETARG_DATUM(0);
- len = VARSIZE_ANY_EXHDR(t);
- result = (char *) palloc(len + 1);
- memcpy(result, VARDATA_ANY(t), len);
- result[len] = '\0';
-
- PG_RETURN_CSTRING(result);
+ PG_RETURN_CSTRING(TextDatumGetCString(txt));
}
/*
str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
- result = (text *) palloc(nbytes + VARHDRSZ);
- SET_VARSIZE(result, nbytes + VARHDRSZ);
- memcpy(VARDATA(result), str, nbytes);
+ result = cstring_to_text_with_len(str, nbytes);
pfree(str);
PG_RETURN_TEXT_P(result);
}
* string.
*/
if (E < 1)
- return PG_STR_GET_TEXT("");
+ return cstring_to_text("");
L1 = E - S1;
}
* string.
*/
if (E < 1)
- return PG_STR_GET_TEXT("");
+ return cstring_to_text("");
/*
* if E is past the end of the string, the tuple toaster will
{
if (slice != (text *) DatumGetPointer(str))
pfree(slice);
- return PG_STR_GET_TEXT("");
+ return cstring_to_text("");
}
/* Now we can get the actual length of the slice in MB characters */
{
if (slice != (text *) DatumGetPointer(str))
pfree(slice);
- return PG_STR_GET_TEXT("");
+ return cstring_to_text("");
}
/*
name_text(PG_FUNCTION_ARGS)
{
Name s = PG_GETARG_NAME(0);
- text *result;
- int len;
-
- len = strlen(NameStr(*s));
-
- result = palloc(VARHDRSZ + len);
- SET_VARSIZE(result, VARHDRSZ + len);
- memcpy(VARDATA(result), NameStr(*s), len);
- PG_RETURN_TEXT_P(result);
+ PG_RETURN_TEXT_P(cstring_to_text(NameStr(*s)));
}
/* Convert to C string (handles possible detoasting). */
/* Note we rely on being able to modify rawname below. */
- rawname = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(textval)));
+ rawname = text_to_cstring(textval);
if (!SplitIdentifierString(rawname, '.', &namelist))
ereport(ERROR,
* appendStringInfoText
*
* Append a text to str.
- * Like appendStringInfoString(str, PG_TEXT_GET_STR(s)) but faster.
+ * Like appendStringInfoString(str, text_to_cstring(t)) but faster.
*/
static void
appendStringInfoText(StringInfo str, const text *t)
text_position_cleanup(&state);
- ret_text = PG_STR_GET_TEXT(str.data);
+ ret_text = cstring_to_text_with_len(str.data, str.len);
pfree(str.data);
PG_RETURN_TEXT_P(ret_text);
appendBinaryStringInfo(&buf, start_ptr, chunk_len);
}
- ret_text = PG_STR_GET_TEXT(buf.data);
+ ret_text = cstring_to_text_with_len(buf.data, buf.len);
pfree(buf.data);
pfree(data);
if (inputstring_len < 1)
{
text_position_cleanup(&state);
- PG_RETURN_TEXT_P(PG_STR_GET_TEXT(""));
+ PG_RETURN_TEXT_P(cstring_to_text(""));
}
/* empty field separator */
if (fldnum == 1)
PG_RETURN_TEXT_P(inputstring);
else
- PG_RETURN_TEXT_P(PG_STR_GET_TEXT(""));
+ PG_RETURN_TEXT_P(cstring_to_text(""));
}
/* identify bounds of first field */
if (fldnum == 1)
PG_RETURN_TEXT_P(inputstring);
else
- PG_RETURN_TEXT_P(PG_STR_GET_TEXT(""));
+ PG_RETURN_TEXT_P(cstring_to_text(""));
}
while (end_posn > 0 && --fldnum > 0)
-1,
true);
else
- result_text = PG_STR_GET_TEXT("");
+ result_text = cstring_to_text("");
}
else
{
}
/* must build a temp text datum to pass to accumArrayResult */
- result_text = (text *) palloc(VARHDRSZ + chunk_len);
- SET_VARSIZE(result_text, VARHDRSZ + chunk_len);
- memcpy(VARDATA(result_text), start_ptr, chunk_len);
+ result_text = cstring_to_text_with_len(start_ptr, chunk_len);
/* stash away this field */
astate = accumArrayResult(astate,
array_to_text(PG_FUNCTION_ARGS)
{
ArrayType *v = PG_GETARG_ARRAYTYPE_P(0);
- char *fldsep = PG_TEXTARG_GET_STR(1);
+ char *fldsep = text_to_cstring(PG_GETARG_TEXT_PP(1));
int nitems,
*dims,
ndims;
/* if there are no elements, return an empty string */
if (nitems == 0)
- PG_RETURN_TEXT_P(PG_STR_GET_TEXT(""));
+ PG_RETURN_TEXT_P(cstring_to_text(""));
element_type = ARR_ELEMTYPE(v);
initStringInfo(&buf);
}
}
- PG_RETURN_TEXT_P(PG_STR_GET_TEXT(buf.data));
+ PG_RETURN_TEXT_P(cstring_to_text_with_len(buf.data, buf.len));
}
#define HEXBASE 16
to_hex32(PG_FUNCTION_ARGS)
{
uint32 value = (uint32) PG_GETARG_INT32(0);
- text *result_text;
char *ptr;
const char *digits = "0123456789abcdef";
char buf[32]; /* bigger than needed, but reasonable */
value /= HEXBASE;
} while (ptr > buf && value);
- result_text = PG_STR_GET_TEXT(ptr);
- PG_RETURN_TEXT_P(result_text);
+ PG_RETURN_TEXT_P(cstring_to_text(ptr));
}
/*
to_hex64(PG_FUNCTION_ARGS)
{
uint64 value = (uint64) PG_GETARG_INT64(0);
- text *result_text;
char *ptr;
const char *digits = "0123456789abcdef";
char buf[32]; /* bigger than needed, but reasonable */
value /= HEXBASE;
} while (ptr > buf && value);
- result_text = PG_STR_GET_TEXT(ptr);
- PG_RETURN_TEXT_P(result_text);
+ PG_RETURN_TEXT_P(cstring_to_text(ptr));
}
/*
text *in_text = PG_GETARG_TEXT_PP(0);
size_t len;
char hexsum[MD5_HASH_LEN + 1];
- text *result_text;
/* Calculate the length of the buffer using varlena metadata */
len = VARSIZE_ANY_EXHDR(in_text);
errmsg("out of memory")));
/* convert to text and return it */
- result_text = PG_STR_GET_TEXT(hexsum);
- PG_RETURN_TEXT_P(result_text);
+ PG_RETURN_TEXT_P(cstring_to_text(hexsum));
}
/*
bytea *in = PG_GETARG_BYTEA_PP(0);
size_t len;
char hexsum[MD5_HASH_LEN + 1];
- text *result_text;
len = VARSIZE_ANY_EXHDR(in);
if (pg_md5_hash(VARDATA_ANY(in), len, hexsum) == false)
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
- result_text = PG_STR_GET_TEXT(hexsum);
- PG_RETURN_TEXT_P(result_text);
+ PG_RETURN_TEXT_P(cstring_to_text(hexsum));
}
/*
Datum
pgsql_version(PG_FUNCTION_ARGS)
{
- int n = strlen(PG_VERSION_STR);
- text *ret = (text *) palloc(n + VARHDRSZ);
-
- SET_VARSIZE(ret, n + VARHDRSZ);
- memcpy(VARDATA(ret), PG_VERSION_STR, n);
-
- PG_RETURN_TEXT_P(ret);
+ PG_RETURN_TEXT_P(cstring_to_text(PG_VERSION_STR));
}
errhint("You need to rebuild PostgreSQL using --with-libxml.")))
-#define _textin(str) DirectFunctionCall1(textin, CStringGetDatum(str))
-#define _textout(x) DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(x)))
-
-
/* from SQL/XML:2003 section 4.7 */
#define NAMESPACE_XSD "http://www.w3.org/2001/XMLSchema"
#define NAMESPACE_XSI "http://www.w3.org/2001/XMLSchema-instance"
#endif
+/*
+ * xml_in uses a plain C string to VARDATA conversion, so for the time being
+ * we use the conversion function for the text datatype.
+ *
+ * This is only acceptable so long as xmltype and text use the same
+ * representation.
+ */
Datum
xml_in(PG_FUNCTION_ARGS)
{
#ifdef USE_LIBXML
char *s = PG_GETARG_CSTRING(0);
- size_t len;
xmltype *vardata;
xmlDocPtr doc;
- len = strlen(s);
- vardata = palloc(len + VARHDRSZ);
- SET_VARSIZE(vardata, len + VARHDRSZ);
- memcpy(VARDATA(vardata), s, len);
+ vardata = (xmltype *) cstring_to_text(s);
/*
* Parse the data to check if it is well-formed XML data. Assume that
#define PG_XML_DEFAULT_VERSION "1.0"
+/*
+ * xml_out_internal uses a plain VARDATA to C string conversion, so for the
+ * time being we use the conversion function for the text datatype.
+ *
+ * This is only acceptable so long as xmltype and text use the same
+ * representation.
+ */
static char *
xml_out_internal(xmltype *x, pg_enc target_encoding)
{
int res_code;
#endif
- len = VARSIZE(x) - VARHDRSZ;
- str = palloc(len + 1);
- memcpy(str, VARDATA(x), len);
- str[len] = '\0';
+ str = text_to_cstring((text *) x);
+ len = strlen(str);
#ifdef USE_LIBXML
if ((res_code = parse_xml_decl((xmlChar *) str,
{
char *string;
- string = _textout(arg);
+ string = text_to_cstring(arg);
if (strstr(string, "?>") != NULL)
ereport(ERROR,
(errcode(ERRCODE_INVALID_XML_PROCESSING_INSTRUCTION),
Oid relid = PG_GETARG_OID(0);
bool nulls = PG_GETARG_BOOL(1);
bool tableforest = PG_GETARG_BOOL(2);
- const char *targetns = _textout(PG_GETARG_TEXT_P(3));
+ const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
PG_RETURN_XML_P(stringinfo_to_xmltype(table_to_xml_internal(relid, NULL,
nulls, tableforest,
Datum
query_to_xml(PG_FUNCTION_ARGS)
{
- char *query = _textout(PG_GETARG_TEXT_P(0));
+ char *query = text_to_cstring(PG_GETARG_TEXT_PP(0));
bool nulls = PG_GETARG_BOOL(1);
bool tableforest = PG_GETARG_BOOL(2);
- const char *targetns = _textout(PG_GETARG_TEXT_P(3));
+ const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
PG_RETURN_XML_P(stringinfo_to_xmltype(query_to_xml_internal(query, NULL,
NULL, nulls, tableforest,
Datum
cursor_to_xml(PG_FUNCTION_ARGS)
{
- char *name = _textout(PG_GETARG_TEXT_P(0));
+ char *name = text_to_cstring(PG_GETARG_TEXT_PP(0));
int32 count = PG_GETARG_INT32(1);
bool nulls = PG_GETARG_BOOL(2);
bool tableforest = PG_GETARG_BOOL(3);
- const char *targetns = _textout(PG_GETARG_TEXT_P(4));
+ const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(4));
StringInfoData result;
Portal portal;
Oid relid = PG_GETARG_OID(0);
bool nulls = PG_GETARG_BOOL(1);
bool tableforest = PG_GETARG_BOOL(2);
- const char *targetns = _textout(PG_GETARG_TEXT_P(3));
+ const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
const char *result;
Relation rel;
Datum
query_to_xmlschema(PG_FUNCTION_ARGS)
{
- char *query = _textout(PG_GETARG_TEXT_P(0));
+ char *query = text_to_cstring(PG_GETARG_TEXT_PP(0));
bool nulls = PG_GETARG_BOOL(1);
bool tableforest = PG_GETARG_BOOL(2);
- const char *targetns = _textout(PG_GETARG_TEXT_P(3));
+ const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
const char *result;
SPIPlanPtr plan;
Portal portal;
Datum
cursor_to_xmlschema(PG_FUNCTION_ARGS)
{
- char *name = _textout(PG_GETARG_TEXT_P(0));
+ char *name = text_to_cstring(PG_GETARG_TEXT_PP(0));
bool nulls = PG_GETARG_BOOL(1);
bool tableforest = PG_GETARG_BOOL(2);
- const char *targetns = _textout(PG_GETARG_TEXT_P(3));
+ const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
const char *xmlschema;
Portal portal;
Oid relid = PG_GETARG_OID(0);
bool nulls = PG_GETARG_BOOL(1);
bool tableforest = PG_GETARG_BOOL(2);
- const char *targetns = _textout(PG_GETARG_TEXT_P(3));
+ const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
Relation rel;
const char *xmlschema;
Datum
query_to_xml_and_xmlschema(PG_FUNCTION_ARGS)
{
- char *query = _textout(PG_GETARG_TEXT_P(0));
+ char *query = text_to_cstring(PG_GETARG_TEXT_PP(0));
bool nulls = PG_GETARG_BOOL(1);
bool tableforest = PG_GETARG_BOOL(2);
- const char *targetns = _textout(PG_GETARG_TEXT_P(3));
+ const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
const char *xmlschema;
SPIPlanPtr plan;
Name name = PG_GETARG_NAME(0);
bool nulls = PG_GETARG_BOOL(1);
bool tableforest = PG_GETARG_BOOL(2);
- const char *targetns = _textout(PG_GETARG_TEXT_P(3));
+ const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
char *schemaname;
Oid nspid;
Name name = PG_GETARG_NAME(0);
bool nulls = PG_GETARG_BOOL(1);
bool tableforest = PG_GETARG_BOOL(2);
- const char *targetns = _textout(PG_GETARG_TEXT_P(3));
+ const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
PG_RETURN_XML_P(stringinfo_to_xmltype(schema_to_xmlschema_internal(NameStr(*name),
nulls, tableforest, targetns)));
Name name = PG_GETARG_NAME(0);
bool nulls = PG_GETARG_BOOL(1);
bool tableforest = PG_GETARG_BOOL(2);
- const char *targetns = _textout(PG_GETARG_TEXT_P(3));
+ const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
char *schemaname;
Oid nspid;
StringInfo xmlschema;
{
bool nulls = PG_GETARG_BOOL(0);
bool tableforest = PG_GETARG_BOOL(1);
- const char *targetns = _textout(PG_GETARG_TEXT_P(2));
+ const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(2));
PG_RETURN_XML_P(stringinfo_to_xmltype(database_to_xml_internal(NULL, nulls,
tableforest, targetns)));
{
bool nulls = PG_GETARG_BOOL(0);
bool tableforest = PG_GETARG_BOOL(1);
- const char *targetns = _textout(PG_GETARG_TEXT_P(2));
+ const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(2));
PG_RETURN_XML_P(stringinfo_to_xmltype(database_to_xmlschema_internal(nulls,
tableforest, targetns)));
{
bool nulls = PG_GETARG_BOOL(0);
bool tableforest = PG_GETARG_BOOL(1);
- const char *targetns = _textout(PG_GETARG_TEXT_P(2));
+ const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(2));
StringInfo xmlschema;
xmlschema = database_to_xmlschema_internal(nulls, tableforest, targetns);
{
str = xmlXPathCastNodeToString(cur);
len = strlen((char *) str);
- result = (text *) palloc(len + VARHDRSZ);
+ result = (xmltype *) palloc(len + VARHDRSZ);
SET_VARSIZE(result, len + VARHDRSZ);
memcpy(VARDATA(result), str, len);
}
ereport(ERROR,
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("neither namespace name nor URI may be null")));
- ns_name = _textout(ns_names_uris[i * 2]);
- ns_uri = _textout(ns_names_uris[i * 2 + 1]);
+ ns_name = TextDatumGetCString(ns_names_uris[i * 2]);
+ ns_uri = TextDatumGetCString(ns_names_uris[i * 2 + 1]);
if (xmlXPathRegisterNs(xpathctx,
(xmlChar *) ns_name,
(xmlChar *) ns_uri) != 0)
if (!isNull)
{
/* We have an expression default */
- expr = stringToNode(DatumGetCString(DirectFunctionCall1(textout,
- datum)));
+ expr = stringToNode(TextDatumGetCString(datum));
}
else
{
char *strDefaultVal;
/* Convert text datum to C string */
- strDefaultVal = DatumGetCString(DirectFunctionCall1(textout,
- datum));
+ strDefaultVal = TextDatumGetCString(datum);
/* Convert C string to a value of the given type */
datum = OidInputFunctionCall(type->typinput, strDefaultVal,
getTypeIOParam(typeTuple), -1);
Form_pg_rewrite rewrite_form = (Form_pg_rewrite) GETSTRUCT(rewrite_tuple);
bool isnull;
Datum rule_datum;
- text *rule_text;
char *rule_str;
RewriteRule *rule;
rewrite_tupdesc,
&isnull);
Assert(!isnull);
- rule_text = DatumGetTextP(rule_datum);
- rule_str = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(rule_text)));
+ rule_str = TextDatumGetCString(rule_datum);
oldcxt = MemoryContextSwitchTo(rulescxt);
rule->actions = (List *) stringToNode(rule_str);
MemoryContextSwitchTo(oldcxt);
pfree(rule_str);
- if ((Pointer) rule_text != DatumGetPointer(rule_datum))
- pfree(rule_text);
rule_datum = heap_getattr(rewrite_tuple,
Anum_pg_rewrite_ev_qual,
rewrite_tupdesc,
&isnull);
Assert(!isnull);
- rule_text = DatumGetTextP(rule_datum);
- rule_str = DatumGetCString(DirectFunctionCall1(textout,
- PointerGetDatum(rule_text)));
+ rule_str = TextDatumGetCString(rule_datum);
oldcxt = MemoryContextSwitchTo(rulescxt);
rule->qual = (Node *) stringToNode(rule_str);
MemoryContextSwitchTo(oldcxt);
pfree(rule_str);
- if ((Pointer) rule_text != DatumGetPointer(rule_datum))
- pfree(rule_text);
/*
* We want the rule's table references to be checked as though by the
RelationGetRelationName(relation));
else
attrdef[i].adbin = MemoryContextStrdup(CacheMemoryContext,
- DatumGetCString(DirectFunctionCall1(textout,
- val)));
+ TextDatumGetCString(val));
break;
}
RelationGetRelationName(relation));
check[found].ccbin = MemoryContextStrdup(CacheMemoryContext,
- DatumGetCString(DirectFunctionCall1(textout,
- val)));
+ TextDatumGetCString(val));
found++;
}
GetPgIndexDescriptor(),
&isnull);
Assert(!isnull);
- exprsString = DatumGetCString(DirectFunctionCall1(textout, exprsDatum));
+ exprsString = TextDatumGetCString(exprsDatum);
result = (List *) stringToNode(exprsString);
pfree(exprsString);
GetPgIndexDescriptor(),
&isnull);
Assert(!isnull);
- predString = DatumGetCString(DirectFunctionCall1(textout, predDatum));
+ predString = TextDatumGetCString(predDatum);
result = (List *) stringToNode(predString);
pfree(predString);
Anum_pg_proc_prosrc, &isnull);
if (isnull)
elog(ERROR, "null prosrc");
- prosrc = DatumGetCString(DirectFunctionCall1(textout,
- prosrcdatum));
+ prosrc = TextDatumGetCString(prosrcdatum);
fbp = fmgr_lookupByName(prosrc);
if (fbp == NULL)
ereport(ERROR,
Anum_pg_proc_prosrc, &isnull);
if (isnull)
elog(ERROR, "null prosrc for function %u", functionId);
- prosrcstring = DatumGetCString(DirectFunctionCall1(textout,
- prosrcattr));
+ prosrcstring = TextDatumGetCString(prosrcattr);
probinattr = SysCacheGetAttr(PROCOID, procedureTuple,
Anum_pg_proc_probin, &isnull);
if (isnull)
elog(ERROR, "null probin for function %u", functionId);
- probinstring = DatumGetCString(DirectFunctionCall1(textout,
- probinattr));
+ probinstring = TextDatumGetCString(probinattr);
/* Look up the function itself */
user_fn = load_external_function(probinstring, prosrcstring, true,
elog(ERROR, "proargnames must have the same number of elements as the function has arguments");
*p_argnames = (char **) palloc(sizeof(char *) * numargs);
for (i = 0; i < numargs; i++)
- (*p_argnames)[i] = DatumGetCString(DirectFunctionCall1(textout,
- elems[i]));
+ (*p_argnames)[i] = TextDatumGetCString(elems[i]);
}
/* Get argument modes, if available */
result = NULL;
break;
}
- result = DatumGetCString(DirectFunctionCall1(textout,
- argnames[i]));
+ result = TextDatumGetCString(argnames[i]);
if (result == NULL || result[0] == '\0')
{
/* Parameter is not named, so forget it */
argmodes[i] == PROARGMODE_INOUT);
outargtypes[numoutargs] = argtypes[i];
if (argnames)
- pname = DatumGetCString(DirectFunctionCall1(textout, argnames[i]));
+ pname = TextDatumGetCString(argnames[i]);
else
pname = NULL;
if (pname == NULL || pname[0] == '\0')
* it is, ignore it, since we can't handle that in startup mode.
*
* It is entirely likely that it's 1-byte format not 4-byte, and
- * theoretically possible that it's compressed inline, but textout
- * should be able to handle those cases even in startup mode.
+ * theoretically possible that it's compressed inline, but
+ * text_to_cstring should be able to handle those cases even in
+ * startup mode.
*/
if (VARATT_IS_EXTERNAL(DatumGetPointer(datum)))
auth_info[curr_role].rolpassword = pstrdup("");
else
- auth_info[curr_role].rolpassword = DatumGetCString(DirectFunctionCall1(textout, datum));
+ auth_info[curr_role].rolpassword = TextDatumGetCString(datum);
/* assume passwd has attlen -1 */
off = att_addlength_pointer(off, -1, tp + off);
char *value;
char *new_value;
bool is_local;
- text *result_text;
if (PG_ARGISNULL(0))
ereport(ERROR,
errmsg("SET requires parameter name")));
/* Get the GUC variable name */
- name = DatumGetCString(DirectFunctionCall1(textout, PG_GETARG_DATUM(0)));
+ name = TextDatumGetCString(PG_GETARG_DATUM(0));
/* Get the desired value or set to NULL for a reset request */
if (PG_ARGISNULL(1))
value = NULL;
else
- value = DatumGetCString(DirectFunctionCall1(textout, PG_GETARG_DATUM(1)));
+ value = TextDatumGetCString(PG_GETARG_DATUM(1));
/*
* Get the desired state of is_local. Default to false if provided value
new_value = GetConfigOptionByName(name, NULL);
/* Convert return string to text */
- result_text = DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(new_value)));
-
- /* return it */
- PG_RETURN_TEXT_P(result_text);
+ PG_RETURN_TEXT_P(cstring_to_text(new_value));
}
{
char *varname;
char *varval;
- text *result_text;
/* Get the GUC variable name */
- varname = DatumGetCString(DirectFunctionCall1(textout, PG_GETARG_DATUM(0)));
+ varname = TextDatumGetCString(PG_GETARG_DATUM(0));
/* Get the value */
varval = GetConfigOptionByName(varname, NULL);
/* Convert to text */
- result_text = DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(varval)));
-
- /* return it */
- PG_RETURN_TEXT_P(result_text);
+ PG_RETURN_TEXT_P(cstring_to_text(varval));
}
/*
if (isnull)
continue;
- s = DatumGetCString(DirectFunctionCall1(textout, d));
+ s = TextDatumGetCString(d);
ParseLongOption(s, &name, &value);
if (!value)
newval = palloc(strlen(name) + 1 + strlen(value) + 1);
sprintf(newval, "%s=%s", name, value);
- datum = DirectFunctionCall1(textin, CStringGetDatum(newval));
+ datum = CStringGetTextDatum(newval);
if (array)
{
&isnull);
if (isnull)
continue;
- current = DatumGetCString(DirectFunctionCall1(textout, d));
+ current = TextDatumGetCString(d);
if (strncmp(current, newval, strlen(name) + 1) == 0)
{
index = i;
&isnull);
if (isnull)
continue;
- val = DatumGetCString(DirectFunctionCall1(textout, d));
+ val = TextDatumGetCString(d);
/* ignore entry if it's what we want to delete */
if (strncmp(val, name, strlen(name)) == 0
MemSet(nulls, 0, sizeof(nulls));
- values[0] = DirectFunctionCall1(textin, CStringGetDatum(portal->name));
+ values[0] = CStringGetTextDatum(portal->name);
if (!portal->sourceText)
nulls[1] = true;
else
- values[1] = DirectFunctionCall1(textin,
- CStringGetDatum(portal->sourceText));
+ values[1] = CStringGetTextDatum(portal->sourceText);
values[2] = BoolGetDatum(portal->cursorOptions & CURSOR_OPT_HOLD);
values[3] = BoolGetDatum(portal->cursorOptions & CURSOR_OPT_BINARY);
values[4] = BoolGetDatum(portal->cursorOptions & CURSOR_OPT_SCROLL);
extern bool TS_execute(QueryItem *curitem, void *checkval, bool calcnot,
bool (*chkcond) (void *checkval, QueryOperand *val));
-/*
- * Useful conversion macros
- */
-#define TextPGetCString(t) DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(t)))
-#define CStringGetTextP(c) DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(c)))
-
/*
* to_ts* - text transformation to tsvector, tsquery
*/
extern Datum varchar(PG_FUNCTION_ARGS);
/* varlena.c */
+extern text *cstring_to_text(const char *s);
+extern text *cstring_to_text_with_len(const char *s, int len);
+extern char *text_to_cstring(const text *t);
+extern void text_to_cstring_buffer(const text *src, char *dst, size_t dst_len);
+
+#define CStringGetTextDatum(s) PointerGetDatum(cstring_to_text(s))
+#define TextDatumGetCString(d) text_to_cstring((text *) DatumGetPointer(d))
+
extern Datum textin(PG_FUNCTION_ARGS);
extern Datum textout(PG_FUNCTION_ARGS);
extern Datum textrecv(PG_FUNCTION_ARGS);
desc.arg_is_rowtype[0] = false;
fmgr_info(F_TEXTOUT, &(desc.arg_out_func[0]));
- fcinfo.arg[0] = DirectFunctionCall1(textin, CStringGetDatum("a"));
+ fcinfo.arg[0] = CStringGetTextDatum("a");
fcinfo.argnull[0] = false;
/* and make the call */
Anum_pg_proc_prosrc, &isnull);
if (isnull)
elog(ERROR, "null prosrc");
- proc_source = DatumGetCString(DirectFunctionCall1(textout,
- prosrcdatum));
+ proc_source = TextDatumGetCString(prosrcdatum);
/************************************************************
* Create the procedure in the interpreter
Anum_pg_proc_prosrc, &isnull);
if (isnull)
elog(ERROR, "null prosrc");
- proc_source = DatumGetCString(DirectFunctionCall1(textout, prosrcdatum));
+ proc_source = TextDatumGetCString(prosrcdatum);
plpgsql_scanner_init(proc_source, functype);
plpgsql_error_funcname = pstrdup(NameStr(procStruct->proname));
var = (PLpgSQL_var *) (estate.datums[func->tg_op_varno]);
if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
- var->value = DirectFunctionCall1(textin, CStringGetDatum("INSERT"));
+ var->value = CStringGetTextDatum("INSERT");
else if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
- var->value = DirectFunctionCall1(textin, CStringGetDatum("UPDATE"));
+ var->value = CStringGetTextDatum("UPDATE");
else if (TRIGGER_FIRED_BY_DELETE(trigdata->tg_event))
- var->value = DirectFunctionCall1(textin, CStringGetDatum("DELETE"));
+ var->value = CStringGetTextDatum("DELETE");
else
elog(ERROR, "unrecognized trigger action: not INSERT, DELETE, or UPDATE");
var->isnull = false;
var = (PLpgSQL_var *) (estate.datums[func->tg_when_varno]);
if (TRIGGER_FIRED_BEFORE(trigdata->tg_event))
- var->value = DirectFunctionCall1(textin, CStringGetDatum("BEFORE"));
+ var->value = CStringGetTextDatum("BEFORE");
else if (TRIGGER_FIRED_AFTER(trigdata->tg_event))
- var->value = DirectFunctionCall1(textin, CStringGetDatum("AFTER"));
+ var->value = CStringGetTextDatum("AFTER");
else
elog(ERROR, "unrecognized trigger execution time: not BEFORE or AFTER");
var->isnull = false;
var = (PLpgSQL_var *) (estate.datums[func->tg_level_varno]);
if (TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
- var->value = DirectFunctionCall1(textin, CStringGetDatum("ROW"));
+ var->value = CStringGetTextDatum("ROW");
else if (TRIGGER_FIRED_FOR_STATEMENT(trigdata->tg_event))
- var->value = DirectFunctionCall1(textin, CStringGetDatum("STATEMENT"));
+ var->value = CStringGetTextDatum("STATEMENT");
else
elog(ERROR, "unrecognized trigger event type: not ROW or STATEMENT");
var->isnull = false;
{
estate.trig_argv = palloc(sizeof(Datum) * estate.trig_nargs);
for (i = 0; i < trigdata->tg_trigger->tgnargs; i++)
- estate.trig_argv[i] = DirectFunctionCall1(textin,
- CStringGetDatum(trigdata->tg_trigger->tgargs[i]));
+ estate.trig_argv[i] = CStringGetTextDatum(trigdata->tg_trigger->tgargs[i]);
}
estate.err_text = gettext_noop("during function entry");
state_var = (PLpgSQL_var *)
estate->datums[block->exceptions->sqlstate_varno];
- state_var->value = DirectFunctionCall1(textin,
- CStringGetDatum(unpack_sql_state(edata->sqlerrcode)));
+ state_var->value = CStringGetTextDatum(unpack_sql_state(edata->sqlerrcode));
state_var->freeval = true;
state_var->isnull = false;
errm_var = (PLpgSQL_var *)
estate->datums[block->exceptions->sqlerrm_varno];
- errm_var->value = DirectFunctionCall1(textin,
- CStringGetDatum(edata->message));
+ errm_var->value = CStringGetTextDatum(edata->message);
errm_var->freeval = true;
errm_var->isnull = false;
curvar = (PLpgSQL_var *) (estate->datums[stmt->curvar]);
if (!curvar->isnull)
{
- curname = DatumGetCString(DirectFunctionCall1(textout, curvar->value));
+ curname = TextDatumGetCString(curvar->value);
if (SPI_cursor_find(curname) != NULL)
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_CURSOR),
* ----------
*/
free_var(curvar);
- curvar->value = DirectFunctionCall1(textin, CStringGetDatum(portal->name));
+ curvar->value = CStringGetTextDatum(portal->name);
curvar->isnull = false;
curvar->freeval = true;
* ----------
*/
free_var(curvar);
- curvar->value = DirectFunctionCall1(textin, CStringGetDatum(portal->name));
+ curvar->value = CStringGetTextDatum(portal->name);
curvar->isnull = false;
curvar->freeval = true;
ereport(ERROR,
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("cursor variable \"%s\" is NULL", curvar->refname)));
- curname = DatumGetCString(DirectFunctionCall1(textout, curvar->value));
+ curname = TextDatumGetCString(curvar->value);
portal = SPI_cursor_find(curname);
if (portal == NULL)
ereport(ERROR,
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("cursor variable \"%s\" is NULL", curvar->refname)));
- curname = DatumGetCString(DirectFunctionCall1(textout, curvar->value));
+ curname = TextDatumGetCString(curvar->value);
portal = SPI_cursor_find(curname);
if (portal == NULL)
/* Fetch argument name */
if (proc->argnames)
- proc->argnames[i] = PLy_strdup(DatumGetCString(DirectFunctionCall1(textout, elems[i])));
+ proc->argnames[i] = PLy_strdup(TextDatumGetCString(elems[i]));
}
/*
Anum_pg_proc_prosrc, &isnull);
if (isnull)
elog(ERROR, "null prosrc");
- procSource = DatumGetCString(DirectFunctionCall1(textout,
- prosrcdatum));
+ procSource = TextDatumGetCString(prosrcdatum);
PLy_procedure_compile(proc, procSource);
Anum_pg_proc_prosrc, &isnull);
if (isnull)
elog(ERROR, "null prosrc");
- proc_source = DatumGetCString(DirectFunctionCall1(textout,
- prosrcdatum));
+ proc_source = TextDatumGetCString(prosrcdatum);
UTF_BEGIN;
Tcl_DStringAppend(&proc_internal_body, UTF_E2U(proc_source), -1);
UTF_END;
return PointerGetDatum(NULL);
}
- {
- text *seqname = DatumGetTextP(DirectFunctionCall1(textin,
- CStringGetDatum("ttdummy_seq")));
-
- newoff = DirectFunctionCall1(nextval,
- PointerGetDatum(seqname));
- /* nextval now returns int64; coerce down to int32 */
- newoff = Int32GetDatum((int32) DatumGetInt64(newoff));
- pfree(seqname);
- }
+ newoff = DirectFunctionCall1(nextval, CStringGetTextDatum("ttdummy_seq"));
+ /* nextval now returns int64; coerce down to int32 */
+ newoff = Int32GetDatum((int32) DatumGetInt64(newoff));
/* Connect to SPI manager */
if ((ret = SPI_connect()) < 0)
projects / users / simon / postgres.git / commitdiff