[フレーム]

varchar.c File Reference

#include "postgres.h"
#include "access/detoast.h"
#include "access/htup_details.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_type.h"
#include "common/hashfn.h"
#include "libpq/pqformat.h"
#include "mb/pg_wchar.h"
#include "nodes/nodeFuncs.h"
#include "nodes/supportnodes.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/pg_locale.h"
#include "utils/varlena.h"

Include dependency graph for varchar.c:

Go to the source code of this file.

Functions

static int32 anychar_typmodin (ArrayType *ta, const char *typename)

static char * anychar_typmodout (int32 typmod)

static BpChar * bpchar_input (const char *s, size_t len, int32 atttypmod, Node *escontext)

Datum bpcharin (PG_FUNCTION_ARGS)

Datum bpcharout (PG_FUNCTION_ARGS)

Datum bpcharrecv (PG_FUNCTION_ARGS)

Datum bpcharsend (PG_FUNCTION_ARGS)

Datum bpchar (PG_FUNCTION_ARGS)

Datum char_bpchar (PG_FUNCTION_ARGS)

Datum bpchar_name (PG_FUNCTION_ARGS)

Datum name_bpchar (PG_FUNCTION_ARGS)

Datum bpchartypmodin (PG_FUNCTION_ARGS)

Datum bpchartypmodout (PG_FUNCTION_ARGS)

static VarChar * varchar_input (const char *s, size_t len, int32 atttypmod, Node *escontext)

Datum varcharin (PG_FUNCTION_ARGS)

Datum varcharout (PG_FUNCTION_ARGS)

Datum varcharrecv (PG_FUNCTION_ARGS)

Datum varcharsend (PG_FUNCTION_ARGS)

Datum varchar_support (PG_FUNCTION_ARGS)

Datum varchar (PG_FUNCTION_ARGS)

Datum varchartypmodin (PG_FUNCTION_ARGS)

Datum varchartypmodout (PG_FUNCTION_ARGS)

static int bcTruelen (BpChar *arg)

int bpchartruelen (char *s, int len)

Datum bpcharlen (PG_FUNCTION_ARGS)

Datum bpcharoctetlen (PG_FUNCTION_ARGS)

static void check_collation_set (Oid collid)

Datum bpchareq (PG_FUNCTION_ARGS)

Datum bpcharne (PG_FUNCTION_ARGS)

Datum bpcharlt (PG_FUNCTION_ARGS)

Datum bpcharle (PG_FUNCTION_ARGS)

Datum bpchargt (PG_FUNCTION_ARGS)

Datum bpcharge (PG_FUNCTION_ARGS)

Datum bpcharcmp (PG_FUNCTION_ARGS)

Datum bpchar_sortsupport (PG_FUNCTION_ARGS)

Datum bpchar_larger (PG_FUNCTION_ARGS)

Datum bpchar_smaller (PG_FUNCTION_ARGS)

Datum hashbpchar (PG_FUNCTION_ARGS)

Datum hashbpcharextended (PG_FUNCTION_ARGS)

static int internal_bpchar_pattern_compare (BpChar *arg1, BpChar *arg2)

Datum bpchar_pattern_lt (PG_FUNCTION_ARGS)

Datum bpchar_pattern_le (PG_FUNCTION_ARGS)

Datum bpchar_pattern_ge (PG_FUNCTION_ARGS)

Datum bpchar_pattern_gt (PG_FUNCTION_ARGS)

Datum btbpchar_pattern_cmp (PG_FUNCTION_ARGS)

Datum btbpchar_pattern_sortsupport (PG_FUNCTION_ARGS)

Function Documentation

◆ anychar_typmodin()

static int32 anychar_typmodin ( ArrayType * ta,

const char * typename

)

static

Definition at line 33 of file varchar.c.

34{

35 int32 typmod;

36 int32 *tl;

37 int n;

38

39 tl = ArrayGetIntegerTypmods(ta, &n);

40

41 /*

42 * we're not too tense about good error message here because grammar

43 * shouldn't allow wrong number of modifiers for CHAR

44 */

45 if (n != 1)

46 ereport(ERROR,

47 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

48 errmsg("invalid type modifier")));

49

50 if (*tl < 1)

51 ereport(ERROR,

52 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

53 errmsg("length for type %s must be at least 1", typename)));

54 if (*tl > MaxAttrSize)

55 ereport(ERROR,

56 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

57 errmsg("length for type %s cannot exceed %d",

58 typename, MaxAttrSize)));

59

60 /*

61 * For largely historical reasons, the typmod is VARHDRSZ plus the number

62 * of characters; there is enough client-side code that knows about that

63 * that we'd better not change it.

64 */

65 typmod = VARHDRSZ + *tl;

66

67 return typmod;

68}

ArrayGetIntegerTypmods

int32 * ArrayGetIntegerTypmods(ArrayType *arr, int *n)

Definition: arrayutils.c:233

VARHDRSZ

#define VARHDRSZ

Definition: c.h:697

int32

int32_t int32

Definition: c.h:534

errcode

int errcode(int sqlerrcode)

Definition: elog.c:854

errmsg

int errmsg(const char *fmt,...)

Definition: elog.c:1071

ERROR

#define ERROR

Definition: elog.h:39

ereport

#define ereport(elevel,...)

Definition: elog.h:150

MaxAttrSize

#define MaxAttrSize

Definition: htup_details.h:635

References ArrayGetIntegerTypmods(), ereport, errcode(), errmsg(), ERROR, MaxAttrSize, and VARHDRSZ.

Referenced by bpchartypmodin(), and varchartypmodin().

◆ anychar_typmodout()

static char * anychar_typmodout ( int32 typmod )

static

Definition at line 72 of file varchar.c.

73{

74 char *res = (char *) palloc(64);

75

76 if (typmod > VARHDRSZ)

77 snprintf(res, 64, "(%d)", (int) (typmod - VARHDRSZ));

78 else

79 *res = '0円';

80

81 return res;

82}

palloc

void * palloc(Size size)

Definition: mcxt.c:1365

snprintf

#define snprintf

Definition: port.h:239

References palloc(), snprintf, and VARHDRSZ.

Referenced by bpchartypmodout(), and varchartypmodout().

◆ bcTruelen()

static int bcTruelen ( BpChar * arg )

inlinestatic

Definition at line 670 of file varchar.c.

671{

672 return bpchartruelen(VARDATA_ANY(arg), VARSIZE_ANY_EXHDR(arg));

673}

arg

void * arg

Definition: pg_backup_utils.c:29

VARSIZE_ANY_EXHDR

static Size VARSIZE_ANY_EXHDR(const void *PTR)

Definition: varatt.h:472

VARDATA_ANY

static char * VARDATA_ANY(const void *PTR)

Definition: varatt.h:486

bpchartruelen

int bpchartruelen(char *s, int len)

Definition: varchar.c:676

