PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
varlena.c File Reference
#include "postgres.h"
#include <ctype.h>
#include <limits.h>
#include "access/hash.h"
#include "access/tuptoaster.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_type.h"
#include "common/md5.h"
#include "lib/hyperloglog.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "parser/scansup.h"
#include "port/pg_bswap.h"
#include "regex/regex.h"
#include "utils/builtins.h"
#include "utils/bytea.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/pg_locale.h"
#include "utils/sortsupport.h"
#include "utils/varlena.h"
#include "levenshtein.c"
Include dependency graph for varlena.c:

Go to the source code of this file.

Data Structures

struct  TextPositionState
 
struct  VarStringSortSupport
 

Macros

#define TEXTBUFLEN   1024
 
#define DatumGetUnknownP(X)   ((unknown *) PG_DETOAST_DATUM(X))
 
#define DatumGetUnknownPCopy(X)   ((unknown *) PG_DETOAST_DATUM_COPY(X))
 
#define PG_GETARG_UNKNOWN_P(n)   DatumGetUnknownP(PG_GETARG_DATUM(n))
 
#define PG_GETARG_UNKNOWN_P_COPY(n)   DatumGetUnknownPCopy(PG_GETARG_DATUM(n))
 
#define PG_RETURN_UNKNOWN_P(x)   PG_RETURN_POINTER(x)
 
#define DatumGetVarStringP(X)   ((VarString *) PG_DETOAST_DATUM(X))
 
#define DatumGetVarStringPP(X)   ((VarString *) PG_DETOAST_DATUM_PACKED(X))
 
#define VAL(CH)   ((CH) - '0')
 
#define DIG(VAL)   ((VAL) + '0')
 
#define PG_STR_GET_BYTEA(str_)   DatumGetByteaPP(DirectFunctionCall1(byteain, CStringGetDatum(str_)))
 
#define REGEXP_REPLACE_BACKREF_CNT   10
 
#define HEXBASE   16
 
#define MD5_HASH_LEN   32
 
#define TEXT_FORMAT_FLAG_MINUS   0x0001 /* is minus flag present? */
 
#define ADVANCE_PARSE_POINTER(ptr, end_ptr)
 
#define LEVENSHTEIN_LESS_EQUAL
 

Typedefs

typedef struct varlena unknown
 
typedef struct varlena VarString
 

Functions

static int varstrfastcmp_c (Datum x, Datum y, SortSupport ssup)
 
static int bpcharfastcmp_c (Datum x, Datum y, SortSupport ssup)
 
static int varstrfastcmp_locale (Datum x, Datum y, SortSupport ssup)
 
static int varstrcmp_abbrev (Datum x, Datum y, SortSupport ssup)
 
static Datum varstr_abbrev_convert (Datum original, SortSupport ssup)
 
static bool varstr_abbrev_abort (int memtupcount, SortSupport ssup)
 
static int32 text_length (Datum str)
 
static texttext_catenate (text *t1, text *t2)
 
static texttext_substring (Datum str, int32 start, int32 length, bool length_not_specified)
 
static texttext_overlay (text *t1, text *t2, int sp, int sl)
 
static int text_position (text *t1, text *t2)
 
static void text_position_setup (text *t1, text *t2, TextPositionState *state)
 
static int text_position_next (int start_pos, TextPositionState *state)
 
static void text_position_cleanup (TextPositionState *state)
 
static int text_cmp (text *arg1, text *arg2, Oid collid)
 
static byteabytea_catenate (bytea *t1, bytea *t2)
 
static byteabytea_substring (Datum str, int S, int L, bool length_not_specified)
 
static byteabytea_overlay (bytea *t1, bytea *t2, int sp, int sl)
 
static void appendStringInfoText (StringInfo str, const text *t)
 
static Datum text_to_array_internal (PG_FUNCTION_ARGS)
 
static textarray_to_text_internal (FunctionCallInfo fcinfo, ArrayType *v, const char *fldsep, const char *null_string)
 
static StringInfo makeStringAggState (FunctionCallInfo fcinfo)
 
static bool text_format_parse_digits (const char **ptr, const char *end_ptr, int *value)
 
static const char * text_format_parse_format (const char *start_ptr, const char *end_ptr, int *argpos, int *widthpos, int *flags, int *width)
 
static void text_format_string_conversion (StringInfo buf, char conversion, FmgrInfo *typOutputInfo, Datum value, bool isNull, int flags, int width)
 
static void text_format_append_string (StringInfo buf, const char *str, int flags, int width)
 
textcstring_to_text (const char *s)
 
textcstring_to_text_with_len (const char *s, int len)
 
char * text_to_cstring (const text *t)
 
void text_to_cstring_buffer (const text *src, char *dst, size_t dst_len)
 
Datum byteain (PG_FUNCTION_ARGS)
 
Datum byteaout (PG_FUNCTION_ARGS)
 
Datum bytearecv (PG_FUNCTION_ARGS)
 
Datum byteasend (PG_FUNCTION_ARGS)
 
Datum bytea_string_agg_transfn (PG_FUNCTION_ARGS)
 
Datum bytea_string_agg_finalfn (PG_FUNCTION_ARGS)
 
Datum textin (PG_FUNCTION_ARGS)
 
Datum textout (PG_FUNCTION_ARGS)
 
Datum textrecv (PG_FUNCTION_ARGS)
 
Datum textsend (PG_FUNCTION_ARGS)
 
Datum unknownin (PG_FUNCTION_ARGS)
 
Datum unknownout (PG_FUNCTION_ARGS)
 
Datum unknownrecv (PG_FUNCTION_ARGS)
 
Datum unknownsend (PG_FUNCTION_ARGS)
 
Datum textlen (PG_FUNCTION_ARGS)
 
Datum textoctetlen (PG_FUNCTION_ARGS)
 
Datum textcat (PG_FUNCTION_ARGS)
 
static int charlen_to_bytelen (const char *p, int n)
 
Datum text_substr (PG_FUNCTION_ARGS)
 
Datum text_substr_no_len (PG_FUNCTION_ARGS)
 
Datum textoverlay (PG_FUNCTION_ARGS)
 
Datum textoverlay_no_len (PG_FUNCTION_ARGS)
 
Datum textpos (PG_FUNCTION_ARGS)
 
int varstr_cmp (char *arg1, int len1, char *arg2, int len2, Oid collid)
 
Datum texteq (PG_FUNCTION_ARGS)
 
Datum textne (PG_FUNCTION_ARGS)
 
Datum text_lt (PG_FUNCTION_ARGS)
 
Datum text_le (PG_FUNCTION_ARGS)
 
Datum text_gt (PG_FUNCTION_ARGS)
 
Datum text_ge (PG_FUNCTION_ARGS)
 
Datum bttextcmp (PG_FUNCTION_ARGS)
 
Datum bttextsortsupport (PG_FUNCTION_ARGS)
 
void varstr_sortsupport (SortSupport ssup, Oid collid, bool bpchar)
 
Datum text_larger (PG_FUNCTION_ARGS)
 
Datum text_smaller (PG_FUNCTION_ARGS)
 
static int internal_text_pattern_compare (text *arg1, text *arg2)
 
Datum text_pattern_lt (PG_FUNCTION_ARGS)
 
Datum text_pattern_le (PG_FUNCTION_ARGS)
 
Datum text_pattern_ge (PG_FUNCTION_ARGS)
 
Datum text_pattern_gt (PG_FUNCTION_ARGS)
 
Datum bttext_pattern_cmp (PG_FUNCTION_ARGS)
 
Datum bttext_pattern_sortsupport (PG_FUNCTION_ARGS)
 
Datum byteaoctetlen (PG_FUNCTION_ARGS)
 
Datum byteacat (PG_FUNCTION_ARGS)
 
Datum bytea_substr (PG_FUNCTION_ARGS)
 
Datum bytea_substr_no_len (PG_FUNCTION_ARGS)
 
Datum byteaoverlay (PG_FUNCTION_ARGS)
 
Datum byteaoverlay_no_len (PG_FUNCTION_ARGS)
 
Datum byteapos (PG_FUNCTION_ARGS)
 
Datum byteaGetByte (PG_FUNCTION_ARGS)
 
Datum byteaGetBit (PG_FUNCTION_ARGS)
 
Datum byteaSetByte (PG_FUNCTION_ARGS)
 
Datum byteaSetBit (PG_FUNCTION_ARGS)
 
Datum text_name (PG_FUNCTION_ARGS)
 
Datum name_text (PG_FUNCTION_ARGS)
 
ListtextToQualifiedNameList (text *textval)
 
bool SplitIdentifierString (char *rawstring, char separator, List **namelist)
 
bool SplitDirectoriesString (char *rawstring, char separator, List **namelist)
 
Datum byteaeq (PG_FUNCTION_ARGS)
 
Datum byteane (PG_FUNCTION_ARGS)
 
Datum bytealt (PG_FUNCTION_ARGS)
 
Datum byteale (PG_FUNCTION_ARGS)
 
Datum byteagt (PG_FUNCTION_ARGS)
 
Datum byteage (PG_FUNCTION_ARGS)
 
Datum byteacmp (PG_FUNCTION_ARGS)
 
Datum bytea_sortsupport (PG_FUNCTION_ARGS)
 
Datum replace_text (PG_FUNCTION_ARGS)
 
static bool check_replace_text_has_escape_char (const text *replace_text)
 
static void appendStringInfoRegexpSubstr (StringInfo str, text *replace_text, regmatch_t *pmatch, char *start_ptr, int data_pos)
 
textreplace_text_regexp (text *src_text, void *regexp, text *replace_text, bool glob)
 
Datum split_text (PG_FUNCTION_ARGS)
 
static bool text_isequal (text *txt1, text *txt2)
 
Datum text_to_array (PG_FUNCTION_ARGS)
 
Datum text_to_array_null (PG_FUNCTION_ARGS)
 
Datum array_to_text (PG_FUNCTION_ARGS)
 
Datum array_to_text_null (PG_FUNCTION_ARGS)
 
Datum to_hex32 (PG_FUNCTION_ARGS)
 
Datum to_hex64 (PG_FUNCTION_ARGS)
 
Datum md5_text (PG_FUNCTION_ARGS)
 
Datum md5_bytea (PG_FUNCTION_ARGS)
 
Datum pg_column_size (PG_FUNCTION_ARGS)
 
Datum string_agg_transfn (PG_FUNCTION_ARGS)
 
Datum string_agg_finalfn (PG_FUNCTION_ARGS)
 
static textconcat_internal (const char *sepstr, int argidx, FunctionCallInfo fcinfo)
 
Datum text_concat (PG_FUNCTION_ARGS)
 
Datum text_concat_ws (PG_FUNCTION_ARGS)
 
Datum text_left (PG_FUNCTION_ARGS)
 
Datum text_right (PG_FUNCTION_ARGS)
 
Datum text_reverse (PG_FUNCTION_ARGS)
 
Datum text_format (PG_FUNCTION_ARGS)
 
Datum text_format_nv (PG_FUNCTION_ARGS)
 
static bool rest_of_char_same (const char *s1, const char *s2, int len)
 

Variables

int bytea_output = BYTEA_OUTPUT_HEX
 

Macro Definition Documentation

#define ADVANCE_PARSE_POINTER (   ptr,
  end_ptr 
)
Value:
do { \
if (++(ptr) >= (end_ptr)) \
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
errmsg("unterminated format() type specifier"), \
errhint("For a single \"%%\" use \"%%%%\"."))); \
} while (0)
int errhint(const char *fmt,...)
Definition: elog.c:987
int errcode(int sqlerrcode)
Definition: elog.c:575
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:122
int errmsg(const char *fmt,...)
Definition: elog.c:797

Definition at line 4911 of file varlena.c.

Referenced by text_format(), text_format_parse_digits(), and text_format_parse_format().

#define DatumGetUnknownP (   X)    ((unknown *) PG_DETOAST_DATUM(X))

Definition at line 85 of file varlena.c.

#define DatumGetUnknownPCopy (   X)    ((unknown *) PG_DETOAST_DATUM_COPY(X))

Definition at line 86 of file varlena.c.

#define DatumGetVarStringP (   X)    ((VarString *) PG_DETOAST_DATUM(X))

Definition at line 91 of file varlena.c.

#define DatumGetVarStringPP (   X)    ((VarString *) PG_DETOAST_DATUM_PACKED(X))

Definition at line 92 of file varlena.c.

Referenced by varstr_abbrev_convert(), varstrfastcmp_c(), and varstrfastcmp_locale().

#define DIG (   VAL)    ((VAL) + '0')

Definition at line 241 of file varlena.c.

Referenced by byteaout().

#define HEXBASE   16

Definition at line 4482 of file varlena.c.

Referenced by to_hex32(), and to_hex64().

#define LEVENSHTEIN_LESS_EQUAL

Definition at line 5451 of file varlena.c.

#define MD5_HASH_LEN   32

Definition at line 4536 of file varlena.c.

Referenced by md5_bytea(), and md5_text().

#define PG_GETARG_UNKNOWN_P (   n)    DatumGetUnknownP(PG_GETARG_DATUM(n))

Definition at line 87 of file varlena.c.

#define PG_GETARG_UNKNOWN_P_COPY (   n)    DatumGetUnknownPCopy(PG_GETARG_DATUM(n))

Definition at line 88 of file varlena.c.

#define PG_RETURN_UNKNOWN_P (   x)    PG_RETURN_POINTER(x)

Definition at line 89 of file varlena.c.

#define PG_STR_GET_BYTEA (   str_)    DatumGetByteaPP(DirectFunctionCall1(byteain, CStringGetDatum(str_)))

Definition at line 2789 of file varlena.c.

Referenced by bytea_substring().

#define REGEXP_REPLACE_BACKREF_CNT   10

Definition at line 3875 of file varlena.c.

Referenced by replace_text_regexp().

#define TEXT_FORMAT_FLAG_MINUS   0x0001 /* is minus flag present? */

Definition at line 4909 of file varlena.c.

Referenced by text_format_append_string(), and text_format_parse_format().

#define TEXTBUFLEN   1024

Definition at line 83 of file varlena.c.

Referenced by varstr_cmp(), and varstr_sortsupport().

#define VAL (   CH)    ((CH) - '0')

Definition at line 240 of file varlena.c.

Referenced by byteain().

Typedef Documentation

Definition at line 43 of file varlena.c.

Definition at line 44 of file varlena.c.

Function Documentation

static void appendStringInfoRegexpSubstr ( StringInfo  str,
text replace_text,
regmatch_t pmatch,
char *  start_ptr,
int  data_pos 
)
static

Definition at line 3781 of file varlena.c.

References appendBinaryStringInfo(), appendStringInfoChar(), Assert, charlen_to_bytelen(), idx(), pg_database_encoding_max_length(), pg_mblen(), regmatch_t::rm_eo, regmatch_t::rm_so, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by replace_text_regexp().

3784 {
3785  const char *p = VARDATA_ANY(replace_text);
3786  const char *p_end = p + VARSIZE_ANY_EXHDR(replace_text);
3787  int eml = pg_database_encoding_max_length();
3788 
3789  for (;;)
3790  {
3791  const char *chunk_start = p;
3792  int so;
3793  int eo;
3794 
3795  /* Find next escape char. */
3796  if (eml == 1)
3797  {
3798  for (; p < p_end && *p != '\\'; p++)
3799  /* nothing */ ;
3800  }
3801  else
3802  {
3803  for (; p < p_end && *p != '\\'; p += pg_mblen(p))
3804  /* nothing */ ;
3805  }
3806 
3807  /* Copy the text we just scanned over, if any. */
3808  if (p > chunk_start)
3809  appendBinaryStringInfo(str, chunk_start, p - chunk_start);
3810 
3811  /* Done if at end of string, else advance over escape char. */
3812  if (p >= p_end)
3813  break;
3814  p++;
3815 
3816  if (p >= p_end)
3817  {
3818  /* Escape at very end of input. Treat same as unexpected char */
3819  appendStringInfoChar(str, '\\');
3820  break;
3821  }
3822 
3823  if (*p >= '1' && *p <= '9')
3824  {
3825  /* Use the back reference of regexp. */
3826  int idx = *p - '0';
3827 
3828  so = pmatch[idx].rm_so;
3829  eo = pmatch[idx].rm_eo;
3830  p++;
3831  }
3832  else if (*p == '&')
3833  {
3834  /* Use the entire matched string. */
3835  so = pmatch[0].rm_so;
3836  eo = pmatch[0].rm_eo;
3837  p++;
3838  }
3839  else if (*p == '\\')
3840  {
3841  /* \\ means transfer one \ to output. */
3842  appendStringInfoChar(str, '\\');
3843  p++;
3844  continue;
3845  }
3846  else
3847  {
3848  /*
3849  * If escape char is not followed by any expected char, just treat
3850  * it as ordinary data to copy. (XXX would it be better to throw
3851  * an error?)
3852  */
3853  appendStringInfoChar(str, '\\');
3854  continue;
3855  }
3856 
3857  if (so != -1 && eo != -1)
3858  {
3859  /*
3860  * Copy the text that is back reference of regexp. Note so and eo
3861  * are counted in characters not bytes.
3862  */
3863  char *chunk_start;
3864  int chunk_len;
3865 
3866  Assert(so >= data_pos);
3867  chunk_start = start_ptr;
3868  chunk_start += charlen_to_bytelen(chunk_start, so - data_pos);
3869  chunk_len = charlen_to_bytelen(chunk_start, eo - so);
3870  appendBinaryStringInfo(str, chunk_start, chunk_len);
3871  }
3872  }
3873 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
regoff_t rm_so
Definition: regex.h:85
Datum idx(PG_FUNCTION_ARGS)
Definition: _int_op.c:264
regoff_t rm_eo
Definition: regex.h:86
static int charlen_to_bytelen(const char *p, int n)
Definition: varlena.c:735
int pg_database_encoding_max_length(void)
Definition: wchar.c:1833
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:201
#define Assert(condition)
Definition: c.h:675
int pg_mblen(const char *mbstr)
Definition: mbutils.c:771
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
void appendBinaryStringInfo(StringInfo str, const char *data, int datalen)
Definition: stringinfo.c:240
static void appendStringInfoText ( StringInfo  str,
const text t 
)
static

Definition at line 3651 of file varlena.c.

References appendBinaryStringInfo(), VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by replace_text(), replace_text_regexp(), string_agg_transfn(), xmlcomment(), and XmlTableGetValue().

3652 {
3654 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
void appendBinaryStringInfo(StringInfo str, const char *data, int datalen)
Definition: stringinfo.c:240
Datum array_to_text ( PG_FUNCTION_ARGS  )

Definition at line 4323 of file varlena.c.

References array_to_text_internal(), NULL, PG_GETARG_ARRAYTYPE_P, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, and text_to_cstring().

4324 {
4326  char *fldsep = text_to_cstring(PG_GETARG_TEXT_PP(1));
4327 
4328  PG_RETURN_TEXT_P(array_to_text_internal(fcinfo, v, fldsep, NULL));
4329 }
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
#define PG_GETARG_ARRAYTYPE_P(n)
Definition: array.h:244
static text * array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v, const char *fldsep, const char *null_string)
Definition: varlena.c:4365
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
#define NULL
Definition: c.h:229
char * text_to_cstring(const text *t)
Definition: varlena.c:182
static text * array_to_text_internal ( FunctionCallInfo  fcinfo,
ArrayType v,
const char *  fldsep,
const char *  null_string 
)
static

Definition at line 4365 of file varlena.c.

References appendStringInfo(), appendStringInfoString(), ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_NDIM, ARR_NULLBITMAP, ArrayGetNItems(), att_addlength_pointer, att_align_nominal, buf, cstring_to_text_with_len(), StringInfoData::data, ArrayMetaState::element_type, fetch_att, FunctionCallInfoData::flinfo, fmgr_info_cxt(), FmgrInfo::fn_extra, FmgrInfo::fn_mcxt, get_type_io_data(), i, initStringInfo(), IOFunc_output, StringInfoData::len, MemoryContextAlloc(), NULL, OutputFunctionCall(), pfree(), ArrayMetaState::proc, result, ArrayMetaState::typalign, ArrayMetaState::typbyval, ArrayMetaState::typdelim, ArrayMetaState::typiofunc, ArrayMetaState::typioparam, ArrayMetaState::typlen, and value.

Referenced by array_to_text(), array_to_text_null(), and concat_internal().

4367 {
4368  text *result;
4369  int nitems,
4370  *dims,
4371  ndims;
4372  Oid element_type;
4373  int typlen;
4374  bool typbyval;
4375  char typalign;
4377  bool printed = false;
4378  char *p;
4379  bits8 *bitmap;
4380  int bitmask;
4381  int i;
4382  ArrayMetaState *my_extra;
4383 
4384  ndims = ARR_NDIM(v);
4385  dims = ARR_DIMS(v);
4386  nitems = ArrayGetNItems(ndims, dims);
4387 
4388  /* if there are no elements, return an empty string */
4389  if (nitems == 0)
4390  return cstring_to_text_with_len("", 0);
4391 
4392  element_type = ARR_ELEMTYPE(v);
4393  initStringInfo(&buf);
4394 
4395  /*
4396  * We arrange to look up info about element type, including its output
4397  * conversion proc, only once per series of calls, assuming the element
4398  * type doesn't change underneath us.
4399  */
4400  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
4401  if (my_extra == NULL)
4402  {
4403  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
4404  sizeof(ArrayMetaState));
4405  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
4406  my_extra->element_type = ~element_type;
4407  }
4408 
4409  if (my_extra->element_type != element_type)
4410  {
4411  /*
4412  * Get info about element type, including its output conversion proc
4413  */
4414  get_type_io_data(element_type, IOFunc_output,
4415  &my_extra->typlen, &my_extra->typbyval,
4416  &my_extra->typalign, &my_extra->typdelim,
4417  &my_extra->typioparam, &my_extra->typiofunc);
4418  fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc,
4419  fcinfo->flinfo->fn_mcxt);
4420  my_extra->element_type = element_type;
4421  }
4422  typlen = my_extra->typlen;
4423  typbyval = my_extra->typbyval;
4424  typalign = my_extra->typalign;
4425 
4426  p = ARR_DATA_PTR(v);
4427  bitmap = ARR_NULLBITMAP(v);
4428  bitmask = 1;
4429 
4430  for (i = 0; i < nitems; i++)
4431  {
4432  Datum itemvalue;
4433  char *value;
4434 
4435  /* Get source element, checking for NULL */
4436  if (bitmap && (*bitmap & bitmask) == 0)
4437  {
4438  /* if null_string is NULL, we just ignore null elements */
4439  if (null_string != NULL)
4440  {
4441  if (printed)
4442  appendStringInfo(&buf, "%s%s", fldsep, null_string);
4443  else
4444  appendStringInfoString(&buf, null_string);
4445  printed = true;
4446  }
4447  }
4448  else
4449  {
4450  itemvalue = fetch_att(p, typbyval, typlen);
4451 
4452  value = OutputFunctionCall(&my_extra->proc, itemvalue);
4453 
4454  if (printed)
4455  appendStringInfo(&buf, "%s%s", fldsep, value);
4456  else
4457  appendStringInfoString(&buf, value);
4458  printed = true;
4459 
4460  p = att_addlength_pointer(p, typlen, p);
4461  p = (char *) att_align_nominal(p, typalign);
4462  }
4463 
4464  /* advance bitmap pointer if any */
4465  if (bitmap)
4466  {
4467  bitmask <<= 1;
4468  if (bitmask == 0x100)
4469  {
4470  bitmap++;
4471  bitmask = 1;
4472  }
4473  }
4474  }
4475 
4476  result = cstring_to_text_with_len(buf.data, buf.len);
4477  pfree(buf.data);
4478 
4479  return result;
4480 }
MemoryContext fn_mcxt
Definition: fmgr.h:65
#define att_align_nominal(cur_offset, attalign)
Definition: tupmacs.h:144
int ArrayGetNItems(int ndim, const int *dims)
Definition: arrayutils.c:75
return result
Definition: formatting.c:1618
unsigned int Oid
Definition: postgres_ext.h:31
char * OutputFunctionCall(FmgrInfo *flinfo, Datum val)
Definition: fmgr.c:1667
bool typbyval
Definition: array.h:221
FmgrInfo * flinfo
Definition: fmgr.h:79
void pfree(void *pointer)
Definition: mcxt.c:950
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:110
#define ARR_DIMS(a)
Definition: array.h:275
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:189
#define ARR_DATA_PTR(a)
Definition: array.h:303
int16 typlen
Definition: array.h:220
static char * buf
Definition: pg_test_fsync.c:66
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:161
char typdelim
Definition: array.h:223
void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
Definition: fmgr.c:137
#define att_addlength_pointer(cur_offset, attlen, attptr)
Definition: tupmacs.h:172
void initStringInfo(StringInfo str)
Definition: stringinfo.c:65
uint8 bits8
Definition: c.h:275
uintptr_t Datum
Definition: postgres.h:372
#define NULL
Definition: c.h:229
Oid typioparam
Definition: array.h:224
void * fn_extra
Definition: fmgr.h:64
#define ARR_NDIM(a)
Definition: array.h:271
Oid typiofunc
Definition: array.h:225
char typalign
Definition: array.h:222
#define fetch_att(T, attbyval, attlen)
Definition: tupmacs.h:71
FmgrInfo proc
Definition: array.h:226
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:707
int i
Oid element_type
Definition: array.h:219
Definition: c.h:439
static struct @121 value
#define ARR_ELEMTYPE(a)
Definition: array.h:273
#define ARR_NULLBITMAP(a)
Definition: array.h:281
void get_type_io_data(Oid typid, IOFuncSelector which_func, int16 *typlen, bool *typbyval, char *typalign, char *typdelim, Oid *typioparam, Oid *func)
Definition: lsyscache.c:2075
Datum array_to_text_null ( PG_FUNCTION_ARGS  )

