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 4944 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 4515 of file varlena.c.

Referenced by to_hex32(), and to_hex64().

#define LEVENSHTEIN_LESS_EQUAL

Definition at line 5484 of file varlena.c.

#define MD5_HASH_LEN   32

Definition at line 4569 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 2809 of file varlena.c.

Referenced by bytea_substring().

#define REGEXP_REPLACE_BACKREF_CNT   10

Definition at line 3897 of file varlena.c.

Referenced by replace_text_regexp().

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

Definition at line 4942 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 3803 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().

3806 {
3807  const char *p = VARDATA_ANY(replace_text);
3808  const char *p_end = p + VARSIZE_ANY_EXHDR(replace_text);
3809  int eml = pg_database_encoding_max_length();
3810 
3811  for (;;)
3812  {
3813  const char *chunk_start = p;
3814  int so;
3815  int eo;
3816 
3817  /* Find next escape char. */
3818  if (eml == 1)
3819  {
3820  for (; p < p_end && *p != '\\'; p++)
3821  /* nothing */ ;
3822  }
3823  else
3824  {
3825  for (; p < p_end && *p != '\\'; p += pg_mblen(p))
3826  /* nothing */ ;
3827  }
3828 
3829  /* Copy the text we just scanned over, if any. */
3830  if (p > chunk_start)
3831  appendBinaryStringInfo(str, chunk_start, p - chunk_start);
3832 
3833  /* Done if at end of string, else advance over escape char. */
3834  if (p >= p_end)
3835  break;
3836  p++;
3837 
3838  if (p >= p_end)
3839  {
3840  /* Escape at very end of input. Treat same as unexpected char */
3841  appendStringInfoChar(str, '\\');
3842  break;
3843  }
3844 
3845  if (*p >= '1' && *p <= '9')
3846  {
3847  /* Use the back reference of regexp. */
3848  int idx = *p - '0';
3849 
3850  so = pmatch[idx].rm_so;
3851  eo = pmatch[idx].rm_eo;
3852  p++;
3853  }
3854  else if (*p == '&')
3855  {
3856  /* Use the entire matched string. */
3857  so = pmatch[0].rm_so;
3858  eo = pmatch[0].rm_eo;
3859  p++;
3860  }
3861  else if (*p == '\\')
3862  {
3863  /* \\ means transfer one \ to output. */
3864  appendStringInfoChar(str, '\\');
3865  p++;
3866  continue;
3867  }
3868  else
3869  {
3870  /*
3871  * If escape char is not followed by any expected char, just treat
3872  * it as ordinary data to copy. (XXX would it be better to throw
3873  * an error?)
3874  */
3875  appendStringInfoChar(str, '\\');
3876  continue;
3877  }
3878 
3879  if (so != -1 && eo != -1)
3880  {
3881  /*
3882  * Copy the text that is back reference of regexp. Note so and eo
3883  * are counted in characters not bytes.
3884  */
3885  char *chunk_start;
3886  int chunk_len;
3887 
3888  Assert(so >= data_pos);
3889  chunk_start = start_ptr;
3890  chunk_start += charlen_to_bytelen(chunk_start, so - data_pos);
3891  chunk_len = charlen_to_bytelen(chunk_start, eo - so);
3892  appendBinaryStringInfo(str, chunk_start, chunk_len);
3893  }
3894  }
3895 }
#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:169
#define Assert(condition)
Definition: c.h:676
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:208
static void appendStringInfoText ( StringInfo  str,
const text t 
)
static

Definition at line 3673 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().

3674 {
3676 }
#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:208
Datum array_to_text ( PG_FUNCTION_ARGS  )

Definition at line 4356 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().

4357 {
4359  char *fldsep = text_to_cstring(PG_GETARG_TEXT_PP(1));
4360 
4361  PG_RETURN_TEXT_P(array_to_text_internal(fcinfo, v, fldsep, NULL));
4362 }
#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:4398
#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 4398 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().

4400 {
4401  text *result;
4402  int nitems,
4403  *dims,
4404  ndims;
4405  Oid element_type;
4406  int typlen;
4407  bool typbyval;
4408  char typalign;
4410  bool printed = false;
4411  char *p;
4412  bits8 *bitmap;
4413  int bitmask;
4414  int i;
4415  ArrayMetaState *my_extra;
4416 
4417  ndims = ARR_NDIM(v);
4418  dims = ARR_DIMS(v);
4419  nitems = ArrayGetNItems(ndims, dims);
4420 
4421  /* if there are no elements, return an empty string */
4422  if (nitems == 0)
4423  return cstring_to_text_with_len("", 0);
4424 
4425  element_type = ARR_ELEMTYPE(v);
4426  initStringInfo(&buf);
4427 
4428  /*
4429  * We arrange to look up info about element type, including its output
4430  * conversion proc, only once per series of calls, assuming the element
4431  * type doesn't change underneath us.
4432  */
4433  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
4434  if (my_extra == NULL)
4435  {
4436  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
4437  sizeof(ArrayMetaState));
4438  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
4439  my_extra->element_type = ~element_type;
4440  }
4441 
4442  if (my_extra->element_type != element_type)
4443  {
4444  /*
4445  * Get info about element type, including its output conversion proc
4446  */
4447  get_type_io_data(element_type, IOFunc_output,
4448  &my_extra->typlen, &my_extra->typbyval,
4449  &my_extra->typalign, &my_extra->typdelim,
4450  &my_extra->typioparam, &my_extra->typiofunc);
4451  fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc,
4452  fcinfo->flinfo->fn_mcxt);
4453  my_extra->element_type = element_type;
4454  }
4455  typlen = my_extra->typlen;
4456  typbyval = my_extra->typbyval;
4457  typalign = my_extra->typalign;
4458 
4459  p = ARR_DATA_PTR(v);
4460  bitmap = ARR_NULLBITMAP(v);
4461  bitmask = 1;
4462 
4463  for (i = 0; i < nitems; i++)
4464  {
4465  Datum itemvalue;
4466  char *value;
4467 
4468  /* Get source element, checking for NULL */
4469  if (bitmap && (*bitmap & bitmask) == 0)
4470  {
4471  /* if null_string is NULL, we just ignore null elements */
4472  if (null_string != NULL)
4473  {
4474  if (printed)
4475  appendStringInfo(&buf, "%s%s", fldsep, null_string);
4476  else
4477  appendStringInfoString(&buf, null_string);
4478  printed = true;
4479  }
4480  }
4481  else
4482  {
4483  itemvalue = fetch_att(p, typbyval, typlen);
4484 
4485  value = OutputFunctionCall(&my_extra->proc, itemvalue);
4486 
4487  if (printed)
4488  appendStringInfo(&buf, "%s%s", fldsep, value);
4489  else
4490  appendStringInfoString(&buf, value);
4491  printed = true;
4492 
4493  p = att_addlength_pointer(p, typlen, p);
4494  p = (char *) att_align_nominal(p, typalign);
4495  }
4496 
4497  /* advance bitmap pointer if any */
4498  if (bitmap)
4499  {
4500  bitmask <<= 1;
4501  if (bitmask == 0x100)
4502  {
4503  bitmap++;
4504  bitmask = 1;
4505  }
4506  }
4507  }
4508 
4509  result = cstring_to_text_with_len(buf.data, buf.len);
4510  pfree(buf.data);
4511 
4512  return result;
4513 }
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:1633
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:78
#define ARR_DIMS(a)
Definition: array.h:275
static struct @121 value
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:157
#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:46
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
#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 4372 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().

4373 {
4374  ArrayType *v;
4375  char *fldsep;
4376  char *null_string;
4377 
4378  /* returns NULL when first or second parameter is NULL */
4379  if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
4380  PG_RETURN_NULL();
4381 
4382  v = PG_GETARG_ARRAYTYPE_P(0);
4383  fldsep = text_to_cstring(PG_GETARG_TEXT_PP(1));
4384 
4385  /* NULL null string is passed through as a null pointer */
4386  if (!PG_ARGISNULL(2))
4387  null_string = text_to_cstring(PG_GETARG_TEXT_PP(2));
4388  else
4389  null_string = NULL;
4390 
4391  PG_RETURN_TEXT_P(array_to_text_internal(fcinfo, v, fldsep, null_string));
4392 }
#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:4398
#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 1997 of file varlena.c.

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

Referenced by varstr_sortsupport().

