#include "postgres.h"
#include "common/int.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "utils/builtins.h"
#include "utils/formatting.h"
#include "utils/memutils.h"
#include "varatt.h"

Include dependency graph for oracle_compat.c:

Functions
static text *	dotrim (const char string, int stringlen, const char set, int setlen, bool doltrim, bool dortrim)

static bytea *	dobyteatrim (bytea string, bytea set, bool doltrim, bool dortrim)

Datum	lower (PG_FUNCTION_ARGS)

Datum	upper (PG_FUNCTION_ARGS)

Datum	initcap (PG_FUNCTION_ARGS)

Datum	lpad (PG_FUNCTION_ARGS)

Datum	rpad (PG_FUNCTION_ARGS)

Datum	btrim (PG_FUNCTION_ARGS)

Datum	btrim1 (PG_FUNCTION_ARGS)

Datum	byteatrim (PG_FUNCTION_ARGS)

Datum	bytealtrim (PG_FUNCTION_ARGS)

Datum	byteartrim (PG_FUNCTION_ARGS)

Datum	ltrim (PG_FUNCTION_ARGS)

Datum	ltrim1 (PG_FUNCTION_ARGS)

Datum	rtrim (PG_FUNCTION_ARGS)

Datum	rtrim1 (PG_FUNCTION_ARGS)

Datum	translate (PG_FUNCTION_ARGS)

Datum	ascii (PG_FUNCTION_ARGS)

Datum	chr (PG_FUNCTION_ARGS)

Datum	repeat (PG_FUNCTION_ARGS)

Function Documentation

◆ ascii()

Datum ascii ( PG_FUNCTION_ARGS )

Definition at line 925 of file oracle_compat.c.

 {
     text       *string = PG_GETARG_TEXT_PP(0);
     int         encoding = GetDatabaseEncoding();
     unsigned char *data;
  
     if (VARSIZE_ANY_EXHDR(string) <= 0)
         PG_RETURN_INT32(0);
  
     data = (unsigned char *) VARDATA_ANY(string);
  
     if (encoding == PG_UTF8 && *data > 127)
     {
         /* return the code point for Unicode */
  
         int         result = 0,
                     tbytes = 0,
                     i;
  
         if (*data >= 0xF0)
         {
             result = *data & 0x07;
             tbytes = 3;
         }
         else if (*data >= 0xE0)
         {
             result = *data & 0x0F;
             tbytes = 2;
         }
         else
         {
             Assert(*data > 0xC0);
             result = *data & 0x1f;
             tbytes = 1;
         }
  
         Assert(tbytes > 0);
  
         for (i = 1; i <= tbytes; i++)
         {
             Assert((data[i] & 0xC0) == 0x80);
             result = (result << 6) + (data[i] & 0x3f);
         }
  
         PG_RETURN_INT32(result);
     }
     else
     {
         if (pg_encoding_max_length(encoding) > 1 && *data > 127)
             ereport(ERROR,
                     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                      errmsg("requested character too large")));
  
  
         PG_RETURN_INT32((int32) *data);
     }
 }

References Assert, data, encoding, ereport, errcode(), errmsg(), ERROR, GetDatabaseEncoding(), i, pg_encoding_max_length(), PG_GETARG_TEXT_PP, PG_RETURN_INT32, PG_UTF8, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by float4out(), float8out_internal(), and pg_to_ascii().

◆ btrim()

Datum btrim ( PG_FUNCTION_ARGS )

Definition at line 342 of file oracle_compat.c.

 {
     text       *string = PG_GETARG_TEXT_PP(0);
     text       *set = PG_GETARG_TEXT_PP(1);
     text       *ret;
  
     ret = dotrim(VARDATA_ANY(string), VARSIZE_ANY_EXHDR(string),
                  VARDATA_ANY(set), VARSIZE_ANY_EXHDR(set),
                  true, true);
  
     PG_RETURN_TEXT_P(ret);
 }

References dotrim(), PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

◆ btrim1()

Datum btrim1 ( PG_FUNCTION_ARGS )

Definition at line 362 of file oracle_compat.c.

 {
     text       *string = PG_GETARG_TEXT_PP(0);
     text       *ret;
  
     ret = dotrim(VARDATA_ANY(string), VARSIZE_ANY_EXHDR(string),
                  " ", 1,
                  true, true);
  
     PG_RETURN_TEXT_P(ret);
 }