References arg, bpchartruelen(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by bpchar_larger(), bpchar_smaller(), bpcharcmp(), bpchareq(), bpcharge(), bpchargt(), bpcharle(), bpcharlen(), bpcharlt(), bpcharne(), hashbpchar(), hashbpcharextended(), and internal_bpchar_pattern_compare().

◆ bpchar()

Datum bpchar ( PG_FUNCTION_ARGS )

Definition at line 271 of file varchar.c.

272{

273 BpChar *source = PG_GETARG_BPCHAR_PP(0);

274 int32 maxlen = PG_GETARG_INT32(1);

275 bool isExplicit = PG_GETARG_BOOL(2);

276 BpChar *result;

277 int32 len;

278 char *r;

279 char *s;

280 int i;

281 int charlen; /* number of characters in the input string +

282 * VARHDRSZ */

283

284 /* No work if typmod is invalid */

285 if (maxlen < (int32) VARHDRSZ)

286 PG_RETURN_BPCHAR_P(source);

287

288 maxlen -= VARHDRSZ;

289

290 len = VARSIZE_ANY_EXHDR(source);

291 s = VARDATA_ANY(source);

292

293 charlen = pg_mbstrlen_with_len(s, len);

294

295 /* No work if supplied data matches typmod already */

296 if (charlen == maxlen)

297 PG_RETURN_BPCHAR_P(source);

298

299 if (charlen > maxlen)

300 {

301 /* Verify that extra characters are spaces, and clip them off */

302 size_t maxmblen;

303

304 maxmblen = pg_mbcharcliplen(s, len, maxlen);

305

306 if (!isExplicit)

307 {

308 for (i = maxmblen; i < len; i++)

309 if (s[i] != ' ')

310 ereport(ERROR,

311 (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),

312 errmsg("value too long for type character(%d)",

313 maxlen)));

314 }

315

316 len = maxmblen;

317

318 /*

319 * At this point, maxlen is the necessary byte length, not the number

320 * of CHARACTERS!

321 */

322 maxlen = len;

323 }

324 else

325 {

326 /*

327 * At this point, maxlen is the necessary byte length, not the number

328 * of CHARACTERS!

329 */

330 maxlen = len + (maxlen - charlen);

331 }

332

333 Assert(maxlen >= len);

334

335 result = palloc(maxlen + VARHDRSZ);

336 SET_VARSIZE(result, maxlen + VARHDRSZ);

337 r = VARDATA(result);

338

339 memcpy(r, s, len);

340

341 /* blank pad the string if necessary */

342 if (maxlen > len)

343 memset(r + len, ' ', maxlen - len);

344

345 PG_RETURN_BPCHAR_P(result);

346}

PG_GETARG_BPCHAR_PP

#define PG_GETARG_BPCHAR_PP(n)

Definition: fmgr.h:310

PG_RETURN_BPCHAR_P

#define PG_RETURN_BPCHAR_P(x)

Definition: fmgr.h:373

PG_GETARG_INT32

#define PG_GETARG_INT32(n)

Definition: fmgr.h:269

PG_GETARG_BOOL

#define PG_GETARG_BOOL(n)

Definition: fmgr.h:274

Assert

Assert(PointerIsAligned(start, uint64))

i

int i

Definition: isn.c:77

pg_mbstrlen_with_len

int pg_mbstrlen_with_len(const char *mbstr, int limit)

Definition: mbutils.c:1058

pg_mbcharcliplen

int pg_mbcharcliplen(const char *mbstr, int len, int limit)

Definition: mbutils.c:1126

len

const void size_t len

Definition: pg_crc32c_sse42.c:28

source

static rewind_source * source

Definition: pg_rewind.c:89

varlena

Definition: c.h:692

VARDATA

static char * VARDATA(const void *PTR)

Definition: varatt.h:305

SET_VARSIZE

static void SET_VARSIZE(void *PTR, Size len)

Definition: varatt.h:432

References Assert(), ereport, errcode(), errmsg(), ERROR, i, len, palloc(), PG_GETARG_BOOL, PG_GETARG_BPCHAR_PP, PG_GETARG_INT32, pg_mbcharcliplen(), pg_mbstrlen_with_len(), PG_RETURN_BPCHAR_P, SET_VARSIZE(), source, VARDATA(), VARDATA_ANY(), VARHDRSZ, and VARSIZE_ANY_EXHDR().

◆ bpchar_input()

static BpChar * bpchar_input ( const char * s,

size_t len,

int32 atttypmod,

Node * escontext

)

static

Definition at line 130 of file varchar.c.

131{

132 BpChar *result;

133 char *r;

134 size_t maxlen;

135

136 /* If typmod is -1 (or invalid), use the actual string length */

137 if (atttypmod < (int32) VARHDRSZ)

138 maxlen = len;

139 else

140 {

141 size_t charlen; /* number of CHARACTERS in the input */

142

143 maxlen = atttypmod - VARHDRSZ;

144 charlen = pg_mbstrlen_with_len(s, len);

145 if (charlen > maxlen)

146 {

147 /* Verify that extra characters are spaces, and clip them off */

148 size_t mbmaxlen = pg_mbcharcliplen(s, len, maxlen);

149 size_t j;

150

151 /*

152 * at this point, len is the actual BYTE length of the input

153 * string, maxlen is the max number of CHARACTERS allowed for this

154 * bpchar type, mbmaxlen is the length in BYTES of those chars.

155 */

156 for (j = mbmaxlen; j < len; j++)

157 {

158 if (s[j] != ' ')

159 ereturn(escontext, NULL,

160 (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),

161 errmsg("value too long for type character(%d)",

162 (int) maxlen)));

163 }

164

165 /*

166 * Now we set maxlen to the necessary byte length, not the number

167 * of CHARACTERS!

168 */

169 maxlen = len = mbmaxlen;

170 }

171 else

172 {

173 /*

174 * Now we set maxlen to the necessary byte length, not the number

175 * of CHARACTERS!

176 */

177 maxlen = len + (maxlen - charlen);

178 }

179 }

180

181 result = (BpChar *) palloc(maxlen + VARHDRSZ);

182 SET_VARSIZE(result, maxlen + VARHDRSZ);

183 r = VARDATA(result);

184 memcpy(r, s, len);

185

186 /* blank pad the string if necessary */

187 if (maxlen > len)

188 memset(r + len, ' ', maxlen - len);

189

190 return result;

191}

ereturn

#define ereturn(context, dummy_value,...)

Definition: elog.h:278

j

int j

Definition: isn.c:78

References ereturn, errcode(), errmsg(), j, len, palloc(), pg_mbcharcliplen(), pg_mbstrlen_with_len(), SET_VARSIZE(), VARDATA(), and VARHDRSZ.

Referenced by bpcharin(), and bpcharrecv().

◆ bpchar_larger()

Datum bpchar_larger ( PG_FUNCTION_ARGS )

Definition at line 947 of file varchar.c.

948{

949 BpChar *arg1 = PG_GETARG_BPCHAR_PP(0);

950 BpChar *arg2 = PG_GETARG_BPCHAR_PP(1);

951 int len1,

952 len2;

953 int cmp;

954

955 len1 = bcTruelen(arg1);

956 len2 = bcTruelen(arg2);

957

958 cmp = varstr_cmp(VARDATA_ANY(arg1), len1, VARDATA_ANY(arg2), len2,

959 PG_GET_COLLATION());

960

961 PG_RETURN_BPCHAR_P((cmp >= 0) ? arg1 : arg2);

962}