1998 {
1999  BpChar *arg1 = DatumGetBpCharPP(x);
2000  BpChar *arg2 = DatumGetBpCharPP(y);
2001  char *a1p,
2002  *a2p;
2003  int len1,
2004  len2,
2005  result;
2006 
2007  a1p = VARDATA_ANY(arg1);
2008  a2p = VARDATA_ANY(arg2);
2009 
2010  len1 = bpchartruelen(a1p, VARSIZE_ANY_EXHDR(arg1));
2011  len2 = bpchartruelen(a2p, VARSIZE_ANY_EXHDR(arg2));
2012 
2013  result = memcmp(a1p, a2p, Min(len1, len2));
2014  if ((result == 0) && (len1 != len2))
2015  result = (len1 < len2) ? -1 : 1;
2016 
2017  /* We can't afford to leak memory here. */
2018  if (PointerGetDatum(arg1) != x)
2019  pfree(arg1);
2020  if (PointerGetDatum(arg2) != y)
2021  pfree(arg2);
2022 
2023  return result;
2024 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define PointerGetDatum(X)
Definition: postgres.h:562
#define Min(x, y)
Definition: c.h:807
return result
Definition: formatting.c:1633
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 2706 of file varlena.c.

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

2707 {
2708  text *arg1 = PG_GETARG_TEXT_PP(0);
2709  text *arg2 = PG_GETARG_TEXT_PP(1);
2710  int result;
2711 
2712  result = internal_text_pattern_compare(arg1, arg2);
2713 
2714  PG_FREE_IF_COPY(arg1, 0);
2715  PG_FREE_IF_COPY(arg2, 1);
2716 
2717  PG_RETURN_INT32(result);
2718 }
#define PG_RETURN_INT32(x)
Definition: fmgr.h:314
return result
Definition: formatting.c:1633
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int internal_text_pattern_compare(text *arg1, text *arg2)
Definition: varlena.c:2620
#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 2722 of file varlena.c.

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

2723 {
2725  MemoryContext oldcontext;
2726 
2727  oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
2728 
2729  /* Use generic string SortSupport, forcing "C" collation */
2730  varstr_sortsupport(ssup, C_COLLATION_OID, false);
2731 
2732  MemoryContextSwitchTo(oldcontext);
2733 
2734  PG_RETURN_VOID();
2735 }
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:1808
#define PG_RETURN_VOID()
Definition: fmgr.h:309
#define C_COLLATION_OID
Definition: pg_collation.h:78
Datum bttextcmp ( PG_FUNCTION_ARGS  )

Definition at line 1766 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().

1767 {
1768  text *arg1 = PG_GETARG_TEXT_PP(0);
1769  text *arg2 = PG_GETARG_TEXT_PP(1);
1770  int32 result;
1771 
1772  result = text_cmp(arg1, arg2, PG_GET_COLLATION());
1773 
1774  PG_FREE_IF_COPY(arg1, 0);
1775  PG_FREE_IF_COPY(arg2, 1);
1776 
1777  PG_RETURN_INT32(result);
1778 }
#define PG_RETURN_INT32(x)
Definition: fmgr.h:314
return result
Definition: formatting.c:1633
#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:1617
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:225
Definition: c.h:439
Datum bttextsortsupport ( PG_FUNCTION_ARGS  )

Definition at line 1781 of file varlena.c.

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

1782 {
1784  Oid collid = ssup->ssup_collation;
1785  MemoryContext oldcontext;
1786 
1787  oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
1788 
1789  /* Use generic string SortSupport */
1790  varstr_sortsupport(ssup, collid, false);
1791 
1792  MemoryContextSwitchTo(oldcontext);
1793 
1794  PG_RETURN_VOID();
1795 }
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:1808
#define PG_RETURN_VOID()
Definition: fmgr.h:309
static bytea * bytea_catenate ( bytea t1,
bytea t2 
)
static

Definition at line 2776 of file varlena.c.

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

Referenced by bytea_overlay(), and byteacat().

2777 {
2778  bytea *result;
2779  int len1,
2780  len2,
2781  len;
2782  char *ptr;
2783 
2784  len1 = VARSIZE_ANY_EXHDR(t1);
2785  len2 = VARSIZE_ANY_EXHDR(t2);
2786 
2787  /* paranoia ... probably should throw error instead? */
2788  if (len1 < 0)
2789  len1 = 0;
2790  if (len2 < 0)
2791  len2 = 0;
2792 
2793  len = len1 + len2 + VARHDRSZ;
2794  result = (bytea *) palloc(len);
2795 
2796  /* Set size of result string... */
2797  SET_VARSIZE(result, len);
2798 
2799  /* Fill data field of result string... */
2800  ptr = VARDATA(result);
2801  if (len1 > 0)
2802  memcpy(ptr, VARDATA_ANY(t1), len1);
2803  if (len2 > 0)
2804  memcpy(ptr + len1, VARDATA_ANY(t2), len2);
2805 
2806  return result;
2807 }
#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:1633
#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 2933 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().

2934 {
2935  bytea *result;
2936  bytea *s1;
2937  bytea *s2;
2938  int sp_pl_sl;
2939 
2940  /*
2941  * Check for possible integer-overflow cases. For negative sp, throw a
2942  * "substring length" error because that's what should be expected
2943  * according to the spec's definition of OVERLAY().
2944  */
2945  if (sp <= 0)
2946  ereport(ERROR,
2947  (errcode(ERRCODE_SUBSTRING_ERROR),
2948  errmsg("negative substring length not allowed")));
2949  sp_pl_sl = sp + sl;
2950  if (sp_pl_sl <= sl)
2951  ereport(ERROR,
2952  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
2953  errmsg("integer out of range")));
2954 
2955  s1 = bytea_substring(PointerGetDatum(t1), 1, sp - 1, false);
2956  s2 = bytea_substring(PointerGetDatum(t1), sp_pl_sl, -1, true);
2957  result = bytea_catenate(s1, t2);
2958  result = bytea_catenate(result, s2);
2959 
2960  return result;
2961 }
#define PointerGetDatum(X)
Definition: postgres.h:562
static bytea * bytea_catenate(bytea *t1, bytea *t2)
Definition: varlena.c:2776
int errcode(int sqlerrcode)
Definition: elog.c:575
return result
Definition: formatting.c:1633
static bytea * bytea_substring(Datum str, int S, int L, bool length_not_specified)
Definition: varlena.c:2851
#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 3651 of file varlena.c.

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

3652 {
3654  MemoryContext oldcontext;
3655 
3656  oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
3657 
3658  /* Use generic string SortSupport, forcing "C" collation */
3659  varstr_sortsupport(ssup, C_COLLATION_OID, false);
3660 
3661  MemoryContextSwitchTo(oldcontext);
3662 
3663  PG_RETURN_VOID();
3664 }
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:1808
#define PG_RETURN_VOID()
Definition: fmgr.h:309
#define C_COLLATION_OID
Definition: pg_collation.h:78
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:43
return result
Definition: formatting.c:1633
#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:676
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
Definition: nodeAgg.c:4027
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:43
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:241
static struct @121 value
#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:4671
Definition: c.h:439
void appendBinaryStringInfo(StringInfo str, const char *data, int datalen)
Definition: stringinfo.c:208
Datum bytea_substr ( PG_FUNCTION_ARGS  )

Definition at line 2828 of file varlena.c.

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

2829 {
2831  PG_GETARG_INT32(1),
2832  PG_GETARG_INT32(2),
2833  false));
2834 }
#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:2851
Datum bytea_substr_no_len ( PG_FUNCTION_ARGS  )

Definition at line 2842 of file varlena.c.

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

2843 {
2845  PG_GETARG_INT32(1),
2846  -1,
2847  true));
2848 }
#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:2851
static bytea * bytea_substring ( Datum  str,
int  S,
int  L,
bool  length_not_specified 
)
static

Definition at line 2851 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().

2855 {
2856  int S1; /* adjusted start position */
2857  int L1; /* adjusted substring length */
2858 
2859  S1 = Max(S, 1);
2860 
2861  if (length_not_specified)
2862  {
2863  /*
2864  * Not passed a length - DatumGetByteaPSlice() grabs everything to the
2865  * end of the string if we pass it a negative value for length.
2866  */
2867  L1 = -1;
2868  }
2869  else
2870  {
2871  /* end position */
2872  int E = S + L;
2873 
2874  /*
2875  * A negative value for L is the only way for the end position to be
2876  * before the start. SQL99 says to throw an error.
2877  */
2878  if (E < S)
2879  ereport(ERROR,
2880  (errcode(ERRCODE_SUBSTRING_ERROR),
2881  errmsg("negative substring length not allowed")));
2882 
2883  /*
2884  * A zero or negative value for the end position can happen if the
2885  * start was negative or one. SQL99 says to return a zero-length
2886  * string.
2887  */
2888  if (E < 1)
2889  return PG_STR_GET_BYTEA("");
2890 
2891  L1 = E - S1;
2892  }
2893 
2894  /*
2895  * If the start position is past the end of the string, SQL99 says to
2896  * return a zero-length string -- DatumGetByteaPSlice() will do that for
2897  * us. Convert to zero-based starting position
2898  */
2899  return DatumGetByteaPSlice(str, S1 - 1, L1);
2900 }
#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:2809
#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:801
int errmsg(const char *fmt,...)
Definition: elog.c:797
Datum byteacat ( PG_FUNCTION_ARGS  )

Definition at line 2761 of file varlena.c.

References bytea_catenate(), PG_GETARG_BYTEA_PP, and PG_RETURN_BYTEA_P.

2762 {
2763  bytea *t1 = PG_GETARG_BYTEA_PP(0);
2764  bytea *t2 = PG_GETARG_BYTEA_PP(1);
2765 
2767 }
static bytea * bytea_catenate(bytea *t1, bytea *t2)
Definition: varlena.c:2776
#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 3629 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().

3630 {
3631  bytea *arg1 = PG_GETARG_BYTEA_PP(0);
3632  bytea *arg2 = PG_GETARG_BYTEA_PP(1);
3633  int len1,
3634  len2;
3635  int cmp;
3636 
3637  len1 = VARSIZE_ANY_EXHDR(arg1);
3638  len2 = VARSIZE_ANY_EXHDR(arg2);
3639 
3640  cmp = memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), Min(len1, len2));
3641  if ((cmp == 0) && (len1 != len2))
3642  cmp = (len1 < len2) ? -1 : 1;
3643 
3644  PG_FREE_IF_COPY(arg1, 0);
3645  PG_FREE_IF_COPY(arg2, 1);
3646 
3647  PG_RETURN_INT32(cmp);
3648 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define Min(x, y)
Definition: c.h:807
#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 3485 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().

3486 {
3487  Datum arg1 = PG_GETARG_DATUM(0);
3488  Datum arg2 = PG_GETARG_DATUM(1);
3489  bool result;
3490  Size len1,
3491  len2;
3492 
3493  /*
3494  * We can use a fast path for unequal lengths, which might save us from
3495  * having to detoast one or both values.
3496  */
3497  len1 = toast_raw_datum_size(arg1);
3498  len2 = toast_raw_datum_size(arg2);
3499  if (len1 != len2)
3500  result = false;
3501  else
3502  {
3503  bytea *barg1 = DatumGetByteaPP(arg1);
3504  bytea *barg2 = DatumGetByteaPP(arg2);
3505 
3506  result = (memcmp(VARDATA_ANY(barg1), VARDATA_ANY(barg2),
3507  len1 - VARHDRSZ) == 0);
3508 
3509  PG_FREE_IF_COPY(barg1, 0);
3510  PG_FREE_IF_COPY(barg2, 1);
3511  }
3512 
3513  PG_RETURN_BOOL(result);
3514 }
#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:1633
#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 3609 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().

3610 {
3611  bytea *arg1 = PG_GETARG_BYTEA_PP(0);
3612  bytea *arg2 = PG_GETARG_BYTEA_PP(1);
3613  int len1,
3614  len2;
3615  int cmp;
3616 
3617  len1 = VARSIZE_ANY_EXHDR(arg1);
3618  len2 = VARSIZE_ANY_EXHDR(arg2);
3619 
3620  cmp = memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), Min(len1, len2));
3621 
3622  PG_FREE_IF_COPY(arg1, 0);
3623  PG_FREE_IF_COPY(arg2, 1);
3624 
3625  PG_RETURN_BOOL((cmp > 0) || ((cmp == 0) && (len1 >= len2)));
3626 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define Min(x, y)
Definition: c.h:807
#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 3043 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.