References dotrim(), PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

◆ bytealtrim()

Datum bytealtrim ( PG_FUNCTION_ARGS )

Definition at line 644 of file oracle_compat.c.

 {
     bytea      *string = PG_GETARG_BYTEA_PP(0);
     bytea      *set = PG_GETARG_BYTEA_PP(1);
     bytea      *ret;
  
     ret = dobyteatrim(string, set, true, false);
  
     PG_RETURN_BYTEA_P(ret);
 }

References dobyteatrim(), PG_GETARG_BYTEA_PP, and PG_RETURN_BYTEA_P.

◆ byteartrim()

Datum byteartrim ( PG_FUNCTION_ARGS )

Definition at line 671 of file oracle_compat.c.

 {
     bytea      *string = PG_GETARG_BYTEA_PP(0);
     bytea      *set = PG_GETARG_BYTEA_PP(1);
     bytea      *ret;
  
     ret = dobyteatrim(string, set, false, true);
  
     PG_RETURN_BYTEA_P(ret);
 }

References dobyteatrim(), PG_GETARG_BYTEA_PP, and PG_RETURN_BYTEA_P.

◆ byteatrim()

Datum byteatrim ( PG_FUNCTION_ARGS )

Definition at line 617 of file oracle_compat.c.

 {
     bytea      *string = PG_GETARG_BYTEA_PP(0);
     bytea      *set = PG_GETARG_BYTEA_PP(1);
     bytea      *ret;
  
     ret = dobyteatrim(string, set, true, true);
  
     PG_RETURN_BYTEA_P(ret);
 }

References dobyteatrim(), PG_GETARG_BYTEA_PP, and PG_RETURN_BYTEA_P.

◆ chr()

Datum chr ( PG_FUNCTION_ARGS )

Definition at line 1006 of file oracle_compat.c.

 {
     int32       arg = PG_GETARG_INT32(0);
     uint32      cvalue;
     text       *result;
     int         encoding = GetDatabaseEncoding();
  
     /*
      * Error out on arguments that make no sense or that we can't validly
      * represent in the encoding.
      */
     if (arg < 0)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("character number must be positive")));
     else if (arg == 0)
         ereport(ERROR,
                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                  errmsg("null character not permitted")));
  
     cvalue = arg;
  
     if (encoding == PG_UTF8 && cvalue > 127)
     {
         /* for Unicode we treat the argument as a code point */
         int         bytes;
         unsigned char *wch;
  
         /*
          * We only allow valid Unicode code points; per RFC3629 that stops at
          * U+10FFFF, even though 4-byte UTF8 sequences can hold values up to
          * U+1FFFFF.
          */
         if (cvalue > 0x0010ffff)
             ereport(ERROR,
                     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                      errmsg("requested character too large for encoding: %u",
                             cvalue)));
  
         if (cvalue > 0xffff)
             bytes = 4;
         else if (cvalue > 0x07ff)
             bytes = 3;
         else
             bytes = 2;
  
         result = (text *) palloc(VARHDRSZ + bytes);
         SET_VARSIZE(result, VARHDRSZ + bytes);
         wch = (unsigned char *) VARDATA(result);
  
         if (bytes == 2)
         {
             wch[0] = 0xC0 | ((cvalue >> 6) & 0x1F);
             wch[1] = 0x80 | (cvalue & 0x3F);
         }
         else if (bytes == 3)
         {
             wch[0] = 0xE0 | ((cvalue >> 12) & 0x0F);
             wch[1] = 0x80 | ((cvalue >> 6) & 0x3F);
             wch[2] = 0x80 | (cvalue & 0x3F);
         }
         else
         {
             wch[0] = 0xF0 | ((cvalue >> 18) & 0x07);
             wch[1] = 0x80 | ((cvalue >> 12) & 0x3F);
             wch[2] = 0x80 | ((cvalue >> 6) & 0x3F);
             wch[3] = 0x80 | (cvalue & 0x3F);
         }
  
         /*
          * The preceding range check isn't sufficient, because UTF8 excludes
          * Unicode "surrogate pair" codes.  Make sure what we created is valid
          * UTF8.
          */
         if (!pg_utf8_islegal(wch, bytes))
             ereport(ERROR,
                     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                      errmsg("requested character not valid for encoding: %u",
                             cvalue)));
     }
     else
     {
         bool        is_mb;
  
         is_mb = pg_encoding_max_length(encoding) > 1;
  
         if ((is_mb && (cvalue > 127)) || (!is_mb && (cvalue > 255)))
             ereport(ERROR,
                     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                      errmsg("requested character too large for encoding: %u",
                             cvalue)));
  
         result = (text *) palloc(VARHDRSZ + 1);
         SET_VARSIZE(result, VARHDRSZ + 1);
         *VARDATA(result) = (char) cvalue;
     }
  
     PG_RETURN_TEXT_P(result);
 }