Definition at line 4339 of file varlena.c.

References array_to_text_internal(), NULL, PG_ARGISNULL, PG_GETARG_ARRAYTYPE_P, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, and text_to_cstring().

4340 {
4341  ArrayType *v;
4342  char *fldsep;
4343  char *null_string;
4344 
4345  /* returns NULL when first or second parameter is NULL */
4346  if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
4347  PG_RETURN_NULL();
4348 
4349  v = PG_GETARG_ARRAYTYPE_P(0);
4350  fldsep = text_to_cstring(PG_GETARG_TEXT_PP(1));
4351 
4352  /* NULL null string is passed through as a null pointer */
4353  if (!PG_ARGISNULL(2))
4354  null_string = text_to_cstring(PG_GETARG_TEXT_PP(2));
4355  else
4356  null_string = NULL;
4357 
4358  PG_RETURN_TEXT_P(array_to_text_internal(fcinfo, v, fldsep, null_string));
4359 }
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
#define PG_GETARG_ARRAYTYPE_P(n)
Definition: array.h:244
static text * array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v, const char *fldsep, const char *null_string)
Definition: varlena.c:4365
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
#define PG_ARGISNULL(n)
Definition: fmgr.h:174
#define NULL
Definition: c.h:229
char * text_to_cstring(const text *t)
Definition: varlena.c:182
#define PG_RETURN_NULL()
Definition: fmgr.h:305
static int bpcharfastcmp_c ( Datum  x,
Datum  y,
SortSupport  ssup 
)
static

Definition at line 1991 of file varlena.c.

References bpchartruelen(), DatumGetBpCharPP, Min, pfree(), PointerGetDatum, result, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by varstr_sortsupport().

1992 {
1993  BpChar *arg1 = DatumGetBpCharPP(x);
1994  BpChar *arg2 = DatumGetBpCharPP(y);
1995  char *a1p,
1996  *a2p;
1997  int len1,
1998  len2,
1999  result;
2000 
2001  a1p = VARDATA_ANY(arg1);
2002  a2p = VARDATA_ANY(arg2);
2003 
2004  len1 = bpchartruelen(a1p, VARSIZE_ANY_EXHDR(arg1));
2005  len2 = bpchartruelen(a2p, VARSIZE_ANY_EXHDR(arg2));
2006 
2007  result = memcmp(a1p, a2p, Min(len1, len2));
2008  if ((result == 0) && (len1 != len2))
2009  result = (len1 < len2) ? -1 : 1;
2010 
2011  /* We can't afford to leak memory here. */
2012  if (PointerGetDatum(arg1) != x)
2013  pfree(arg1);
2014  if (PointerGetDatum(arg2) != y)
2015  pfree(arg2);
2016 
2017  return result;
2018 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define PointerGetDatum(X)
Definition: postgres.h:562
#define Min(x, y)
Definition: c.h:806
return result
Definition: formatting.c:1618
void pfree(void *pointer)
Definition: mcxt.c:950
int bpchartruelen(char *s, int len)
Definition: varchar.c:660
#define DatumGetBpCharPP(X)
Definition: fmgr.h:257
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
Definition: c.h:439
Datum bttext_pattern_cmp ( PG_FUNCTION_ARGS  )

Definition at line 2686 of file varlena.c.

References internal_text_pattern_compare(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_INT32, and result.

2687 {
2688  text *arg1 = PG_GETARG_TEXT_PP(0);
2689  text *arg2 = PG_GETARG_TEXT_PP(1);
2690  int result;
2691 
2692  result = internal_text_pattern_compare(arg1, arg2);
2693 
2694  PG_FREE_IF_COPY(arg1, 0);
2695  PG_FREE_IF_COPY(arg2, 1);
2696 
2697  PG_RETURN_INT32(result);
2698 }
#define PG_RETURN_INT32(x)
Definition: fmgr.h:314
return result
Definition: formatting.c:1618
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int internal_text_pattern_compare(text *arg1, text *arg2)
Definition: varlena.c:2600
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
Definition: c.h:439
Datum bttext_pattern_sortsupport ( PG_FUNCTION_ARGS  )

Definition at line 2702 of file varlena.c.

References C_COLLATION_OID, MemoryContextSwitchTo(), PG_GETARG_POINTER, PG_RETURN_VOID, SortSupportData::ssup_cxt, and varstr_sortsupport().

2703 {
2705  MemoryContext oldcontext;
2706 
2707  oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
2708 
2709  /* Use generic string SortSupport, forcing "C" collation */
2710  varstr_sortsupport(ssup, C_COLLATION_OID, false);
2711 
2712  MemoryContextSwitchTo(oldcontext);
2713 
2714  PG_RETURN_VOID();
2715 }
struct SortSupportData * SortSupport
Definition: sortsupport.h:58
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:241
MemoryContext ssup_cxt
Definition: sortsupport.h:66
void varstr_sortsupport(SortSupport ssup, Oid collid, bool bpchar)
Definition: varlena.c:1802
#define PG_RETURN_VOID()
Definition: fmgr.h:309
#define C_COLLATION_OID
Definition: pg_collation.h:77
Datum bttextcmp ( PG_FUNCTION_ARGS  )

Definition at line 1760 of file varlena.c.

References PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_INT32, result, and text_cmp().

Referenced by gbt_textcmp().

1761 {
1762  text *arg1 = PG_GETARG_TEXT_PP(0);
1763  text *arg2 = PG_GETARG_TEXT_PP(1);
1764  int32 result;
1765 
1766  result = text_cmp(arg1, arg2, PG_GET_COLLATION());
1767 
1768  PG_FREE_IF_COPY(arg1, 0);
1769  PG_FREE_IF_COPY(arg2, 1);
1770 
1771  PG_RETURN_INT32(result);
1772 }
#define PG_RETURN_INT32(x)
Definition: fmgr.h:314
return result
Definition: formatting.c:1618
#define PG_GET_COLLATION()
Definition: fmgr.h:163
signed int int32
Definition: c.h:256
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int text_cmp(text *arg1, text *arg2, Oid collid)
Definition: varlena.c:1611
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
Definition: c.h:439
Datum bttextsortsupport ( PG_FUNCTION_ARGS  )

Definition at line 1775 of file varlena.c.

References MemoryContextSwitchTo(), PG_GETARG_POINTER, PG_RETURN_VOID, SortSupportData::ssup_collation, SortSupportData::ssup_cxt, and varstr_sortsupport().

1776 {
1778  Oid collid = ssup->ssup_collation;
1779  MemoryContext oldcontext;
1780 
1781  oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
1782 
1783  /* Use generic string SortSupport */
1784  varstr_sortsupport(ssup, collid, false);
1785 
1786  MemoryContextSwitchTo(oldcontext);
1787 
1788  PG_RETURN_VOID();
1789 }
struct SortSupportData * SortSupport
Definition: sortsupport.h:58
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:241
unsigned int Oid
Definition: postgres_ext.h:31
MemoryContext ssup_cxt
Definition: sortsupport.h:66
void varstr_sortsupport(SortSupport ssup, Oid collid, bool bpchar)
Definition: varlena.c:1802
#define PG_RETURN_VOID()
Definition: fmgr.h:309
static bytea * bytea_catenate ( bytea t1,
bytea t2 
)
static

Definition at line 2756 of file varlena.c.

References palloc(), result, SET_VARSIZE, VARDATA, VARDATA_ANY, VARHDRSZ, and VARSIZE_ANY_EXHDR.

Referenced by bytea_overlay(), and byteacat().

2757 {
2758  bytea *result;
2759  int len1,
2760  len2,
2761  len;
2762  char *ptr;
2763 
2764  len1 = VARSIZE_ANY_EXHDR(t1);
2765  len2 = VARSIZE_ANY_EXHDR(t2);
2766 
2767  /* paranoia ... probably should throw error instead? */
2768  if (len1 < 0)
2769  len1 = 0;
2770  if (len2 < 0)
2771  len2 = 0;
2772 
2773  len = len1 + len2 + VARHDRSZ;
2774  result = (bytea *) palloc(len);
2775 
2776  /* Set size of result string... */
2777  SET_VARSIZE(result, len);
2778 
2779  /* Fill data field of result string... */
2780  ptr = VARDATA(result);
2781  if (len1 > 0)
2782  memcpy(ptr, VARDATA_ANY(t1), len1);
2783  if (len2 > 0)
2784  memcpy(ptr + len1, VARDATA_ANY(t2), len2);
2785 
2786  return result;
2787 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define VARDATA(PTR)
Definition: postgres.h:303
#define VARHDRSZ
Definition: c.h:445
return result
Definition: formatting.c:1618
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
void * palloc(Size size)
Definition: mcxt.c:849
Definition: c.h:439
#define SET_VARSIZE(PTR, len)
Definition: postgres.h:328
static bytea * bytea_overlay ( bytea t1,
bytea t2,
int  sp,
int  sl 
)
static

Definition at line 2913 of file varlena.c.

References bytea_catenate(), bytea_substring(), ereport, errcode(), errmsg(), ERROR, PointerGetDatum, result, s1, and s2.

Referenced by byteaoverlay(), and byteaoverlay_no_len().

2914 {
2915  bytea *result;
2916  bytea *s1;
2917  bytea *s2;
2918  int sp_pl_sl;
2919 
2920  /*
2921  * Check for possible integer-overflow cases. For negative sp, throw a
2922  * "substring length" error because that's what should be expected
2923  * according to the spec's definition of OVERLAY().
2924  */
2925  if (sp <= 0)
2926  ereport(ERROR,
2927  (errcode(ERRCODE_SUBSTRING_ERROR),
2928  errmsg("negative substring length not allowed")));
2929  sp_pl_sl = sp + sl;
2930  if (sp_pl_sl <= sl)
2931  ereport(ERROR,
2932  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
2933  errmsg("integer out of range")));
2934 
2935  s1 = bytea_substring(PointerGetDatum(t1), 1, sp - 1, false);
2936  s2 = bytea_substring(PointerGetDatum(t1), sp_pl_sl, -1, true);
2937  result = bytea_catenate(s1, t2);
2938  result = bytea_catenate(result, s2);
2939 
2940  return result;
2941 }
#define PointerGetDatum(X)
Definition: postgres.h:562
static bytea * bytea_catenate(bytea *t1, bytea *t2)
Definition: varlena.c:2756
int errcode(int sqlerrcode)
Definition: elog.c:575
return result
Definition: formatting.c:1618
static bytea * bytea_substring(Datum str, int S, int L, bool length_not_specified)
Definition: varlena.c:2831
#define ERROR
Definition: elog.h:43
char * s1
#define ereport(elevel, rest)
Definition: elog.h:122
char * s2
int errmsg(const char *fmt,...)
Definition: elog.c:797
Definition: c.h:439
Datum bytea_sortsupport ( PG_FUNCTION_ARGS  )

Definition at line 3629 of file varlena.c.

References C_COLLATION_OID, MemoryContextSwitchTo(), PG_GETARG_POINTER, PG_RETURN_VOID, SortSupportData::ssup_cxt, and varstr_sortsupport().

3630 {
3632  MemoryContext oldcontext;
3633 
3634  oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
3635 
3636  /* Use generic string SortSupport, forcing "C" collation */
3637  varstr_sortsupport(ssup, C_COLLATION_OID, false);
3638 
3639  MemoryContextSwitchTo(oldcontext);
3640 
3641  PG_RETURN_VOID();
3642 }
struct SortSupportData * SortSupport
Definition: sortsupport.h:58
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:241
MemoryContext ssup_cxt
Definition: sortsupport.h:66
void varstr_sortsupport(SortSupport ssup, Oid collid, bool bpchar)
Definition: varlena.c:1802
#define PG_RETURN_VOID()
Definition: fmgr.h:309
#define C_COLLATION_OID
Definition: pg_collation.h:77
Datum bytea_string_agg_finalfn ( PG_FUNCTION_ARGS  )

Definition at line 482 of file varlena.c.

References AggCheckCallContext(), Assert, StringInfoData::data, StringInfoData::len, NULL, palloc(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_BYTEA_P, PG_RETURN_NULL, result, SET_VARSIZE, VARDATA, and VARHDRSZ.

483 {
485 
486  /* cannot be called directly because of internal-type argument */
487  Assert(AggCheckCallContext(fcinfo, NULL));
488 
489  state = PG_ARGISNULL(0) ? NULL : (StringInfo) PG_GETARG_POINTER(0);
490 
491  if (state != NULL)
492  {
493  bytea *result;
494 
495  result = (bytea *) palloc(state->len + VARHDRSZ);
496  SET_VARSIZE(result, state->len + VARHDRSZ);
497  memcpy(VARDATA(result), state->data, state->len);
498  PG_RETURN_BYTEA_P(result);
499  }
500  else
501  PG_RETURN_NULL();
502 }
#define VARDATA(PTR)
Definition: postgres.h:303
#define VARHDRSZ
Definition: c.h:445
StringInfoData * StringInfo
Definition: stringinfo.h:46
return result
Definition: formatting.c:1618
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:241
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:329
#define PG_ARGISNULL(n)
Definition: fmgr.h:174
#define NULL
Definition: c.h:229
#define Assert(condition)
Definition: c.h:675
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
Definition: nodeAgg.c:4018
void * palloc(Size size)
Definition: mcxt.c:849
Definition: c.h:439
#define SET_VARSIZE(PTR, len)
Definition: postgres.h:328
#define PG_RETURN_NULL()
Definition: fmgr.h:305
Datum bytea_string_agg_transfn ( PG_FUNCTION_ARGS  )

Definition at line 450 of file varlena.c.

References appendBinaryStringInfo(), makeStringAggState(), NULL, PG_ARGISNULL, PG_GETARG_BYTEA_PP, PG_GETARG_POINTER, PG_RETURN_POINTER, value, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

451 {
453 
454  state = PG_ARGISNULL(0) ? NULL : (StringInfo) PG_GETARG_POINTER(0);
455 
456  /* Append the value unless null. */
457  if (!PG_ARGISNULL(1))
458  {
460 
461  /* On the first time through, we ignore the delimiter. */
462  if (state == NULL)
463  state = makeStringAggState(fcinfo);
464  else if (!PG_ARGISNULL(2))
465  {
466  bytea *delim = PG_GETARG_BYTEA_PP(2);
467 
469  }
470 
472  }
473 
474  /*
475  * The transition type for string_agg() is declared to be "internal",
476  * which is a pass-by-value type the same size as a pointer.
477  */
478  PG_RETURN_POINTER(state);
479 }
#define PG_RETURN_POINTER(x)
Definition: fmgr.h:321
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
StringInfoData * StringInfo
Definition: stringinfo.h:46
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:241
#define PG_ARGISNULL(n)
Definition: fmgr.h:174
#define NULL
Definition: c.h:229
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:272
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
static StringInfo makeStringAggState(FunctionCallInfo fcinfo)
Definition: varlena.c:4638
Definition: c.h:439
static struct @121 value
void appendBinaryStringInfo(StringInfo str, const char *data, int datalen)
Definition: stringinfo.c:240
Datum bytea_substr ( PG_FUNCTION_ARGS  )

Definition at line 2808 of file varlena.c.

References bytea_substring(), PG_GETARG_DATUM, PG_GETARG_INT32, and PG_RETURN_BYTEA_P.

2809 {
2811  PG_GETARG_INT32(1),
2812  PG_GETARG_INT32(2),
2813  false));
2814 }
#define PG_GETARG_INT32(n)
Definition: fmgr.h:234
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:233
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:329
static bytea * bytea_substring(Datum str, int S, int L, bool length_not_specified)
Definition: varlena.c:2831
Datum bytea_substr_no_len ( PG_FUNCTION_ARGS  )

Definition at line 2822 of file varlena.c.

References bytea_substring(), PG_GETARG_DATUM, PG_GETARG_INT32, and PG_RETURN_BYTEA_P.

2823 {
2825  PG_GETARG_INT32(1),
2826  -1,
2827  true));
2828 }
#define PG_GETARG_INT32(n)
Definition: fmgr.h:234
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:233
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:329
static bytea * bytea_substring(Datum str, int S, int L, bool length_not_specified)
Definition: varlena.c:2831
static bytea * bytea_substring ( Datum  str,
int  S,
int  L,
bool  length_not_specified 
)
static

Definition at line 2831 of file varlena.c.

References DatumGetByteaPSlice, ereport, errcode(), errmsg(), ERROR, Max, and PG_STR_GET_BYTEA.

Referenced by bytea_overlay(), bytea_substr(), and bytea_substr_no_len().

2835 {
2836  int S1; /* adjusted start position */
2837  int L1; /* adjusted substring length */
2838 
2839  S1 = Max(S, 1);
2840 
2841  if (length_not_specified)
2842  {
2843  /*
2844  * Not passed a length - DatumGetByteaPSlice() grabs everything to the
2845  * end of the string if we pass it a negative value for length.
2846  */
2847  L1 = -1;
2848  }
2849  else
2850  {
2851  /* end position */
2852  int E = S + L;
2853 
2854  /*
2855  * A negative value for L is the only way for the end position to be
2856  * before the start. SQL99 says to throw an error.
2857  */
2858  if (E < S)
2859  ereport(ERROR,
2860  (errcode(ERRCODE_SUBSTRING_ERROR),
2861  errmsg("negative substring length not allowed")));
2862 
2863  /*
2864  * A zero or negative value for the end position can happen if the
2865  * start was negative or one. SQL99 says to return a zero-length
2866  * string.
2867  */
2868  if (E < 1)
2869  return PG_STR_GET_BYTEA("");
2870 
2871  L1 = E - S1;
2872  }
2873 
2874  /*
2875  * If the start position is past the end of the string, SQL99 says to
2876  * return a zero-length string -- DatumGetByteaPSlice() will do that for
2877  * us. Convert to zero-based starting position
2878  */
2879  return DatumGetByteaPSlice(str, S1 - 1, L1);
2880 }
#define DatumGetByteaPSlice(X, m, n)
Definition: fmgr.h:267
int errcode(int sqlerrcode)
Definition: elog.c:575
#define PG_STR_GET_BYTEA(str_)
Definition: varlena.c:2789
#define ERROR
Definition: elog.h:43
#define S(n, x)
Definition: sha1.c:55
#define ereport(elevel, rest)
Definition: elog.h:122
#define Max(x, y)
Definition: c.h:800
int errmsg(const char *fmt,...)
Definition: elog.c:797
Datum byteacat ( PG_FUNCTION_ARGS  )

Definition at line 2741 of file varlena.c.

References bytea_catenate(), PG_GETARG_BYTEA_PP, and PG_RETURN_BYTEA_P.

2742 {
2743  bytea *t1 = PG_GETARG_BYTEA_PP(0);
2744  bytea *t2 = PG_GETARG_BYTEA_PP(1);
2745 
2747 }
static bytea * bytea_catenate(bytea *t1, bytea *t2)
Definition: varlena.c:2756
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:329
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:272
Definition: c.h:439
Datum byteacmp ( PG_FUNCTION_ARGS  )

Definition at line 3607 of file varlena.c.

References cmp(), Min, PG_FREE_IF_COPY, PG_GETARG_BYTEA_PP, PG_RETURN_INT32, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by gbt_bitcmp(), and gbt_byteacmp().