3044 {
3045  bytea *v = PG_GETARG_BYTEA_PP(0);
3046  int32 n = PG_GETARG_INT32(1);
3047  int byteNo,
3048  bitNo;
3049  int len;
3050  int byte;
3051 
3052  len = VARSIZE_ANY_EXHDR(v);
3053 
3054  if (n < 0 || n >= len * 8)
3055  ereport(ERROR,
3056  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
3057  errmsg("index %d out of valid range, 0..%d",
3058  n, len * 8 - 1)));
3059 
3060  byteNo = n / 8;
3061  bitNo = n % 8;
3062 
3063  byte = ((unsigned char *) VARDATA_ANY(v))[byteNo];
3064 
3065  if (byte & (1 << bitNo))
3066  PG_RETURN_INT32(1);
3067  else
3068  PG_RETURN_INT32(0);
3069 }
#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 3014 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.

3015 {
3016  bytea *v = PG_GETARG_BYTEA_PP(0);
3017  int32 n = PG_GETARG_INT32(1);
3018  int len;
3019  int byte;
3020 
3021  len = VARSIZE_ANY_EXHDR(v);
3022 
3023  if (n < 0 || n >= len)
3024  ereport(ERROR,
3025  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
3026  errmsg("index %d out of valid range, 0..%d",
3027  n, len - 1)));
3028 
3029  byte = ((unsigned char *) VARDATA_ANY(v))[n];
3030 
3031  PG_RETURN_INT32(byte);
3032 }
#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 3589 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().

3590 {
3591  bytea *arg1 = PG_GETARG_BYTEA_PP(0);
3592  bytea *arg2 = PG_GETARG_BYTEA_PP(1);
3593  int len1,
3594  len2;
3595  int cmp;
3596 
3597  len1 = VARSIZE_ANY_EXHDR(arg1);
3598  len2 = VARSIZE_ANY_EXHDR(arg2);
3599 
3600  cmp = memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), Min(len1, len2));
3601 
3602  PG_FREE_IF_COPY(arg1, 0);
3603  PG_FREE_IF_COPY(arg2, 1);
3604 
3605  PG_RETURN_BOOL((cmp > 0) || ((cmp == 0) && (len1 > len2)));
3606 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define Min(x, y)
Definition: c.h:807
#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:1633
#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 3569 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().

3570 {
3571  bytea *arg1 = PG_GETARG_BYTEA_PP(0);
3572  bytea *arg2 = PG_GETARG_BYTEA_PP(1);
3573  int len1,
3574  len2;
3575  int cmp;
3576 
3577  len1 = VARSIZE_ANY_EXHDR(arg1);
3578  len2 = VARSIZE_ANY_EXHDR(arg2);
3579 
3580  cmp = memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), Min(len1, len2));
3581 
3582  PG_FREE_IF_COPY(arg1, 0);
3583  PG_FREE_IF_COPY(arg2, 1);
3584 
3585  PG_RETURN_BOOL((cmp < 0) || ((cmp == 0) && (len1 <= len2)));
3586 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define Min(x, y)
Definition: c.h:807
#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 3549 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().

3550 {
3551  bytea *arg1 = PG_GETARG_BYTEA_PP(0);
3552  bytea *arg2 = PG_GETARG_BYTEA_PP(1);
3553  int len1,
3554  len2;
3555  int cmp;
3556 
3557  len1 = VARSIZE_ANY_EXHDR(arg1);
3558  len2 = VARSIZE_ANY_EXHDR(arg2);
3559 
3560  cmp = memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), Min(len1, len2));
3561 
3562  PG_FREE_IF_COPY(arg1, 0);
3563  PG_FREE_IF_COPY(arg2, 1);
3564 
3565  PG_RETURN_BOOL((cmp < 0) || ((cmp == 0) && (len1 < len2)));
3566 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define Min(x, y)
Definition: c.h:807
#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 3517 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.

3518 {
3519  Datum arg1 = PG_GETARG_DATUM(0);
3520  Datum arg2 = PG_GETARG_DATUM(1);
3521  bool result;
3522  Size len1,
3523  len2;
3524 
3525  /*
3526  * We can use a fast path for unequal lengths, which might save us from
3527  * having to detoast one or both values.
3528  */
3529  len1 = toast_raw_datum_size(arg1);
3530  len2 = toast_raw_datum_size(arg2);
3531  if (len1 != len2)
3532  result = true;
3533  else
3534  {
3535  bytea *barg1 = DatumGetByteaPP(arg1);
3536  bytea *barg2 = DatumGetByteaPP(arg2);
3537 
3538  result = (memcmp(VARDATA_ANY(barg1), VARDATA_ANY(barg2),
3539  len1 - VARHDRSZ) != 0);
3540 
3541  PG_FREE_IF_COPY(barg1, 0);
3542  PG_FREE_IF_COPY(barg2, 1);
3543  }
3544 
3545  PG_RETURN_BOOL(result);
3546 }
#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:1633
#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 2745 of file varlena.c.

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

2746 {
2747  Datum str = PG_GETARG_DATUM(0);
2748 
2749  /* We need not detoast the input at all */
2751 }
#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:1633
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 2910 of file varlena.c.

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

2911 {
2912  bytea *t1 = PG_GETARG_BYTEA_PP(0);
2913  bytea *t2 = PG_GETARG_BYTEA_PP(1);
2914  int sp = PG_GETARG_INT32(2); /* substring start position */
2915  int sl = PG_GETARG_INT32(3); /* substring length */
2916 
2917  PG_RETURN_BYTEA_P(bytea_overlay(t1, t2, sp, sl));
2918 }
#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:2933
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:272
Definition: c.h:439
Datum byteaoverlay_no_len ( PG_FUNCTION_ARGS  )

Definition at line 2921 of file varlena.c.

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

2922 {
2923  bytea *t1 = PG_GETARG_BYTEA_PP(0);
2924  bytea *t2 = PG_GETARG_BYTEA_PP(1);
2925  int sp = PG_GETARG_INT32(2); /* substring start position */
2926  int sl;
2927 
2928  sl = VARSIZE_ANY_EXHDR(t2); /* defaults to length(t2) */
2929  PG_RETURN_BYTEA_P(bytea_overlay(t1, t2, sp, sl));
2930 }
#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:2933
#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 2970 of file varlena.c.

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

2971 {
2972  bytea *t1 = PG_GETARG_BYTEA_PP(0);
2973  bytea *t2 = PG_GETARG_BYTEA_PP(1);
2974  int pos;
2975  int px,
2976  p;
2977  int len1,
2978  len2;
2979  char *p1,
2980  *p2;
2981 
2982  len1 = VARSIZE_ANY_EXHDR(t1);
2983  len2 = VARSIZE_ANY_EXHDR(t2);
2984 
2985  if (len2 <= 0)
2986  PG_RETURN_INT32(1); /* result for empty pattern */
2987 
2988  p1 = VARDATA_ANY(t1);
2989  p2 = VARDATA_ANY(t2);
2990 
2991  pos = 0;
2992  px = (len1 - len2);
2993  for (p = 0; p <= px; p++)
2994  {
2995  if ((*p2 == *p1) && (memcmp(p1, p2, len2) == 0))
2996  {
2997  pos = p + 1;
2998  break;
2999  };
3000  p1++;
3001  };
3002 
3003  PG_RETURN_INT32(pos);
3004 }
#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)
#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:43
return result
Definition: formatting.c:1633
#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 3112 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.

3113 {
3114  bytea *res = PG_GETARG_BYTEA_P_COPY(0);
3115  int32 n = PG_GETARG_INT32(1);
3116  int32 newBit = PG_GETARG_INT32(2);
3117  int len;
3118  int oldByte,
3119  newByte;
3120  int byteNo,
3121  bitNo;
3122 
3123  len = VARSIZE(res) - VARHDRSZ;
3124 
3125  if (n < 0 || n >= len * 8)
3126  ereport(ERROR,
3127  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
3128  errmsg("index %d out of valid range, 0..%d",
3129  n, len * 8 - 1)));
3130 
3131  byteNo = n / 8;
3132  bitNo = n % 8;
3133 
3134  /*
3135  * sanity check!
3136  */
3137  if (newBit != 0 && newBit != 1)
3138  ereport(ERROR,
3139  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3140  errmsg("new bit must be 0 or 1")));
3141 
3142  /*
3143  * Update the byte.
3144  */
3145  oldByte = ((unsigned char *) VARDATA(res))[byteNo];
3146 
3147  if (newBit == 0)
3148  newByte = oldByte & (~(1 << bitNo));
3149  else
3150  newByte = oldByte | (1 << bitNo);
3151 
3152  ((unsigned char *) VARDATA(res))[byteNo] = newByte;
3153 
3154  PG_RETURN_BYTEA_P(res);
3155 }
#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 3080 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.

3081 {
3082  bytea *res = PG_GETARG_BYTEA_P_COPY(0);
3083  int32 n = PG_GETARG_INT32(1);
3084  int32 newByte = PG_GETARG_INT32(2);
3085  int len;
3086 
3087  len = VARSIZE(res) - VARHDRSZ;
3088 
3089  if (n < 0 || n >= len)
3090  ereport(ERROR,
3091  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
3092  errmsg("index %d out of valid range, 0..%d",
3093  n, len - 1)));
3094 
3095  /*
3096  * Now set the byte.
3097  */
3098  ((unsigned char *) VARDATA(res))[n] = newByte;
3099 
3100  PG_RETURN_BYTEA_P(res);
3101 }
#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 3770 of file varlena.c.

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

Referenced by replace_text_regexp().

3771 {
3772  const char *p = VARDATA_ANY(replace_text);
3773  const char *p_end = p + VARSIZE_ANY_EXHDR(replace_text);
3774 
3776  {
3777  for (; p < p_end; p++)
3778  {
3779  if (*p == '\\')
3780  return true;
3781  }
3782  }
3783  else
3784  {
3785  for (; p < p_end; p += pg_mblen(p))
3786  {
3787  if (*p == '\\')
3788  return true;
3789  }
3790  }
3791 
3792  return false;
3793 }
#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 4744 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().