References arg, encoding, ereport, errcode(), errmsg(), ERROR, GetDatabaseEncoding(), palloc(), pg_encoding_max_length(), PG_GETARG_INT32, PG_RETURN_TEXT_P, PG_UTF8, pg_utf8_islegal(), SET_VARSIZE, VARDATA, and VARHDRSZ.

◆ dobyteatrim()

bytea * dobyteatrim	(	bytea *	string,
		bytea *	set,
		bool	doltrim,
		bool	dortrim
	)

static

Definition at line 534 of file oracle_compat.c.

 {
     bytea      *ret;
     char       *ptr,
                *end,
                *ptr2,
                *ptr2start,
                *end2;
     int         m,
                 stringlen,
                 setlen;
  
     stringlen = VARSIZE_ANY_EXHDR(string);
     setlen = VARSIZE_ANY_EXHDR(set);
  
     if (stringlen <= 0 || setlen <= 0)
         return string;
  
     m = stringlen;
     ptr = VARDATA_ANY(string);
     end = ptr + stringlen - 1;
     ptr2start = VARDATA_ANY(set);
     end2 = ptr2start + setlen - 1;
  
     if (doltrim)
     {
         while (m > 0)
         {
             ptr2 = ptr2start;
             while (ptr2 <= end2)
             {
                 if (*ptr == *ptr2)
                     break;
                 ++ptr2;
             }
             if (ptr2 > end2)
                 break;
             ptr++;
             m--;
         }
     }
  
     if (dortrim)
     {
         while (m > 0)
         {
             ptr2 = ptr2start;
             while (ptr2 <= end2)
             {
                 if (*end == *ptr2)
                     break;
                 ++ptr2;
             }
             if (ptr2 > end2)
                 break;
             end--;
             m--;
         }
     }
  
     ret = (bytea *) palloc(VARHDRSZ + m);
     SET_VARSIZE(ret, VARHDRSZ + m);
     memcpy(VARDATA(ret), ptr, m);
     return ret;
 }

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

Referenced by bytealtrim(), byteartrim(), and byteatrim().

◆ dotrim()

static text * dotrim	(	const char *	string,
		int	stringlen,
		const char *	set,
		int	setlen,
		bool	doltrim,
		bool	dortrim
	)

static