PG_GET_COLLATION

#define PG_GET_COLLATION()

Definition: fmgr.h:198

cmp

static int cmp(const chr *x, const chr *y, size_t len)

Definition: regc_locale.c:743

bcTruelen

static int bcTruelen(BpChar *arg)

Definition: varchar.c:670

varstr_cmp

int varstr_cmp(const char *arg1, int len1, const char *arg2, int len2, Oid collid)

Definition: varlena.c:1297

References bcTruelen(), cmp(), PG_GET_COLLATION, PG_GETARG_BPCHAR_PP, PG_RETURN_BPCHAR_P, VARDATA_ANY(), and varstr_cmp().

◆ bpchar_name()

Datum bpchar_name ( PG_FUNCTION_ARGS )

Definition at line 371 of file varchar.c.

372{

373 BpChar *s = PG_GETARG_BPCHAR_PP(0);

374 char *s_data;

375 Name result;

376 int len;

377

378 len = VARSIZE_ANY_EXHDR(s);

379 s_data = VARDATA_ANY(s);

380

381 /* Truncate oversize input */

382 if (len >= NAMEDATALEN)

383 len = pg_mbcliplen(s_data, len, NAMEDATALEN - 1);

384

385 /* Remove trailing blanks */

386 while (len > 0)

387 {

388 if (s_data[len - 1] != ' ')

389 break;

390 len--;

391 }

392

393 /* We use palloc0 here to ensure result is zero-padded */

394 result = (Name) palloc0(NAMEDATALEN);

395 memcpy(NameStr(*result), s_data, len);

396

397 PG_RETURN_NAME(result);

398}

NameStr

#define NameStr(name)

Definition: c.h:751

Name

NameData * Name

Definition: c.h:749

PG_RETURN_NAME

#define PG_RETURN_NAME(x)

Definition: fmgr.h:363

pg_mbcliplen

int pg_mbcliplen(const char *mbstr, int len, int limit)

Definition: mbutils.c:1084

palloc0

void * palloc0(Size size)

Definition: mcxt.c:1395

NAMEDATALEN

#define NAMEDATALEN

Definition: pg_config_manual.h:29

nameData

Definition: c.h:746

References len, NAMEDATALEN, NameStr, palloc0(), PG_GETARG_BPCHAR_PP, pg_mbcliplen(), PG_RETURN_NAME, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

◆ bpchar_pattern_ge()

Datum bpchar_pattern_ge ( PG_FUNCTION_ARGS )

Definition at line 1163 of file varchar.c.

1164{

1165 BpChar *arg1 = PG_GETARG_BPCHAR_PP(0);

1166 BpChar *arg2 = PG_GETARG_BPCHAR_PP(1);

1167 int result;

1168

1169 result = internal_bpchar_pattern_compare(arg1, arg2);

1170

1171 PG_FREE_IF_COPY(arg1, 0);

1172 PG_FREE_IF_COPY(arg2, 1);

1173

1174 PG_RETURN_BOOL(result >= 0);

1175}

PG_FREE_IF_COPY

#define PG_FREE_IF_COPY(ptr, n)

Definition: fmgr.h:260

PG_RETURN_BOOL

#define PG_RETURN_BOOL(x)

Definition: fmgr.h:359

internal_bpchar_pattern_compare

static int internal_bpchar_pattern_compare(BpChar *arg1, BpChar *arg2)

Definition: varchar.c:1109

References internal_bpchar_pattern_compare(), PG_FREE_IF_COPY, PG_GETARG_BPCHAR_PP, and PG_RETURN_BOOL.

◆ bpchar_pattern_gt()

Datum bpchar_pattern_gt ( PG_FUNCTION_ARGS )

Definition at line 1179 of file varchar.c.

1180{

1181 BpChar *arg1 = PG_GETARG_BPCHAR_PP(0);

1182 BpChar *arg2 = PG_GETARG_BPCHAR_PP(1);

1183 int result;

1184

1185 result = internal_bpchar_pattern_compare(arg1, arg2);

1186

1187 PG_FREE_IF_COPY(arg1, 0);

1188 PG_FREE_IF_COPY(arg2, 1);

1189

1190 PG_RETURN_BOOL(result > 0);

1191}

References internal_bpchar_pattern_compare(), PG_FREE_IF_COPY, PG_GETARG_BPCHAR_PP, and PG_RETURN_BOOL.

◆ bpchar_pattern_le()

Datum bpchar_pattern_le ( PG_FUNCTION_ARGS )

Definition at line 1147 of file varchar.c.

1148{

1149 BpChar *arg1 = PG_GETARG_BPCHAR_PP(0);

1150 BpChar *arg2 = PG_GETARG_BPCHAR_PP(1);

1151 int result;

1152

1153 result = internal_bpchar_pattern_compare(arg1, arg2);

1154

1155 PG_FREE_IF_COPY(arg1, 0);

1156 PG_FREE_IF_COPY(arg2, 1);

1157

1158 PG_RETURN_BOOL(result <= 0);

1159}

References internal_bpchar_pattern_compare(), PG_FREE_IF_COPY, PG_GETARG_BPCHAR_PP, and PG_RETURN_BOOL.

◆ bpchar_pattern_lt()

Datum bpchar_pattern_lt ( PG_FUNCTION_ARGS )

Definition at line 1131 of file varchar.c.

1132{

1133 BpChar *arg1 = PG_GETARG_BPCHAR_PP(0);

1134 BpChar *arg2 = PG_GETARG_BPCHAR_PP(1);

1135 int result;

1136

1137 result = internal_bpchar_pattern_compare(arg1, arg2);

1138

1139 PG_FREE_IF_COPY(arg1, 0);

1140 PG_FREE_IF_COPY(arg2, 1);

1141

1142 PG_RETURN_BOOL(result < 0);

1143}

References internal_bpchar_pattern_compare(), PG_FREE_IF_COPY, PG_GETARG_BPCHAR_PP, and PG_RETURN_BOOL.

◆ bpchar_smaller()

Datum bpchar_smaller ( PG_FUNCTION_ARGS )

Definition at line 965 of file varchar.c.

966{

967 BpChar *arg1 = PG_GETARG_BPCHAR_PP(0);

968 BpChar *arg2 = PG_GETARG_BPCHAR_PP(1);

969 int len1,

970 len2;

971 int cmp;

972

973 len1 = bcTruelen(arg1);

974 len2 = bcTruelen(arg2);

975

976 cmp = varstr_cmp(VARDATA_ANY(arg1), len1, VARDATA_ANY(arg2), len2,

977 PG_GET_COLLATION());

978

979 PG_RETURN_BPCHAR_P((cmp <= 0) ? arg1 : arg2);

980}

References bcTruelen(), cmp(), PG_GET_COLLATION, PG_GETARG_BPCHAR_PP, PG_RETURN_BPCHAR_P, VARDATA_ANY(), and varstr_cmp().