4746 {
4747  text *result;
4748  StringInfoData str;
4749  bool first_arg = true;
4750  int i;
4751 
4752  /*
4753  * concat(VARIADIC some-array) is essentially equivalent to
4754  * array_to_text(), ie concat the array elements with the given separator.
4755  * So we just pass the case off to that code.
4756  */
4757  if (get_fn_expr_variadic(fcinfo->flinfo))
4758  {
4759  ArrayType *arr;
4760 
4761  /* Should have just the one argument */
4762  Assert(argidx == PG_NARGS() - 1);
4763 
4764  /* concat(VARIADIC NULL) is defined as NULL */
4765  if (PG_ARGISNULL(argidx))
4766  return NULL;
4767 
4768  /*
4769  * Non-null argument had better be an array. We assume that any call
4770  * context that could let get_fn_expr_variadic return true will have
4771  * checked that a VARIADIC-labeled parameter actually is an array. So
4772  * it should be okay to just Assert that it's an array rather than
4773  * doing a full-fledged error check.
4774  */
4776 
4777  /* OK, safe to fetch the array value */
4778  arr = PG_GETARG_ARRAYTYPE_P(argidx);
4779 
4780  /*
4781  * And serialize the array. We tell array_to_text to ignore null
4782  * elements, which matches the behavior of the loop below.
4783  */
4784  return array_to_text_internal(fcinfo, arr, sepstr, NULL);
4785  }
4786 
4787  /* Normal case without explicit VARIADIC marker */
4788  initStringInfo(&str);
4789 
4790  for (i = argidx; i < PG_NARGS(); i++)
4791  {
4792  if (!PG_ARGISNULL(i))
4793  {
4795  Oid valtype;
4796  Oid typOutput;
4797  bool typIsVarlena;
4798 
4799  /* add separator if appropriate */
4800  if (first_arg)
4801  first_arg = false;
4802  else
4803  appendStringInfoString(&str, sepstr);
4804 
4805  /* call the appropriate type output function, append the result */
4806  valtype = get_fn_expr_argtype(fcinfo->flinfo, i);
4807  if (!OidIsValid(valtype))
4808  elog(ERROR, "could not determine data type of concat() input");
4809  getTypeOutputInfo(valtype, &typOutput, &typIsVarlena);
4811  OidOutputFunctionCall(typOutput, value));
4812  }
4813  }
4814 
4815  result = cstring_to_text_with_len(str.data, str.len);
4816  pfree(str.data);
4817 
4818  return result;
4819 }
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:1633
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 struct @121 value
static text * array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v, const char *fldsep, const char *null_string)
Definition: varlena.c:4398
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:157
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:161
void initStringInfo(StringInfo str)
Definition: stringinfo.c:46
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:676
#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
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:1633
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 2620 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().

2621 {
2622  int result;
2623  int len1,
2624  len2;
2625 
2626  len1 = VARSIZE_ANY_EXHDR(arg1);
2627  len2 = VARSIZE_ANY_EXHDR(arg2);
2628 
2629  result = memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), Min(len1, len2));
2630  if (result != 0)
2631  return result;
2632  else if (len1 < len2)
2633  return -1;
2634  else if (len1 > len2)
2635  return 1;
2636  else
2637  return 0;
2638 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define Min(x, y)
Definition: c.h:807
return result
Definition: formatting.c:1633
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:340
static StringInfo makeStringAggState ( FunctionCallInfo  fcinfo)
static

Definition at line 4671 of file varlena.c.

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

Referenced by bytea_string_agg_transfn(), and string_agg_transfn().

4672 {
4673  StringInfo state;
4674  MemoryContext aggcontext;
4675  MemoryContext oldcontext;
4676 
4677  if (!AggCheckCallContext(fcinfo, &aggcontext))
4678  {
4679  /* cannot be called directly because of internal-type argument */
4680  elog(ERROR, "string_agg_transfn called in non-aggregate context");
4681  }
4682 
4683  /*
4684  * Create state in aggregate context. It'll stay there across subsequent
4685  * calls.
4686  */
4687  oldcontext = MemoryContextSwitchTo(aggcontext);
4688  state = makeStringInfo();
4689  MemoryContextSwitchTo(oldcontext);
4690 
4691  return state;
4692 }
StringInfo makeStringInfo(void)
Definition: stringinfo.c:28
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
#define ERROR
Definition: elog.h:43
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
Definition: nodeAgg.c:4027
#define elog
Definition: elog.h:219
Datum md5_bytea ( PG_FUNCTION_ARGS  )

Definition at line 4596 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.