Definition at line 378 of file oracle_compat.c.

 {
     int         i;
  
     /* Nothing to do if either string or set is empty */
     if (stringlen > 0 && setlen > 0)
     {
         if (pg_database_encoding_max_length() > 1)
         {
             /*
              * In the multibyte-encoding case, build arrays of pointers to
              * character starts, so that we can avoid inefficient checks in
              * the inner loops.
              */
             const char **stringchars;
             const char **setchars;
             int        *stringmblen;
             int        *setmblen;
             int         stringnchars;
             int         setnchars;
             int         resultndx;
             int         resultnchars;
             const char *p;
             int         len;
             int         mblen;
             const char *str_pos;
             int         str_len;
  
             stringchars = (const char **) palloc(stringlen * sizeof(char *));
             stringmblen = (int *) palloc(stringlen * sizeof(int));
             stringnchars = 0;
             p = string;
             len = stringlen;
             while (len > 0)
             {
                 stringchars[stringnchars] = p;
                 stringmblen[stringnchars] = mblen = pg_mblen(p);
                 stringnchars++;
                 p += mblen;
                 len -= mblen;
             }
  
             setchars = (const char **) palloc(setlen * sizeof(char *));
             setmblen = (int *) palloc(setlen * sizeof(int));
             setnchars = 0;
             p = set;
             len = setlen;
             while (len > 0)
             {
                 setchars[setnchars] = p;
                 setmblen[setnchars] = mblen = pg_mblen(p);
                 setnchars++;
                 p += mblen;
                 len -= mblen;
             }
  
             resultndx = 0;      /* index in stringchars[] */
             resultnchars = stringnchars;
  
             if (doltrim)
             {
                 while (resultnchars > 0)
                 {
                     str_pos = stringchars[resultndx];
                     str_len = stringmblen[resultndx];
                     for (i = 0; i < setnchars; i++)
                     {
                         if (str_len == setmblen[i] &&
                             memcmp(str_pos, setchars[i], str_len) == 0)
                             break;
                     }
                     if (i >= setnchars)
                         break;  /* no match here */
                     string += str_len;
                     stringlen -= str_len;
                     resultndx++;
                     resultnchars--;
                 }
             }
  
             if (dortrim)
             {
                 while (resultnchars > 0)
                 {
                     str_pos = stringchars[resultndx + resultnchars - 1];
                     str_len = stringmblen[resultndx + resultnchars - 1];
                     for (i = 0; i < setnchars; i++)
                     {
                         if (str_len == setmblen[i] &&
                             memcmp(str_pos, setchars[i], str_len) == 0)
                             break;
                     }
                     if (i >= setnchars)
                         break;  /* no match here */
                     stringlen -= str_len;
                     resultnchars--;
                 }
             }
  
             pfree(stringchars);
             pfree(stringmblen);
             pfree(setchars);
             pfree(setmblen);
         }
         else
         {
             /*
              * In the single-byte-encoding case, we don't need such overhead.
              */
             if (doltrim)
             {
                 while (stringlen > 0)
                 {
                     char        str_ch = *string;
  
                     for (i = 0; i < setlen; i++)
                     {
                         if (str_ch == set[i])
                             break;
                     }
                     if (i >= setlen)
                         break;  /* no match here */
                     string++;
                     stringlen--;
                 }
             }
  
             if (dortrim)
             {
                 while (stringlen > 0)
                 {
                     char        str_ch = string[stringlen - 1];
  
                     for (i = 0; i < setlen; i++)
                     {
                         if (str_ch == set[i])
                             break;
                     }
                     if (i >= setlen)
                         break;  /* no match here */
                     stringlen--;
                 }
             }
         }
     }
  
     /* Return selected portion of string */
     return cstring_to_text_with_len(string, stringlen);
 }

References cstring_to_text_with_len(), i, len, palloc(), pfree(), pg_database_encoding_max_length(), and pg_mblen().

Referenced by btrim(), btrim1(), ltrim(), ltrim1(), rtrim(), and rtrim1().

◆ initcap()

Datum initcap ( PG_FUNCTION_ARGS )

Definition at line 114 of file oracle_compat.c.

 {
     text       *in_string = PG_GETARG_TEXT_PP(0);
     char       *out_string;
     text       *result;
  
     out_string = str_initcap(VARDATA_ANY(in_string),
                              VARSIZE_ANY_EXHDR(in_string),
                              PG_GET_COLLATION());
     result = cstring_to_text(out_string);
     pfree(out_string);
  
     PG_RETURN_TEXT_P(result);
 }

References cstring_to_text(), pfree(), PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, str_initcap(), VARDATA_ANY, and VARSIZE_ANY_EXHDR.

◆ lower()

Datum lower ( PG_FUNCTION_ARGS )

Definition at line 49 of file oracle_compat.c.

 {
     text       *in_string = PG_GETARG_TEXT_PP(0);
     char       *out_string;
     text       *result;
  
     out_string = str_tolower(VARDATA_ANY(in_string),
                              VARSIZE_ANY_EXHDR(in_string),
                              PG_GET_COLLATION());
     result = cstring_to_text(out_string);
     pfree(out_string);
  
     PG_RETURN_TEXT_P(result);
 }