3608 {
3609  bytea *arg1 = PG_GETARG_BYTEA_PP(0);
3610  bytea *arg2 = PG_GETARG_BYTEA_PP(1);
3611  int len1,
3612  len2;
3613  int cmp;
3614 
3615  len1 = VARSIZE_ANY_EXHDR(arg1);
3616  len2 = VARSIZE_ANY_EXHDR(arg2);
3617 
3618  cmp = memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), Min(len1, len2));
3619  if ((cmp == 0) && (len1 != len2))
3620  cmp = (len1 < len2) ? -1 : 1;
3621 
3622  PG_FREE_IF_COPY(arg1, 0);
3623  PG_FREE_IF_COPY(arg2, 1);
3624 
3625  PG_RETURN_INT32(cmp);
3626 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define Min(x, y)
Definition: c.h:806
#define PG_RETURN_INT32(x)
Definition: fmgr.h:314
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:272
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
Definition: c.h:439
static int cmp(const chr *x, const chr *y, size_t len)
Definition: regc_locale.c:742
Datum byteaeq ( PG_FUNCTION_ARGS  )

Definition at line 3463 of file varlena.c.

References DatumGetByteaPP, PG_FREE_IF_COPY, PG_GETARG_DATUM, PG_RETURN_BOOL, result, toast_raw_datum_size(), VARDATA_ANY, and VARHDRSZ.

Referenced by gbt_byteaeq().

3464 {
3465  Datum arg1 = PG_GETARG_DATUM(0);
3466  Datum arg2 = PG_GETARG_DATUM(1);
3467  bool result;
3468  Size len1,
3469  len2;
3470 
3471  /*
3472  * We can use a fast path for unequal lengths, which might save us from
3473  * having to detoast one or both values.
3474  */
3475  len1 = toast_raw_datum_size(arg1);
3476  len2 = toast_raw_datum_size(arg2);
3477  if (len1 != len2)
3478  result = false;
3479  else
3480  {
3481  bytea *barg1 = DatumGetByteaPP(arg1);
3482  bytea *barg2 = DatumGetByteaPP(arg2);
3483 
3484  result = (memcmp(VARDATA_ANY(barg1), VARDATA_ANY(barg2),
3485  len1 - VARHDRSZ) == 0);
3486 
3487  PG_FREE_IF_COPY(barg1, 0);
3488  PG_FREE_IF_COPY(barg2, 1);
3489  }
3490 
3491  PG_RETURN_BOOL(result);
3492 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:233
#define VARHDRSZ
Definition: c.h:445
return result
Definition: formatting.c:1618
#define DatumGetByteaPP(X)
Definition: fmgr.h:255
Size toast_raw_datum_size(Datum value)
Definition: tuptoaster.c:353
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:319
uintptr_t Datum
Definition: postgres.h:372
size_t Size
Definition: c.h:356
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
Definition: c.h:439
Datum byteage ( PG_FUNCTION_ARGS  )

Definition at line 3587 of file varlena.c.

References cmp(), Min, PG_FREE_IF_COPY, PG_GETARG_BYTEA_PP, PG_RETURN_BOOL, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by gbt_byteage().

3588 {
3589  bytea *arg1 = PG_GETARG_BYTEA_PP(0);
3590  bytea *arg2 = PG_GETARG_BYTEA_PP(1);
3591  int len1,
3592  len2;
3593  int cmp;
3594 
3595  len1 = VARSIZE_ANY_EXHDR(arg1);
3596  len2 = VARSIZE_ANY_EXHDR(arg2);
3597 
3598  cmp = memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), Min(len1, len2));
3599 
3600  PG_FREE_IF_COPY(arg1, 0);
3601  PG_FREE_IF_COPY(arg2, 1);
3602 
3603  PG_RETURN_BOOL((cmp > 0) || ((cmp == 0) && (len1 >= len2)));
3604 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define Min(x, y)
Definition: c.h:806
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:319
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:272
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
Definition: c.h:439
static int cmp(const chr *x, const chr *y, size_t len)
Definition: regc_locale.c:742
Datum byteaGetBit ( PG_FUNCTION_ARGS  )

Definition at line 3023 of file varlena.c.

References byte, ereport, errcode(), errmsg(), ERROR, PG_GETARG_BYTEA_PP, PG_GETARG_INT32, PG_RETURN_INT32, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

3024 {
3025  bytea *v = PG_GETARG_BYTEA_PP(0);
3026  int32 n = PG_GETARG_INT32(1);
3027  int byteNo,
3028  bitNo;
3029  int len;
3030  int byte;
3031 
3032  len = VARSIZE_ANY_EXHDR(v);
3033 
3034  if (n < 0 || n >= len * 8)
3035  ereport(ERROR,
3036  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
3037  errmsg("index %d out of valid range, 0..%d",
3038  n, len * 8 - 1)));
3039 
3040  byteNo = n / 8;
3041  bitNo = n % 8;
3042 
3043  byte = ((unsigned char *) VARDATA_ANY(v))[byteNo];
3044 
3045  if (byte & (1 << bitNo))
3046  PG_RETURN_INT32(1);
3047  else
3048  PG_RETURN_INT32(0);
3049 }
#define PG_GETARG_INT32(n)
Definition: fmgr.h:234
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define PG_RETURN_INT32(x)
Definition: fmgr.h:314
int errcode(int sqlerrcode)
Definition: elog.c:575
signed int int32
Definition: c.h:256
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:122
#define byte(x, n)
Definition: rijndael.c:68
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:272
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
int errmsg(const char *fmt,...)
Definition: elog.c:797
Definition: c.h:439
Datum byteaGetByte ( PG_FUNCTION_ARGS  )

Definition at line 2994 of file varlena.c.

References byte, ereport, errcode(), errmsg(), ERROR, PG_GETARG_BYTEA_PP, PG_GETARG_INT32, PG_RETURN_INT32, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

2995 {
2996  bytea *v = PG_GETARG_BYTEA_PP(0);
2997  int32 n = PG_GETARG_INT32(1);
2998  int len;
2999  int byte;
3000 
3001  len = VARSIZE_ANY_EXHDR(v);
3002 
3003  if (n < 0 || n >= len)
3004  ereport(ERROR,
3005  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
3006  errmsg("index %d out of valid range, 0..%d",
3007  n, len - 1)));
3008 
3009  byte = ((unsigned char *) VARDATA_ANY(v))[n];
3010 
3011  PG_RETURN_INT32(byte);
3012 }
#define PG_GETARG_INT32(n)
Definition: fmgr.h:234
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define PG_RETURN_INT32(x)
Definition: fmgr.h:314
int errcode(int sqlerrcode)
Definition: elog.c:575
signed int int32
Definition: c.h:256
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:122
#define byte(x, n)
Definition: rijndael.c:68
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:272
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
int errmsg(const char *fmt,...)
Definition: elog.c:797
Definition: c.h:439
Datum byteagt ( PG_FUNCTION_ARGS  )

Definition at line 3567 of file varlena.c.

References cmp(), Min, PG_FREE_IF_COPY, PG_GETARG_BYTEA_PP, PG_RETURN_BOOL, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by gbt_byteagt().

3568 {
3569  bytea *arg1 = PG_GETARG_BYTEA_PP(0);
3570  bytea *arg2 = PG_GETARG_BYTEA_PP(1);
3571  int len1,
3572  len2;
3573  int cmp;
3574 
3575  len1 = VARSIZE_ANY_EXHDR(arg1);
3576  len2 = VARSIZE_ANY_EXHDR(arg2);
3577 
3578  cmp = memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), Min(len1, len2));
3579 
3580  PG_FREE_IF_COPY(arg1, 0);
3581  PG_FREE_IF_COPY(arg2, 1);
3582 
3583  PG_RETURN_BOOL((cmp > 0) || ((cmp == 0) && (len1 > len2)));
3584 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define Min(x, y)
Definition: c.h:806
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:319
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:272
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
Definition: c.h:439
static int cmp(const chr *x, const chr *y, size_t len)
Definition: regc_locale.c:742
Datum byteain ( PG_FUNCTION_ARGS  )

Definition at line 255 of file varlena.c.

References ereport, errcode(), errmsg(), ERROR, hex_decode(), palloc(), PG_GETARG_CSTRING, PG_RETURN_BYTEA_P, result, SET_VARSIZE, VAL, VARDATA, and VARHDRSZ.

Referenced by CreateTrigger(), and string_to_datum().

256 {
257  char *inputText = PG_GETARG_CSTRING(0);
258  char *tp;
259  char *rp;
260  int bc;
261  bytea *result;
262 
263  /* Recognize hex input */
264  if (inputText[0] == '\\' && inputText[1] == 'x')
265  {
266  size_t len = strlen(inputText);
267 
268  bc = (len - 2) / 2 + VARHDRSZ; /* maximum possible length */
269  result = palloc(bc);
270  bc = hex_decode(inputText + 2, len - 2, VARDATA(result));
271  SET_VARSIZE(result, bc + VARHDRSZ); /* actual length */
272 
273  PG_RETURN_BYTEA_P(result);
274  }
275 
276  /* Else, it's the traditional escaped style */
277  for (bc = 0, tp = inputText; *tp != '\0'; bc++)
278  {
279  if (tp[0] != '\\')
280  tp++;
281  else if ((tp[0] == '\\') &&
282  (tp[1] >= '0' && tp[1] <= '3') &&
283  (tp[2] >= '0' && tp[2] <= '7') &&
284  (tp[3] >= '0' && tp[3] <= '7'))
285  tp += 4;
286  else if ((tp[0] == '\\') &&
287  (tp[1] == '\\'))
288  tp += 2;
289  else
290  {
291  /*
292  * one backslash, not followed by another or ### valid octal
293  */
294  ereport(ERROR,
295  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
296  errmsg("invalid input syntax for type %s", "bytea")));
297  }
298  }
299 
300  bc += VARHDRSZ;
301 
302  result = (bytea *) palloc(bc);
303  SET_VARSIZE(result, bc);
304 
305  tp = inputText;
306  rp = VARDATA(result);
307  while (*tp != '\0')
308  {
309  if (tp[0] != '\\')
310  *rp++ = *tp++;
311  else if ((tp[0] == '\\') &&
312  (tp[1] >= '0' && tp[1] <= '3') &&
313  (tp[2] >= '0' && tp[2] <= '7') &&
314  (tp[3] >= '0' && tp[3] <= '7'))
315  {
316  bc = VAL(tp[1]);
317  bc <<= 3;
318  bc += VAL(tp[2]);
319  bc <<= 3;
320  *rp++ = bc + VAL(tp[3]);
321 
322  tp += 4;
323  }
324  else if ((tp[0] == '\\') &&
325  (tp[1] == '\\'))
326  {
327  *rp++ = '\\';
328  tp += 2;
329  }
330  else
331  {
332  /*
333  * We should never get here. The first pass should not allow it.
334  */
335  ereport(ERROR,
336  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
337  errmsg("invalid input syntax for type %s", "bytea")));
338  }
339  }
340 
341  PG_RETURN_BYTEA_P(result);
342 }
#define VARDATA(PTR)
Definition: postgres.h:303
#define VARHDRSZ
Definition: c.h:445
int errcode(int sqlerrcode)
Definition: elog.c:575
return result
Definition: formatting.c:1618
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:329
unsigned hex_decode(const char *src, unsigned len, char *dst)
Definition: encode.c:156
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:122
void * palloc(Size size)
Definition: mcxt.c:849
int errmsg(const char *fmt,...)
Definition: elog.c:797
#define PG_GETARG_CSTRING(n)
Definition: fmgr.h:242
#define VAL(CH)
Definition: varlena.c:240
Definition: c.h:439
#define SET_VARSIZE(PTR, len)
Definition: postgres.h:328
Datum byteale ( PG_FUNCTION_ARGS  )

Definition at line 3547 of file varlena.c.

References cmp(), Min, PG_FREE_IF_COPY, PG_GETARG_BYTEA_PP, PG_RETURN_BOOL, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by gbt_byteale().

3548 {
3549  bytea *arg1 = PG_GETARG_BYTEA_PP(0);
3550  bytea *arg2 = PG_GETARG_BYTEA_PP(1);
3551  int len1,
3552  len2;
3553  int cmp;
3554 
3555  len1 = VARSIZE_ANY_EXHDR(arg1);
3556  len2 = VARSIZE_ANY_EXHDR(arg2);
3557 
3558  cmp = memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), Min(len1, len2));
3559 
3560  PG_FREE_IF_COPY(arg1, 0);
3561  PG_FREE_IF_COPY(arg2, 1);
3562 
3563  PG_RETURN_BOOL((cmp < 0) || ((cmp == 0) && (len1 <= len2)));
3564 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define Min(x, y)
Definition: c.h:806
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:319
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:272
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
Definition: c.h:439
static int cmp(const chr *x, const chr *y, size_t len)
Definition: regc_locale.c:742
Datum bytealt ( PG_FUNCTION_ARGS  )

Definition at line 3527 of file varlena.c.

References cmp(), Min, PG_FREE_IF_COPY, PG_GETARG_BYTEA_PP, PG_RETURN_BOOL, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by gbt_bytealt().

3528 {
3529  bytea *arg1 = PG_GETARG_BYTEA_PP(0);
3530  bytea *arg2 = PG_GETARG_BYTEA_PP(1);
3531  int len1,
3532  len2;
3533  int cmp;
3534 
3535  len1 = VARSIZE_ANY_EXHDR(arg1);
3536  len2 = VARSIZE_ANY_EXHDR(arg2);
3537 
3538  cmp = memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), Min(len1, len2));
3539 
3540  PG_FREE_IF_COPY(arg1, 0);
3541  PG_FREE_IF_COPY(arg2, 1);
3542 
3543  PG_RETURN_BOOL((cmp < 0) || ((cmp == 0) && (len1 < len2)));
3544 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define Min(x, y)
Definition: c.h:806
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:319
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:272
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
Definition: c.h:439
static int cmp(const chr *x, const chr *y, size_t len)
Definition: regc_locale.c:742
Datum byteane ( PG_FUNCTION_ARGS  )

Definition at line 3495 of file varlena.c.

References DatumGetByteaPP, PG_FREE_IF_COPY, PG_GETARG_DATUM, PG_RETURN_BOOL, result, toast_raw_datum_size(), VARDATA_ANY, and VARHDRSZ.

3496 {
3497  Datum arg1 = PG_GETARG_DATUM(0);
3498  Datum arg2 = PG_GETARG_DATUM(1);
3499  bool result;
3500  Size len1,
3501  len2;
3502 
3503  /*
3504  * We can use a fast path for unequal lengths, which might save us from
3505  * having to detoast one or both values.
3506  */
3507  len1 = toast_raw_datum_size(arg1);
3508  len2 = toast_raw_datum_size(arg2);
3509  if (len1 != len2)
3510  result = true;
3511  else
3512  {
3513  bytea *barg1 = DatumGetByteaPP(arg1);
3514  bytea *barg2 = DatumGetByteaPP(arg2);
3515 
3516  result = (memcmp(VARDATA_ANY(barg1), VARDATA_ANY(barg2),
3517  len1 - VARHDRSZ) != 0);
3518 
3519  PG_FREE_IF_COPY(barg1, 0);
3520  PG_FREE_IF_COPY(barg2, 1);
3521  }
3522 
3523  PG_RETURN_BOOL(result);
3524 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:233
#define VARHDRSZ
Definition: c.h:445
return result
Definition: formatting.c:1618
#define DatumGetByteaPP(X)
Definition: fmgr.h:255
Size toast_raw_datum_size(Datum value)
Definition: tuptoaster.c:353
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:319
uintptr_t Datum
Definition: postgres.h:372
size_t Size
Definition: c.h:356
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
Definition: c.h:439
Datum byteaoctetlen ( PG_FUNCTION_ARGS  )

Definition at line 2725 of file varlena.c.

References PG_GETARG_DATUM, PG_RETURN_INT32, toast_raw_datum_size(), and VARHDRSZ.

2726 {
2727  Datum str = PG_GETARG_DATUM(0);
2728 
2729  /* We need not detoast the input at all */
2731 }
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:233
#define VARHDRSZ
Definition: c.h:445
#define PG_RETURN_INT32(x)
Definition: fmgr.h:314
Size toast_raw_datum_size(Datum value)
Definition: tuptoaster.c:353
uintptr_t Datum
Definition: postgres.h:372
Datum byteaout ( PG_FUNCTION_ARGS  )

Definition at line 351 of file varlena.c.

References bytea_output, BYTEA_OUTPUT_ESCAPE, BYTEA_OUTPUT_HEX, DIG, elog, ERROR, hex_encode(), i, NULL, palloc(), PG_GETARG_BYTEA_PP, PG_RETURN_CSTRING, result, val, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by patternsel(), and prefix_quals().

352 {
353  bytea *vlena = PG_GETARG_BYTEA_PP(0);
354  char *result;
355  char *rp;
356 
358  {
359  /* Print hex format */
360  rp = result = palloc(VARSIZE_ANY_EXHDR(vlena) * 2 + 2 + 1);
361  *rp++ = '\\';
362  *rp++ = 'x';
363  rp += hex_encode(VARDATA_ANY(vlena), VARSIZE_ANY_EXHDR(vlena), rp);
364  }
365  else if (bytea_output == BYTEA_OUTPUT_ESCAPE)
366  {
367  /* Print traditional escaped format */
368  char *vp;
369  int len;
370  int i;
371 
372  len = 1; /* empty string has 1 char */
373  vp = VARDATA_ANY(vlena);
374  for (i = VARSIZE_ANY_EXHDR(vlena); i != 0; i--, vp++)
375  {
376  if (*vp == '\\')
377  len += 2;
378  else if ((unsigned char) *vp < 0x20 || (unsigned char) *vp > 0x7e)
379  len += 4;
380  else
381  len++;
382  }
383  rp = result = (char *) palloc(len);
384  vp = VARDATA_ANY(vlena);
385  for (i = VARSIZE_ANY_EXHDR(vlena); i != 0; i--, vp++)
386  {
387  if (*vp == '\\')
388  {
389  *rp++ = '\\';
390  *rp++ = '\\';
391  }
392  else if ((unsigned char) *vp < 0x20 || (unsigned char) *vp > 0x7e)
393  {
394  int val; /* holds unprintable chars */
395 
396  val = *vp;
397  rp[0] = '\\';
398  rp[3] = DIG(val & 07);
399  val >>= 3;
400  rp[2] = DIG(val & 07);
401  val >>= 3;
402  rp[1] = DIG(val & 03);
403  rp += 4;
404  }
405  else
406  *rp++ = *vp;
407  }
408  }
409  else
410  {
411  elog(ERROR, "unrecognized bytea_output setting: %d",
412  bytea_output);
413  rp = result = NULL; /* keep compiler quiet */
414  }
415  *rp = '\0';
416  PG_RETURN_CSTRING(result);
417 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
return result
Definition: formatting.c:1618
unsigned hex_encode(const char *src, unsigned len, char *dst)
Definition: encode.c:126
#define ERROR
Definition: elog.h:43
int bytea_output
Definition: varlena.c:41
#define NULL
Definition: c.h:229
#define PG_RETURN_CSTRING(x)
Definition: fmgr.h:322
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:272
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
void * palloc(Size size)
Definition: mcxt.c:849
int i
Definition: c.h:439
#define elog
Definition: elog.h:219
long val
Definition: informix.c:689
#define DIG(VAL)
Definition: varlena.c:241
Datum byteaoverlay ( PG_FUNCTION_ARGS  )

Definition at line 2890 of file varlena.c.

References bytea_overlay(), PG_GETARG_BYTEA_PP, PG_GETARG_INT32, and PG_RETURN_BYTEA_P.

2891 {
2892  bytea *t1 = PG_GETARG_BYTEA_PP(0);
2893  bytea *t2 = PG_GETARG_BYTEA_PP(1);
2894  int sp = PG_GETARG_INT32(2); /* substring start position */
2895  int sl = PG_GETARG_INT32(3); /* substring length */
2896 
2897  PG_RETURN_BYTEA_P(bytea_overlay(t1, t2, sp, sl));
2898 }
#define PG_GETARG_INT32(n)
Definition: fmgr.h:234
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:329
static bytea * bytea_overlay(bytea *t1, bytea *t2, int sp, int sl)
Definition: varlena.c:2913
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:272
Definition: c.h:439
Datum byteaoverlay_no_len ( PG_FUNCTION_ARGS  )

Definition at line 2901 of file varlena.c.

References bytea_overlay(), PG_GETARG_BYTEA_PP, PG_GETARG_INT32, PG_RETURN_BYTEA_P, and VARSIZE_ANY_EXHDR.

2902 {
2903  bytea *t1 = PG_GETARG_BYTEA_PP(0);
2904  bytea *t2 = PG_GETARG_BYTEA_PP(1);
2905  int sp = PG_GETARG_INT32(2); /* substring start position */
2906  int sl;
2907 
2908  sl = VARSIZE_ANY_EXHDR(t2); /* defaults to length(t2) */
2909  PG_RETURN_BYTEA_P(bytea_overlay(t1, t2, sp, sl));
2910 }
#define PG_GETARG_INT32(n)
Definition: fmgr.h:234
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:329
static bytea * bytea_overlay(bytea *t1, bytea *t2, int sp, int sl)
Definition: varlena.c:2913
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:272
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
Definition: c.h:439
Datum byteapos ( PG_FUNCTION_ARGS  )

Definition at line 2950 of file varlena.c.

References PG_GETARG_BYTEA_PP, PG_RETURN_INT32, px(), VARDATA_ANY, and VARSIZE_ANY_EXHDR.

2951 {
2952  bytea *t1 = PG_GETARG_BYTEA_PP(0);
2953  bytea *t2 = PG_GETARG_BYTEA_PP(1);
2954  int pos;
2955  int px,
2956  p;
2957  int len1,
2958  len2;
2959  char *p1,
2960  *p2;
2961 
2962  len1 = VARSIZE_ANY_EXHDR(t1);
2963  len2 = VARSIZE_ANY_EXHDR(t2);
2964 
2965  if (len2 <= 0)
2966  PG_RETURN_INT32(1); /* result for empty pattern */
2967 
2968  p1 = VARDATA_ANY(t1);
2969  p2 = VARDATA_ANY(t2);
2970 
2971  pos = 0;
2972  px = (len1 - len2);
2973  for (p = 0; p <= px; p++)
2974  {
2975  if ((*p2 == *p1) && (memcmp(p1, p2, len2) == 0))
2976  {
2977  pos = p + 1;
2978  break;
2979  };
2980  p1++;
2981  };
2982 
2983  PG_RETURN_INT32(pos);
2984 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define PG_RETURN_INT32(x)
Definition: fmgr.h:314
void px(PlannerInfo *root, Gene *tour1, Gene *tour2, Gene *offspring, int num_gene, City *city_table)
Definition: geqo_px.c:46
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:272
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
Definition: c.h:439
Datum bytearecv ( PG_FUNCTION_ARGS  )

Definition at line 423 of file varlena.c.

References buf, StringInfoData::cursor, StringInfoData::len, palloc(), PG_GETARG_POINTER, PG_RETURN_BYTEA_P, pq_copymsgbytes(), result, SET_VARSIZE, VARDATA, and VARHDRSZ.

424 {
426  bytea *result;
427  int nbytes;
428 
429  nbytes = buf->len - buf->cursor;
430  result = (bytea *) palloc(nbytes + VARHDRSZ);
431  SET_VARSIZE(result, nbytes + VARHDRSZ);
432  pq_copymsgbytes(buf, VARDATA(result), nbytes);
433  PG_RETURN_BYTEA_P(result);
434 }
#define VARDATA(PTR)
Definition: postgres.h:303
#define VARHDRSZ
Definition: c.h:445
StringInfoData * StringInfo
Definition: stringinfo.h:46
return result
Definition: formatting.c:1618
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:241
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:329
static char * buf
Definition: pg_test_fsync.c:66
void pq_copymsgbytes(StringInfo msg, char *buf, int datalen)
Definition: pqformat.c:570
void * palloc(Size size)
Definition: mcxt.c:849
Definition: c.h:439
#define SET_VARSIZE(PTR, len)
Definition: postgres.h:328
Datum byteasend ( PG_FUNCTION_ARGS  )

Definition at line 442 of file varlena.c.

References PG_GETARG_BYTEA_P_COPY, and PG_RETURN_BYTEA_P.

Referenced by pg_dependencies_send(), and pg_ndistinct_send().

443 {
444  bytea *vlena = PG_GETARG_BYTEA_P_COPY(0);
445 
446  PG_RETURN_BYTEA_P(vlena);
447 }
#define PG_GETARG_BYTEA_P_COPY(n)
Definition: fmgr.h:278
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:329
Definition: c.h:439
Datum byteaSetBit ( PG_FUNCTION_ARGS  )

Definition at line 3092 of file varlena.c.

References ereport, errcode(), errmsg(), ERROR, PG_GETARG_BYTEA_P_COPY, PG_GETARG_INT32, PG_RETURN_BYTEA_P, VARDATA, VARHDRSZ, and VARSIZE.

3093 {
3094  bytea *res = PG_GETARG_BYTEA_P_COPY(0);
3095  int32 n = PG_GETARG_INT32(1);
3096  int32 newBit = PG_GETARG_INT32(2);
3097  int len;
3098  int oldByte,
3099  newByte;
3100  int byteNo,
3101  bitNo;
3102 
3103  len = VARSIZE(res) - VARHDRSZ;
3104 
3105  if (n < 0 || n >= len * 8)
3106  ereport(ERROR,
3107  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
3108  errmsg("index %d out of valid range, 0..%d",
3109  n, len * 8 - 1)));
3110 
3111  byteNo = n / 8;
3112  bitNo = n % 8;
3113 
3114  /*
3115  * sanity check!
3116  */
3117  if (newBit != 0 && newBit != 1)
3118  ereport(ERROR,
3119  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3120  errmsg("new bit must be 0 or 1")));
3121 
3122  /*
3123  * Update the byte.
3124  */
3125  oldByte = ((unsigned char *) VARDATA(res))[byteNo];
3126 
3127  if (newBit == 0)
3128  newByte = oldByte & (~(1 << bitNo));
3129  else
3130  newByte = oldByte | (1 << bitNo);
3131 
3132  ((unsigned char *) VARDATA(res))[byteNo] = newByte;
3133 
3134  PG_RETURN_BYTEA_P(res);
3135 }
#define PG_GETARG_INT32(n)
Definition: fmgr.h:234
#define VARDATA(PTR)
Definition: postgres.h:303
#define VARSIZE(PTR)
Definition: postgres.h:304
#define VARHDRSZ
Definition: c.h:445
#define PG_GETARG_BYTEA_P_COPY(n)
Definition: fmgr.h:278
int errcode(int sqlerrcode)
Definition: elog.c:575
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:329
signed int int32
Definition: c.h:256
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:122
int errmsg(const char *fmt,...)
Definition: elog.c:797
Definition: c.h:439
Datum byteaSetByte ( PG_FUNCTION_ARGS  )

Definition at line 3060 of file varlena.c.

References ereport, errcode(), errmsg(), ERROR, PG_GETARG_BYTEA_P_COPY, PG_GETARG_INT32, PG_RETURN_BYTEA_P, VARDATA, VARHDRSZ, and VARSIZE.

3061 {
3062  bytea *res = PG_GETARG_BYTEA_P_COPY(0);
3063  int32 n = PG_GETARG_INT32(1);
3064  int32 newByte = PG_GETARG_INT32(2);
3065  int len;
3066 
3067  len = VARSIZE(res) - VARHDRSZ;
3068 
3069  if (n < 0 || n >= len)
3070  ereport(ERROR,
3071  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
3072  errmsg("index %d out of valid range, 0..%d",
3073  n, len - 1)));
3074 
3075  /*
3076  * Now set the byte.
3077  */
3078  ((unsigned char *) VARDATA(res))[n] = newByte;
3079 
3080  PG_RETURN_BYTEA_P(res);
3081 }
#define PG_GETARG_INT32(n)
Definition: fmgr.h:234
#define VARDATA(PTR)
Definition: postgres.h:303
#define VARSIZE(PTR)
Definition: postgres.h:304
#define VARHDRSZ
Definition: c.h:445
#define PG_GETARG_BYTEA_P_COPY(n)
Definition: fmgr.h:278
int errcode(int sqlerrcode)
Definition: elog.c:575
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:329
signed int int32
Definition: c.h:256
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:122
int errmsg(const char *fmt,...)
Definition: elog.c:797
Definition: c.h:439
static int charlen_to_bytelen ( const char *  p,
int  n 
)
static