4597 {
4598  bytea *in = PG_GETARG_BYTEA_PP(0);
4599  size_t len;
4600  char hexsum[MD5_HASH_LEN + 1];
4601 
4602  len = VARSIZE_ANY_EXHDR(in);
4603  if (pg_md5_hash(VARDATA_ANY(in), len, hexsum) == false)
4604  ereport(ERROR,
4605  (errcode(ERRCODE_OUT_OF_MEMORY),
4606  errmsg("out of memory")));
4607 
4609 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define MD5_HASH_LEN
Definition: varlena.c:4569
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 4572 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.

4573 {
4574  text *in_text = PG_GETARG_TEXT_PP(0);
4575  size_t len;
4576  char hexsum[MD5_HASH_LEN + 1];
4577 
4578  /* Calculate the length of the buffer using varlena metadata */
4579  len = VARSIZE_ANY_EXHDR(in_text);
4580 
4581  /* get the hash result */
4582  if (pg_md5_hash(VARDATA_ANY(in_text), len, hexsum) == false)
4583  ereport(ERROR,
4584  (errcode(ERRCODE_OUT_OF_MEMORY),
4585  errmsg("out of memory")));
4586 
4587  /* convert to text and return it */
4589 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
#define MD5_HASH_LEN
Definition: varlena.c:4569
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 3185 of file varlena.c.

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

Referenced by nameiclike(), and nameicnlike().

3186 {
3187  Name s = PG_GETARG_NAME(0);
3188 
3190 }
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 4617 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.

4618 {
4620  int32 result;
4621  int typlen;
4622 
4623  /* On first call, get the input type's typlen, and save at *fn_extra */
4624  if (fcinfo->flinfo->fn_extra == NULL)
4625  {
4626  /* Lookup the datatype of the supplied argument */
4627  Oid argtypeid = get_fn_expr_argtype(fcinfo->flinfo, 0);
4628 
4629  typlen = get_typlen(argtypeid);
4630  if (typlen == 0) /* should not happen */
4631  elog(ERROR, "cache lookup failed for type %u", argtypeid);
4632 
4633  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
4634  sizeof(int));
4635  *((int *) fcinfo->flinfo->fn_extra) = typlen;
4636  }
4637  else
4638  typlen = *((int *) fcinfo->flinfo->fn_extra);
4639 
4640  if (typlen == -1)
4641  {
4642  /* varlena type, possibly toasted */
4643  result = toast_datum_size(value);
4644  }
4645  else if (typlen == -2)
4646  {
4647  /* cstring */
4648  result = strlen(DatumGetCString(value)) + 1;
4649  }
4650  else
4651  {
4652  /* ordinary fixed-width type */
4653  result = typlen;
4654  }
4655 
4656  PG_RETURN_INT32(result);
4657 }
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:233
#define PG_RETURN_INT32(x)
Definition: fmgr.h:314
return result
Definition: formatting.c:1633
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
static struct @121 value
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
Datum replace_text ( PG_FUNCTION_ARGS  )

Definition at line 3687 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().

3688 {
3689  text *src_text = PG_GETARG_TEXT_PP(0);
3690  text *from_sub_text = PG_GETARG_TEXT_PP(1);
3691  text *to_sub_text = PG_GETARG_TEXT_PP(2);
3692  int src_text_len;
3693  int from_sub_text_len;
3695  text *ret_text;
3696  int start_posn;
3697  int curr_posn;
3698  int chunk_len;
3699  char *start_ptr;
3700  StringInfoData str;
3701 
3702  text_position_setup(src_text, from_sub_text, &state);
3703 
3704  /*
3705  * Note: we check the converted string length, not the original, because
3706  * they could be different if the input contained invalid encoding.
3707  */
3708  src_text_len = state.len1;
3709  from_sub_text_len = state.len2;
3710 
3711  /* Return unmodified source string if empty source or pattern */
3712  if (src_text_len < 1 || from_sub_text_len < 1)
3713  {
3714  text_position_cleanup(&state);
3715  PG_RETURN_TEXT_P(src_text);
3716  }
3717 
3718  start_posn = 1;
3719  curr_posn = text_position_next(1, &state);
3720 
3721  /* When the from_sub_text is not found, there is nothing to do. */
3722  if (curr_posn == 0)
3723  {
3724  text_position_cleanup(&state);
3725  PG_RETURN_TEXT_P(src_text);
3726  }
3727 
3728  /* start_ptr points to the start_posn'th character of src_text */
3729  start_ptr = VARDATA_ANY(src_text);
3730 
3731  initStringInfo(&str);
3732 
3733  do
3734  {
3736 
3737  /* copy the data skipped over by last text_position_next() */
3738  chunk_len = charlen_to_bytelen(start_ptr, curr_posn - start_posn);
3739  appendBinaryStringInfo(&str, start_ptr, chunk_len);
3740 
3741  appendStringInfoText(&str, to_sub_text);
3742 
3743  start_posn = curr_posn;
3744  start_ptr += chunk_len;
3745  start_posn += from_sub_text_len;
3746  start_ptr += charlen_to_bytelen(start_ptr, from_sub_text_len);
3747 
3748  curr_posn = text_position_next(start_posn, &state);
3749  }
3750  while (curr_posn > 0);
3751 
3752  /* copy trailing data */
3753  chunk_len = ((char *) src_text + VARSIZE_ANY(src_text)) - start_ptr;
3754  appendBinaryStringInfo(&str, start_ptr, chunk_len);
3755 
3756  text_position_cleanup(&state);
3757 
3758  ret_text = cstring_to_text_with_len(str.data, str.len);
3759  pfree(str.data);
3760 
3761  PG_RETURN_TEXT_P(ret_text);
3762 }
#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:3673
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:161
void initStringInfo(StringInfo str)
Definition: stringinfo.c:46
#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:98
void appendBinaryStringInfo(StringInfo str, const char *data, int datalen)
Definition: stringinfo.c:208
text* replace_text_regexp ( text src_text,
void *  regexp,
text replace_text,
bool  glob 
)

Definition at line 3908 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().

3910 {
3911  text *ret_text;
3912  regex_t *re = (regex_t *) regexp;
3913  int src_text_len = VARSIZE_ANY_EXHDR(src_text);
3916  pg_wchar *data;
3917  size_t data_len;
3918  int search_start;
3919  int data_pos;
3920  char *start_ptr;
3921  bool have_escape;
3922 
3923  initStringInfo(&buf);
3924 
3925  /* Convert data string to wide characters. */
3926  data = (pg_wchar *) palloc((src_text_len + 1) * sizeof(pg_wchar));
3927  data_len = pg_mb2wchar_with_len(VARDATA_ANY(src_text), data, src_text_len);
3928 
3929  /* Check whether replace_text has escape char. */
3930  have_escape = check_replace_text_has_escape_char(replace_text);
3931 
3932  /* start_ptr points to the data_pos'th character of src_text */
3933  start_ptr = (char *) VARDATA_ANY(src_text);
3934  data_pos = 0;
3935 
3936  search_start = 0;
3937  while (search_start <= data_len)
3938  {
3939  int regexec_result;
3940 
3942 
3943  regexec_result = pg_regexec(re,
3944  data,
3945  data_len,
3946  search_start,
3947  NULL, /* no details */
3949  pmatch,
3950  0);
3951 
3952  if (regexec_result == REG_NOMATCH)
3953  break;
3954 
3955  if (regexec_result != REG_OKAY)
3956  {
3957  char errMsg[100];
3958 
3960  pg_regerror(regexec_result, re, errMsg, sizeof(errMsg));
3961  ereport(ERROR,
3962  (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
3963  errmsg("regular expression failed: %s", errMsg)));
3964  }
3965 
3966  /*
3967  * Copy the text to the left of the match position. Note we are given
3968  * character not byte indexes.
3969  */
3970  if (pmatch[0].rm_so - data_pos > 0)
3971  {
3972  int chunk_len;
3973 
3974  chunk_len = charlen_to_bytelen(start_ptr,
3975  pmatch[0].rm_so - data_pos);
3976  appendBinaryStringInfo(&buf, start_ptr, chunk_len);
3977 
3978  /*
3979  * Advance start_ptr over that text, to avoid multiple rescans of
3980  * it if the replace_text contains multiple back-references.
3981  */
3982  start_ptr += chunk_len;
3983  data_pos = pmatch[0].rm_so;
3984  }
3985 
3986  /*
3987  * Copy the replace_text. Process back references when the
3988  * replace_text has escape characters.
3989  */
3990  if (have_escape)
3991  appendStringInfoRegexpSubstr(&buf, replace_text, pmatch,
3992  start_ptr, data_pos);
3993  else
3994  appendStringInfoText(&buf, replace_text);
3995 
3996  /* Advance start_ptr and data_pos over the matched text. */
3997  start_ptr += charlen_to_bytelen(start_ptr,
3998  pmatch[0].rm_eo - data_pos);
3999  data_pos = pmatch[0].rm_eo;
4000 
4001  /*
4002  * When global option is off, replace the first instance only.
4003  */
4004  if (!glob)
4005  break;
4006 
4007  /*
4008  * Advance search position. Normally we start the next search at the
4009  * end of the previous match; but if the match was of zero length, we
4010  * have to advance by one character, or we'd just find the same match
4011  * again.
4012  */
4013  search_start = data_pos;
4014  if (pmatch[0].rm_so == pmatch[0].rm_eo)
4015  search_start++;
4016  }
4017 
4018  /*
4019  * Copy the text to the right of the last match.
4020  */
4021  if (data_pos < data_len)
4022  {
4023  int chunk_len;
4024 
4025  chunk_len = ((char *) src_text + VARSIZE_ANY(src_text)) - start_ptr;
4026  appendBinaryStringInfo(&buf, start_ptr, chunk_len);
4027  }
4028 
4029  ret_text = cstring_to_text_with_len(buf.data, buf.len);
4030  pfree(buf.data);
4031  pfree(data);
4032 
4033  return ret_text;
4034 }
#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:3770
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:3673
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:46
#define REGEXP_REPLACE_BACKREF_CNT
Definition: varlena.c:3897
#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:3803
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:98
void appendBinaryStringInfo(StringInfo str, const char *data, int datalen)
Definition: stringinfo.c:208
Definition: regex.h:55
static bool rest_of_char_same ( const char *  s1,
const char *  s2,
int  len 
)
inlinestatic

Definition at line 5471 of file varlena.c.

Referenced by varstr_levenshtein().

5472 {
5473  while (len > 0)
5474  {
5475  len--;
5476  if (s1[len] != s2[len])
5477  return false;
5478  }
5479  return true;
5480 }
char * s1
char * s2
Datum split_text ( PG_FUNCTION_ARGS  )

Definition at line 4043 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().

4044 {
4045  text *inputstring = PG_GETARG_TEXT_PP(0);
4046  text *fldsep = PG_GETARG_TEXT_PP(1);
4047  int fldnum = PG_GETARG_INT32(2);
4048  int inputstring_len;
4049  int fldsep_len;
4051  int start_posn;
4052  int end_posn;
4053  text *result_text;
4054 
4055  /* field number is 1 based */
4056  if (fldnum < 1)
4057  ereport(ERROR,
4058  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4059  errmsg("field position must be greater than zero")));
4060 
4061  text_position_setup(inputstring, fldsep, &state);
4062 
4063  /*
4064  * Note: we check the converted string length, not the original, because
4065  * they could be different if the input contained invalid encoding.
4066  */
4067  inputstring_len = state.len1;
4068  fldsep_len = state.len2;
4069 
4070  /* return empty string for empty input string */
4071  if (inputstring_len < 1)
4072  {
4073  text_position_cleanup(&state);
4075  }
4076 
4077  /* empty field separator */
4078  if (fldsep_len < 1)
4079  {
4080  text_position_cleanup(&state);
4081  /* if first field, return input string, else empty string */
4082  if (fldnum == 1)
4083  PG_RETURN_TEXT_P(inputstring);
4084  else
4086  }
4087 
4088  /* identify bounds of first field */
4089  start_posn = 1;
4090  end_posn = text_position_next(1, &state);
4091 
4092  /* special case if fldsep not found at all */
4093  if (end_posn == 0)
4094  {
4095  text_position_cleanup(&state);
4096  /* if field 1 requested, return input string, else empty string */
4097  if (fldnum == 1)
4098  PG_RETURN_TEXT_P(inputstring);
4099  else
4101  }
4102 
4103  while (end_posn > 0 && --fldnum > 0)
4104  {
4105  /* identify bounds of next field */
4106  start_posn = end_posn + fldsep_len;
4107  end_posn = text_position_next(start_posn, &state);
4108  }
4109 
4110  text_position_cleanup(&state);
4111 
4112  if (fldnum > 0)
4113  {
4114  /* N'th field separator not found */
4115  /* if last field requested, return it, else empty string */
4116  if (fldnum == 1)
4117  result_text = text_substring(PointerGetDatum(inputstring),
4118  start_posn,
4119  -1,
4120  true);
4121  else
4122  result_text = cstring_to_text("");
4123  }
4124  else
4125  {
4126  /* non-last field requested */
4127  result_text = text_substring(PointerGetDatum(inputstring),
4128  start_posn,
4129  end_posn - start_posn,
4130  false);
4131  }
4132 
4133  PG_RETURN_TEXT_P(result_text);
4134 }
#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 3387 of file varlena.c.

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

Referenced by load_libraries(), and PostmasterMain().

3389 {
3390  char *nextp = rawstring;
3391  bool done = false;
3392 
3393  *namelist = NIL;
3394 
3395  while (scanner_isspace(*nextp))
3396  nextp++; /* skip leading whitespace */
3397 
3398  if (*nextp == '\0')
3399  return true; /* allow empty string */
3400 
3401  /* At the top of the loop, we are at start of a new directory. */
3402  do
3403  {
3404  char *curname;
3405  char *endp;
3406 
3407  if (*nextp == '"')
3408  {
3409  /* Quoted name --- collapse quote-quote pairs */
3410  curname = nextp + 1;
3411  for (;;)
3412  {
3413  endp = strchr(nextp + 1, '"');
3414  if (endp == NULL)
3415  return false; /* mismatched quotes */
3416  if (endp[1] != '"')
3417  break; /* found end of quoted name */
3418  /* Collapse adjacent quotes into one quote, and look again */
3419  memmove(endp, endp + 1, strlen(endp));
3420  nextp = endp;
3421  }
3422  /* endp now points at the terminating quote */
3423  nextp = endp + 1;
3424  }
3425  else
3426  {
3427  /* Unquoted name --- extends to separator or end of string */
3428  curname = endp = nextp;
3429  while (*nextp && *nextp != separator)
3430  {
3431  /* trailing whitespace should not be included in name */
3432  if (!scanner_isspace(*nextp))
3433  endp = nextp + 1;
3434  nextp++;
3435  }
3436  if (curname == endp)
3437  return false; /* empty unquoted name not allowed */
3438  }
3439 
3440  while (scanner_isspace(*nextp))
3441  nextp++; /* skip trailing whitespace */
3442 
3443  if (*nextp == separator)
3444  {
3445  nextp++;
3446  while (scanner_isspace(*nextp))
3447  nextp++; /* skip leading whitespace for next */
3448  /* we expect another name, so done remains false */
3449  }
3450  else if (*nextp == '\0')
3451  done = true;
3452  else
3453  return false; /* invalid syntax */
3454 
3455  /* Now safe to overwrite separator with a null */
3456  *endp = '\0';
3457 
3458  /* Truncate path if it's overlength */
3459  if (strlen(curname) >= MAXPGPATH)
3460  curname[MAXPGPATH - 1] = '\0';
3461 
3462  /*
3463  * Finished isolating current name --- add it to list
3464  */
3465  curname = pstrdup(curname);
3466  canonicalize_path(curname);
3467  *namelist = lappend(*namelist, curname);
3468 
3469  /* Loop back if we didn't reach end of string */
3470  } while (!done);
3471 
3472  return true;
3473 }
#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:1059
List * lappend(List *list, void *datum)
Definition: list.c:128
bool scanner_isspace(char ch)
Definition: scansup.c:221
#define NULL
Definition: c.h:229
bool SplitIdentifierString ( char *  rawstring,
char  separator,
List **  namelist 
)

Definition at line 3260 of file varlena.c.

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

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