◆ bpchar_sortsupport()

Datum bpchar_sortsupport ( PG_FUNCTION_ARGS )

Definition at line 930 of file varchar.c.

931{

932 SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);

933 Oid collid = ssup->ssup_collation;

934 MemoryContext oldcontext;

935

936 oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);

937

938 /* Use generic string SortSupport */

939 varstr_sortsupport(ssup, BPCHAROID, collid);

940

941 MemoryContextSwitchTo(oldcontext);

942

943 PG_RETURN_VOID();

944}

collid

Oid collid

Definition: collationcmds.c:700

PG_RETURN_VOID

#define PG_RETURN_VOID()

Definition: fmgr.h:349

PG_GETARG_POINTER

#define PG_GETARG_POINTER(n)

Definition: fmgr.h:276

MemoryContextSwitchTo

static MemoryContext MemoryContextSwitchTo(MemoryContext context)

Definition: palloc.h:124

Oid

unsigned int Oid

Definition: postgres_ext.h:32

SortSupport

struct SortSupportData * SortSupport

Definition: sortsupport.h:58

MemoryContextData

Definition: memnodes.h:118

SortSupportData

Definition: sortsupport.h:61

SortSupportData::ssup_collation

Oid ssup_collation

Definition: sortsupport.h:67

SortSupportData::ssup_cxt

MemoryContext ssup_cxt

Definition: sortsupport.h:66

varstr_sortsupport

void varstr_sortsupport(SortSupport ssup, Oid typid, Oid collid)

Definition: varlena.c:1615

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

◆ bpcharcmp()

Datum bpcharcmp ( PG_FUNCTION_ARGS )

Definition at line 909 of file varchar.c.

910{

911 BpChar *arg1 = PG_GETARG_BPCHAR_PP(0);

912 BpChar *arg2 = PG_GETARG_BPCHAR_PP(1);

913 int len1,

914 len2;

915 int cmp;

916

917 len1 = bcTruelen(arg1);

918 len2 = bcTruelen(arg2);

919

920 cmp = varstr_cmp(VARDATA_ANY(arg1), len1, VARDATA_ANY(arg2), len2,

921 PG_GET_COLLATION());

922

923 PG_FREE_IF_COPY(arg1, 0);

924 PG_FREE_IF_COPY(arg2, 1);

925

926 PG_RETURN_INT32(cmp);

927}

PG_RETURN_INT32

#define PG_RETURN_INT32(x)

Definition: fmgr.h:354

References bcTruelen(), cmp(), PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_BPCHAR_PP, PG_RETURN_INT32, VARDATA_ANY(), and varstr_cmp().

Referenced by gbt_bpchar_ssup_cmp(), and gbt_bpcharcmp().

◆ bpchareq()

Datum bpchareq ( PG_FUNCTION_ARGS )

Definition at line 743 of file varchar.c.

744{

745 BpChar *arg1 = PG_GETARG_BPCHAR_PP(0);

746 BpChar *arg2 = PG_GETARG_BPCHAR_PP(1);

747 int len1,

748 len2;

749 bool result;

750 Oid collid = PG_GET_COLLATION();

751 pg_locale_t mylocale;

752

753 check_collation_set(collid);

754

755 len1 = bcTruelen(arg1);

756 len2 = bcTruelen(arg2);

757

758 mylocale = pg_newlocale_from_collation(collid);

759

760 if (mylocale->deterministic)

761 {

762 /*

763 * Since we only care about equality or not-equality, we can avoid all

764 * the expense of strcoll() here, and just do bitwise comparison.

765 */

766 if (len1 != len2)

767 result = false;

768 else

769 result = (memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), len1) == 0);

770 }

771 else

772 {

773 result = (varstr_cmp(VARDATA_ANY(arg1), len1, VARDATA_ANY(arg2), len2,

774 collid) == 0);

775 }

776

777 PG_FREE_IF_COPY(arg1, 0);

778 PG_FREE_IF_COPY(arg2, 1);

779

780 PG_RETURN_BOOL(result);

781}

pg_newlocale_from_collation

pg_locale_t pg_newlocale_from_collation(Oid collid)

Definition: pg_locale.c:1166

pg_locale_struct

Definition: pg_locale.h:150

pg_locale_struct::deterministic

bool deterministic

Definition: pg_locale.h:151

check_collation_set

static void check_collation_set(Oid collid)

Definition: varchar.c:727

References bcTruelen(), check_collation_set(), collid, pg_locale_struct::deterministic, PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_BPCHAR_PP, pg_newlocale_from_collation(), PG_RETURN_BOOL, VARDATA_ANY(), and varstr_cmp().

Referenced by gbt_bpchareq().

◆ bpcharge()

Datum bpcharge ( PG_FUNCTION_ARGS )

Definition at line 888 of file varchar.c.

889{

890 BpChar *arg1 = PG_GETARG_BPCHAR_PP(0);

891 BpChar *arg2 = PG_GETARG_BPCHAR_PP(1);

892 int len1,

893 len2;

894 int cmp;

895

896 len1 = bcTruelen(arg1);

897 len2 = bcTruelen(arg2);

898

899 cmp = varstr_cmp(VARDATA_ANY(arg1), len1, VARDATA_ANY(arg2), len2,

900 PG_GET_COLLATION());

901

902 PG_FREE_IF_COPY(arg1, 0);

903 PG_FREE_IF_COPY(arg2, 1);

904

905 PG_RETURN_BOOL(cmp >= 0);

906}

References bcTruelen(), cmp(), PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_BPCHAR_PP, PG_RETURN_BOOL, VARDATA_ANY(), and varstr_cmp().

Referenced by gbt_bpcharge().

◆ bpchargt()

Datum bpchargt ( PG_FUNCTION_ARGS )

Definition at line 867 of file varchar.c.

868{

869 BpChar *arg1 = PG_GETARG_BPCHAR_PP(0);

870 BpChar *arg2 = PG_GETARG_BPCHAR_PP(1);

871 int len1,

872 len2;

873 int cmp;

874

875 len1 = bcTruelen(arg1);

876 len2 = bcTruelen(arg2);

877

878 cmp = varstr_cmp(VARDATA_ANY(arg1), len1, VARDATA_ANY(arg2), len2,

879 PG_GET_COLLATION());

880

881 PG_FREE_IF_COPY(arg1, 0);

882 PG_FREE_IF_COPY(arg2, 1);

883

884 PG_RETURN_BOOL(cmp > 0);

885}

References bcTruelen(), cmp(), PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_BPCHAR_PP, PG_RETURN_BOOL, VARDATA_ANY(), and varstr_cmp().

Referenced by gbt_bpchargt().

◆ bpcharin()

Datum bpcharin ( PG_FUNCTION_ARGS )

Definition at line 198 of file varchar.c.

199{

200 char *s = PG_GETARG_CSTRING(0);

201#ifdef NOT_USED

202 Oid typelem = PG_GETARG_OID(1);

203#endif

204 int32 atttypmod = PG_GETARG_INT32(2);

205 BpChar *result;

206

207 result = bpchar_input(s, strlen(s), atttypmod, fcinfo->context);

208 PG_RETURN_BPCHAR_P(result);

209}