References cstring_to_text(), pfree(), PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, str_tolower(), VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by _hash_binsearch(), _hash_binsearch_last(), bms_add_range(), calc_hist_selectivity_contained(), calc_hist_selectivity_contains(), check_new_partition_bound(), check_partition_bounds_for_split_range(), compute_range_stats(), create_range_bounds(), daterange_canonical(), enum_range_bounds(), enum_range_internal(), find_simplified_clause(), Generic_Text_IC_like(), geqo_randint(), getQuadrant(), gist_box_picksplit(), hash_multirange(), hash_multirange_extended(), hash_range(), hash_range_extended(), hyphenate(), int4range_canonical(), int8range_canonical(), iterate_word_similarity(), length_hist_bsearch(), make_empty_range(), make_one_partition_rbound(), make_range(), multirange_bsearch_match(), multirange_elem_bsearch_comparison(), multirange_get_bounds(), multirange_get_union_range(), multirange_lower(), multirange_lower_inc(), multirange_lower_inf(), multirange_range_contains_bsearch_comparison(), multirange_range_overlaps_bsearch_comparison(), multirange_upper(), multirange_upper_inc(), multirange_upper_inf(), multirangesel(), PageAddItemExtended(), range_constructor2(), range_constructor3(), range_contains_elem_internal(), range_deserialize(), range_gist_double_sorting_split(), range_in(), range_lower(), range_out(), range_recv(), range_send(), range_serialize(), range_upper(), rangesel(), rbound_bsearch(), spg_range_quad_inner_consistent(), trim_array(), XLogRecordAssemble(), and XLogSaveBufferForHint().

◆ lpad()

Datum lpad ( PG_FUNCTION_ARGS )

Definition at line 147 of file oracle_compat.c.

 {
     text       *string1 = PG_GETARG_TEXT_PP(0);
     int32       len = PG_GETARG_INT32(1);
     text       *string2 = PG_GETARG_TEXT_PP(2);
     text       *ret;
     char       *ptr1,
                *ptr2,
                *ptr2start,
                *ptr2end,
                *ptr_ret;
     int         m,
                 s1len,
                 s2len;
     int         bytelen;
  
     /* Negative len is silently taken as zero */
     if (len < 0)
         len = 0;
  
     s1len = VARSIZE_ANY_EXHDR(string1);
     if (s1len < 0)
         s1len = 0;              /* shouldn't happen */
  
     s2len = VARSIZE_ANY_EXHDR(string2);
     if (s2len < 0)
         s2len = 0;              /* shouldn't happen */
  
     s1len = pg_mbstrlen_with_len(VARDATA_ANY(string1), s1len);
  
     if (s1len > len)
         s1len = len;            /* truncate string1 to len chars */
  
     if (s2len <= 0)
         len = s1len;            /* nothing to pad with, so don't pad */
  
     /* compute worst-case output length */
     if (unlikely(pg_mul_s32_overflow(pg_database_encoding_max_length(), len,
                                      &bytelen)) ||
         unlikely(pg_add_s32_overflow(bytelen, VARHDRSZ, &bytelen)) ||
         unlikely(!AllocSizeIsValid(bytelen)))
         ereport(ERROR,
                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                  errmsg("requested length too large")));
  
     ret = (text *) palloc(bytelen);
  
     m = len - s1len;
  
     ptr2 = ptr2start = VARDATA_ANY(string2);
     ptr2end = ptr2 + s2len;
     ptr_ret = VARDATA(ret);
  
     while (m--)
     {
         int         mlen = pg_mblen(ptr2);
  
         memcpy(ptr_ret, ptr2, mlen);
         ptr_ret += mlen;
         ptr2 += mlen;
         if (ptr2 == ptr2end)    /* wrap around at end of s2 */
             ptr2 = ptr2start;
     }
  
     ptr1 = VARDATA_ANY(string1);
  
     while (s1len--)
     {
         int         mlen = pg_mblen(ptr1);
  
         memcpy(ptr_ret, ptr1, mlen);
         ptr_ret += mlen;
         ptr1 += mlen;
     }
  
     SET_VARSIZE(ret, ptr_ret - (char *) ret);
  
     PG_RETURN_TEXT_P(ret);
 }

References AllocSizeIsValid, ereport, errcode(), errmsg(), ERROR, len, palloc(), pg_add_s32_overflow(), pg_database_encoding_max_length(), PG_GETARG_INT32, PG_GETARG_TEXT_PP, pg_mblen(), pg_mbstrlen_with_len(), pg_mul_s32_overflow(), PG_RETURN_TEXT_P, SET_VARSIZE, unlikely, VARDATA, VARDATA_ANY, VARHDRSZ, and VARSIZE_ANY_EXHDR.

◆ ltrim()

Datum ltrim ( PG_FUNCTION_ARGS )