3262 {
3263  char *nextp = rawstring;
3264  bool done = false;
3265 
3266  *namelist = NIL;
3267 
3268  while (scanner_isspace(*nextp))
3269  nextp++; /* skip leading whitespace */
3270 
3271  if (*nextp == '\0')
3272  return true; /* allow empty string */
3273 
3274  /* At the top of the loop, we are at start of a new identifier. */
3275  do
3276  {
3277  char *curname;
3278  char *endp;
3279 
3280  if (*nextp == '"')
3281  {
3282  /* Quoted name --- collapse quote-quote pairs, no downcasing */
3283  curname = nextp + 1;
3284  for (;;)
3285  {
3286  endp = strchr(nextp + 1, '"');
3287  if (endp == NULL)
3288  return false; /* mismatched quotes */
3289  if (endp[1] != '"')
3290  break; /* found end of quoted name */
3291  /* Collapse adjacent quotes into one quote, and look again */
3292  memmove(endp, endp + 1, strlen(endp));
3293  nextp = endp;
3294  }
3295  /* endp now points at the terminating quote */
3296  nextp = endp + 1;
3297  }
3298  else
3299  {
3300  /* Unquoted name --- extends to separator or whitespace */
3301  char *downname;
3302  int len;
3303 
3304  curname = nextp;
3305  while (*nextp && *nextp != separator &&
3306  !scanner_isspace(*nextp))
3307  nextp++;
3308  endp = nextp;
3309  if (curname == nextp)
3310  return false; /* empty unquoted name not allowed */
3311 
3312  /*
3313  * Downcase the identifier, using same code as main lexer does.
3314  *
3315  * XXX because we want to overwrite the input in-place, we cannot
3316  * support a downcasing transformation that increases the string
3317  * length. This is not a problem given the current implementation
3318  * of downcase_truncate_identifier, but we'll probably have to do
3319  * something about this someday.
3320  */
3321  len = endp - curname;
3322  downname = downcase_truncate_identifier(curname, len, false);
3323  Assert(strlen(downname) <= len);
3324  strncpy(curname, downname, len); /* strncpy is required here */
3325  pfree(downname);
3326  }
3327 
3328  while (scanner_isspace(*nextp))
3329  nextp++; /* skip trailing whitespace */
3330 
3331  if (*nextp == separator)
3332  {
3333  nextp++;
3334  while (scanner_isspace(*nextp))
3335  nextp++; /* skip leading whitespace for next */
3336  /* we expect another name, so done remains false */
3337  }
3338  else if (*nextp == '\0')
3339  done = true;
3340  else
3341  return false; /* invalid syntax */
3342 
3343  /* Now safe to overwrite separator with a null */
3344  *endp = '\0';
3345 
3346  /* Truncate name if it's overlength */
3347  truncate_identifier(curname, strlen(curname), false);
3348 
3349  /*
3350  * Finished isolating current name --- add it to list
3351  */
3352  *namelist = lappend(*namelist, curname);
3353 
3354  /* Loop back if we didn't reach end of string */
3355  } while (!done);
3356 
3357  return true;
3358 }
#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:1059
List * lappend(List *list, void *datum)
Definition: list.c:128
bool scanner_isspace(char ch)
Definition: scansup.c:221
#define NULL
Definition: c.h:229
#define Assert(condition)
Definition: c.h:676
Datum string_agg_finalfn ( PG_FUNCTION_ARGS  )

Definition at line 4721 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.

4722 {
4723  StringInfo state;
4724 
4725  /* cannot be called directly because of internal-type argument */
4726  Assert(AggCheckCallContext(fcinfo, NULL));
4727 
4728  state = PG_ARGISNULL(0) ? NULL : (StringInfo) PG_GETARG_POINTER(0);
4729 
4730  if (state != NULL)
4732  else
4733  PG_RETURN_NULL();
4734 }
StringInfoData * StringInfo
Definition: stringinfo.h:43
#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:676
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
Definition: nodeAgg.c:4027
#define PG_RETURN_NULL()
Definition: fmgr.h:305
Datum string_agg_transfn ( PG_FUNCTION_ARGS  )

Definition at line 4695 of file varlena.c.

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

4696 {
4697  StringInfo state;
4698 
4699  state = PG_ARGISNULL(0) ? NULL : (StringInfo) PG_GETARG_POINTER(0);
4700 
4701  /* Append the value unless null. */
4702  if (!PG_ARGISNULL(1))
4703  {
4704  /* On the first time through, we ignore the delimiter. */
4705  if (state == NULL)
4706  state = makeStringAggState(fcinfo);
4707  else if (!PG_ARGISNULL(2))
4708  appendStringInfoText(state, PG_GETARG_TEXT_PP(2)); /* delimiter */
4709 
4710  appendStringInfoText(state, PG_GETARG_TEXT_PP(1)); /* value */
4711  }
4712 
4713  /*
4714  * The transition type for string_agg() is declared to be "internal",
4715  * which is a pass-by-value type the same size as a pointer.
4716  */
4717  PG_RETURN_POINTER(state);
4718 }
#define PG_RETURN_POINTER(x)
Definition: fmgr.h:321
StringInfoData * StringInfo
Definition: stringinfo.h:43
#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:3673
#define PG_ARGISNULL(n)
Definition: fmgr.h:174
#define NULL
Definition: c.h:229
static StringInfo makeStringAggState(FunctionCallInfo fcinfo)
Definition: varlena.c:4671
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:1633
#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 1617 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().

1618 {
1619  char *a1p,
1620  *a2p;
1621  int len1,
1622  len2;
1623 
1624  a1p = VARDATA_ANY(arg1);
1625  a2p = VARDATA_ANY(arg2);
1626 
1627  len1 = VARSIZE_ANY_EXHDR(arg1);
1628  len2 = VARSIZE_ANY_EXHDR(arg2);
1629 
1630  return varstr_cmp(a1p, len1, a2p, len2, collid);
1631 }
#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 4825 of file varlena.c.

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

4826 {
4827  text *result;
4828 
4829  result = concat_internal("", 0, fcinfo);
4830  if (result == NULL)
4831  PG_RETURN_NULL();
4832  PG_RETURN_TEXT_P(result);
4833 }
return result
Definition: formatting.c:1633
#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:4744
Definition: c.h:439
#define PG_RETURN_NULL()
Definition: fmgr.h:305
Datum text_concat_ws ( PG_FUNCTION_ARGS  )

Definition at line 4840 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().

4841 {
4842  char *sep;
4843  text *result;
4844 
4845  /* return NULL when separator is NULL */
4846  if (PG_ARGISNULL(0))
4847  PG_RETURN_NULL();
4849 
4850  result = concat_internal(sep, 1, fcinfo);
4851  if (result == NULL)
4852  PG_RETURN_NULL();
4853  PG_RETURN_TEXT_P(result);
4854 }
return result
Definition: formatting.c:1633
#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:4744
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 4957 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().

4958 {
4959  text *fmt;
4960  StringInfoData str;
4961  const char *cp;
4962  const char *start_ptr;
4963  const char *end_ptr;
4964  text *result;
4965  int arg;
4966  bool funcvariadic;
4967  int nargs;
4968  Datum *elements = NULL;
4969  bool *nulls = NULL;
4970  Oid element_type = InvalidOid;
4971  Oid prev_type = InvalidOid;
4972  Oid prev_width_type = InvalidOid;
4973  FmgrInfo typoutputfinfo;
4974  FmgrInfo typoutputinfo_width;
4975 
4976  /* When format string is null, immediately return null */
4977  if (PG_ARGISNULL(0))
4978  PG_RETURN_NULL();
4979 
4980  /* If argument is marked VARIADIC, expand array into elements */
4981  if (get_fn_expr_variadic(fcinfo->flinfo))
4982  {
4983  ArrayType *arr;
4984  int16 elmlen;
4985  bool elmbyval;
4986  char elmalign;
4987  int nitems;
4988 
4989  /* Should have just the one argument */
4990  Assert(PG_NARGS() == 2);
4991 
4992  /* If argument is NULL, we treat it as zero-length array */
4993  if (PG_ARGISNULL(1))
4994  nitems = 0;
4995  else
4996  {
4997  /*
4998  * Non-null argument had better be an array. We assume that any
4999  * call context that could let get_fn_expr_variadic return true
5000  * will have checked that a VARIADIC-labeled parameter actually is
5001  * an array. So it should be okay to just Assert that it's an
5002  * array rather than doing a full-fledged error check.
5003  */
5005 
5006  /* OK, safe to fetch the array value */
5007  arr = PG_GETARG_ARRAYTYPE_P(1);
5008 
5009  /* Get info about array element type */
5010  element_type = ARR_ELEMTYPE(arr);
5011  get_typlenbyvalalign(element_type,
5012  &elmlen, &elmbyval, &elmalign);
5013 
5014  /* Extract all array elements */
5015  deconstruct_array(arr, element_type, elmlen, elmbyval, elmalign,
5016  &elements, &nulls, &nitems);
5017  }
5018 
5019  nargs = nitems + 1;
5020  funcvariadic = true;
5021  }
5022  else
5023  {
5024  /* Non-variadic case, we'll process the arguments individually */
5025  nargs = PG_NARGS();
5026  funcvariadic = false;
5027  }
5028 
5029  /* Setup for main loop. */
5030  fmt = PG_GETARG_TEXT_PP(0);
5031  start_ptr = VARDATA_ANY(fmt);
5032  end_ptr = start_ptr + VARSIZE_ANY_EXHDR(fmt);
5033  initStringInfo(&str);
5034  arg = 1; /* next argument position to print */
5035 
5036  /* Scan format string, looking for conversion specifiers. */
5037  for (cp = start_ptr; cp < end_ptr; cp++)
5038  {
5039  int argpos;
5040  int widthpos;
5041  int flags;
5042  int width;
5043  Datum value;
5044  bool isNull;
5045  Oid typid;
5046 
5047  /*
5048  * If it's not the start of a conversion specifier, just copy it to
5049  * the output buffer.
5050  */
5051  if (*cp != '%')
5052  {
5053  appendStringInfoCharMacro(&str, *cp);
5054  continue;
5055  }
5056 
5057  ADVANCE_PARSE_POINTER(cp, end_ptr);
5058 
5059  /* Easy case: %% outputs a single % */
5060  if (*cp == '%')
5061  {
5062  appendStringInfoCharMacro(&str, *cp);
5063  continue;
5064  }
5065 
5066  /* Parse the optional portions of the format specifier */
5067  cp = text_format_parse_format(cp, end_ptr,
5068  &argpos, &widthpos,
5069  &flags, &width);
5070 
5071  /*
5072  * Next we should see the main conversion specifier. Whether or not
5073  * an argument position was present, it's known that at least one
5074  * character remains in the string at this point. Experience suggests
5075  * that it's worth checking that that character is one of the expected
5076  * ones before we try to fetch arguments, so as to produce the least
5077  * confusing response to a mis-formatted specifier.
5078  */
5079  if (strchr("sIL", *cp) == NULL)
5080  ereport(ERROR,
5081  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5082  errmsg("unrecognized format() type specifier \"%c\"",
5083  *cp),
5084  errhint("For a single \"%%\" use \"%%%%\".")));
5085 
5086  /* If indirect width was specified, get its value */
5087  if (widthpos >= 0)
5088  {
5089  /* Collect the specified or next argument position */
5090  if (widthpos > 0)
5091  arg = widthpos;
5092  if (arg >= nargs)
5093  ereport(ERROR,
5094  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5095  errmsg("too few arguments for format()")));
5096 
5097  /* Get the value and type of the selected argument */
5098  if (!funcvariadic)
5099  {
5100  value = PG_GETARG_DATUM(arg);
5101  isNull = PG_ARGISNULL(arg);
5102  typid = get_fn_expr_argtype(fcinfo->flinfo, arg);
5103  }
5104  else
5105  {
5106  value = elements[arg - 1];
5107  isNull = nulls[arg - 1];
5108  typid = element_type;
5109  }
5110  if (!OidIsValid(typid))
5111  elog(ERROR, "could not determine data type of format() input");
5112 
5113  arg++;
5114 
5115  /* We can treat NULL width the same as zero */
5116  if (isNull)
5117  width = 0;
5118  else if (typid == INT4OID)
5119  width = DatumGetInt32(value);
5120  else if (typid == INT2OID)
5121  width = DatumGetInt16(value);
5122  else
5123  {
5124  /* For less-usual datatypes, convert to text then to int */
5125  char *str;
5126 
5127  if (typid != prev_width_type)
5128  {
5129  Oid typoutputfunc;
5130  bool typIsVarlena;
5131 
5132  getTypeOutputInfo(typid, &typoutputfunc, &typIsVarlena);
5133  fmgr_info(typoutputfunc, &typoutputinfo_width);
5134  prev_width_type = typid;
5135  }
5136 
5137  str = OutputFunctionCall(&typoutputinfo_width, value);
5138 
5139  /* pg_atoi will complain about bad data or overflow */
5140  width = pg_atoi(str, sizeof(int), '\0');
5141 
5142  pfree(str);
5143  }
5144  }
5145 
5146  /* Collect the specified or next argument position */
5147  if (argpos > 0)
5148  arg = argpos;
5149  if (arg >= nargs)
5150  ereport(ERROR,
5151  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5152  errmsg("too few arguments for format()")));
5153 
5154  /* Get the value and type of the selected argument */
5155  if (!funcvariadic)
5156  {
5157  value = PG_GETARG_DATUM(arg);
5158  isNull = PG_ARGISNULL(arg);
5159  typid = get_fn_expr_argtype(fcinfo->flinfo, arg);
5160  }
5161  else
5162  {
5163  value = elements[arg - 1];
5164  isNull = nulls[arg - 1];
5165  typid = element_type;
5166  }
5167  if (!OidIsValid(typid))
5168  elog(ERROR, "could not determine data type of format() input");
5169 
5170  arg++;
5171 
5172  /*
5173  * Get the appropriate typOutput function, reusing previous one if
5174  * same type as previous argument. That's particularly useful in the
5175  * variadic-array case, but often saves work even for ordinary calls.
5176  */
5177  if (typid != prev_type)
5178  {
5179  Oid typoutputfunc;
5180  bool typIsVarlena;
5181 
5182  getTypeOutputInfo(typid, &typoutputfunc, &typIsVarlena);
5183  fmgr_info(typoutputfunc, &typoutputfinfo);
5184  prev_type = typid;
5185  }
5186 
5187  /*
5188  * And now we can format the value.
5189  */
5190  switch (*cp)
5191  {
5192  case 's':
5193  case 'I':
5194  case 'L':
5195  text_format_string_conversion(&str, *cp, &typoutputfinfo,
5196  value, isNull,
5197  flags, width);
5198  break;
5199  default:
5200  /* should not get here, because of previous check */
5201  ereport(ERROR,
5202  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5203  errmsg("unrecognized format() type specifier \"%c\"",
5204  *cp),
5205  errhint("For a single \"%%\" use \"%%%%\".")));
5206  break;
5207  }
5208  }
5209 
5210  /* Don't need deconstruct_array results anymore. */
5211  if (elements != NULL)
5212  pfree(elements);
5213  if (nulls != NULL)
5214  pfree(nulls);
5215 
5216  /* Generate results. */
5217  result = cstring_to_text_with_len(str.data, str.len);
5218  pfree(str.data);
5219 
5220  PG_RETURN_TEXT_P(result);
5221 }
signed short int16
Definition: c.h:255
#define ADVANCE_PARSE_POINTER(ptr, end_ptr)
Definition: varlena.c:4944
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:5360
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:1633
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:127
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
static struct @121 value
#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:46
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:676
#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:5283
#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 5409 of file varlena.c.

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