PG_GETARG_OID

#define PG_GETARG_OID(n)

Definition: fmgr.h:275

PG_GETARG_CSTRING

#define PG_GETARG_CSTRING(n)

Definition: fmgr.h:277

bpchar_input

static BpChar * bpchar_input(const char *s, size_t len, int32 atttypmod, Node *escontext)

Definition: varchar.c:130

References bpchar_input(), PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, and PG_RETURN_BPCHAR_P.

◆ bpcharle()

Datum bpcharle ( PG_FUNCTION_ARGS )

Definition at line 846 of file varchar.c.

847{

848 BpChar *arg1 = PG_GETARG_BPCHAR_PP(0);

849 BpChar *arg2 = PG_GETARG_BPCHAR_PP(1);

850 int len1,

851 len2;

852 int cmp;

853

854 len1 = bcTruelen(arg1);

855 len2 = bcTruelen(arg2);

856

857 cmp = varstr_cmp(VARDATA_ANY(arg1), len1, VARDATA_ANY(arg2), len2,

858 PG_GET_COLLATION());

859

860 PG_FREE_IF_COPY(arg1, 0);

861 PG_FREE_IF_COPY(arg2, 1);

862

863 PG_RETURN_BOOL(cmp <= 0);

864}

References bcTruelen(), cmp(), PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_BPCHAR_PP, PG_RETURN_BOOL, VARDATA_ANY(), and varstr_cmp().

Referenced by gbt_bpcharle().

◆ bpcharlen()

Datum bpcharlen ( PG_FUNCTION_ARGS )

Definition at line 693 of file varchar.c.

694{

695 BpChar *arg = PG_GETARG_BPCHAR_PP(0);

696 int len;

697

698 /* get number of bytes, ignoring trailing spaces */

699 len = bcTruelen(arg);

700

701 /* in multibyte encoding, convert to number of characters */

702 if (pg_database_encoding_max_length() != 1)

703 len = pg_mbstrlen_with_len(VARDATA_ANY(arg), len);

704

705 PG_RETURN_INT32(len);

706}

pg_database_encoding_max_length

int pg_database_encoding_max_length(void)

Definition: mbutils.c:1547

References arg, bcTruelen(), len, pg_database_encoding_max_length(), PG_GETARG_BPCHAR_PP, pg_mbstrlen_with_len(), PG_RETURN_INT32, and VARDATA_ANY().

◆ bpcharlt()

Datum bpcharlt ( PG_FUNCTION_ARGS )

Definition at line 825 of file varchar.c.

826{

827 BpChar *arg1 = PG_GETARG_BPCHAR_PP(0);

828 BpChar *arg2 = PG_GETARG_BPCHAR_PP(1);

829 int len1,

830 len2;

831 int cmp;

832

833 len1 = bcTruelen(arg1);

834 len2 = bcTruelen(arg2);

835

836 cmp = varstr_cmp(VARDATA_ANY(arg1), len1, VARDATA_ANY(arg2), len2,

837 PG_GET_COLLATION());

838

839 PG_FREE_IF_COPY(arg1, 0);

840 PG_FREE_IF_COPY(arg2, 1);

841

842 PG_RETURN_BOOL(cmp < 0);

843}

References bcTruelen(), cmp(), PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_BPCHAR_PP, PG_RETURN_BOOL, VARDATA_ANY(), and varstr_cmp().

Referenced by gbt_bpcharlt().

◆ bpcharne()

Datum bpcharne ( PG_FUNCTION_ARGS )

Definition at line 784 of file varchar.c.

785{

786 BpChar *arg1 = PG_GETARG_BPCHAR_PP(0);

787 BpChar *arg2 = PG_GETARG_BPCHAR_PP(1);

788 int len1,

789 len2;

790 bool result;

791 Oid collid = PG_GET_COLLATION();

792 pg_locale_t mylocale;

793

794 check_collation_set(collid);

795

796 len1 = bcTruelen(arg1);

797 len2 = bcTruelen(arg2);

798

799 mylocale = pg_newlocale_from_collation(collid);

800

801 if (mylocale->deterministic)

802 {

803 /*

804 * Since we only care about equality or not-equality, we can avoid all

805 * the expense of strcoll() here, and just do bitwise comparison.

806 */

807 if (len1 != len2)

808 result = true;

809 else

810 result = (memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), len1) != 0);

811 }

812 else

813 {

814 result = (varstr_cmp(VARDATA_ANY(arg1), len1, VARDATA_ANY(arg2), len2,

815 collid) != 0);

816 }

817

818 PG_FREE_IF_COPY(arg1, 0);

819 PG_FREE_IF_COPY(arg2, 1);

820

821 PG_RETURN_BOOL(result);

822}

References bcTruelen(), check_collation_set(), collid, pg_locale_struct::deterministic, PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_BPCHAR_PP, pg_newlocale_from_collation(), PG_RETURN_BOOL, VARDATA_ANY(), and varstr_cmp().

◆ bpcharoctetlen()

Datum bpcharoctetlen ( PG_FUNCTION_ARGS )

Definition at line 709 of file varchar.c.

710{

711 Datum arg = PG_GETARG_DATUM(0);

712

713 /* We need not detoast the input at all */

714 PG_RETURN_INT32(toast_raw_datum_size(arg) - VARHDRSZ);

715}

toast_raw_datum_size

Size toast_raw_datum_size(Datum value)

Definition: detoast.c:545

PG_GETARG_DATUM

#define PG_GETARG_DATUM(n)

Definition: fmgr.h:268

Datum

uint64_t Datum

Definition: postgres.h:70

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

◆ bpcharout()

Datum bpcharout ( PG_FUNCTION_ARGS )

Definition at line 219 of file varchar.c.

220{

221 Datum txt = PG_GETARG_DATUM(0);

222

223 PG_RETURN_CSTRING(TextDatumGetCString(txt));

224}

TextDatumGetCString

#define TextDatumGetCString(d)

Definition: builtins.h:98

PG_RETURN_CSTRING

#define PG_RETURN_CSTRING(x)

Definition: fmgr.h:362

References PG_GETARG_DATUM, PG_RETURN_CSTRING, and TextDatumGetCString.

◆ bpcharrecv()

Datum bpcharrecv ( PG_FUNCTION_ARGS )

Definition at line 230 of file varchar.c.

231{

232 StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);

233#ifdef NOT_USED

234 Oid typelem = PG_GETARG_OID(1);

235#endif

236 int32 atttypmod = PG_GETARG_INT32(2);

237 BpChar *result;

238 char *str;

239 int nbytes;

240

241 str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);

242 result = bpchar_input(str, nbytes, atttypmod, NULL);

243 pfree(str);

244 PG_RETURN_BPCHAR_P(result);

245}

str

const char * str

Definition: hashfn_unstable.h:254

pfree

void pfree(void *pointer)

Definition: mcxt.c:1594

buf

static char * buf

Definition: pg_test_fsync.c:72

pq_getmsgtext