Definition at line 735 of file varlena.c.

References pg_database_encoding_max_length(), and pg_mblen().

Referenced by appendStringInfoRegexpSubstr(), replace_text(), replace_text_regexp(), and text_to_array_internal().

736 {
738  {
739  /* Optimization for single-byte encodings */
740  return n;
741  }
742  else
743  {
744  const char *s;
745 
746  for (s = p; n > 0; n--)
747  s += pg_mblen(s);
748 
749  return s - p;
750  }
751 }
int pg_database_encoding_max_length(void)
Definition: wchar.c:1833
int pg_mblen(const char *mbstr)
Definition: mbutils.c:771
static bool check_replace_text_has_escape_char ( const text replace_text)
static

Definition at line 3748 of file varlena.c.

References pg_database_encoding_max_length(), pg_mblen(), VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by replace_text_regexp().

3749 {
3750  const char *p = VARDATA_ANY(replace_text);
3751  const char *p_end = p + VARSIZE_ANY_EXHDR(replace_text);
3752 
3754  {
3755  for (; p < p_end; p++)
3756  {
3757  if (*p == '\\')
3758  return true;
3759  }
3760  }
3761  else
3762  {
3763  for (; p < p_end; p += pg_mblen(p))
3764  {
3765  if (*p == '\\')
3766  return true;
3767  }
3768  }
3769 
3770  return false;
3771 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
int pg_database_encoding_max_length(void)
Definition: wchar.c:1833
int pg_mblen(const char *mbstr)
Definition: mbutils.c:771
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
static text* concat_internal ( const char *  sepstr,
int  argidx,
FunctionCallInfo  fcinfo 
)
static

Definition at line 4711 of file varlena.c.

References appendStringInfoString(), array_to_text_internal(), Assert, cstring_to_text_with_len(), StringInfoData::data, elog, ERROR, FunctionCallInfoData::flinfo, get_base_element_type(), get_fn_expr_argtype(), get_fn_expr_variadic(), getTypeOutputInfo(), i, initStringInfo(), StringInfoData::len, NULL, OidIsValid, OidOutputFunctionCall(), pfree(), PG_ARGISNULL, PG_GETARG_ARRAYTYPE_P, PG_GETARG_DATUM, PG_NARGS, result, and value.

Referenced by text_concat(), and text_concat_ws().

4713 {
4714  text *result;
4715  StringInfoData str;
4716  bool first_arg = true;
4717  int i;
4718 
4719  /*
4720  * concat(VARIADIC some-array) is essentially equivalent to
4721  * array_to_text(), ie concat the array elements with the given separator.
4722  * So we just pass the case off to that code.
4723  */
4724  if (get_fn_expr_variadic(fcinfo->flinfo))
4725  {
4726  ArrayType *arr;
4727 
4728  /* Should have just the one argument */
4729  Assert(argidx == PG_NARGS() - 1);
4730 
4731  /* concat(VARIADIC NULL) is defined as NULL */
4732  if (PG_ARGISNULL(argidx))
4733  return NULL;
4734 
4735  /*
4736  * Non-null argument had better be an array. We assume that any call
4737  * context that could let get_fn_expr_variadic return true will have
4738  * checked that a VARIADIC-labeled parameter actually is an array. So
4739  * it should be okay to just Assert that it's an array rather than
4740  * doing a full-fledged error check.
4741  */
4743 
4744  /* OK, safe to fetch the array value */
4745  arr = PG_GETARG_ARRAYTYPE_P(argidx);
4746 
4747  /*
4748  * And serialize the array. We tell array_to_text to ignore null
4749  * elements, which matches the behavior of the loop below.
4750  */
4751  return array_to_text_internal(fcinfo, arr, sepstr, NULL);
4752  }
4753 
4754  /* Normal case without explicit VARIADIC marker */
4755  initStringInfo(&str);
4756 
4757  for (i = argidx; i < PG_NARGS(); i++)
4758  {
4759  if (!PG_ARGISNULL(i))
4760  {
4762  Oid valtype;
4763  Oid typOutput;
4764  bool typIsVarlena;
4765 
4766  /* add separator if appropriate */
4767  if (first_arg)
4768  first_arg = false;
4769  else
4770  appendStringInfoString(&str, sepstr);
4771 
4772  /* call the appropriate type output function, append the result */
4773  valtype = get_fn_expr_argtype(fcinfo->flinfo, i);
4774  if (!OidIsValid(valtype))
4775  elog(ERROR, "could not determine data type of concat() input");
4776  getTypeOutputInfo(valtype, &typOutput, &typIsVarlena);
4778  OidOutputFunctionCall(typOutput, value));
4779  }
4780  }
4781 
4782  result = cstring_to_text_with_len(str.data, str.len);
4783  pfree(str.data);
4784 
4785  return result;
4786 }
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
Definition: lsyscache.c:2632
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:233
bool get_fn_expr_variadic(FmgrInfo *flinfo)
Definition: fmgr.c:2051
return result
Definition: formatting.c:1618
unsigned int Oid
Definition: postgres_ext.h:31
#define OidIsValid(objectId)
Definition: c.h:538
FmgrInfo * flinfo
Definition: fmgr.h:79
#define PG_GETARG_ARRAYTYPE_P(n)
Definition: array.h:244
void pfree(void *pointer)
Definition: mcxt.c:950
#define ERROR
Definition: elog.h:43
Oid get_fn_expr_argtype(FmgrInfo *flinfo, int argnum)
Definition: fmgr.c:1909
static text * array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v, const char *fldsep, const char *null_string)
Definition: varlena.c:4365
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:189
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:161
void initStringInfo(StringInfo str)
Definition: stringinfo.c:65
uintptr_t Datum
Definition: postgres.h:372
#define PG_ARGISNULL(n)
Definition: fmgr.h:174
#define NULL
Definition: c.h:229
#define Assert(condition)
Definition: c.h:675
#define PG_NARGS()
Definition: fmgr.h:168
Oid get_base_element_type(Oid typid)
Definition: lsyscache.c:2557
char * OidOutputFunctionCall(Oid functionId, Datum val)
Definition: fmgr.c:1747
int i
Definition: c.h:439
#define elog
Definition: elog.h:219
static struct @121 value
text* cstring_to_text ( const char *  s)

Definition at line 149 of file varlena.c.

References cstring_to_text_with_len().

Referenced by array_dims(), ASN1_STRING_to_text(), booltext(), brin_page_type(), cash_words(), chkpass_rout(), cidr_abbrev(), convert_charset(), cstring_to_xmltype(), current_query(), datetime_to_char_body(), dblink_build_sql_delete(), dblink_build_sql_insert(), dblink_build_sql_update(), dblink_cancel_query(), dblink_close(), dblink_connect(), dblink_disconnect(), dblink_error_message(), dblink_exec(), dblink_open(), dmetaphone(), dmetaphone_alt(), exec_assign_c_string(), filter_list_to_array(), format_type(), get_command_tag(), get_command_type(), get_jsonb_path_all(), get_scalar(), hash_page_type(), hstore_to_json(), hstore_to_json_loose(), inet_abbrev(), initcap(), json_in(), json_typeof(), jsonb_array_element_text(), jsonb_object_field_text(), jsonb_typeof(), lower(), md5_bytea(), md5_text(), metaphone(), name_bpchar(), name_text(), network_host(), network_show(), oidvectortypes(), pg_collation_actual_version(), pg_collation_for(), pg_crypt(), pg_current_logfile(), pg_describe_object(), pg_export_snapshot(), pg_relation_filepath(), pg_size_pretty(), pg_size_pretty_numeric(), pg_stat_get_backend_activity(), pg_stat_get_backend_wait_event(), pg_stat_get_backend_wait_event_type(), pg_tablespace_location(), pg_walfile_name(), pgsql_version(), pgxml_result_to_text(), quote_ident(), quote_ident_cstr(), quote_nullable(), sepgsql_getcon(), sepgsql_mcstrans_in(), sepgsql_mcstrans_out(), set_config_by_name(), show_all_file_settings(), show_config_by_name(), show_config_by_name_missing_ok(), ShowAllGUCConfig(), soundex(), split_text(), ssl_cipher(), ssl_version(), string_to_text(), text_substring(), textin(), timeofday(), to_hex32(), to_hex64(), tsquerytree(), txid_status(), unaccent_dict(), upper(), X509_NAME_to_text(), xml_encode_special_chars(), xml_in(), and xml_recv().

150 {
151  return cstring_to_text_with_len(s, strlen(s));
152 }
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:161
text* cstring_to_text_with_len ( const char *  s,
int  len 
)

Definition at line 161 of file varlena.c.

References palloc(), result, SET_VARSIZE, VARDATA, and VARHDRSZ.

Referenced by array_to_json(), array_to_json_pretty(), array_to_text_internal(), compute_tsvector_stats(), concat_internal(), cstring_to_text(), do_text_output_multiline(), dotrim(), each_object_field_end(), each_worker_jsonb(), elements_array_element_end(), elements_worker_jsonb(), ExecEvalXmlExpr(), fsm_page_contents(), get_array_element_end(), get_array_end(), get_jsonb_path_all(), get_object_end(), get_object_field_end(), get_scalar(), gin_extract_tsquery(), gin_extract_tsvector(), hstore_akeys(), hstore_avals(), hstore_each(), hstore_fetchval(), hstore_skeys(), hstore_slice_to_array(), hstore_svals(), hstore_to_array_internal(), hstore_to_json(), hstore_to_json_loose(), json_build_array(), json_build_array_noargs(), json_build_object(), json_build_object_noargs(), json_object(), json_object_two_arg(), json_recv(), json_strip_nulls(), jsonb_array_element_text(), jsonb_object_field_text(), jsonb_pretty(), leftmostvalue_text(), LogicalOutputWrite(), parse_ident(), pg_gen_salt(), pg_gen_salt_rounds(), replace_text(), replace_text_regexp(), row_to_json(), row_to_json_pretty(), serialize_deflist(), ssl_extension_info(), string_agg_finalfn(), stringinfo_to_xmltype(), text_format(), text_left(), text_right(), text_to_array_internal(), textrecv(), to_json(), transform_json_string_values(), tsquerytree(), tsvector_to_array(), tsvector_unnest(), varchar(), varchar_input(), and xslt_process().

162 {
163  text *result = (text *) palloc(len + VARHDRSZ);
164 
165  SET_VARSIZE(result, len + VARHDRSZ);
166  memcpy(VARDATA(result), s, len);
167 
168  return result;
169 }
#define VARDATA(PTR)
Definition: postgres.h:303
#define VARHDRSZ
Definition: c.h:445
return result
Definition: formatting.c:1618
void * palloc(Size size)
Definition: mcxt.c:849
Definition: c.h:439
#define SET_VARSIZE(PTR, len)
Definition: postgres.h:328
static int internal_text_pattern_compare ( text arg1,
text arg2 
)
static

Definition at line 2600 of file varlena.c.

References Min, result, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by bttext_pattern_cmp(), text_pattern_ge(), text_pattern_gt(), text_pattern_le(), and text_pattern_lt().

2601 {
2602  int result;
2603  int len1,
2604  len2;
2605 
2606  len1 = VARSIZE_ANY_EXHDR(arg1);
2607  len2 = VARSIZE_ANY_EXHDR(arg2);
2608 
2609  result = memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), Min(len1, len2));
2610  if (result != 0)
2611  return result;
2612  else if (len1 < len2)
2613  return -1;
2614  else if (len1 > len2)
2615  return 1;
2616  else
2617  return 0;
2618 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define Min(x, y)
Definition: c.h:806
return result
Definition: formatting.c:1618
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
static StringInfo makeStringAggState ( FunctionCallInfo  fcinfo)
static

Definition at line 4638 of file varlena.c.

References AggCheckCallContext(), elog, ERROR, makeStringInfo(), and MemoryContextSwitchTo().

Referenced by bytea_string_agg_transfn(), and string_agg_transfn().

4639 {
4640  StringInfo state;
4641  MemoryContext aggcontext;
4642  MemoryContext oldcontext;
4643 
4644  if (!AggCheckCallContext(fcinfo, &aggcontext))
4645  {
4646  /* cannot be called directly because of internal-type argument */
4647  elog(ERROR, "string_agg_transfn called in non-aggregate context");
4648  }
4649 
4650  /*
4651  * Create state in aggregate context. It'll stay there across subsequent
4652  * calls.
4653  */
4654  oldcontext = MemoryContextSwitchTo(aggcontext);
4655  state = makeStringInfo();
4656  MemoryContextSwitchTo(oldcontext);
4657 
4658  return state;
4659 }
StringInfo makeStringInfo(void)
Definition: stringinfo.c:29
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
#define ERROR
Definition: elog.h:43
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
Definition: nodeAgg.c:4018
#define elog
Definition: elog.h:219
Datum md5_bytea ( PG_FUNCTION_ARGS  )

Definition at line 4563 of file varlena.c.

References cstring_to_text(), ereport, errcode(), errmsg(), ERROR, MD5_HASH_LEN, PG_GETARG_BYTEA_PP, pg_md5_hash(), PG_RETURN_TEXT_P, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