Referenced by text_format_string_conversion().

5411 {
5412  bool align_to_left = false;
5413  int len;
5414 
5415  /* fast path for typical easy case */
5416  if (width == 0)
5417  {
5418  appendStringInfoString(buf, str);
5419  return;
5420  }
5421 
5422  if (width < 0)
5423  {
5424  /* Negative width: implicit '-' flag, then take absolute value */
5425  align_to_left = true;
5426  /* -INT_MIN is undefined */
5427  if (width <= INT_MIN)
5428  ereport(ERROR,
5429  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
5430  errmsg("number is out of range")));
5431  width = -width;
5432  }
5433  else if (flags & TEXT_FORMAT_FLAG_MINUS)
5434  align_to_left = true;
5435 
5436  len = pg_mbstrlen(str);
5437  if (align_to_left)
5438  {
5439  /* left justify */
5440  appendStringInfoString(buf, str);
5441  if (len < width)
5442  appendStringInfoSpaces(buf, width - len);
5443  }
5444  else
5445  {
5446  /* right justify */
5447  if (len < width)
5448  appendStringInfoSpaces(buf, width - len);
5449  appendStringInfoString(buf, str);
5450  }
5451 }
int errcode(int sqlerrcode)
Definition: elog.c:575
#define ERROR
Definition: elog.h:43
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:157
#define ereport(elevel, rest)
Definition: elog.h:122
void appendStringInfoSpaces(StringInfo str, int count)
Definition: stringinfo.c:187
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:4942
Datum text_format_nv ( PG_FUNCTION_ARGS  )

Definition at line 5461 of file varlena.c.

References text_format().

5462 {
5463  return text_format(fcinfo);
5464 }
Datum text_format(PG_FUNCTION_ARGS)
Definition: varlena.c:4957
static bool text_format_parse_digits ( const char **  ptr,
const char *  end_ptr,
int *  value 
)
static

Definition at line 5234 of file varlena.c.

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

Referenced by text_format_parse_format().

5235 {
5236  bool found = false;
5237  const char *cp = *ptr;
5238  int val = 0;
5239 
5240  while (*cp >= '0' && *cp <= '9')
5241  {
5242  int newval = val * 10 + (*cp - '0');
5243 
5244  if (newval / 10 != val) /* overflow? */
5245  ereport(ERROR,
5246  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
5247  errmsg("number is out of range")));
5248  val = newval;
5249  ADVANCE_PARSE_POINTER(cp, end_ptr);
5250  found = true;
5251  }
5252 
5253  *ptr = cp;
5254  *value = val;
5255 
5256  return found;
5257 }
#define ADVANCE_PARSE_POINTER(ptr, end_ptr)
Definition: varlena.c:4944
int errcode(int sqlerrcode)
Definition: elog.c:575
#define ERROR
Definition: elog.h:43
static struct @121 value
#define ereport(elevel, rest)
Definition: elog.h:122
#define newval
int errmsg(const char *fmt,...)
Definition: elog.c:797
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 5283 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().

5286 {
5287  const char *cp = start_ptr;
5288  int n;
5289 
5290  /* set defaults for output parameters */
5291  *argpos = -1;
5292  *widthpos = -1;
5293  *flags = 0;
5294  *width = 0;
5295 
5296  /* try to identify first number */
5297  if (text_format_parse_digits(&cp, end_ptr, &n))
5298  {
5299  if (*cp != '$')
5300  {
5301  /* Must be just a width and a type, so we're done */
5302  *width = n;
5303  return cp;
5304  }
5305  /* The number was argument position */
5306  *argpos = n;
5307  /* Explicit 0 for argument index is immediately refused */
5308  if (n == 0)
5309  ereport(ERROR,
5310  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5311  errmsg("format specifies argument 0, but arguments are numbered from 1")));
5312  ADVANCE_PARSE_POINTER(cp, end_ptr);
5313  }
5314 
5315  /* Handle flags (only minus is supported now) */
5316  while (*cp == '-')
5317  {
5318  *flags |= TEXT_FORMAT_FLAG_MINUS;
5319  ADVANCE_PARSE_POINTER(cp, end_ptr);
5320  }
5321 
5322  if (*cp == '*')
5323  {
5324  /* Handle indirect width */
5325  ADVANCE_PARSE_POINTER(cp, end_ptr);
5326  if (text_format_parse_digits(&cp, end_ptr, &n))
5327  {
5328  /* number in this position must be closed by $ */
5329  if (*cp != '$')
5330  ereport(ERROR,
5331  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5332  errmsg("width argument position must be ended by \"$\"")));
5333  /* The number was width argument position */
5334  *widthpos = n;
5335  /* Explicit 0 for argument index is immediately refused */
5336  if (n == 0)
5337  ereport(ERROR,
5338  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5339  errmsg("format specifies argument 0, but arguments are numbered from 1")));
5340  ADVANCE_PARSE_POINTER(cp, end_ptr);
5341  }
5342  else
5343  *widthpos = 0; /* width's argument position is unspecified */
5344  }
5345  else
5346  {
5347  /* Check for direct width specification */
5348  if (text_format_parse_digits(&cp, end_ptr, &n))
5349  *width = n;
5350  }
5351 
5352  /* cp should now be pointing at type character */
5353  return cp;
5354 }
#define ADVANCE_PARSE_POINTER(ptr, end_ptr)
Definition: varlena.c:4944
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:5234
int errmsg(const char *fmt,...)
Definition: elog.c:797
#define TEXT_FORMAT_FLAG_MINUS
Definition: varlena.c:4942
static void text_format_string_conversion ( StringInfo  buf,
char  conversion,
FmgrInfo typOutputInfo,
Datum  value,
bool  isNull,
int  flags,
int  width 
)
static

Definition at line 5360 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().