Definition at line 698 of file oracle_compat.c.

 {
     text       *string = PG_GETARG_TEXT_PP(0);
     text       *set = PG_GETARG_TEXT_PP(1);
     text       *ret;
  
     ret = dotrim(VARDATA_ANY(string), VARSIZE_ANY_EXHDR(string),
                  VARDATA_ANY(set), VARSIZE_ANY_EXHDR(set),
                  true, false);
  
     PG_RETURN_TEXT_P(ret);
 }

References dotrim(), PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

◆ ltrim1()

Datum ltrim1 ( PG_FUNCTION_ARGS )

Definition at line 718 of file oracle_compat.c.

 {
     text       *string = PG_GETARG_TEXT_PP(0);
     text       *ret;
  
     ret = dotrim(VARDATA_ANY(string), VARSIZE_ANY_EXHDR(string),
                  " ", 1,
                  true, false);
  
     PG_RETURN_TEXT_P(ret);
 }

References dotrim(), PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

◆ repeat()

Datum repeat ( PG_FUNCTION_ARGS )

Definition at line 1121 of file oracle_compat.c.

 {
     text       *string = PG_GETARG_TEXT_PP(0);
     int32       count = PG_GETARG_INT32(1);
     text       *result;
     int         slen,
                 tlen;
     int         i;
     char       *cp,
                *sp;
  
     if (count < 0)
         count = 0;
  
     slen = VARSIZE_ANY_EXHDR(string);
  
     if (unlikely(pg_mul_s32_overflow(count, slen, &tlen)) ||
         unlikely(pg_add_s32_overflow(tlen, VARHDRSZ, &tlen)) ||
         unlikely(!AllocSizeIsValid(tlen)))
         ereport(ERROR,
                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                  errmsg("requested length too large")));
  
     result = (text *) palloc(tlen);
  
     SET_VARSIZE(result, tlen);
     cp = VARDATA(result);
     sp = VARDATA_ANY(string);
     for (i = 0; i < count; i++)
     {
         memcpy(cp, sp, slen);
         cp += slen;
         CHECK_FOR_INTERRUPTS();
     }
  
     PG_RETURN_TEXT_P(result);
 }

References AllocSizeIsValid, CHECK_FOR_INTERRUPTS, ereport, errcode(), errmsg(), ERROR, i, palloc(), pg_add_s32_overflow(), PG_GETARG_INT32, PG_GETARG_TEXT_PP, pg_mul_s32_overflow(), PG_RETURN_TEXT_P, SET_VARSIZE, unlikely, VARDATA, VARDATA_ANY, VARHDRSZ, and VARSIZE_ANY_EXHDR.

Referenced by in_grouping(), in_grouping_b(), in_grouping_b_U(), in_grouping_U(), out_grouping(), out_grouping_b(), out_grouping_b_U(), and out_grouping_U().

◆ rpad()

Datum rpad ( PG_FUNCTION_ARGS )

Definition at line 245 of file oracle_compat.c.

 {
     text       *string1 = PG_GETARG_TEXT_PP(0);
     int32       len = PG_GETARG_INT32(1);
     text       *string2 = PG_GETARG_TEXT_PP(2);
     text       *ret;
     char       *ptr1,
                *ptr2,
                *ptr2start,
                *ptr2end,
                *ptr_ret;
     int         m,
                 s1len,
                 s2len;
     int         bytelen;
  
     /* Negative len is silently taken as zero */
     if (len < 0)
         len = 0;
  
     s1len = VARSIZE_ANY_EXHDR(string1);
     if (s1len < 0)
         s1len = 0;              /* shouldn't happen */
  
     s2len = VARSIZE_ANY_EXHDR(string2);
     if (s2len < 0)
         s2len = 0;              /* shouldn't happen */
  
     s1len = pg_mbstrlen_with_len(VARDATA_ANY(string1), s1len);
  
     if (s1len > len)
         s1len = len;            /* truncate string1 to len chars */
  
     if (s2len <= 0)
         len = s1len;            /* nothing to pad with, so don't pad */
  
     /* compute worst-case output length */
     if (unlikely(pg_mul_s32_overflow(pg_database_encoding_max_length(), len,
                                      &bytelen)) ||
         unlikely(pg_add_s32_overflow(bytelen, VARHDRSZ, &bytelen)) ||
         unlikely(!AllocSizeIsValid(bytelen)))
         ereport(ERROR,
                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                  errmsg("requested length too large")));
  
     ret = (text *) palloc(bytelen);
  
     m = len - s1len;
  
     ptr1 = VARDATA_ANY(string1);
     ptr_ret = VARDATA(ret);
  
     while (s1len--)
     {
         int         mlen = pg_mblen(ptr1);
  
         memcpy(ptr_ret, ptr1, mlen);
         ptr_ret += mlen;
         ptr1 += mlen;
     }
  
     ptr2 = ptr2start = VARDATA_ANY(string2);
     ptr2end = ptr2 + s2len;
  
     while (m--)
     {
         int         mlen = pg_mblen(ptr2);
  
         memcpy(ptr_ret, ptr2, mlen);
         ptr_ret += mlen;
         ptr2 += mlen;
         if (ptr2 == ptr2end)    /* wrap around at end of s2 */
             ptr2 = ptr2start;
     }
  
     SET_VARSIZE(ret, ptr_ret - (char *) ret);
  
     PG_RETURN_TEXT_P(ret);
 }