char * pq_getmsgtext(StringInfo msg, int rawbytes, int *nbytes)

Definition: pqformat.c:546

StringInfo

struct StringInfoData * StringInfo

Definition: string.h:15

StringInfoData

Definition: stringinfo.h:47

References bpchar_input(), buf, pfree(), PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_BPCHAR_P, pq_getmsgtext(), and str.

◆ bpcharsend()

Datum bpcharsend ( PG_FUNCTION_ARGS )

Definition at line 251 of file varchar.c.

252{

253 /* Exactly the same as textsend, so share code */

254 return textsend(fcinfo);

255}

textsend

Datum textsend(PG_FUNCTION_ARGS)

Definition: varlena.c:315

References textsend().

◆ bpchartruelen()

int bpchartruelen ( char * s,

int len

)

Definition at line 676 of file varchar.c.

677{

678 int i;

679

680 /*

681 * Note that we rely on the assumption that ' ' is a singleton unit on

682 * every supported multibyte server encoding.

683 */

684 for (i = len - 1; i >= 0; i--)

685 {

686 if (s[i] != ' ')

687 break;

688 }

689 return i + 1;

690}

References i, and len.

Referenced by bcTruelen(), bpcharfastcmp_c(), varstr_abbrev_convert(), and varstrfastcmp_locale().

◆ bpchartypmodin()

Datum bpchartypmodin ( PG_FUNCTION_ARGS )

Definition at line 417 of file varchar.c.

418{

419 ArrayType *ta = PG_GETARG_ARRAYTYPE_P(0);

420

421 PG_RETURN_INT32(anychar_typmodin(ta, "char"));

422}

PG_GETARG_ARRAYTYPE_P

#define PG_GETARG_ARRAYTYPE_P(n)

Definition: array.h:263

ArrayType

Definition: array.h:93

anychar_typmodin

static int32 anychar_typmodin(ArrayType *ta, const char *typename)

Definition: varchar.c:33

References anychar_typmodin(), PG_GETARG_ARRAYTYPE_P, and PG_RETURN_INT32.

◆ bpchartypmodout()

Datum bpchartypmodout ( PG_FUNCTION_ARGS )

Definition at line 425 of file varchar.c.

426{

427 int32 typmod = PG_GETARG_INT32(0);

428

429 PG_RETURN_CSTRING(anychar_typmodout(typmod));

430}

anychar_typmodout

static char * anychar_typmodout(int32 typmod)

Definition: varchar.c:72

References anychar_typmodout(), PG_GETARG_INT32, and PG_RETURN_CSTRING.

◆ btbpchar_pattern_cmp()

Datum btbpchar_pattern_cmp ( PG_FUNCTION_ARGS )

Definition at line 1195 of file varchar.c.

1196{

1197 BpChar *arg1 = PG_GETARG_BPCHAR_PP(0);

1198 BpChar *arg2 = PG_GETARG_BPCHAR_PP(1);

1199 int result;

1200

1201 result = internal_bpchar_pattern_compare(arg1, arg2);

1202

1203 PG_FREE_IF_COPY(arg1, 0);

1204 PG_FREE_IF_COPY(arg2, 1);

1205

1206 PG_RETURN_INT32(result);

1207}

References internal_bpchar_pattern_compare(), PG_FREE_IF_COPY, PG_GETARG_BPCHAR_PP, and PG_RETURN_INT32.

◆ btbpchar_pattern_sortsupport()

Datum btbpchar_pattern_sortsupport ( PG_FUNCTION_ARGS )

Definition at line 1211 of file varchar.c.

1212{

1213 SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);

1214 MemoryContext oldcontext;

1215

1216 oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);

1217

1218 /* Use generic string SortSupport, forcing "C" collation */

1219 varstr_sortsupport(ssup, BPCHAROID, C_COLLATION_OID);

1220

1221 MemoryContextSwitchTo(oldcontext);

1222

1223 PG_RETURN_VOID();

1224}

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

◆ char_bpchar()

Datum char_bpchar ( PG_FUNCTION_ARGS )

Definition at line 353 of file varchar.c.

354{

355 char c = PG_GETARG_CHAR(0);

356 BpChar *result;

357

358 result = (BpChar *) palloc(VARHDRSZ + 1);

359

360 SET_VARSIZE(result, VARHDRSZ + 1);

361 *(VARDATA(result)) = c;

362

363 PG_RETURN_BPCHAR_P(result);

364}

PG_GETARG_CHAR

#define PG_GETARG_CHAR(n)

Definition: fmgr.h:273

c

char * c

Definition: preproc-cursor.c:31

References palloc(), PG_GETARG_CHAR, PG_RETURN_BPCHAR_P, SET_VARSIZE(), VARDATA(), and VARHDRSZ.

◆ check_collation_set()

static void check_collation_set ( Oid collid )

static

Definition at line 727 of file varchar.c.

728{

729 if (!OidIsValid(collid))

730 {

731 /*

732 * This typically means that the parser could not resolve a conflict

733 * of implicit collations, so report it that way.

734 */

735 ereport(ERROR,

736 (errcode(ERRCODE_INDETERMINATE_COLLATION),

737 errmsg("could not determine which collation to use for string comparison"),

738 errhint("Use the COLLATE clause to set the collation explicitly.")));

739 }

740}

OidIsValid

#define OidIsValid(objectId)

Definition: c.h:774

errhint

int errhint(const char *fmt,...)

Definition: elog.c:1321

References collid, ereport, errcode(), errhint(), errmsg(), ERROR, and OidIsValid.

Referenced by bpchareq(), and bpcharne().

◆ hashbpchar()

Datum hashbpchar ( PG_FUNCTION_ARGS )

Definition at line 988 of file varchar.c.

989{

990 BpChar *key = PG_GETARG_BPCHAR_PP(0);

991 Oid collid = PG_GET_COLLATION();

992 char *keydata;

993 int keylen;

994 pg_locale_t mylocale;

995 Datum result;

996

997 if (!collid)

998 ereport(ERROR,

999 (errcode(ERRCODE_INDETERMINATE_COLLATION),

1000 errmsg("could not determine which collation to use for string hashing"),

1001 errhint("Use the COLLATE clause to set the collation explicitly.")));

1002

1003 keydata = VARDATA_ANY(key);

1004 keylen = bcTruelen(key);

1005

1006 mylocale = pg_newlocale_from_collation(collid);

1007

1008 if (mylocale->deterministic)

1009 {

1010 result = hash_any((unsigned char *) keydata, keylen);

1011 }

1012 else

1013 {

1014 Size bsize,

1015 rsize;

1016 char *buf;

1017

1018 bsize = pg_strnxfrm(NULL, 0, keydata, keylen, mylocale);

1019 buf = palloc(bsize + 1);

1020

1021 rsize = pg_strnxfrm(buf, bsize + 1, keydata, keylen, mylocale);

1022

1023 /* the second call may return a smaller value than the first */

1024 if (rsize > bsize)

1025 elog(ERROR, "pg_strnxfrm() returned unexpected result");

1026

1027 /*

1028 * In principle, there's no reason to include the terminating NUL

1029 * character in the hash, but it was done before and the behavior must

1030 * be preserved.

1031 */

1032 result = hash_any((uint8_t *) buf, bsize + 1);

1033

1034 pfree(buf);

1035 }

1036

1037 /* Avoid leaking memory for toasted inputs */

1038 PG_FREE_IF_COPY(key, 0);

1039

1040 return result;

1041}