4564 {
4565  bytea *in = PG_GETARG_BYTEA_PP(0);
4566  size_t len;
4567  char hexsum[MD5_HASH_LEN + 1];
4568 
4569  len = VARSIZE_ANY_EXHDR(in);
4570  if (pg_md5_hash(VARDATA_ANY(in), len, hexsum) == false)
4571  ereport(ERROR,
4572  (errcode(ERRCODE_OUT_OF_MEMORY),
4573  errmsg("out of memory")));
4574 
4576 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define MD5_HASH_LEN
Definition: varlena.c:4536
int errcode(int sqlerrcode)
Definition: elog.c:575
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:122
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
text * cstring_to_text(const char *s)
Definition: varlena.c:149
bool pg_md5_hash(const void *buff, size_t len, char *hexsum)
Definition: md5.c:293
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:272
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
int errmsg(const char *fmt,...)
Definition: elog.c:797
Definition: c.h:439
Datum md5_text ( PG_FUNCTION_ARGS  )

Definition at line 4539 of file varlena.c.

References cstring_to_text(), ereport, errcode(), errmsg(), ERROR, MD5_HASH_LEN, PG_GETARG_TEXT_PP, pg_md5_hash(), PG_RETURN_TEXT_P, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

4540 {
4541  text *in_text = PG_GETARG_TEXT_PP(0);
4542  size_t len;
4543  char hexsum[MD5_HASH_LEN + 1];
4544 
4545  /* Calculate the length of the buffer using varlena metadata */
4546  len = VARSIZE_ANY_EXHDR(in_text);
4547 
4548  /* get the hash result */
4549  if (pg_md5_hash(VARDATA_ANY(in_text), len, hexsum) == false)
4550  ereport(ERROR,
4551  (errcode(ERRCODE_OUT_OF_MEMORY),
4552  errmsg("out of memory")));
4553 
4554  /* convert to text and return it */
4556 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define MD5_HASH_LEN
Definition: varlena.c:4536
int errcode(int sqlerrcode)
Definition: elog.c:575
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:122
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
text * cstring_to_text(const char *s)
Definition: varlena.c:149
bool pg_md5_hash(const void *buff, size_t len, char *hexsum)
Definition: md5.c:293
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
int errmsg(const char *fmt,...)
Definition: elog.c:797
Definition: c.h:439
Datum name_text ( PG_FUNCTION_ARGS  )

Definition at line 3165 of file varlena.c.

References cstring_to_text(), NameStr, PG_GETARG_NAME, and PG_RETURN_TEXT_P.

Referenced by nameiclike(), and nameicnlike().

3166 {
3167  Name s = PG_GETARG_NAME(0);
3168 
3170 }
Definition: c.h:493
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
text * cstring_to_text(const char *s)
Definition: varlena.c:149
#define NameStr(name)
Definition: c.h:499
#define PG_GETARG_NAME(n)
Definition: fmgr.h:243
Datum pg_column_size ( PG_FUNCTION_ARGS  )

Definition at line 4584 of file varlena.c.

References DatumGetCString, elog, ERROR, get_fn_expr_argtype(), get_typlen(), MemoryContextAlloc(), NULL, PG_GETARG_DATUM, PG_RETURN_INT32, result, toast_datum_size(), and value.

4585 {
4587  int32 result;
4588  int typlen;
4589 
4590  /* On first call, get the input type's typlen, and save at *fn_extra */
4591  if (fcinfo->flinfo->fn_extra == NULL)
4592  {
4593  /* Lookup the datatype of the supplied argument */
4594  Oid argtypeid = get_fn_expr_argtype(fcinfo->flinfo, 0);
4595 
4596  typlen = get_typlen(argtypeid);
4597  if (typlen == 0) /* should not happen */
4598  elog(ERROR, "cache lookup failed for type %u", argtypeid);
4599 
4600  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
4601  sizeof(int));
4602  *((int *) fcinfo->flinfo->fn_extra) = typlen;
4603  }
4604  else
4605  typlen = *((int *) fcinfo->flinfo->fn_extra);
4606 
4607  if (typlen == -1)
4608  {
4609  /* varlena type, possibly toasted */
4610  result = toast_datum_size(value);
4611  }
4612  else if (typlen == -2)
4613  {
4614  /* cstring */
4615  result = strlen(DatumGetCString(value)) + 1;
4616  }
4617  else
4618  {
4619  /* ordinary fixed-width type */
4620  result = typlen;
4621  }
4622 
4623  PG_RETURN_INT32(result);
4624 }
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:233
#define PG_RETURN_INT32(x)
Definition: fmgr.h:314
return result
Definition: formatting.c:1618
unsigned int Oid
Definition: postgres_ext.h:31
signed int int32
Definition: c.h:256
#define ERROR
Definition: elog.h:43
#define DatumGetCString(X)
Definition: postgres.h:572
Size toast_datum_size(Datum value)
Definition: tuptoaster.c:409
Oid get_fn_expr_argtype(FmgrInfo *flinfo, int argnum)
Definition: fmgr.c:1909
uintptr_t Datum
Definition: postgres.h:372
#define NULL
Definition: c.h:229
int16 get_typlen(Oid typid)
Definition: lsyscache.c:1947
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:707
#define elog
Definition: elog.h:219
static struct @121 value
Datum replace_text ( PG_FUNCTION_ARGS  )

Definition at line 3665 of file varlena.c.

References appendBinaryStringInfo(), appendStringInfoText(), charlen_to_bytelen(), CHECK_FOR_INTERRUPTS, cstring_to_text_with_len(), StringInfoData::data, initStringInfo(), StringInfoData::len, TextPositionState::len1, TextPositionState::len2, pfree(), PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, text_position_cleanup(), text_position_next(), text_position_setup(), VARDATA_ANY, and VARSIZE_ANY.

Referenced by execute_extension_script().

3666 {
3667  text *src_text = PG_GETARG_TEXT_PP(0);
3668  text *from_sub_text = PG_GETARG_TEXT_PP(1);
3669  text *to_sub_text = PG_GETARG_TEXT_PP(2);
3670  int src_text_len;
3671  int from_sub_text_len;
3673  text *ret_text;
3674  int start_posn;
3675  int curr_posn;
3676  int chunk_len;
3677  char *start_ptr;
3678  StringInfoData str;
3679 
3680  text_position_setup(src_text, from_sub_text, &state);
3681 
3682  /*
3683  * Note: we check the converted string length, not the original, because
3684  * they could be different if the input contained invalid encoding.
3685  */
3686  src_text_len = state.len1;
3687  from_sub_text_len = state.len2;
3688 
3689  /* Return unmodified source string if empty source or pattern */
3690  if (src_text_len < 1 || from_sub_text_len < 1)
3691  {
3692  text_position_cleanup(&state);
3693  PG_RETURN_TEXT_P(src_text);
3694  }
3695 
3696  start_posn = 1;
3697  curr_posn = text_position_next(1, &state);
3698 
3699  /* When the from_sub_text is not found, there is nothing to do. */
3700  if (curr_posn == 0)
3701  {
3702  text_position_cleanup(&state);
3703  PG_RETURN_TEXT_P(src_text);
3704  }
3705 
3706  /* start_ptr points to the start_posn'th character of src_text */
3707  start_ptr = VARDATA_ANY(src_text);
3708 
3709  initStringInfo(&str);
3710 
3711  do
3712  {
3714 
3715  /* copy the data skipped over by last text_position_next() */
3716  chunk_len = charlen_to_bytelen(start_ptr, curr_posn - start_posn);
3717  appendBinaryStringInfo(&str, start_ptr, chunk_len);
3718 
3719  appendStringInfoText(&str, to_sub_text);
3720 
3721  start_posn = curr_posn;
3722  start_ptr += chunk_len;
3723  start_posn += from_sub_text_len;
3724  start_ptr += charlen_to_bytelen(start_ptr, from_sub_text_len);
3725 
3726  curr_posn = text_position_next(start_posn, &state);
3727  }
3728  while (curr_posn > 0);
3729 
3730  /* copy trailing data */
3731  chunk_len = ((char *) src_text + VARSIZE_ANY(src_text)) - start_ptr;
3732  appendBinaryStringInfo(&str, start_ptr, chunk_len);
3733 
3734  text_position_cleanup(&state);
3735 
3736  ret_text = cstring_to_text_with_len(str.data, str.len);
3737  pfree(str.data);
3738 
3739  PG_RETURN_TEXT_P(ret_text);
3740 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
static void text_position_setup(text *t1, text *t2, TextPositionState *state)
Definition: varlena.c:1119
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
void pfree(void *pointer)
Definition: mcxt.c:950
static int text_position_next(int start_pos, TextPositionState *state)
Definition: varlena.c:1231
static int charlen_to_bytelen(const char *p, int n)
Definition: varlena.c:735
static void appendStringInfoText(StringInfo str, const text *t)
Definition: varlena.c:3651
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:161
void initStringInfo(StringInfo str)
Definition: stringinfo.c:65
#define VARSIZE_ANY(PTR)
Definition: postgres.h:334
static void text_position_cleanup(TextPositionState *state)
Definition: varlena.c:1365
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
Definition: c.h:439
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:97
void appendBinaryStringInfo(StringInfo str, const char *data, int datalen)
Definition: stringinfo.c:240
text* replace_text_regexp ( text src_text,
void *  regexp,
text replace_text,
bool  glob 
)

Definition at line 3886 of file varlena.c.

References appendBinaryStringInfo(), appendStringInfoRegexpSubstr(), appendStringInfoText(), buf, charlen_to_bytelen(), CHECK_FOR_INTERRUPTS, check_replace_text_has_escape_char(), cstring_to_text_with_len(), StringInfoData::data, ereport, errcode(), errmsg(), ERROR, initStringInfo(), StringInfoData::len, NULL, palloc(), pfree(), pg_mb2wchar_with_len(), pg_regerror(), pg_regexec(), REG_NOMATCH, REG_OKAY, REGEXP_REPLACE_BACKREF_CNT, regmatch_t::rm_eo, regmatch_t::rm_so, VARDATA_ANY, VARSIZE_ANY, and VARSIZE_ANY_EXHDR.

Referenced by textregexreplace(), and textregexreplace_noopt().

3888 {
3889  text *ret_text;
3890  regex_t *re = (regex_t *) regexp;
3891  int src_text_len = VARSIZE_ANY_EXHDR(src_text);
3894  pg_wchar *data;
3895  size_t data_len;
3896  int search_start;
3897  int data_pos;
3898  char *start_ptr;
3899  bool have_escape;
3900 
3901  initStringInfo(&buf);
3902 
3903  /* Convert data string to wide characters. */
3904  data = (pg_wchar *) palloc((src_text_len + 1) * sizeof(pg_wchar));
3905  data_len = pg_mb2wchar_with_len(VARDATA_ANY(src_text), data, src_text_len);
3906 
3907  /* Check whether replace_text has escape char. */
3908  have_escape = check_replace_text_has_escape_char(replace_text);
3909 
3910  /* start_ptr points to the data_pos'th character of src_text */
3911  start_ptr = (char *) VARDATA_ANY(src_text);
3912  data_pos = 0;
3913 
3914  search_start = 0;
3915  while (search_start <= data_len)
3916  {
3917  int regexec_result;
3918 
3920 
3921  regexec_result = pg_regexec(re,
3922  data,
3923  data_len,
3924  search_start,
3925  NULL, /* no details */
3927  pmatch,
3928  0);
3929 
3930  if (regexec_result == REG_NOMATCH)
3931  break;
3932 
3933  if (regexec_result != REG_OKAY)
3934  {
3935  char errMsg[100];
3936 
3938  pg_regerror(regexec_result, re, errMsg, sizeof(errMsg));
3939  ereport(ERROR,
3940  (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
3941  errmsg("regular expression failed: %s", errMsg)));
3942  }
3943 
3944  /*
3945  * Copy the text to the left of the match position. Note we are given
3946  * character not byte indexes.
3947  */
3948  if (pmatch[0].rm_so - data_pos > 0)
3949  {
3950  int chunk_len;
3951 
3952  chunk_len = charlen_to_bytelen(start_ptr,
3953  pmatch[0].rm_so - data_pos);
3954  appendBinaryStringInfo(&buf, start_ptr, chunk_len);
3955 
3956  /*
3957  * Advance start_ptr over that text, to avoid multiple rescans of
3958  * it if the replace_text contains multiple back-references.
3959  */
3960  start_ptr += chunk_len;
3961  data_pos = pmatch[0].rm_so;
3962  }
3963 
3964  /*
3965  * Copy the replace_text. Process back references when the
3966  * replace_text has escape characters.
3967  */
3968  if (have_escape)
3969  appendStringInfoRegexpSubstr(&buf, replace_text, pmatch,
3970  start_ptr, data_pos);
3971  else
3972  appendStringInfoText(&buf, replace_text);
3973 
3974  /* Advance start_ptr and data_pos over the matched text. */
3975  start_ptr += charlen_to_bytelen(start_ptr,
3976  pmatch[0].rm_eo - data_pos);
3977  data_pos = pmatch[0].rm_eo;
3978 
3979  /*
3980  * When global option is off, replace the first instance only.
3981  */
3982  if (!glob)
3983  break;
3984 
3985  /*
3986  * Advance search position. Normally we start the next search at the
3987  * end of the previous match; but if the match was of zero length, we
3988  * have to advance by one character, or we'd just find the same match
3989  * again.
3990  */
3991  search_start = data_pos;
3992  if (pmatch[0].rm_so == pmatch[0].rm_eo)
3993  search_start++;
3994  }
3995 
3996  /*
3997  * Copy the text to the right of the last match.
3998  */
3999  if (data_pos < data_len)
4000  {
4001  int chunk_len;
4002 
4003  chunk_len = ((char *) src_text + VARSIZE_ANY(src_text)) - start_ptr;
4004  appendBinaryStringInfo(&buf, start_ptr, chunk_len);
4005  }
4006 
4007  ret_text = cstring_to_text_with_len(buf.data, buf.len);
4008  pfree(buf.data);
4009  pfree(data);
4010 
4011  return ret_text;
4012 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
regoff_t rm_so
Definition: regex.h:85
int errcode(int sqlerrcode)
Definition: elog.c:575
regoff_t rm_eo
Definition: regex.h:86
void pfree(void *pointer)
Definition: mcxt.c:950
#define REG_OKAY
Definition: regex.h:137
#define ERROR
Definition: elog.h:43
static bool check_replace_text_has_escape_char(const text *replace_text)
Definition: varlena.c:3748
static int charlen_to_bytelen(const char *p, int n)
Definition: varlena.c:735
static void appendStringInfoText(StringInfo str, const text *t)
Definition: varlena.c:3651
static char * buf
Definition: pg_test_fsync.c:66
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:161
size_t pg_regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
Definition: regerror.c:60
#define ereport(elevel, rest)
Definition: elog.h:122
unsigned int pg_wchar
Definition: mbprint.c:31
void initStringInfo(StringInfo str)
Definition: stringinfo.c:65
#define REGEXP_REPLACE_BACKREF_CNT
Definition: varlena.c:3875
#define VARSIZE_ANY(PTR)
Definition: postgres.h:334
int pg_mb2wchar_with_len(const char *from, pg_wchar *to, int len)
Definition: mbutils.c:734
#define NULL
Definition: c.h:229
static void appendStringInfoRegexpSubstr(StringInfo str, text *replace_text, regmatch_t *pmatch, char *start_ptr, int data_pos)
Definition: varlena.c:3781
int pg_regexec(regex_t *re, const chr *string, size_t len, size_t search_start, rm_detail_t *details, size_t nmatch, regmatch_t pmatch[], int flags)
Definition: regexec.c:172
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
void * palloc(Size size)
Definition: mcxt.c:849
int errmsg(const char *fmt,...)
Definition: elog.c:797
#define REG_NOMATCH
Definition: regex.h:138
Definition: c.h:439
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:97
void appendBinaryStringInfo(StringInfo str, const char *data, int datalen)
Definition: stringinfo.c:240
Definition: regex.h:55
static bool rest_of_char_same ( const char *  s1,
const char *  s2,
int  len 
)
inlinestatic

Definition at line 5438 of file varlena.c.

Referenced by varstr_levenshtein().

5439 {
5440  while (len > 0)
5441  {
5442  len--;
5443  if (s1[len] != s2[len])
5444  return false;
5445  }
5446  return true;
5447 }
char * s1
char * s2
Datum split_text ( PG_FUNCTION_ARGS  )

Definition at line 4021 of file varlena.c.

References cstring_to_text(), ereport, errcode(), errmsg(), ERROR, TextPositionState::len1, TextPositionState::len2, PG_GETARG_INT32, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, PointerGetDatum, text_position_cleanup(), text_position_next(), text_position_setup(), and text_substring().

4022 {
4023  text *inputstring = PG_GETARG_TEXT_PP(0);
4024  text *fldsep = PG_GETARG_TEXT_PP(1);
4025  int fldnum = PG_GETARG_INT32(2);
4026  int inputstring_len;
4027  int fldsep_len;
4029  int start_posn;
4030  int end_posn;
4031  text *result_text;
4032 
4033  /* field number is 1 based */
4034  if (fldnum < 1)
4035  ereport(ERROR,
4036  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4037  errmsg("field position must be greater than zero")));
4038 
4039  text_position_setup(inputstring, fldsep, &state);
4040 
4041  /*
4042  * Note: we check the converted string length, not the original, because
4043  * they could be different if the input contained invalid encoding.
4044  */
4045  inputstring_len = state.len1;
4046  fldsep_len = state.len2;
4047 
4048  /* return empty string for empty input string */
4049  if (inputstring_len < 1)
4050  {
4051  text_position_cleanup(&state);
4053  }
4054 
4055  /* empty field separator */
4056  if (fldsep_len < 1)
4057  {
4058  text_position_cleanup(&state);
4059  /* if first field, return input string, else empty string */
4060  if (fldnum == 1)
4061  PG_RETURN_TEXT_P(inputstring);
4062  else
4064  }
4065 
4066  /* identify bounds of first field */
4067  start_posn = 1;
4068  end_posn = text_position_next(1, &state);
4069 
4070  /* special case if fldsep not found at all */
4071  if (end_posn == 0)
4072  {
4073  text_position_cleanup(&state);
4074  /* if field 1 requested, return input string, else empty string */
4075  if (fldnum == 1)
4076  PG_RETURN_TEXT_P(inputstring);
4077  else
4079  }
4080 
4081  while (end_posn > 0 && --fldnum > 0)
4082  {
4083  /* identify bounds of next field */
4084  start_posn = end_posn + fldsep_len;
4085  end_posn = text_position_next(start_posn, &state);
4086  }
4087 
4088  text_position_cleanup(&state);
4089 
4090  if (fldnum > 0)
4091  {
4092  /* N'th field separator not found */
4093  /* if last field requested, return it, else empty string */
4094  if (fldnum == 1)
4095  result_text = text_substring(PointerGetDatum(inputstring),
4096  start_posn,
4097  -1,
4098  true);
4099  else
4100  result_text = cstring_to_text("");
4101  }
4102  else
4103  {
4104  /* non-last field requested */
4105  result_text = text_substring(PointerGetDatum(inputstring),
4106  start_posn,
4107  end_posn - start_posn,
4108  false);
4109  }
4110 
4111  PG_RETURN_TEXT_P(result_text);
4112 }
#define PG_GETARG_INT32(n)
Definition: fmgr.h:234
#define PointerGetDatum(X)
Definition: postgres.h:562
static void text_position_setup(text *t1, text *t2, TextPositionState *state)
Definition: varlena.c:1119
int errcode(int sqlerrcode)
Definition: elog.c:575
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
#define ERROR
Definition: elog.h:43
static int text_position_next(int start_pos, TextPositionState *state)
Definition: varlena.c:1231
static text * text_substring(Datum str, int32 start, int32 length, bool length_not_specified)
Definition: varlena.c:814
#define ereport(elevel, rest)
Definition: elog.h:122
static void text_position_cleanup(TextPositionState *state)
Definition: varlena.c:1365
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
text * cstring_to_text(const char *s)
Definition: varlena.c:149
int errmsg(const char *fmt,...)
Definition: elog.c:797
Definition: c.h:439
bool SplitDirectoriesString ( char *  rawstring,
char  separator,
List **  namelist 
)

Definition at line 3365 of file varlena.c.

References canonicalize_path(), lappend(), MAXPGPATH, memmove, NIL, NULL, and pstrdup().

Referenced by PostmasterMain().

3367 {
3368  char *nextp = rawstring;
3369  bool done = false;
3370 
3371  *namelist = NIL;
3372 
3373  while (isspace((unsigned char) *nextp))
3374  nextp++; /* skip leading whitespace */
3375 
3376  if (*nextp == '\0')
3377  return true; /* allow empty string */
3378 
3379  /* At the top of the loop, we are at start of a new directory. */
3380  do
3381  {
3382  char *curname;
3383  char *endp;
3384 
3385  if (*nextp == '"')
3386  {
3387  /* Quoted name --- collapse quote-quote pairs */
3388  curname = nextp + 1;
3389  for (;;)
3390  {
3391  endp = strchr(nextp + 1, '"');
3392  if (endp == NULL)
3393  return false; /* mismatched quotes */
3394  if (endp[1] != '"')
3395  break; /* found end of quoted name */
3396  /* Collapse adjacent quotes into one quote, and look again */
3397  memmove(endp, endp + 1, strlen(endp));
3398  nextp = endp;
3399  }
3400  /* endp now points at the terminating quote */
3401  nextp = endp + 1;
3402  }
3403  else
3404  {
3405  /* Unquoted name --- extends to separator or end of string */
3406  curname = endp = nextp;
3407  while (*nextp && *nextp != separator)
3408  {
3409  /* trailing whitespace should not be included in name */
3410  if (!isspace((unsigned char) *nextp))
3411  endp = nextp + 1;
3412  nextp++;
3413  }
3414  if (curname == endp)
3415  return false; /* empty unquoted name not allowed */
3416  }
3417 
3418  while (isspace((unsigned char) *nextp))
3419  nextp++; /* skip trailing whitespace */
3420 
3421  if (*nextp == separator)
3422  {
3423  nextp++;
3424  while (isspace((unsigned char) *nextp))
3425  nextp++; /* skip leading whitespace for next */
3426  /* we expect another name, so done remains false */
3427  }
3428  else if (*nextp == '\0')
3429  done = true;
3430  else
3431  return false; /* invalid syntax */
3432 
3433  /* Now safe to overwrite separator with a null */
3434  *endp = '\0';
3435 
3436  /* Truncate path if it's overlength */
3437  if (strlen(curname) >= MAXPGPATH)
3438  curname[MAXPGPATH - 1] = '\0';
3439 
3440  /*
3441  * Finished isolating current name --- add it to list
3442  */
3443  curname = pstrdup(curname);
3444  canonicalize_path(curname);
3445  *namelist = lappend(*namelist, curname);
3446 
3447  /* Loop back if we didn't reach end of string */
3448  } while (!done);
3449 
3450  return true;
3451 }
#define NIL
Definition: pg_list.h:69
char * pstrdup(const char *in)
Definition: mcxt.c:1077
void canonicalize_path(char *path)
Definition: path.c:254
#define MAXPGPATH
#define memmove(d, s, c)
Definition: c.h:1058
List * lappend(List *list, void *datum)
Definition: list.c:128
#define NULL
Definition: c.h:229
bool SplitIdentifierString ( char *  rawstring,
char  separator,
List **  namelist 
)

Definition at line 3240 of file varlena.c.

References Assert, downcase_truncate_identifier(), lappend(), memmove, NIL, NULL, pfree(), and truncate_identifier().

Referenced by check_datestyle(), check_log_destination(), check_search_path(), check_temp_tablespaces(), check_wal_consistency_checking(), ExtractExtensionList(), load_libraries(), parse_extension_control_file(), parse_hba_auth_opt(), parse_output_parameters(), plpgsql_extra_checks_check_hook(), PostmasterMain(), PrepareTempTablespaces(), recomputeNamespacePath(), stringToQualifiedNameList(), and textToQualifiedNameList().

3242 {
3243  char *nextp = rawstring;
3244  bool done = false;
3245 
3246  *namelist = NIL;
3247 
3248  while (isspace((unsigned char) *nextp))
3249  nextp++; /* skip leading whitespace */
3250 
3251  if (*nextp == '\0')
3252  return true; /* allow empty string */
3253 
3254  /* At the top of the loop, we are at start of a new identifier. */
3255  do
3256  {
3257  char *curname;
3258  char *endp;
3259 
3260  if (*nextp == '"')
3261  {
3262  /* Quoted name --- collapse quote-quote pairs, no downcasing */
3263  curname = nextp + 1;
3264  for (;;)
3265  {
3266  endp = strchr(nextp + 1, '"');
3267  if (endp == NULL)
3268  return false; /* mismatched quotes */
3269  if (endp[1] != '"')
3270  break; /* found end of quoted name */
3271  /* Collapse adjacent quotes into one quote, and look again */
3272  memmove(endp, endp + 1, strlen(endp));
3273  nextp = endp;
3274  }
3275  /* endp now points at the terminating quote */
3276  nextp = endp + 1;
3277  }
3278  else
3279  {
3280  /* Unquoted name --- extends to separator or whitespace */
3281  char *downname;
3282  int len;
3283 
3284  curname = nextp;
3285  while (*nextp && *nextp != separator &&
3286  !isspace((unsigned char) *nextp))
3287  nextp++;
3288  endp = nextp;
3289  if (curname == nextp)
3290  return false; /* empty unquoted name not allowed */
3291 
3292  /*
3293  * Downcase the identifier, using same code as main lexer does.
3294  *
3295  * XXX because we want to overwrite the input in-place, we cannot
3296  * support a downcasing transformation that increases the string
3297  * length. This is not a problem given the current implementation
3298  * of downcase_truncate_identifier, but we'll probably have to do
3299  * something about this someday.
3300  */
3301  len = endp - curname;
3302  downname = downcase_truncate_identifier(curname, len, false);
3303  Assert(strlen(downname) <= len);
3304  strncpy(curname, downname, len); /* strncpy is required here */
3305  pfree(downname);
3306  }
3307 
3308  while (isspace((unsigned char) *nextp))
3309  nextp++; /* skip trailing whitespace */
3310 
3311  if (*nextp == separator)
3312  {
3313  nextp++;
3314  while (isspace((unsigned char) *nextp))
3315  nextp++; /* skip leading whitespace for next */
3316  /* we expect another name, so done remains false */
3317  }
3318  else if (*nextp == '\0')
3319  done = true;
3320  else
3321  return false; /* invalid syntax */
3322 
3323  /* Now safe to overwrite separator with a null */
3324  *endp = '\0';
3325 
3326  /* Truncate name if it's overlength */
3327  truncate_identifier(curname, strlen(curname), false);
3328 
3329  /*
3330  * Finished isolating current name --- add it to list
3331  */
3332  *namelist = lappend(*namelist, curname);
3333 
3334  /* Loop back if we didn't reach end of string */
3335  } while (!done);
3336 
3337  return true;
3338 }
#define NIL
Definition: pg_list.h:69
char * downcase_truncate_identifier(const char *ident, int len, bool warn)
Definition: scansup.c:131
void truncate_identifier(char *ident, int len, bool warn)
Definition: scansup.c:187
void pfree(void *pointer)
Definition: mcxt.c:950
#define memmove(d, s, c)
Definition: c.h:1058
List * lappend(List *list, void *datum)
Definition: list.c:128
#define NULL
Definition: c.h:229
#define Assert(condition)
Definition: c.h:675
Datum string_agg_finalfn ( PG_FUNCTION_ARGS  )

Definition at line 4688 of file varlena.c.

References AggCheckCallContext(), Assert, cstring_to_text_with_len(), StringInfoData::data, StringInfoData::len, NULL, PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_TEXT_P.

4689 {
4690  StringInfo state;
4691 
4692  /* cannot be called directly because of internal-type argument */
4693  Assert(AggCheckCallContext(fcinfo, NULL));
4694 
4695  state = PG_ARGISNULL(0) ? NULL : (StringInfo) PG_GETARG_POINTER(0);
4696 
4697  if (state != NULL)
4699  else
4700  PG_RETURN_NULL();
4701 }
StringInfoData * StringInfo
Definition: stringinfo.h:46
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:241
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:161
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
#define PG_ARGISNULL(n)
Definition: fmgr.h:174
#define NULL
Definition: c.h:229
#define Assert(condition)
Definition: c.h:675
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
Definition: nodeAgg.c:4018
#define PG_RETURN_NULL()
Definition: fmgr.h:305
Datum string_agg_transfn ( PG_FUNCTION_ARGS  )

Definition at line 4662 of file varlena.c.

References appendStringInfoText(), makeStringAggState(), NULL, PG_ARGISNULL, PG_GETARG_POINTER, PG_GETARG_TEXT_PP, and PG_RETURN_POINTER.

4663 {
4664  StringInfo state;
4665 
4666  state = PG_ARGISNULL(0) ? NULL : (StringInfo) PG_GETARG_POINTER(0);
4667 
4668  /* Append the value unless null. */
4669  if (!PG_ARGISNULL(1))
4670  {
4671  /* On the first time through, we ignore the delimiter. */
4672  if (state == NULL)
4673  state = makeStringAggState(fcinfo);
4674  else if (!PG_ARGISNULL(2))
4675  appendStringInfoText(state, PG_GETARG_TEXT_PP(2)); /* delimiter */
4676 
4677  appendStringInfoText(state, PG_GETARG_TEXT_PP(1)); /* value */
4678  }
4679 
4680  /*
4681  * The transition type for string_agg() is declared to be "internal",
4682  * which is a pass-by-value type the same size as a pointer.
4683  */
4684  PG_RETURN_POINTER(state);
4685 }
#define PG_RETURN_POINTER(x)
Definition: fmgr.h:321
StringInfoData * StringInfo
Definition: stringinfo.h:46
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:241
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static void appendStringInfoText(StringInfo str, const text *t)
Definition: varlena.c:3651
#define PG_ARGISNULL(n)
Definition: fmgr.h:174
#define NULL
Definition: c.h:229
static StringInfo makeStringAggState(FunctionCallInfo fcinfo)
Definition: varlena.c:4638
static text * text_catenate ( text t1,
text t2 
)
static

Definition at line 694 of file varlena.c.

References palloc(), result, SET_VARSIZE, VARDATA, VARDATA_ANY, VARHDRSZ, and VARSIZE_ANY_EXHDR.

Referenced by text_overlay(), and textcat().

695 {
696  text *result;
697  int len1,
698  len2,
699  len;
700  char *ptr;
701 
702  len1 = VARSIZE_ANY_EXHDR(t1);
703  len2 = VARSIZE_ANY_EXHDR(t2);
704 
705  /* paranoia ... probably should throw error instead? */
706  if (len1 < 0)
707  len1 = 0;
708  if (len2 < 0)
709  len2 = 0;
710 
711  len = len1 + len2 + VARHDRSZ;
712  result = (text *) palloc(len);
713 
714  /* Set size of result string... */
715  SET_VARSIZE(result, len);
716 
717  /* Fill data field of result string... */
718  ptr = VARDATA(result);
719  if (len1 > 0)
720  memcpy(ptr, VARDATA_ANY(t1), len1);
721  if (len2 > 0)
722  memcpy(ptr + len1, VARDATA_ANY(t2), len2);
723 
724  return result;
725 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define VARDATA(PTR)
Definition: postgres.h:303
#define VARHDRSZ
Definition: c.h:445
return result
Definition: formatting.c:1618
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
void * palloc(Size size)
Definition: mcxt.c:849
Definition: c.h:439
#define SET_VARSIZE(PTR, len)
Definition: postgres.h:328
static int text_cmp ( text arg1,
text arg2,
Oid  collid 
)
static

Definition at line 1611 of file varlena.c.

References VARDATA_ANY, VARSIZE_ANY_EXHDR, and varstr_cmp().

Referenced by bttextcmp(), text_ge(), text_gt(), text_larger(), text_le(), text_lt(), and text_smaller().

1612 {
1613  char *a1p,
1614  *a2p;
1615  int len1,
1616  len2;
1617 
1618  a1p = VARDATA_ANY(arg1);
1619  a2p = VARDATA_ANY(arg2);
1620 
1621  len1 = VARSIZE_ANY_EXHDR(arg1);
1622  len2 = VARSIZE_ANY_EXHDR(arg2);
1623 
1624  return varstr_cmp(a1p, len1, a2p, len2, collid);
1625 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
int varstr_cmp(char *arg1, int len1, char *arg2, int len2, Oid collid)
Definition: varlena.c:1382
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
Datum text_concat ( PG_FUNCTION_ARGS  )

Definition at line 4792 of file varlena.c.

References concat_internal(), NULL, PG_RETURN_NULL, PG_RETURN_TEXT_P, and result.

4793 {
4794  text *result;
4795 
4796  result = concat_internal("", 0, fcinfo);
4797  if (result == NULL)
4798  PG_RETURN_NULL();
4799  PG_RETURN_TEXT_P(result);
4800 }
return result
Definition: formatting.c:1618
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
#define NULL
Definition: c.h:229
static text * concat_internal(const char *sepstr, int argidx, FunctionCallInfo fcinfo)
Definition: varlena.c:4711
Definition: c.h:439
#define PG_RETURN_NULL()
Definition: fmgr.h:305
Datum text_concat_ws ( PG_FUNCTION_ARGS  )

Definition at line 4807 of file varlena.c.

References concat_internal(), NULL, PG_ARGISNULL, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, result, and text_to_cstring().

4808 {
4809  char *sep;
4810  text *result;
4811 
4812  /* return NULL when separator is NULL */
4813  if (PG_ARGISNULL(0))
4814  PG_RETURN_NULL();
4816 
4817  result = concat_internal(sep, 1, fcinfo);
4818  if (result == NULL)
4819  PG_RETURN_NULL();
4820  PG_RETURN_TEXT_P(result);
4821 }
return result
Definition: formatting.c:1618
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
#define PG_ARGISNULL(n)
Definition: fmgr.h:174
#define NULL
Definition: c.h:229
static text * concat_internal(const char *sepstr, int argidx, FunctionCallInfo fcinfo)
Definition: varlena.c:4711
char * text_to_cstring(const text *t)
Definition: varlena.c:182
Definition: c.h:439
#define PG_RETURN_NULL()
Definition: fmgr.h:305
Datum text_format ( PG_FUNCTION_ARGS  )

Definition at line 4924 of file varlena.c.

References ADVANCE_PARSE_POINTER, appendStringInfoCharMacro, arg, ARR_ELEMTYPE, Assert, cstring_to_text_with_len(), StringInfoData::data, DatumGetInt16, DatumGetInt32, deconstruct_array(), elog, ereport, errcode(), errhint(), errmsg(), ERROR, fmgr_info(), get_base_element_type(), get_fn_expr_argtype(), get_fn_expr_variadic(), get_typlenbyvalalign(), getTypeOutputInfo(), initStringInfo(), INT2OID, INT4OID, InvalidOid, StringInfoData::len, NULL, OidIsValid, OutputFunctionCall(), pfree(), PG_ARGISNULL, pg_atoi(), PG_GETARG_ARRAYTYPE_P, PG_GETARG_DATUM, PG_GETARG_TEXT_PP, PG_NARGS, PG_RETURN_NULL, PG_RETURN_TEXT_P, result, text_format_parse_format(), text_format_string_conversion(), value, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by text_format_nv().

4925 {
4926  text *fmt;
4927  StringInfoData str;
4928  const char *cp;
4929  const char *start_ptr;
4930  const char *end_ptr;
4931  text *result;
4932  int arg;
4933  bool funcvariadic;
4934  int nargs;
4935  Datum *elements = NULL;
4936  bool *nulls = NULL;
4937  Oid element_type = InvalidOid;
4938  Oid prev_type = InvalidOid;
4939  Oid prev_width_type = InvalidOid;
4940  FmgrInfo typoutputfinfo;
4941  FmgrInfo typoutputinfo_width;
4942 
4943  /* When format string is null, immediately return null */
4944  if (PG_ARGISNULL(0))
4945  PG_RETURN_NULL();
4946 
4947  /* If argument is marked VARIADIC, expand array into elements */
4948  if (get_fn_expr_variadic(fcinfo->flinfo))
4949  {
4950  ArrayType *arr;
4951  int16 elmlen;
4952  bool elmbyval;
4953  char elmalign;
4954  int nitems;
4955 
4956  /* Should have just the one argument */
4957  Assert(PG_NARGS() == 2);
4958 
4959  /* If argument is NULL, we treat it as zero-length array */
4960  if (PG_ARGISNULL(1))
4961  nitems = 0;
4962  else
4963  {
4964  /*
4965  * Non-null argument had better be an array. We assume that any
4966  * call context that could let get_fn_expr_variadic return true
4967  * will have checked that a VARIADIC-labeled parameter actually is
4968  * an array. So it should be okay to just Assert that it's an
4969  * array rather than doing a full-fledged error check.
4970  */
4972 
4973  /* OK, safe to fetch the array value */
4974  arr = PG_GETARG_ARRAYTYPE_P(1);
4975 
4976  /* Get info about array element type */
4977  element_type = ARR_ELEMTYPE(arr);
4978  get_typlenbyvalalign(element_type,
4979  &elmlen, &elmbyval, &elmalign);
4980 
4981  /* Extract all array elements */
4982  deconstruct_array(arr, element_type, elmlen, elmbyval, elmalign,
4983  &elements, &nulls, &nitems);
4984  }
4985 
4986  nargs = nitems + 1;
4987  funcvariadic = true;
4988  }
4989  else
4990  {
4991  /* Non-variadic case, we'll process the arguments individually */
4992  nargs = PG_NARGS();
4993  funcvariadic = false;
4994  }
4995 
4996  /* Setup for main loop. */
4997  fmt = PG_GETARG_TEXT_PP(0);
4998  start_ptr = VARDATA_ANY(fmt);
4999  end_ptr = start_ptr + VARSIZE_ANY_EXHDR(fmt);
5000  initStringInfo(&str);
5001  arg = 1; /* next argument position to print */
5002 
5003  /* Scan format string, looking for conversion specifiers. */
5004  for (cp = start_ptr; cp < end_ptr; cp++)
5005  {
5006  int argpos;
5007  int widthpos;
5008  int flags;
5009  int width;
5010  Datum value;
5011  bool isNull;
5012  Oid typid;
5013 
5014  /*
5015  * If it's not the start of a conversion specifier, just copy it to
5016  * the output buffer.
5017  */
5018  if (*cp != '%')
5019  {
5020  appendStringInfoCharMacro(&str, *cp);
5021  continue;
5022  }
5023 
5024  ADVANCE_PARSE_POINTER(cp, end_ptr);
5025 
5026  /* Easy case: %% outputs a single % */
5027  if (*cp == '%')
5028  {
5029  appendStringInfoCharMacro(&str, *cp);
5030  continue;
5031  }
5032 
5033  /* Parse the optional portions of the format specifier */
5034  cp = text_format_parse_format(cp, end_ptr,
5035  &argpos, &widthpos,
5036  &flags, &width);
5037 
5038  /*
5039  * Next we should see the main conversion specifier. Whether or not
5040  * an argument position was present, it's known that at least one
5041  * character remains in the string at this point. Experience suggests
5042  * that it's worth checking that that character is one of the expected
5043  * ones before we try to fetch arguments, so as to produce the least
5044  * confusing response to a mis-formatted specifier.
5045  */
5046  if (strchr("sIL", *cp) == NULL)
5047  ereport(ERROR,
5048  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5049  errmsg("unrecognized format() type specifier \"%c\"",
5050  *cp),
5051  errhint("For a single \"%%\" use \"%%%%\".")));
5052 
5053  /* If indirect width was specified, get its value */
5054  if (widthpos >= 0)
5055  {
5056  /* Collect the specified or next argument position */
5057  if (widthpos > 0)
5058  arg = widthpos;
5059  if (arg >= nargs)
5060  ereport(ERROR,
5061  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5062  errmsg("too few arguments for format()")));
5063 
5064  /* Get the value and type of the selected argument */
5065  if (!funcvariadic)
5066  {
5067  value = PG_GETARG_DATUM(arg);
5068  isNull = PG_ARGISNULL(arg);
5069  typid = get_fn_expr_argtype(fcinfo->flinfo, arg);
5070  }
5071  else
5072  {
5073  value = elements[arg - 1];
5074  isNull = nulls[arg - 1];
5075  typid = element_type;
5076  }
5077  if (!OidIsValid(typid))
5078  elog(ERROR, "could not determine data type of format() input");
5079 
5080  arg++;
5081 
5082  /* We can treat NULL width the same as zero */
5083  if (isNull)
5084  width = 0;
5085  else if (typid == INT4OID)
5086  width = DatumGetInt32(value);
5087  else if (typid == INT2OID)
5088  width = DatumGetInt16(value);
5089  else
5090  {
5091  /* For less-usual datatypes, convert to text then to int */
5092  char *str;
5093 
5094  if (typid != prev_width_type)
5095  {
5096  Oid typoutputfunc;
5097  bool typIsVarlena;
5098 
5099  getTypeOutputInfo(typid, &typoutputfunc, &typIsVarlena);
5100  fmgr_info(typoutputfunc, &typoutputinfo_width);
5101  prev_width_type = typid;
5102  }
5103 
5104  str = OutputFunctionCall(&typoutputinfo_width, value);
5105 
5106  /* pg_atoi will complain about bad data or overflow */
5107  width = pg_atoi(str, sizeof(int), '\0');
5108 
5109  pfree(str);
5110  }
5111  }
5112 
5113  /* Collect the specified or next argument position */
5114  if (argpos > 0)
5115  arg = argpos;
5116  if (arg >= nargs)
5117  ereport(ERROR,
5118  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5119  errmsg("too few arguments for format()")));
5120 
5121  /* Get the value and type of the selected argument */
5122  if (!funcvariadic)
5123  {
5124  value = PG_GETARG_DATUM(arg);
5125  isNull = PG_ARGISNULL(arg);
5126  typid = get_fn_expr_argtype(fcinfo->flinfo, arg);
5127  }
5128  else
5129  {
5130  value = elements[arg - 1];
5131  isNull = nulls[arg - 1];
5132  typid = element_type;
5133  }
5134  if (!OidIsValid(typid))
5135  elog(ERROR, "could not determine data type of format() input");
5136 
5137  arg++;
5138 
5139  /*
5140  * Get the appropriate typOutput function, reusing previous one if
5141  * same type as previous argument. That's particularly useful in the
5142  * variadic-array case, but often saves work even for ordinary calls.
5143  */
5144  if (typid != prev_type)
5145  {
5146  Oid typoutputfunc;
5147  bool typIsVarlena;
5148 
5149  getTypeOutputInfo(typid, &typoutputfunc, &typIsVarlena);
5150  fmgr_info(typoutputfunc, &typoutputfinfo);
5151  prev_type = typid;
5152  }
5153 
5154  /*
5155  * And now we can format the value.
5156  */
5157  switch (*cp)
5158  {
5159  case 's':
5160  case 'I':
5161  case 'L':
5162  text_format_string_conversion(&str, *cp, &typoutputfinfo,
5163  value, isNull,
5164  flags, width);
5165  break;
5166  default:
5167  /* should not get here, because of previous check */
5168  ereport(ERROR,
5169  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5170  errmsg("unrecognized format() type specifier \"%c\"",
5171  *cp),
5172  errhint("For a single \"%%\" use \"%%%%\".")));
5173  break;
5174  }
5175  }
5176 
5177  /* Don't need deconstruct_array results anymore. */
5178  if (elements != NULL)
5179  pfree(elements);
5180  if (nulls != NULL)
5181  pfree(nulls);
5182 
5183  /* Generate results. */
5184  result = cstring_to_text_with_len(str.data, str.len);
5185  pfree(str.data);
5186 
5187  PG_RETURN_TEXT_P(result);
5188 }
signed short int16
Definition: c.h:255
#define ADVANCE_PARSE_POINTER(ptr, end_ptr)
Definition: varlena.c:4911
Definition: fmgr.h:56
int errhint(const char *fmt,...)
Definition: elog.c:987
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
Definition: lsyscache.c:2632
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define DatumGetInt32(X)
Definition: postgres.h:478
static void text_format_string_conversion(StringInfo buf, char conversion, FmgrInfo *typOutputInfo, Datum value, bool isNull, int flags, int width)
Definition: varlena.c:5327
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
Definition: lsyscache.c:2021
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:233
#define INT4OID
Definition: pg_type.h:316
bool get_fn_expr_variadic(FmgrInfo *flinfo)
Definition: fmgr.c:2051
int errcode(int sqlerrcode)
Definition: elog.c:575
return result
Definition: formatting.c:1618
unsigned int Oid
Definition: postgres_ext.h:31
#define OidIsValid(objectId)
Definition: c.h:538
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
char * OutputFunctionCall(FmgrInfo *flinfo, Datum val)
Definition: fmgr.c:1667
#define PG_GETARG_ARRAYTYPE_P(n)
Definition: array.h:244
#define appendStringInfoCharMacro(str, ch)
Definition: stringinfo.h:135
void pfree(void *pointer)
Definition: mcxt.c:950
#define ERROR
Definition: elog.h:43
Oid get_fn_expr_argtype(FmgrInfo *flinfo, int argnum)
Definition: fmgr.c:1909
void fmgr_info(Oid functionId, FmgrInfo *finfo)
Definition: fmgr.c:127
#define INT2OID
Definition: pg_type.h:308
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:161
#define DatumGetInt16(X)
Definition: postgres.h:450
#define ereport(elevel, rest)
Definition: elog.h:122
void initStringInfo(StringInfo str)
Definition: stringinfo.c:65
uintptr_t Datum
Definition: postgres.h:372
#define InvalidOid
Definition: postgres_ext.h:36
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
#define PG_ARGISNULL(n)
Definition: fmgr.h:174
#define NULL
Definition: c.h:229
#define Assert(condition)
Definition: c.h:675
#define PG_NARGS()
Definition: fmgr.h:168
void deconstruct_array(ArrayType *array, Oid elmtype, int elmlen, bool elmbyval, char elmalign, Datum **elemsp, bool **nullsp, int *nelemsp)
Definition: arrayfuncs.c:3475
Oid get_base_element_type(Oid typid)
Definition: lsyscache.c:2557
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
int errmsg(const char *fmt,...)
Definition: elog.c:797
void * arg
Definition: c.h:439
#define elog
Definition: elog.h:219
static const char * text_format_parse_format(const char *start_ptr, const char *end_ptr, int *argpos, int *widthpos, int *flags, int *width)
Definition: varlena.c:5250
static struct @121 value
#define ARR_ELEMTYPE(a)
Definition: array.h:273
#define PG_RETURN_NULL()
Definition: fmgr.h:305
int32 pg_atoi(const char *s, int size, int c)
Definition: numutils.c:37
static void text_format_append_string ( StringInfo  buf,
const char *  str,
int  flags,
int  width 
)
static