References AllocSizeIsValid, ereport, errcode(), errmsg(), ERROR, len, palloc(), pg_add_s32_overflow(), pg_database_encoding_max_length(), PG_GETARG_INT32, PG_GETARG_TEXT_PP, pg_mblen(), pg_mbstrlen_with_len(), pg_mul_s32_overflow(), PG_RETURN_TEXT_P, SET_VARSIZE, unlikely, VARDATA, VARDATA_ANY, VARHDRSZ, and VARSIZE_ANY_EXHDR.

◆ rtrim()

Datum rtrim ( PG_FUNCTION_ARGS )

Definition at line 746 of file oracle_compat.c.

 {
     text       *string = PG_GETARG_TEXT_PP(0);
     text       *set = PG_GETARG_TEXT_PP(1);
     text       *ret;
  
     ret = dotrim(VARDATA_ANY(string), VARSIZE_ANY_EXHDR(string),
                  VARDATA_ANY(set), VARSIZE_ANY_EXHDR(set),
                  false, true);
  
     PG_RETURN_TEXT_P(ret);
 }

References dotrim(), PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

◆ rtrim1()

Datum rtrim1 ( PG_FUNCTION_ARGS )

Definition at line 766 of file oracle_compat.c.

 {
     text       *string = PG_GETARG_TEXT_PP(0);
     text       *ret;
  
     ret = dotrim(VARDATA_ANY(string), VARSIZE_ANY_EXHDR(string),
                  " ", 1,
                  false, true);
  
     PG_RETURN_TEXT_P(ret);
 }

References dotrim(), PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

◆ translate()

Datum translate ( PG_FUNCTION_ARGS )

Definition at line 797 of file oracle_compat.c.

 {
     text       *string = PG_GETARG_TEXT_PP(0);
     text       *from = PG_GETARG_TEXT_PP(1);
     text       *to = PG_GETARG_TEXT_PP(2);
     text       *result;
     char       *from_ptr,
                *to_ptr,
                *to_end;
     char       *source,
                *target;
     int         m,
                 fromlen,
                 tolen,
                 retlen,
                 i;
     int         bytelen;
     int         len;
     int         source_len;
     int         from_index;
  
     m = VARSIZE_ANY_EXHDR(string);
     if (m <= 0)
         PG_RETURN_TEXT_P(string);
     source = VARDATA_ANY(string);
  
     fromlen = VARSIZE_ANY_EXHDR(from);
     from_ptr = VARDATA_ANY(from);
     tolen = VARSIZE_ANY_EXHDR(to);
     to_ptr = VARDATA_ANY(to);
     to_end = to_ptr + tolen;
  
     /*
      * The worst-case expansion is to substitute a max-length character for a
      * single-byte character at each position of the string.
      */
     if (unlikely(pg_mul_s32_overflow(pg_database_encoding_max_length(), m,
                                      &bytelen)) ||
         unlikely(pg_add_s32_overflow(bytelen, VARHDRSZ, &bytelen)) ||
         unlikely(!AllocSizeIsValid(bytelen)))
         ereport(ERROR,
                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                  errmsg("requested length too large")));
  
     result = (text *) palloc(bytelen);
  
     target = VARDATA(result);
     retlen = 0;
  
     while (m > 0)
     {
         source_len = pg_mblen(source);
         from_index = 0;
  
         for (i = 0; i < fromlen; i += len)
         {
             len = pg_mblen(&from_ptr[i]);
             if (len == source_len &&
                 memcmp(source, &from_ptr[i], len) == 0)
                 break;
  
             from_index++;
         }
         if (i < fromlen)
         {
             /* substitute, or delete if no corresponding "to" character */
             char       *p = to_ptr;
  
             for (i = 0; i < from_index; i++)
             {
                 if (p >= to_end)
                     break;
                 p += pg_mblen(p);
             }
             if (p < to_end)
             {
                 len = pg_mblen(p);
                 memcpy(target, p, len);
                 target += len;
                 retlen += len;
             }
         }
         else
         {
             /* no match, so copy */
             memcpy(target, source, source_len);
             target += source_len;
             retlen += source_len;
         }
  
         source += source_len;
         m -= source_len;
     }
  
     SET_VARSIZE(result, retlen + VARHDRSZ);
  
     /*
      * The function result is probably much bigger than needed, if we're using
      * a multibyte encoding, but it's not worth reallocating it; the result
      * probably won't live long anyway.
      */
  
     PG_RETURN_TEXT_P(result);
 }