Size

size_t Size

Definition: c.h:610

elog

#define elog(elevel,...)

Definition: elog.h:226

hash_any

static Datum hash_any(const unsigned char *k, int keylen)

Definition: hashfn.h:31

sort-test.key

key

Definition: sort-test.py:19

pg_strnxfrm

size_t pg_strnxfrm(char *dest, size_t destsize, const char *src, ssize_t srclen, pg_locale_t locale)

Definition: pg_locale.c:1345

References bcTruelen(), buf, collid, pg_locale_struct::deterministic, elog, ereport, errcode(), errhint(), errmsg(), ERROR, hash_any(), sort-test::key, palloc(), pfree(), PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_BPCHAR_PP, pg_newlocale_from_collation(), pg_strnxfrm(), and VARDATA_ANY().

◆ hashbpcharextended()

Datum hashbpcharextended ( PG_FUNCTION_ARGS )

Definition at line 1044 of file varchar.c.

1045{

1046 BpChar *key = PG_GETARG_BPCHAR_PP(0);

1047 Oid collid = PG_GET_COLLATION();

1048 char *keydata;

1049 int keylen;

1050 pg_locale_t mylocale;

1051 Datum result;

1052

1053 if (!collid)

1054 ereport(ERROR,

1055 (errcode(ERRCODE_INDETERMINATE_COLLATION),

1056 errmsg("could not determine which collation to use for string hashing"),

1057 errhint("Use the COLLATE clause to set the collation explicitly.")));

1058

1059 keydata = VARDATA_ANY(key);

1060 keylen = bcTruelen(key);

1061

1062 mylocale = pg_newlocale_from_collation(collid);

1063

1064 if (mylocale->deterministic)

1065 {

1066 result = hash_any_extended((unsigned char *) keydata, keylen,

1067 PG_GETARG_INT64(1));

1068 }

1069 else

1070 {

1071 Size bsize,

1072 rsize;

1073 char *buf;

1074

1075 bsize = pg_strnxfrm(NULL, 0, keydata, keylen, mylocale);

1076 buf = palloc(bsize + 1);

1077

1078 rsize = pg_strnxfrm(buf, bsize + 1, keydata, keylen, mylocale);

1079

1080 /* the second call may return a smaller value than the first */

1081 if (rsize > bsize)

1082 elog(ERROR, "pg_strnxfrm() returned unexpected result");

1083

1084 /*

1085 * In principle, there's no reason to include the terminating NUL

1086 * character in the hash, but it was done before and the behavior must

1087 * be preserved.

1088 */

1089 result = hash_any_extended((uint8_t *) buf, bsize + 1,

1090 PG_GETARG_INT64(1));

1091

1092 pfree(buf);

1093 }

1094

1095 PG_FREE_IF_COPY(key, 0);

1096

1097 return result;

1098}

PG_GETARG_INT64

#define PG_GETARG_INT64(n)

Definition: fmgr.h:283

hash_any_extended

static Datum hash_any_extended(const unsigned char *k, int keylen, uint64 seed)

Definition: hashfn.h:37

References bcTruelen(), buf, collid, pg_locale_struct::deterministic, elog, ereport, errcode(), errhint(), errmsg(), ERROR, hash_any_extended(), sort-test::key, palloc(), pfree(), PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_BPCHAR_PP, PG_GETARG_INT64, pg_newlocale_from_collation(), pg_strnxfrm(), and VARDATA_ANY().

◆ internal_bpchar_pattern_compare()

static int internal_bpchar_pattern_compare ( BpChar * arg1,

BpChar * arg2

)

static

Definition at line 1109 of file varchar.c.

1110{

1111 int result;

1112 int len1,

1113 len2;

1114

1115 len1 = bcTruelen(arg1);

1116 len2 = bcTruelen(arg2);

1117

1118 result = memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), Min(len1, len2));

1119 if (result != 0)

1120 return result;

1121 else if (len1 < len2)

1122 return -1;

1123 else if (len1 > len2)

1124 return 1;

1125 else

1126 return 0;

1127}

Min

#define Min(x, y)

Definition: c.h:1003

References bcTruelen(), Min, and VARDATA_ANY().

Referenced by bpchar_pattern_ge(), bpchar_pattern_gt(), bpchar_pattern_le(), bpchar_pattern_lt(), and btbpchar_pattern_cmp().

◆ name_bpchar()

Datum name_bpchar ( PG_FUNCTION_ARGS )

Definition at line 407 of file varchar.c.

408{

409 Name s = PG_GETARG_NAME(0);

410 BpChar *result;

411

412 result = (BpChar *) cstring_to_text(NameStr(*s));

413 PG_RETURN_BPCHAR_P(result);

414}

PG_GETARG_NAME

#define PG_GETARG_NAME(n)

Definition: fmgr.h:278

cstring_to_text

text * cstring_to_text(const char *s)

Definition: varlena.c:181

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

◆ varchar()

Datum varchar ( PG_FUNCTION_ARGS )

Definition at line 609 of file varchar.c.

610{

611 VarChar *source = PG_GETARG_VARCHAR_PP(0);

612 int32 typmod = PG_GETARG_INT32(1);

613 bool isExplicit = PG_GETARG_BOOL(2);

614 int32 len,

615 maxlen;

616 size_t maxmblen;

617 int i;

618 char *s_data;

619

620 len = VARSIZE_ANY_EXHDR(source);

621 s_data = VARDATA_ANY(source);

622 maxlen = typmod - VARHDRSZ;

623

624 /* No work if typmod is invalid or supplied data fits it already */

625 if (maxlen < 0 || len <= maxlen)

626 PG_RETURN_VARCHAR_P(source);

627

628 /* only reach here if string is too long... */

629

630 /* truncate multibyte string preserving multibyte boundary */

631 maxmblen = pg_mbcharcliplen(s_data, len, maxlen);

632

633 if (!isExplicit)

634 {

635 for (i = maxmblen; i < len; i++)

636 if (s_data[i] != ' ')

637 ereport(ERROR,

638 (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),

639 errmsg("value too long for type character varying(%d)",

640 maxlen)));

641 }

642

643 PG_RETURN_VARCHAR_P((VarChar *) cstring_to_text_with_len(s_data,

644 maxmblen));

645}

PG_GETARG_VARCHAR_PP

#define PG_GETARG_VARCHAR_PP(n)

Definition: fmgr.h:311

PG_RETURN_VARCHAR_P

#define PG_RETURN_VARCHAR_P(x)

Definition: fmgr.h:374

cstring_to_text_with_len

text * cstring_to_text_with_len(const char *s, int len)

Definition: varlena.c:193