Definition at line 5376 of file varlena.c.

References appendStringInfoSpaces(), appendStringInfoString(), ereport, errcode(), errmsg(), ERROR, pg_mbstrlen(), and TEXT_FORMAT_FLAG_MINUS.

Referenced by text_format_string_conversion().

5378 {
5379  bool align_to_left = false;
5380  int len;
5381 
5382  /* fast path for typical easy case */
5383  if (width == 0)
5384  {
5385  appendStringInfoString(buf, str);
5386  return;
5387  }
5388 
5389  if (width < 0)
5390  {
5391  /* Negative width: implicit '-' flag, then take absolute value */
5392  align_to_left = true;
5393  /* -INT_MIN is undefined */
5394  if (width <= INT_MIN)
5395  ereport(ERROR,
5396  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
5397  errmsg("number is out of range")));
5398  width = -width;
5399  }
5400  else if (flags & TEXT_FORMAT_FLAG_MINUS)
5401  align_to_left = true;
5402 
5403  len = pg_mbstrlen(str);
5404  if (align_to_left)
5405  {
5406  /* left justify */
5407  appendStringInfoString(buf, str);
5408  if (len < width)
5409  appendStringInfoSpaces(buf, width - len);
5410  }
5411  else
5412  {
5413  /* right justify */
5414  if (len < width)
5415  appendStringInfoSpaces(buf, width - len);
5416  appendStringInfoString(buf, str);
5417  }
5418 }
int errcode(int sqlerrcode)
Definition: elog.c:575
#define ERROR
Definition: elog.h:43
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:189
#define ereport(elevel, rest)
Definition: elog.h:122
void appendStringInfoSpaces(StringInfo str, int count)
Definition: stringinfo.c:219
int pg_mbstrlen(const char *mbstr)
Definition: mbutils.c:785
int errmsg(const char *fmt,...)
Definition: elog.c:797
#define TEXT_FORMAT_FLAG_MINUS
Definition: varlena.c:4909
Datum text_format_nv ( PG_FUNCTION_ARGS  )