References AllocSizeIsValid, ereport, errcode(), errmsg(), ERROR, i, len, palloc(), pg_add_s32_overflow(), pg_database_encoding_max_length(), PG_GETARG_TEXT_PP, pg_mblen(), pg_mul_s32_overflow(), PG_RETURN_TEXT_P, SET_VARSIZE, source, unlikely, VARDATA, VARDATA_ANY, VARHDRSZ, and VARSIZE_ANY_EXHDR.

Referenced by printQuery(), printTableAddCell(), and printTableAddHeader().

◆ upper()

Datum upper ( PG_FUNCTION_ARGS )

Definition at line 80 of file oracle_compat.c.

 {
     text       *in_string = PG_GETARG_TEXT_PP(0);
     char       *out_string;
     text       *result;
  
     out_string = str_toupper(VARDATA_ANY(in_string),
                              VARSIZE_ANY_EXHDR(in_string),
                              PG_GET_COLLATION());
     result = cstring_to_text(out_string);
     pfree(out_string);
  
     PG_RETURN_TEXT_P(result);
 }

References cstring_to_text(), pfree(), PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, str_toupper(), VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by _hash_binsearch(), _hash_binsearch_last(), bms_add_range(), calc_hist_selectivity_contained(), calc_hist_selectivity_contains(), check_new_partition_bound(), check_partition_bounds_for_split_range(), compactify_tuples(), compute_range_stats(), create_range_bounds(), cube_coord_llur(), daterange_canonical(), enum_range_bounds(), enum_range_internal(), find_simplified_clause(), g_cube_distance(), geqo_randint(), getQuadrant(), gist_box_picksplit(), hash_multirange(), hash_multirange_extended(), hash_range(), hash_range_extended(), hyphenate(), int4range_canonical(), int8range_canonical(), iterate_word_similarity(), length_hist_bsearch(), make_empty_range(), make_range(), multirange_bsearch_match(), multirange_elem_bsearch_comparison(), multirange_get_bounds(), multirange_get_union_range(), multirange_lower(), multirange_lower_inc(), multirange_lower_inf(), multirange_range_contains_bsearch_comparison(), multirange_range_overlaps_bsearch_comparison(), multirange_upper(), multirange_upper_inc(), multirange_upper_inf(), multirangesel(), PageAddItemExtended(), range_constructor2(), range_constructor3(), range_contains_elem_internal(), range_deserialize(), range_gist_double_sorting_split(), range_in(), range_lower(), range_out(), range_recv(), range_send(), range_serialize(), range_upper(), rangesel(), rbound_bsearch(), spg_range_quad_inner_consistent(), trim_array(), XLogRecordAssemble(), and XLogSaveBufferForHint().

Functions

Function Documentation

◆ ascii()

◆ btrim()

◆ btrim1()

◆ bytealtrim()

◆ byteartrim()

◆ byteatrim()

◆ chr()

◆ dobyteatrim()

◆ dotrim()

◆ initcap()

◆ lower()

◆ lpad()

◆ ltrim()

◆ ltrim1()

◆ repeat()

◆ rpad()

◆ rtrim()

◆ rtrim1()

◆ translate()

◆ upper()