5364 {
5365  char *str;
5366 
5367  /* Handle NULL arguments before trying to stringify the value. */
5368  if (isNull)
5369  {
5370  if (conversion == 's')
5371  text_format_append_string(buf, "", flags, width);
5372  else if (conversion == 'L')
5373  text_format_append_string(buf, "NULL", flags, width);
5374  else if (conversion == 'I')
5375  ereport(ERROR,
5376  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
5377  errmsg("null values cannot be formatted as an SQL identifier")));
5378  return;
5379  }
5380 
5381  /* Stringify. */
5382  str = OutputFunctionCall(typOutputInfo, value);
5383 
5384  /* Escape. */
5385  if (conversion == 'I')
5386  {
5387  /* quote_identifier may or may not allocate a new string. */
5388  text_format_append_string(buf, quote_identifier(str), flags, width);
5389  }
5390  else if (conversion == 'L')
5391  {
5392  char *qstr = quote_literal_cstr(str);
5393 
5394  text_format_append_string(buf, qstr, flags, width);
5395  /* quote_literal_cstr() always allocates a new string */
5396  pfree(qstr);
5397  }
5398  else
5399  text_format_append_string(buf, str, flags, width);
5400 
5401  /* Cleanup. */
5402  pfree(str);
5403 }
char * quote_literal_cstr(const char *rawstr)
Definition: quote.c:102
const char * quote_identifier(const char *ident)
Definition: ruleutils.c:10381
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:5409
char * OutputFunctionCall(FmgrInfo *flinfo, Datum val)
Definition: fmgr.c:1667
void pfree(void *pointer)
Definition: mcxt.c:950
#define ERROR
Definition: elog.h:43
static struct @121 value
#define ereport(elevel, rest)
Definition: elog.h:122
int errmsg(const char *fmt,...)
Definition: elog.c:797
Datum text_ge ( PG_FUNCTION_ARGS  )

Definition at line 1751 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().

1752 {
1753  text *arg1 = PG_GETARG_TEXT_PP(0);
1754  text *arg2 = PG_GETARG_TEXT_PP(1);
1755  bool result;
1756 
1757  result = (text_cmp(arg1, arg2, PG_GET_COLLATION()) >= 0);
1758 
1759  PG_FREE_IF_COPY(arg1, 0);
1760  PG_FREE_IF_COPY(arg2, 1);
1761 
1762  PG_RETURN_BOOL(result);
1763 }
return result
Definition: formatting.c:1633
#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:1617
#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 1736 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().

1737 {
1738  text *arg1 = PG_GETARG_TEXT_PP(0);
1739  text *arg2 = PG_GETARG_TEXT_PP(1);
1740  bool result;
1741 
1742  result = (text_cmp(arg1, arg2, PG_GET_COLLATION()) > 0);
1743 
1744  PG_FREE_IF_COPY(arg1, 0);
1745  PG_FREE_IF_COPY(arg2, 1);
1746 
1747  PG_RETURN_BOOL(result);
1748 }
return result
Definition: formatting.c:1633
#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:1617
#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 4140 of file varlena.c.

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

Referenced by text_to_array_internal().

4141 {
4143  PointerGetDatum(txt1),
4144  PointerGetDatum(txt2)));
4145 }
#define PointerGetDatum(X)
Definition: postgres.h:562
Datum texteq(PG_FUNCTION_ARGS)
Definition: varlena.c:1642
#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 2587 of file varlena.c.

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

2588 {
2589  text *arg1 = PG_GETARG_TEXT_PP(0);
2590  text *arg2 = PG_GETARG_TEXT_PP(1);
2591  text *result;
2592 
2593  result = ((text_cmp(arg1, arg2, PG_GET_COLLATION()) > 0) ? arg1 : arg2);
2594 
2595  PG_RETURN_TEXT_P(result);
2596 }
return result
Definition: formatting.c:1633
#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:1617
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:330
Definition: c.h:439
Datum text_le ( PG_FUNCTION_ARGS  )

Definition at line 1721 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().

1722 {
1723  text *arg1 = PG_GETARG_TEXT_PP(0);
1724  text *arg2 = PG_GETARG_TEXT_PP(1);
1725  bool result;
1726 
1727  result = (text_cmp(arg1, arg2, PG_GET_COLLATION()) <= 0);
1728 
1729  PG_FREE_IF_COPY(arg1, 0);
1730  PG_FREE_IF_COPY(arg2, 1);
1731 
1732  PG_RETURN_BOOL(result);
1733 }
return result
Definition: formatting.c:1633
#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:1617
#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 4861 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.

4862 {
4863  text *str = PG_GETARG_TEXT_PP(0);
4864  const char *p = VARDATA_ANY(str);
4865  int len = VARSIZE_ANY_EXHDR(str);
4866  int n = PG_GETARG_INT32(1);
4867  int rlen;
4868 
4869  if (n < 0)
4870  n = pg_mbstrlen_with_len(p, len) + n;
4871  rlen = pg_mbcharcliplen(p, len, n);
4872 
4874 }
#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 1706 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().

1707 {
1708  text *arg1 = PG_GETARG_TEXT_PP(0);
1709  text *arg2 = PG_GETARG_TEXT_PP(1);
1710  bool result;
1711 
1712  result = (text_cmp(arg1, arg2, PG_GET_COLLATION()) < 0);
1713 
1714  PG_FREE_IF_COPY(arg1, 0);
1715  PG_FREE_IF_COPY(arg2, 1);
1716 
1717  PG_RETURN_BOOL(result);
1718 }
return result
Definition: formatting.c:1633
#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:1617
#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 3162 of file varlena.c.

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

3163 {
3164  text *s = PG_GETARG_TEXT_PP(0);
3165  Name result;
3166  int len;
3167 
3168  len = VARSIZE_ANY_EXHDR(s);
3169 
3170  /* Truncate oversize input */
3171  if (len >= NAMEDATALEN)
3172  len = pg_mbcliplen(VARDATA_ANY(s), len, NAMEDATALEN - 1);
3173 
3174  /* We use palloc0 here to ensure result is zero-padded */
3175  result = (Name) palloc0(NAMEDATALEN);
3176  memcpy(NameStr(*result), VARDATA_ANY(s), len);
3177 
3178  PG_RETURN_NAME(result);
3179 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:347
return result
Definition: formatting.c:1633
#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:1633
#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 2674 of file varlena.c.

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

2675 {
2676  text *arg1 = PG_GETARG_TEXT_PP(0);
2677  text *arg2 = PG_GETARG_TEXT_PP(1);
2678  int result;
2679 
2680  result = internal_text_pattern_compare(arg1, arg2);
2681 
2682  PG_FREE_IF_COPY(arg1, 0);
2683  PG_FREE_IF_COPY(arg2, 1);
2684 
2685  PG_RETURN_BOOL(result >= 0);
2686 }
return result
Definition: formatting.c:1633
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int internal_text_pattern_compare(text *arg1, text *arg2)
Definition: varlena.c:2620
#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 2690 of file varlena.c.

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

2691 {
2692  text *arg1 = PG_GETARG_TEXT_PP(0);
2693  text *arg2 = PG_GETARG_TEXT_PP(1);
2694  int result;
2695 
2696  result = internal_text_pattern_compare(arg1, arg2);
2697 
2698  PG_FREE_IF_COPY(arg1, 0);
2699  PG_FREE_IF_COPY(arg2, 1);
2700 
2701  PG_RETURN_BOOL(result > 0);
2702 }
return result
Definition: formatting.c:1633
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int internal_text_pattern_compare(text *arg1, text *arg2)
Definition: varlena.c:2620
#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 2658 of file varlena.c.

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

2659 {
2660  text *arg1 = PG_GETARG_TEXT_PP(0);
2661  text *arg2 = PG_GETARG_TEXT_PP(1);
2662  int result;
2663 
2664  result = internal_text_pattern_compare(arg1, arg2);
2665 
2666  PG_FREE_IF_COPY(arg1, 0);
2667  PG_FREE_IF_COPY(arg2, 1);
2668 
2669  PG_RETURN_BOOL(result <= 0);
2670 }
return result
Definition: formatting.c:1633
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int internal_text_pattern_compare(text *arg1, text *arg2)
Definition: varlena.c:2620
#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 2642 of file varlena.c.

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

2643 {
2644  text *arg1 = PG_GETARG_TEXT_PP(0);
2645  text *arg2 = PG_GETARG_TEXT_PP(1);
2646  int result;
2647 
2648  result = internal_text_pattern_compare(arg1, arg2);
2649 
2650  PG_FREE_IF_COPY(arg1, 0);
2651  PG_FREE_IF_COPY(arg2, 1);
2652 
2653  PG_RETURN_BOOL(result < 0);
2654 }
return result
Definition: formatting.c:1633
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:273
static int internal_text_pattern_compare(text *arg1, text *arg2)
Definition: varlena.c:2620
#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:1633
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:676
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 4902 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.

4903 {
4904  text *str = PG_GETARG_TEXT_PP(0);
4905  const char *p = VARDATA_ANY(str);
4906  int len = VARSIZE_ANY_EXHDR(str);
4907  const char *endp = p + len;
4908  text *result;
4909  char *dst;
4910 
4911  result = palloc(len + VARHDRSZ);
4912  dst = (char *) VARDATA(result) + len;
4913  SET_VARSIZE(result, len + VARHDRSZ);
4914 
4916  {
4917  /* multibyte version */
4918  while (p < endp)
4919  {
4920  int sz;
4921 
4922  sz = pg_mblen(p);
4923  dst -= sz;
4924  memcpy(dst, p, sz);
4925  p += sz;
4926  }
4927  }
4928  else
4929  {
4930  /* single byte version */
4931  while (p < endp)
4932  *(--dst) = *p++;
4933  }
4934 
4935  PG_RETURN_TEXT_P(result);
4936 }
#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:1633
#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 4881 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.

4882 {
4883  text *str = PG_GETARG_TEXT_PP(0);
4884  const char *p = VARDATA_ANY(str);
4885  int len = VARSIZE_ANY_EXHDR(str);
4886  int n = PG_GETARG_INT32(1);
4887  int off;
4888 
4889  if (n < 0)
4890  n = -n;
4891  else
4892  n = pg_mbstrlen_with_len(p, len) - n;
4893  off = pg_mbcharcliplen(p, len, n);
4894 
4895  PG_RETURN_TEXT_P(cstring_to_text_with_len(p + off, len - off));
4896 }
#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 2599 of file varlena.c.

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

2600 {
2601  text *arg1 = PG_GETARG_TEXT_PP(0);
2602  text *arg2 = PG_GETARG_TEXT_PP(1);
2603  text *result;
2604 
2605  result = ((text_cmp(arg1, arg2, PG_GET_COLLATION()) < 0) ? arg1 : arg2);
2606 
2607  PG_RETURN_TEXT_P(result);
2608 }
return result
Definition: formatting.c:1633
#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:1617
#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:807
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:801
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