Definition at line 5428 of file varlena.c.

References text_format().

5429 {
5430  return text_format(fcinfo);
5431 }
Datum text_format(PG_FUNCTION_ARGS)
Definition: varlena.c:4924
static bool text_format_parse_digits ( const char **  ptr,
const char *  end_ptr,
int *  value 
)
static

Definition at line 5201 of file varlena.c.

References ADVANCE_PARSE_POINTER, ereport, errcode(), errmsg(), ERROR, newval, and val.

Referenced by text_format_parse_format().

5202 {
5203  bool found = false;
5204  const char *cp = *ptr;
5205  int val = 0;
5206 
5207  while (*cp >= '0' && *cp <= '9')
5208  {
5209  int newval = val * 10 + (*cp - '0');
5210 
5211  if (newval / 10 != val) /* overflow? */
5212  ereport(ERROR,
5213  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
5214  errmsg("number is out of range")));
5215  val = newval;
5216  ADVANCE_PARSE_POINTER(cp, end_ptr);
5217  found = true;
5218  }
5219 
5220  *ptr = cp;
5221  *value = val;
5222 
5223  return found;
5224 }
#define ADVANCE_PARSE_POINTER(ptr, end_ptr)
Definition: varlena.c:4911
int errcode(int sqlerrcode)
Definition: elog.c:575
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:122
#define newval
int errmsg(const char *fmt,...)
Definition: elog.c:797
static struct @121 value
long val
Definition: informix.c:689
static const char * text_format_parse_format ( const char *  start_ptr,
const char *  end_ptr,
int *  argpos,
int *  widthpos,
int *  flags,
int *  width 
)
static

Definition at line 5250 of file varlena.c.

References ADVANCE_PARSE_POINTER, ereport, errcode(), errmsg(), ERROR, TEXT_FORMAT_FLAG_MINUS, and text_format_parse_digits().

Referenced by text_format().

5253 {
5254  const char *cp = start_ptr;
5255  int n;
5256 
5257  /* set defaults for output parameters */
5258  *argpos = -1;
5259  *widthpos = -1;
5260  *flags = 0;
5261  *width = 0;
5262 
5263  /* try to identify first number */
5264  if (text_format_parse_digits(&cp, end_ptr, &n))
5265  {
5266  if (*cp != '$')
5267  {
5268  /* Must be just a width and a type, so we're done */
5269  *width = n;
5270  return cp;
5271  }
5272  /* The number was argument position */
5273  *argpos = n;
5274  /* Explicit 0 for argument index is immediately refused */
5275  if (n == 0)
5276  ereport(ERROR,
5277  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5278  errmsg("format specifies argument 0, but arguments are numbered from 1")));
5279  ADVANCE_PARSE_POINTER(cp, end_ptr);
5280  }
5281 
5282  /* Handle flags (only minus is supported now) */
5283  while (*cp == '-')
5284  {
5285  *flags |= TEXT_FORMAT_FLAG_MINUS;
5286  ADVANCE_PARSE_POINTER(cp, end_ptr);
5287  }
5288 
5289  if (*cp == '*')
5290  {
5291  /* Handle indirect width */
5292  ADVANCE_PARSE_POINTER(cp, end_ptr);
5293  if (text_format_parse_digits(&cp, end_ptr, &n))
5294  {
5295  /* number in this position must be closed by $ */
5296  if (*cp != '$')
5297  ereport(ERROR,
5298  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5299  errmsg("width argument position must be ended by \"$\"")));
5300  /* The number was width argument position */
5301  *widthpos = n;
5302  /* Explicit 0 for argument index is immediately refused */
5303  if (n == 0)
5304  ereport(ERROR,
5305  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5306  errmsg("format specifies argument 0, but arguments are numbered from 1")));
5307  ADVANCE_PARSE_POINTER(cp, end_ptr);
5308  }
5309  else
5310  *widthpos = 0; /* width's argument position is unspecified */
5311  }
5312  else
5313  {
5314  /* Check for direct width specification */
5315  if (text_format_parse_digits(&cp, end_ptr, &n))
5316  *width = n;
5317  }
5318 
5319  /* cp should now be pointing at type character */
5320  return cp;
5321 }
#define ADVANCE_PARSE_POINTER(ptr, end_ptr)
Definition: varlena.c:4911
int errcode(int sqlerrcode)
Definition: elog.c:575
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:122
static bool text_format_parse_digits(const char **ptr, const char *end_ptr, int *value)
Definition: varlena.c:5201
int errmsg(const char *fmt,...)
Definition: elog.c:797
#define TEXT_FORMAT_FLAG_MINUS
Definition: varlena.c:4909
static void text_format_string_conversion ( StringInfo  buf,
char  conversion,
FmgrInfo typOutputInfo,
Datum  value,
bool  isNull,
int  flags,
int  width 
)
static

Definition at line 5327 of file varlena.c.

References ereport, errcode(), errmsg(), ERROR, OutputFunctionCall(), pfree(), quote_identifier(), quote_literal_cstr(), and text_format_append_string().

Referenced by text_format().

5331 {
5332  char *str;
5333 
5334  /* Handle NULL arguments before trying to stringify the value. */
5335  if (isNull)
5336  {
5337  if (conversion == 's')
5338  text_format_append_string(buf, "", flags, width);
5339  else if (conversion == 'L')
5340  text_format_append_string(buf, "NULL", flags, width);
5341  else if (conversion == 'I')
5342  ereport(ERROR,
5343  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
5344  errmsg("null values cannot be formatted as an SQL identifier")));
5345  return;
5346  }
5347 
5348  /* Stringify. */
5349  str = OutputFunctionCall(typOutputInfo, value);
5350 
5351  /* Escape. */
5352  if (conversion == 'I')
5353  {
5354  /* quote_identifier may or may not allocate a new string. */
5355  text_format_append_string(buf, quote_identifier(str), flags, width);
5356  }
5357  else if (conversion == 'L')
5358  {
5359  char *qstr = quote_literal_cstr(str);
5360 
5361  text_format_append_string(buf, qstr, flags, width);
5362  /* quote_literal_cstr() always allocates a new string */
5363  pfree(qstr);
5364  }
5365  else
5366  text_format_append_string(buf, str, flags, width);
5367 
5368  /* Cleanup. */
5369  pfree(str);
5370 }
char * quote_literal_cstr(const char *rawstr)
Definition: quote.c:102
const char * quote_identifier(const char *ident)
Definition: ruleutils.c:10254
int errcode(int sqlerrcode)
Definition: elog.c:575
static void text_format_append_string(StringInfo buf, const char *str, int flags, int width)
Definition: varlena.c:5376
char * OutputFunctionCall(FmgrInfo *flinfo, Datum val)
Definition: fmgr.c:1667
void pfree(void *pointer)
Definition: mcxt.c:950
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:122
int errmsg(const char *fmt,...)
Definition: elog.c:797
static struct @121 value
Datum text_ge ( PG_FUNCTION_ARGS  )

Definition at line 1745 of file varlena.c.

References PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, result, and text_cmp().

Referenced by gbt_textge().

1746 {
1747  text *arg1 = PG_GETARG_TEXT_PP(0);
1748  text *arg2 = PG_GETARG_TEXT_PP(1);
1749  bool result;
1750 
1751  result = (text_cmp(arg1, arg2, PG_GET_COLLATION()) >= 0);
1752 
1753  PG_FREE_IF_COPY(arg1, 0);
1754  PG_FREE_IF_COPY(arg2, 1);
1755 
1756  PG_RETURN_BOOL(result);
1757 }
return result
Definition: formatting.c:1618
#define PG_GET_COLLATION()
Definition: fmgr.h:163
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int text_cmp(text *arg1, text *arg2, Oid collid)
Definition: varlena.c:1611
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:319
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
Definition: c.h:439
Datum text_gt ( PG_FUNCTION_ARGS  )

Definition at line 1730 of file varlena.c.

References PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, result, and text_cmp().

Referenced by gbt_textgt().

1731 {
1732  text *arg1 = PG_GETARG_TEXT_PP(0);
1733  text *arg2 = PG_GETARG_TEXT_PP(1);
1734  bool result;
1735 
1736  result = (text_cmp(arg1, arg2, PG_GET_COLLATION()) > 0);
1737 
1738  PG_FREE_IF_COPY(arg1, 0);
1739  PG_FREE_IF_COPY(arg2, 1);
1740 
1741  PG_RETURN_BOOL(result);
1742 }
return result
Definition: formatting.c:1618
#define PG_GET_COLLATION()
Definition: fmgr.h:163
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int text_cmp(text *arg1, text *arg2, Oid collid)
Definition: varlena.c:1611
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:319
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
Definition: c.h:439
static bool text_isequal ( text txt1,
text txt2 
)
static

Definition at line 4118 of file varlena.c.

References DatumGetBool, DirectFunctionCall2, PointerGetDatum, and texteq().

Referenced by text_to_array_internal().

4119 {
4121  PointerGetDatum(txt1),
4122  PointerGetDatum(txt2)));
4123 }
#define PointerGetDatum(X)
Definition: postgres.h:562
Datum texteq(PG_FUNCTION_ARGS)
Definition: varlena.c:1636
#define DatumGetBool(X)
Definition: postgres.h:399
#define DirectFunctionCall2(func, arg1, arg2)
Definition: fmgr.h:586
Datum text_larger ( PG_FUNCTION_ARGS  )

Definition at line 2567 of file varlena.c.

References PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, result, and text_cmp().

2568 {
2569  text *arg1 = PG_GETARG_TEXT_PP(0);
2570  text *arg2 = PG_GETARG_TEXT_PP(1);
2571  text *result;
2572 
2573  result = ((text_cmp(arg1, arg2, PG_GET_COLLATION()) > 0) ? arg1 : arg2);
2574 
2575  PG_RETURN_TEXT_P(result);
2576 }
return result
Definition: formatting.c:1618
#define PG_GET_COLLATION()
Definition: fmgr.h:163
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int text_cmp(text *arg1, text *arg2, Oid collid)
Definition: varlena.c:1611
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
Definition: c.h:439
Datum text_le ( PG_FUNCTION_ARGS  )

Definition at line 1715 of file varlena.c.

References PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, result, and text_cmp().

Referenced by gbt_textle().

1716 {
1717  text *arg1 = PG_GETARG_TEXT_PP(0);
1718  text *arg2 = PG_GETARG_TEXT_PP(1);
1719  bool result;
1720 
1721  result = (text_cmp(arg1, arg2, PG_GET_COLLATION()) <= 0);
1722 
1723  PG_FREE_IF_COPY(arg1, 0);
1724  PG_FREE_IF_COPY(arg2, 1);
1725 
1726  PG_RETURN_BOOL(result);
1727 }
return result
Definition: formatting.c:1618
#define PG_GET_COLLATION()
Definition: fmgr.h:163
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int text_cmp(text *arg1, text *arg2, Oid collid)
Definition: varlena.c:1611
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:319
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
Definition: c.h:439
Datum text_left ( PG_FUNCTION_ARGS  )

Definition at line 4828 of file varlena.c.

References cstring_to_text_with_len(), PG_GETARG_INT32, PG_GETARG_TEXT_PP, pg_mbcharcliplen(), pg_mbstrlen_with_len(), PG_RETURN_TEXT_P, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

4829 {
4830  text *str = PG_GETARG_TEXT_PP(0);
4831  const char *p = VARDATA_ANY(str);
4832  int len = VARSIZE_ANY_EXHDR(str);
4833  int n = PG_GETARG_INT32(1);
4834  int rlen;
4835 
4836  if (n < 0)
4837  n = pg_mbstrlen_with_len(p, len) + n;
4838  rlen = pg_mbcharcliplen(p, len, n);
4839 
4841 }
#define PG_GETARG_INT32(n)
Definition: fmgr.h:234
int pg_mbcharcliplen(const char *mbstr, int len, int limit)
Definition: mbutils.c:873
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
int pg_mbstrlen_with_len(const char *mbstr, int limit)
Definition: mbutils.c:805
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:161
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
Definition: c.h:439
static int32 text_length ( Datum  str)
static

Definition at line 640 of file varlena.c.

References DatumGetTextPP, pg_database_encoding_max_length(), pg_mbstrlen_with_len(), PG_RETURN_INT32, toast_raw_datum_size(), VARDATA_ANY, VARHDRSZ, and VARSIZE_ANY_EXHDR.

Referenced by textlen(), and textoverlay_no_len().

641 {
642  /* fastpath when max encoding length is one */
645  else
646  {
647  text *t = DatumGetTextPP(str);
648 
650  VARSIZE_ANY_EXHDR(t)));
651  }
652 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define VARHDRSZ
Definition: c.h:445
#define DatumGetTextPP(X)
Definition: fmgr.h:256
#define PG_RETURN_INT32(x)
Definition: fmgr.h:314
int pg_mbstrlen_with_len(const char *mbstr, int limit)
Definition: mbutils.c:805
Size toast_raw_datum_size(Datum value)
Definition: tuptoaster.c:353
int pg_database_encoding_max_length(void)
Definition: wchar.c:1833
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
Definition: c.h:439
Datum text_lt ( PG_FUNCTION_ARGS  )

Definition at line 1700 of file varlena.c.

References PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, result, and text_cmp().

Referenced by gbt_textlt().

1701 {
1702  text *arg1 = PG_GETARG_TEXT_PP(0);
1703  text *arg2 = PG_GETARG_TEXT_PP(1);
1704  bool result;
1705 
1706  result = (text_cmp(arg1, arg2, PG_GET_COLLATION()) < 0);
1707 
1708  PG_FREE_IF_COPY(arg1, 0);
1709  PG_FREE_IF_COPY(arg2, 1);
1710 
1711  PG_RETURN_BOOL(result);
1712 }
return result
Definition: formatting.c:1618
#define PG_GET_COLLATION()
Definition: fmgr.h:163
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int text_cmp(text *arg1, text *arg2, Oid collid)
Definition: varlena.c:1611
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:319
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
Definition: c.h:439
Datum text_name ( PG_FUNCTION_ARGS  )

Definition at line 3142 of file varlena.c.

References NAMEDATALEN, NameStr, palloc0(), PG_GETARG_TEXT_PP, pg_mbcliplen(), PG_RETURN_NAME, result, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

3143 {
3144  text *s = PG_GETARG_TEXT_PP(0);
3145  Name result;
3146  int len;
3147 
3148  len = VARSIZE_ANY_EXHDR(s);
3149 
3150  /* Truncate oversize input */
3151  if (len >= NAMEDATALEN)
3152  len = pg_mbcliplen(VARDATA_ANY(s), len, NAMEDATALEN - 1);
3153 
3154  /* We use palloc0 here to ensure result is zero-padded */
3155  result = (Name) palloc0(NAMEDATALEN);
3156  memcpy(NameStr(*result), VARDATA_ANY(s), len);
3157 
3158  PG_RETURN_NAME(result);
3159 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
return result
Definition: formatting.c:1618
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
#define NAMEDATALEN
int pg_mbcliplen(const char *mbstr, int len, int limit)
Definition: mbutils.c:831
Definition: c.h:493
void * palloc0(Size size)
Definition: mcxt.c:878
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
#define NameStr(name)
Definition: c.h:499
Definition: c.h:439
NameData * Name
Definition: c.h:497
#define PG_RETURN_NAME(x)
Definition: fmgr.h:323
static text * text_overlay ( text t1,
text t2,
int  sp,
int  sl 
)
static

Definition at line 1034 of file varlena.c.

References ereport, errcode(), errmsg(), ERROR, PointerGetDatum, result, s1, s2, text_catenate(), and text_substring().

Referenced by textoverlay(), and textoverlay_no_len().

1035 {
1036  text *result;
1037  text *s1;
1038  text *s2;
1039  int sp_pl_sl;
1040 
1041  /*
1042  * Check for possible integer-overflow cases. For negative sp, throw a
1043  * "substring length" error because that's what should be expected
1044  * according to the spec's definition of OVERLAY().
1045  */
1046  if (sp <= 0)
1047  ereport(ERROR,
1048  (errcode(ERRCODE_SUBSTRING_ERROR),
1049  errmsg("negative substring length not allowed")));
1050  sp_pl_sl = sp + sl;
1051  if (sp_pl_sl <= sl)
1052  ereport(ERROR,
1053  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1054  errmsg("integer out of range")));
1055 
1056  s1 = text_substring(PointerGetDatum(t1), 1, sp - 1, false);
1057  s2 = text_substring(PointerGetDatum(t1), sp_pl_sl, -1, true);
1058  result = text_catenate(s1, t2);
1059  result = text_catenate(result, s2);
1060 
1061  return result;
1062 }
#define PointerGetDatum(X)
Definition: postgres.h:562
int errcode(int sqlerrcode)
Definition: elog.c:575
return result
Definition: formatting.c:1618
#define ERROR
Definition: elog.h:43
char * s1
static text * text_substring(Datum str, int32 start, int32 length, bool length_not_specified)
Definition: varlena.c:814
static text * text_catenate(text *t1, text *t2)
Definition: varlena.c:694
#define ereport(elevel, rest)
Definition: elog.h:122
char * s2
int errmsg(const char *fmt,...)
Definition: elog.c:797
Definition: c.h:439
Datum text_pattern_ge ( PG_FUNCTION_ARGS  )

Definition at line 2654 of file varlena.c.