References cstring_to_text_with_len(), ereport, errcode(), errmsg(), ERROR, i, len, PG_GETARG_BOOL, PG_GETARG_INT32, PG_GETARG_VARCHAR_PP, pg_mbcharcliplen(), PG_RETURN_VARCHAR_P, source, VARDATA_ANY(), VARHDRSZ, and VARSIZE_ANY_EXHDR().

Referenced by main().

◆ varchar_input()

static VarChar * varchar_input ( const char * s,

size_t len,

int32 atttypmod,

Node * escontext

)

static

Definition at line 457 of file varchar.c.

458{

459 VarChar *result;

460 size_t maxlen;

461

462 maxlen = atttypmod - VARHDRSZ;

463

464 if (atttypmod >= (int32) VARHDRSZ && len > maxlen)

465 {

466 /* Verify that extra characters are spaces, and clip them off */

467 size_t mbmaxlen = pg_mbcharcliplen(s, len, maxlen);

468 size_t j;

469

470 for (j = mbmaxlen; j < len; j++)

471 {

472 if (s[j] != ' ')

473 ereturn(escontext, NULL,

474 (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),

475 errmsg("value too long for type character varying(%d)",

476 (int) maxlen)));

477 }

478

479 len = mbmaxlen;

480 }

481

482 /*

483 * We can use cstring_to_text_with_len because VarChar and text are

484 * binary-compatible types.

485 */

486 result = (VarChar *) cstring_to_text_with_len(s, len);

487 return result;

488}

References cstring_to_text_with_len(), ereturn, errcode(), errmsg(), j, len, pg_mbcharcliplen(), and VARHDRSZ.

Referenced by varcharin(), and varcharrecv().

◆ varchar_support()

Datum varchar_support ( PG_FUNCTION_ARGS )

Definition at line 565 of file varchar.c.

566{

567 Node *rawreq = (Node *) PG_GETARG_POINTER(0);

568 Node *ret = NULL;

569

570 if (IsA(rawreq, SupportRequestSimplify))

571 {

572 SupportRequestSimplify *req = (SupportRequestSimplify *) rawreq;

573 FuncExpr *expr = req->fcall;

574 Node *typmod;

575

576 Assert(list_length(expr->args) >= 2);

577

578 typmod = (Node *) lsecond(expr->args);

579

580 if (IsA(typmod, Const) && !((Const *) typmod)->constisnull)

581 {

582 Node *source = (Node *) linitial(expr->args);

583 int32 old_typmod = exprTypmod(source);

584 int32 new_typmod = DatumGetInt32(((Const *) typmod)->constvalue);

585 int32 old_max = old_typmod - VARHDRSZ;

586 int32 new_max = new_typmod - VARHDRSZ;

587

588 if (new_typmod < 0 || (old_typmod >= 0 && old_max <= new_max))

589 ret = relabel_to_typmod(source, new_typmod);

590 }

591 }

592

593 PG_RETURN_POINTER(ret);

594}

PG_RETURN_POINTER

#define PG_RETURN_POINTER(x)

Definition: fmgr.h:361

exprTypmod

int32 exprTypmod(const Node *expr)

Definition: nodeFuncs.c:301

relabel_to_typmod

Node * relabel_to_typmod(Node *expr, int32 typmod)

Definition: nodeFuncs.c:689

IsA

#define IsA(nodeptr, _type_)

Definition: nodes.h:164

list_length

static int list_length(const List *l)

Definition: pg_list.h:152

linitial

#define linitial(l)

Definition: pg_list.h:178

lsecond

#define lsecond(l)

Definition: pg_list.h:183

DatumGetInt32

static int32 DatumGetInt32(Datum X)

Definition: postgres.h:212

Const

Definition: primnodes.h:324

FuncExpr

Definition: primnodes.h:779

FuncExpr::args

List * args

Definition: primnodes.h:800

Node

Definition: nodes.h:135

SupportRequestSimplify

Definition: supportnodes.h:65

SupportRequestSimplify::fcall

FuncExpr * fcall

Definition: supportnodes.h:69

References FuncExpr::args, Assert(), DatumGetInt32(), exprTypmod(), SupportRequestSimplify::fcall, IsA, linitial, list_length(), lsecond, PG_GETARG_POINTER, PG_RETURN_POINTER, relabel_to_typmod(), source, and VARHDRSZ.

◆ varcharin()

Datum varcharin ( PG_FUNCTION_ARGS )

Definition at line 495 of file varchar.c.

496{

497 char *s = PG_GETARG_CSTRING(0);

498#ifdef NOT_USED

499 Oid typelem = PG_GETARG_OID(1);

500#endif

501 int32 atttypmod = PG_GETARG_INT32(2);

502 VarChar *result;

503

504 result = varchar_input(s, strlen(s), atttypmod, fcinfo->context);

505 PG_RETURN_VARCHAR_P(result);

506}

varchar_input

static VarChar * varchar_input(const char *s, size_t len, int32 atttypmod, Node *escontext)

Definition: varchar.c:457

References PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_VARCHAR_P, and varchar_input().

◆ varcharout()

Datum varcharout ( PG_FUNCTION_ARGS )

Definition at line 516 of file varchar.c.

517{

518 Datum txt = PG_GETARG_DATUM(0);

519

520 PG_RETURN_CSTRING(TextDatumGetCString(txt));

521}

References PG_GETARG_DATUM, PG_RETURN_CSTRING, and TextDatumGetCString.

◆ varcharrecv()

Datum varcharrecv ( PG_FUNCTION_ARGS )

Definition at line 527 of file varchar.c.

528{

529 StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);

530#ifdef NOT_USED

531 Oid typelem = PG_GETARG_OID(1);

532#endif

533 int32 atttypmod = PG_GETARG_INT32(2);

534 VarChar *result;

535 char *str;

536 int nbytes;

537

538 str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);

539 result = varchar_input(str, nbytes, atttypmod, NULL);

540 pfree(str);

541 PG_RETURN_VARCHAR_P(result);

542}

References buf, pfree(), PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_VARCHAR_P, pq_getmsgtext(), str, and varchar_input().

◆ varcharsend()

Datum varcharsend ( PG_FUNCTION_ARGS )

Definition at line 548 of file varchar.c.

549{

550 /* Exactly the same as textsend, so share code */

551 return textsend(fcinfo);

552}

References textsend().

◆ varchartypmodin()

Datum varchartypmodin ( PG_FUNCTION_ARGS )

Definition at line 648 of file varchar.c.

649{

650 ArrayType *ta = PG_GETARG_ARRAYTYPE_P(0);

651

652 PG_RETURN_INT32(anychar_typmodin(ta, "varchar"));

653}

References anychar_typmodin(), PG_GETARG_ARRAYTYPE_P, and PG_RETURN_INT32.

◆ varchartypmodout()

Datum varchartypmodout ( PG_FUNCTION_ARGS )

Definition at line 656 of file varchar.c.

657{

658 int32 typmod = PG_GETARG_INT32(0);

659

660 PG_RETURN_CSTRING(anychar_typmodout(typmod));

661}

References anychar_typmodout(), PG_GETARG_INT32, and PG_RETURN_CSTRING.