References internal_text_pattern_compare(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, and result.

2655 {
2656  text *arg1 = PG_GETARG_TEXT_PP(0);
2657  text *arg2 = PG_GETARG_TEXT_PP(1);
2658  int result;
2659 
2660  result = internal_text_pattern_compare(arg1, arg2);
2661 
2662  PG_FREE_IF_COPY(arg1, 0);
2663  PG_FREE_IF_COPY(arg2, 1);
2664 
2665  PG_RETURN_BOOL(result >= 0);
2666 }
return result
Definition: formatting.c:1618
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int internal_text_pattern_compare(text *arg1, text *arg2)
Definition: varlena.c:2600
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:319
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
Definition: c.h:439
Datum text_pattern_gt ( PG_FUNCTION_ARGS  )

Definition at line 2670 of file varlena.c.

References internal_text_pattern_compare(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, and result.

2671 {
2672  text *arg1 = PG_GETARG_TEXT_PP(0);
2673  text *arg2 = PG_GETARG_TEXT_PP(1);
2674  int result;
2675 
2676  result = internal_text_pattern_compare(arg1, arg2);
2677 
2678  PG_FREE_IF_COPY(arg1, 0);
2679  PG_FREE_IF_COPY(arg2, 1);
2680 
2681  PG_RETURN_BOOL(result > 0);
2682 }
return result
Definition: formatting.c:1618
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int internal_text_pattern_compare(text *arg1, text *arg2)
Definition: varlena.c:2600
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:319
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
Definition: c.h:439
Datum text_pattern_le ( PG_FUNCTION_ARGS  )

Definition at line 2638 of file varlena.c.

References internal_text_pattern_compare(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, and result.

2639 {
2640  text *arg1 = PG_GETARG_TEXT_PP(0);
2641  text *arg2 = PG_GETARG_TEXT_PP(1);
2642  int result;
2643 
2644  result = internal_text_pattern_compare(arg1, arg2);
2645 
2646  PG_FREE_IF_COPY(arg1, 0);
2647  PG_FREE_IF_COPY(arg2, 1);
2648 
2649  PG_RETURN_BOOL(result <= 0);
2650 }
return result
Definition: formatting.c:1618
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int internal_text_pattern_compare(text *arg1, text *arg2)
Definition: varlena.c:2600
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:319
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
Definition: c.h:439
Datum text_pattern_lt ( PG_FUNCTION_ARGS  )

Definition at line 2622 of file varlena.c.

References internal_text_pattern_compare(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, and result.

2623 {
2624  text *arg1 = PG_GETARG_TEXT_PP(0);
2625  text *arg2 = PG_GETARG_TEXT_PP(1);
2626  int result;
2627 
2628  result = internal_text_pattern_compare(arg1, arg2);
2629 
2630  PG_FREE_IF_COPY(arg1, 0);
2631  PG_FREE_IF_COPY(arg2, 1);
2632 
2633  PG_RETURN_BOOL(result < 0);
2634 }
return result
Definition: formatting.c:1618
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int internal_text_pattern_compare(text *arg1, text *arg2)
Definition: varlena.c:2600
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:319
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
Definition: c.h:439
static int text_position ( text t1,
text t2 
)
static

Definition at line 1095 of file varlena.c.

References result, text_position_cleanup(), text_position_next(), and text_position_setup().

Referenced by textpos().

1096 {
1098  int result;
1099 
1100  text_position_setup(t1, t2, &state);
1101  result = text_position_next(1, &state);
1102  text_position_cleanup(&state);
1103  return result;
1104 }
static void text_position_setup(text *t1, text *t2, TextPositionState *state)
Definition: varlena.c:1119
return result
Definition: formatting.c:1618
static int text_position_next(int start_pos, TextPositionState *state)
Definition: varlena.c:1231
static void text_position_cleanup(TextPositionState *state)
Definition: varlena.c:1365
static void text_position_cleanup ( TextPositionState state)
static

Definition at line 1365 of file varlena.c.

References pfree(), TextPositionState::use_wchar, TextPositionState::wstr1, and TextPositionState::wstr2.

Referenced by replace_text(), split_text(), text_position(), and text_to_array_internal().

1366 {
1367  if (state->use_wchar)
1368  {
1369  pfree(state->wstr1);
1370  pfree(state->wstr2);
1371  }
1372 }
pg_wchar * wstr2
Definition: varlena.c:52
void pfree(void *pointer)
Definition: mcxt.c:950
pg_wchar * wstr1
Definition: varlena.c:51
static int text_position_next ( int  start_pos,
TextPositionState state 
)
static

Definition at line 1231 of file varlena.c.

References Assert, TextPositionState::len1, TextPositionState::len2, TextPositionState::skiptable, TextPositionState::skiptablemask, TextPositionState::str1, TextPositionState::str2, TextPositionState::use_wchar, TextPositionState::wstr1, and TextPositionState::wstr2.

Referenced by replace_text(), split_text(), text_position(), and text_to_array_internal().

1232 {
1233  int haystack_len = state->len1;
1234  int needle_len = state->len2;
1235  int skiptablemask = state->skiptablemask;
1236 
1237  Assert(start_pos > 0); /* else caller error */
1238 
1239  if (needle_len <= 0)
1240  return start_pos; /* result for empty pattern */
1241 
1242  start_pos--; /* adjust for zero based arrays */
1243 
1244  /* Done if the needle can't possibly fit */
1245  if (haystack_len < start_pos + needle_len)
1246  return 0;
1247 
1248  if (!state->use_wchar)
1249  {
1250  /* simple case - single byte encoding */
1251  const char *haystack = state->str1;
1252  const char *needle = state->str2;
1253  const char *haystack_end = &haystack[haystack_len];
1254  const char *hptr;
1255 
1256  if (needle_len == 1)
1257  {
1258  /* No point in using B-M-H for a one-character needle */
1259  char nchar = *needle;
1260 
1261  hptr = &haystack[start_pos];
1262  while (hptr < haystack_end)
1263  {
1264  if (*hptr == nchar)
1265  return hptr - haystack + 1;
1266  hptr++;
1267  }
1268  }
1269  else
1270  {
1271  const char *needle_last = &needle[needle_len - 1];
1272 
1273  /* Start at startpos plus the length of the needle */
1274  hptr = &haystack[start_pos + needle_len - 1];
1275  while (hptr < haystack_end)
1276  {
1277  /* Match the needle scanning *backward* */
1278  const char *nptr;
1279  const char *p;
1280 
1281  nptr = needle_last;
1282  p = hptr;
1283  while (*nptr == *p)
1284  {
1285  /* Matched it all? If so, return 1-based position */
1286  if (nptr == needle)
1287  return p - haystack + 1;
1288  nptr--, p--;
1289  }
1290 
1291  /*
1292  * No match, so use the haystack char at hptr to decide how
1293  * far to advance. If the needle had any occurrence of that
1294  * character (or more precisely, one sharing the same
1295  * skiptable entry) before its last character, then we advance
1296  * far enough to align the last such needle character with
1297  * that haystack position. Otherwise we can advance by the
1298  * whole needle length.
1299  */
1300  hptr += state->skiptable[(unsigned char) *hptr & skiptablemask];
1301  }
1302  }
1303  }
1304  else
1305  {
1306  /* The multibyte char version. This works exactly the same way. */
1307  const pg_wchar *haystack = state->wstr1;
1308  const pg_wchar *needle = state->wstr2;
1309  const pg_wchar *haystack_end = &haystack[haystack_len];
1310  const pg_wchar *hptr;
1311 
1312  if (needle_len == 1)
1313  {
1314  /* No point in using B-M-H for a one-character needle */
1315  pg_wchar nchar = *needle;
1316 
1317  hptr = &haystack[start_pos];
1318  while (hptr < haystack_end)
1319  {
1320  if (*hptr == nchar)
1321  return hptr - haystack + 1;
1322  hptr++;
1323  }
1324  }
1325  else
1326  {
1327  const pg_wchar *needle_last = &needle[needle_len - 1];
1328 
1329  /* Start at startpos plus the length of the needle */
1330  hptr = &haystack[start_pos + needle_len - 1];
1331  while (hptr < haystack_end)
1332  {
1333  /* Match the needle scanning *backward* */
1334  const pg_wchar *nptr;
1335  const pg_wchar *p;
1336 
1337  nptr = needle_last;
1338  p = hptr;
1339  while (*nptr == *p)
1340  {
1341  /* Matched it all? If so, return 1-based position */
1342  if (nptr == needle)
1343  return p - haystack + 1;
1344  nptr--, p--;
1345  }
1346 
1347  /*
1348  * No match, so use the haystack char at hptr to decide how
1349  * far to advance. If the needle had any occurrence of that
1350  * character (or more precisely, one sharing the same
1351  * skiptable entry) before its last character, then we advance
1352  * far enough to align the last such needle character with
1353  * that haystack position. Otherwise we can advance by the
1354  * whole needle length.
1355  */
1356  hptr += state->skiptable[*hptr & skiptablemask];
1357  }
1358  }
1359  }
1360 
1361  return 0; /* not found */
1362 }
pg_wchar * wstr2
Definition: varlena.c:52
unsigned int pg_wchar
Definition: mbprint.c:31
int skiptable[256]
Definition: varlena.c:57
#define Assert(condition)
Definition: c.h:675
pg_wchar * wstr1
Definition: varlena.c:51
static void text_position_setup ( text t1,
text t2,
TextPositionState state 
)
static

Definition at line 1119 of file varlena.c.

References i, TextPositionState::len1, TextPositionState::len2, palloc(), pg_database_encoding_max_length(), pg_mb2wchar_with_len(), TextPositionState::skiptable, TextPositionState::skiptablemask, TextPositionState::str1, TextPositionState::str2, TextPositionState::use_wchar, VARDATA_ANY, VARSIZE_ANY_EXHDR, TextPositionState::wstr1, and TextPositionState::wstr2.

Referenced by replace_text(), split_text(), text_position(), and text_to_array_internal().

1120 {
1121  int len1 = VARSIZE_ANY_EXHDR(t1);
1122  int len2 = VARSIZE_ANY_EXHDR(t2);
1123 
1125  {
1126  /* simple case - single byte encoding */
1127  state->use_wchar = false;
1128  state->str1 = VARDATA_ANY(t1);
1129  state->str2 = VARDATA_ANY(t2);
1130  state->len1 = len1;
1131  state->len2 = len2;
1132  }
1133  else
1134  {
1135  /* not as simple - multibyte encoding */
1136  pg_wchar *p1,
1137  *p2;
1138 
1139  p1 = (pg_wchar *) palloc((len1 + 1) * sizeof(pg_wchar));
1140  len1 = pg_mb2wchar_with_len(VARDATA_ANY(t1), p1, len1);
1141  p2 = (pg_wchar *) palloc((len2 + 1) * sizeof(pg_wchar));
1142  len2 = pg_mb2wchar_with_len(VARDATA_ANY(t2), p2, len2);
1143 
1144  state->use_wchar = true;
1145  state->wstr1 = p1;
1146  state->wstr2 = p2;
1147  state->len1 = len1;
1148  state->len2 = len2;
1149  }
1150 
1151  /*
1152  * Prepare the skip table for Boyer-Moore-Horspool searching. In these
1153  * notes we use the terminology that the "haystack" is the string to be
1154  * searched (t1) and the "needle" is the pattern being sought (t2).
1155  *
1156  * If the needle is empty or bigger than the haystack then there is no
1157  * point in wasting cycles initializing the table. We also choose not to
1158  * use B-M-H for needles of length 1, since the skip table can't possibly
1159  * save anything in that case.
1160  */
1161  if (len1 >= len2 && len2 > 1)
1162  {
1163  int searchlength = len1 - len2;
1164  int skiptablemask;
1165  int last;
1166  int i;
1167 
1168  /*
1169  * First we must determine how much of the skip table to use. The
1170  * declaration of TextPositionState allows up to 256 elements, but for
1171  * short search problems we don't really want to have to initialize so
1172  * many elements --- it would take too long in comparison to the
1173  * actual search time. So we choose a useful skip table size based on
1174  * the haystack length minus the needle length. The closer the needle
1175  * length is to the haystack length the less useful skipping becomes.
1176  *
1177  * Note: since we use bit-masking to select table elements, the skip
1178  * table size MUST be a power of 2, and so the mask must be 2^N-1.
1179  */
1180  if (searchlength < 16)
1181  skiptablemask = 3;
1182  else if (searchlength < 64)
1183  skiptablemask = 7;
1184  else if (searchlength < 128)
1185  skiptablemask = 15;
1186  else if (searchlength < 512)
1187  skiptablemask = 31;
1188  else if (searchlength < 2048)
1189  skiptablemask = 63;
1190  else if (searchlength < 4096)
1191  skiptablemask = 127;
1192  else
1193  skiptablemask = 255;
1194  state->skiptablemask = skiptablemask;
1195 
1196  /*
1197  * Initialize the skip table. We set all elements to the needle
1198  * length, since this is the correct skip distance for any character
1199  * not found in the needle.
1200  */
1201  for (i = 0; i <= skiptablemask; i++)
1202  state->skiptable[i] = len2;
1203 
1204  /*
1205  * Now examine the needle. For each character except the last one,
1206  * set the corresponding table element to the appropriate skip
1207  * distance. Note that when two characters share the same skip table
1208  * entry, the one later in the needle must determine the skip
1209  * distance.
1210  */
1211  last = len2 - 1;
1212 
1213  if (!state->use_wchar)
1214  {
1215  const char *str2 = state->str2;
1216 
1217  for (i = 0; i < last; i++)
1218  state->skiptable[(unsigned char) str2[i] & skiptablemask] = last - i;
1219  }
1220  else
1221  {
1222  const pg_wchar *wstr2 = state->wstr2;
1223 
1224  for (i = 0; i < last; i++)
1225  state->skiptable[wstr2[i] & skiptablemask] = last - i;
1226  }
1227  }
1228 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
pg_wchar * wstr2
Definition: varlena.c:52
int pg_database_encoding_max_length(void)
Definition: wchar.c:1833
unsigned int pg_wchar
Definition: mbprint.c:31
int skiptable[256]
Definition: varlena.c:57
int pg_mb2wchar_with_len(const char *from, pg_wchar *to, int len)
Definition: mbutils.c:734
pg_wchar * wstr1
Definition: varlena.c:51
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
void * palloc(Size size)
Definition: mcxt.c:849
int i
Datum text_reverse ( PG_FUNCTION_ARGS  )

Definition at line 4869 of file varlena.c.

References palloc(), pg_database_encoding_max_length(), PG_GETARG_TEXT_PP, pg_mblen(), PG_RETURN_TEXT_P, result, SET_VARSIZE, VARDATA, VARDATA_ANY, VARHDRSZ, and VARSIZE_ANY_EXHDR.

4870 {
4871  text *str = PG_GETARG_TEXT_PP(0);
4872  const char *p = VARDATA_ANY(str);
4873  int len = VARSIZE_ANY_EXHDR(str);
4874  const char *endp = p + len;
4875  text *result;
4876  char *dst;
4877 
4878  result = palloc(len + VARHDRSZ);
4879  dst = (char *) VARDATA(result) + len;
4880  SET_VARSIZE(result, len + VARHDRSZ);
4881 
4883  {
4884  /* multibyte version */
4885  while (p < endp)
4886  {
4887  int sz;
4888 
4889  sz = pg_mblen(p);
4890  dst -= sz;
4891  memcpy(dst, p, sz);
4892  p += sz;
4893  }
4894  }
4895  else
4896  {
4897  /* single byte version */
4898  while (p < endp)
4899  *(--dst) = *p++;
4900  }
4901 
4902  PG_RETURN_TEXT_P(result);
4903 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define VARDATA(PTR)
Definition: postgres.h:303
#define VARHDRSZ
Definition: c.h:445
return result
Definition: formatting.c:1618
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
int pg_database_encoding_max_length(void)
Definition: wchar.c:1833
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
int pg_mblen(const char *mbstr)
Definition: mbutils.c:771
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
void * palloc(Size size)
Definition: mcxt.c:849
Definition: c.h:439
#define SET_VARSIZE(PTR, len)
Definition: postgres.h:328
Datum text_right ( PG_FUNCTION_ARGS  )

Definition at line 4848 of file varlena.c.

References cstring_to_text_with_len(), PG_GETARG_INT32, PG_GETARG_TEXT_PP, pg_mbcharcliplen(), pg_mbstrlen_with_len(), PG_RETURN_TEXT_P, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

4849 {
4850  text *str = PG_GETARG_TEXT_PP(0);
4851  const char *p = VARDATA_ANY(str);
4852  int len = VARSIZE_ANY_EXHDR(str);
4853  int n = PG_GETARG_INT32(1);
4854  int off;
4855 
4856  if (n < 0)
4857  n = -n;
4858  else
4859  n = pg_mbstrlen_with_len(p, len) - n;
4860  off = pg_mbcharcliplen(p, len, n);
4861 
4862  PG_RETURN_TEXT_P(cstring_to_text_with_len(p + off, len - off));
4863 }
#define PG_GETARG_INT32(n)
Definition: fmgr.h:234
int pg_mbcharcliplen(const char *mbstr, int len, int limit)
Definition: mbutils.c:873
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
int pg_mbstrlen_with_len(const char *mbstr, int limit)
Definition: mbutils.c:805
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:161
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
Definition: c.h:439
Datum text_smaller ( PG_FUNCTION_ARGS  )

Definition at line 2579 of file varlena.c.

References PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, result, and text_cmp().

2580 {
2581  text *arg1 = PG_GETARG_TEXT_PP(0);
2582  text *arg2 = PG_GETARG_TEXT_PP(1);
2583  text *result;
2584 
2585  result = ((text_cmp(arg1, arg2, PG_GET_COLLATION()) < 0) ? arg1 : arg2);
2586 
2587  PG_RETURN_TEXT_P(result);
2588 }
return result
Definition: formatting.c:1618
#define PG_GET_COLLATION()
Definition: fmgr.h:163
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int text_cmp(text *arg1, text *arg2, Oid collid)
Definition: varlena.c:1611
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
Definition: c.h:439
Datum text_substr ( PG_FUNCTION_ARGS  )

Definition at line 781 of file varlena.c.

References PG_GETARG_DATUM, PG_GETARG_INT32, PG_RETURN_TEXT_P, and text_substring().

Referenced by build_regexp_match_result(), build_regexp_split_result(), and textregexsubstr().

782 {
784  PG_GETARG_INT32(1),
785  PG_GETARG_INT32(2),
786  false));
787 }
#define PG_GETARG_INT32(n)
Definition: fmgr.h:234
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:233
static text * text_substring(Datum str, int32 start, int32 length, bool length_not_specified)
Definition: varlena.c:814
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
Datum text_substr_no_len ( PG_FUNCTION_ARGS  )

Definition at line 795 of file varlena.c.

References PG_GETARG_DATUM, PG_GETARG_INT32, PG_RETURN_TEXT_P, and text_substring().

Referenced by build_regexp_split_result().

796 {
798  PG_GETARG_INT32(1),
799  -1, true));
800 }
#define PG_GETARG_INT32(n)
Definition: fmgr.h:234
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:233
static text * text_substring(Datum str, int32 start, int32 length, bool length_not_specified)
Definition: varlena.c:814
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
static text * text_substring ( Datum  str,
int32  start,
int32  length,
bool  length_not_specified 
)
static

Definition at line 814 of file varlena.c.

References cstring_to_text(), DatumGetPointer, DatumGetTextPSlice, elog, ereport, errcode(), errmsg(), ERROR, i, length(), Max, Min, NULL, palloc(), pfree(), pg_database_encoding_max_length(), pg_mblen(), pg_mbstrlen_with_len(), S, SET_VARSIZE, VARATT_IS_COMPRESSED, VARATT_IS_EXTERNAL, VARDATA, VARDATA_ANY, VARHDRSZ, and VARSIZE_ANY_EXHDR.

Referenced by split_text(), text_overlay(), text_substr(), and text_substr_no_len().

815 {
817  int32 S = start; /* start position */
818  int32 S1; /* adjusted start position */
819  int32 L1; /* adjusted substring length */
820 
821  /* life is easy if the encoding max length is 1 */
822  if (eml == 1)
823  {
824  S1 = Max(S, 1);
825 
826  if (length_not_specified) /* special case - get length to end of
827  * string */
828  L1 = -1;
829  else
830  {
831  /* end position */
832  int E = S + length;
833 
834  /*
835  * A negative value for L is the only way for the end position to
836  * be before the start. SQL99 says to throw an error.
837  */
838  if (E < S)
839  ereport(ERROR,
840  (errcode(ERRCODE_SUBSTRING_ERROR),
841  errmsg("negative substring length not allowed")));
842 
843  /*
844  * A zero or negative value for the end position can happen if the
845  * start was negative or one. SQL99 says to return a zero-length
846  * string.
847  */
848  if (E < 1)
849  return cstring_to_text("");
850 
851  L1 = E - S1;
852  }
853 
854  /*
855  * If the start position is past the end of the string, SQL99 says to
856  * return a zero-length string -- PG_GETARG_TEXT_P_SLICE() will do
857  * that for us. Convert to zero-based starting position
858  */
859  return DatumGetTextPSlice(str, S1 - 1, L1);
860  }
861  else if (eml > 1)
862  {
863  /*
864  * When encoding max length is > 1, we can't get LC without
865  * detoasting, so we'll grab a conservatively large slice now and go
866  * back later to do the right thing
867  */
868  int32 slice_start;
869  int32 slice_size;
870  int32 slice_strlen;
871  text *slice;
872  int32 E1;
873  int32 i;
874  char *p;
875  char *s;
876  text *ret;
877 
878  /*
879  * if S is past the end of the string, the tuple toaster will return a
880  * zero-length string to us
881  */
882  S1 = Max(S, 1);
883 
884  /*
885  * We need to start at position zero because there is no way to know
886  * in advance which byte offset corresponds to the supplied start
887  * position.
888  */
889  slice_start = 0;
890 
891  if (length_not_specified) /* special case - get length to end of
892  * string */
893  slice_size = L1 = -1;
894  else
895  {
896  int E = S + length;
897 
898  /*
899  * A negative value for L is the only way for the end position to
900  * be before the start. SQL99 says to throw an error.
901  */
902  if (E < S)
903  ereport(ERROR,
904  (errcode(ERRCODE_SUBSTRING_ERROR),
905  errmsg("negative substring length not allowed")));
906 
907  /*
908  * A zero or negative value for the end position can happen if the
909  * start was negative or one. SQL99 says to return a zero-length
910  * string.
911  */
912  if (E < 1)
913  return cstring_to_text("");
914 
915  /*
916  * if E is past the end of the string, the tuple toaster will
917  * truncate the length for us
918  */
919  L1 = E - S1;
920 
921  /*
922  * Total slice size in bytes can't be any longer than the start
923  * position plus substring length times the encoding max length.
924  */
925  slice_size = (S1 + L1) * eml;
926  }
927 
928  /*
929  * If we're working with an untoasted source, no need to do an extra
930  * copying step.
931  */
934  slice = DatumGetTextPSlice(str, slice_start, slice_size);
935  else
936  slice = (text *) DatumGetPointer(str);
937 
938  /* see if we got back an empty string */
939  if (VARSIZE_ANY_EXHDR(slice) == 0)
940  {
941  if (slice != (text *) DatumGetPointer(str))
942  pfree(slice);
943  return cstring_to_text("");
944  }
945 
946  /* Now we can get the actual length of the slice in MB characters */
947  slice_strlen = pg_mbstrlen_with_len(VARDATA_ANY(slice),
948  VARSIZE_ANY_EXHDR(slice));
949 
950  /*
951  * Check that the start position wasn't > slice_strlen. If so, SQL99
952  * says to return a zero-length string.
953  */
954  if (S1 > slice_strlen)
955  {
956  if (slice != (text *) DatumGetPointer(str))
957  pfree(slice);
958  return cstring_to_text("");
959  }
960 
961  /*
962  * Adjust L1 and E1 now that we know the slice string length. Again
963  * remember that S1 is one based, and slice_start is zero based.
964  */
965  if (L1 > -1)
966  E1 = Min(S1 + L1, slice_start + 1 + slice_strlen);
967  else
968  E1 = slice_start + 1 + slice_strlen;
969 
970  /*
971  * Find the start position in the slice; remember S1 is not zero based
972  */
973  p = VARDATA_ANY(slice);
974  for (i = 0; i < S1 - 1; i++)
975  p += pg_mblen(p);
976 
977  /* hang onto a pointer to our start position */
978  s = p;
979 
980  /*
981  * Count the actual bytes used by the substring of the requested
982  * length.
983  */
984  for (i = S1; i < E1; i++)
985  p += pg_mblen(p);
986 
987  ret = (text *) palloc(VARHDRSZ + (p - s));
988  SET_VARSIZE(ret, VARHDRSZ + (p - s));
989  memcpy(VARDATA(ret), s, (p - s));
990 
991  if (slice != (text *) DatumGetPointer(str))
992  pfree(slice);
993 
994  return ret;
995  }
996  else
997  elog(ERROR, "invalid backend encoding: encoding max length < 1");
998 
999  /* not reached: suppress compiler warning */
1000  return NULL;
1001 }
int length(const List *list)
Definition: list.c:1271
#define VARATT_IS_COMPRESSED(PTR)
Definition: postgres.h:313
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define VARDATA(PTR)
Definition: postgres.h:303
#define DatumGetTextPSlice(X, m, n)
Definition: fmgr.h:268
#define VARHDRSZ
Definition: c.h:445
#define Min(x, y)
Definition: c.h:806
int errcode(int sqlerrcode)
Definition: elog.c:575
signed int int32
Definition: c.h:256
int pg_mbstrlen_with_len(const char *mbstr, int limit)
Definition: mbutils.c:805
#define VARATT_IS_EXTERNAL(PTR)
Definition: postgres.h:314
void pfree(void *pointer)
Definition: mcxt.c:950
#define ERROR
Definition: elog.h:43
int pg_database_encoding_max_length(void)
Definition: wchar.c:1833
#define S(n, x)
Definition: sha1.c:55
#define ereport(elevel, rest)
Definition: elog.h:122
#define Max(x, y)
Definition: c.h:800
text * cstring_to_text(const char *s)
Definition: varlena.c:149
#define NULL
Definition: c.h:229
int pg_mblen(const char *mbstr)
Definition: mbutils.c:771
#define DatumGetPointer(X)
Definition: postgres.h:555
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
void * palloc(Size size)
Definition: mcxt.c:849
int errmsg(const char *fmt,...)
Definition: elog.c:797
int i
Definition: c.h:439
#define SET_VARSIZE(PTR, len)
Definition: postgres.h:328
#define elog
Definition: elog.h:219