varchar.c Source File (original) (raw)

34{

37 int n;

45 if (n != 1)

47 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

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

50 if (*tl < 1)

52 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

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

56 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

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

67 return typmod;

68}

71static char *

73{

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

78 else

79 *res = '\0';

81 return res;

82}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

131{

133 char *r;

134 size_t maxlen;

135

136

138 maxlen = len;

139 else

140 {

141 size_t charlen;

142

143 maxlen = atttypmod - VARHDRSZ;

145 if (charlen > maxlen)

146 {

147

149 size_t j;

150

151

152

153

154

155

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

157 {

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

160 (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),

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

162 (int) maxlen)));

163 }

164

165

166

167

168

169 maxlen = len = mbmaxlen;

170 }

171 else

172 {

173

174

175

176

177 maxlen = len + (maxlen - charlen);

178 }

179 }

180

184 memcpy(r, s, len);

185

186

187 if (maxlen > len)

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

189

190 return result;

191}

192

193

194

195

196

199{

201#ifdef NOT_USED

203#endif

206

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

209}

210

211

212

213

214

215

216

217

220{

222

224}

225

226

227

228

231{

233#ifdef NOT_USED

235#endif

238 char *str;

239 int nbytes;

240

245}

246

247

248

249

252{

253

255}

256

257

258

259

260

261

262

263

264

265

266

267

268

269

272{

278 char *r;

279 char *s;

280 int i;

281 int charlen;

282

283

284

287

289

292

294

295

296 if (charlen == maxlen)

298

299 if (charlen > maxlen)

300 {

301

302 size_t maxmblen;

303

305

306 if (!isExplicit)

307 {

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

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

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

320

321

322 maxlen = len;

323 }

324 else

325 {

326

327

328

329

330 maxlen = len + (maxlen - charlen);

331 }

332

334

338

339 memcpy(r, s, len);

340

341

342 if (maxlen > len)

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

344

346}

347

348

349

350

351

354{

357

359

362

364}

365

366

367

368

369

372{

374 char *s_data;

377

380

381

384

385

386 while (len > 0)

387 {

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

389 break;

391 }

392

393

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

396

398}

399

400

401

402

403

404

405

408{

411

414}

415

418{

420

422}

423

426{

428

430}

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

458{

460 size_t maxlen;

461

462 maxlen = atttypmod - VARHDRSZ;

463

465 {

466

468 size_t j;

469

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

471 {

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

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

484

485

487 return result;

488}

489

490

491

492

493

496{

498#ifdef NOT_USED

500#endif

503

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

506}

507

508

509

510

511

512

513

514

517{

519

521}

522

523

524

525

528{

530#ifdef NOT_USED

532#endif

535 char *str;

536 int nbytes;

537

542}

543

544

545

546

549{

550

552}

553

554

555

556

557

558

559

560

561

562

563

566{

568 Node *ret = NULL;

569

571 {

574 Node *typmod;

575

577

579

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

581 {

587

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

590 }

591 }

592

594}

595

596

597

598

599

600

601

602

603

604

605

606

607

610{

615 maxlen;

616 size_t maxmblen;

617 int i;

618 char *s_data;

619

623

624

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

627

628

629

630

632

633 if (!isExplicit)

634 {

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

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

638 (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),

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

640 maxlen)));

641 }

642

644 maxmblen));

645}

646

649{

651

653}

654

657{

659

661}

662

663

664

665

666

667

668

669static inline int

671{

673}

674

675int

677{

678 int i;

679

680

681

682

683

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

685 {

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

687 break;

688 }

689 return i + 1;

690}

691

694{

697

698

700

701

704

706}

707

710{

712

713

715}

716

717

718

719

720

721

722

723

724

725

726static void

728{

730 {

731

732

733

734

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}

741

744{

747 int len1,

748 len2;

749 bool result;

752

754

757

759

761 {

762

763

764

765

766 if (len1 != len2)

767 result = false;

768 else

770 }

771 else

772 {

775 }

776

779

781}

782

785{

788 int len1,

789 len2;

790 bool result;

793

795

798

800

802 {

803

804

805

806

807 if (len1 != len2)

808 result = true;

809 else

811 }

812 else

813 {

816 }

817

820

822}

823

826{

829 int len1,

830 len2;

832

835

838

841

843}

844

847{

850 int len1,

851 len2;

853

856

859

862

864}

865

868{

871 int len1,

872 len2;

874

877

880

883

885}

886

889{

892 int len1,

893 len2;

895

898

901

904

906}

907

910{

913 int len1,

914 len2;

916

919

922

925

927}

928

931{

935

937

938

940

942

944}

945

948{

951 int len1,

952 len2;

954

957

960

962}

963

966{

969 int len1,

970 len2;

972

975

978

980}

981

982

983

984

985

986

989{

992 char *keydata;

993 int keylen;

996

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

1005

1007

1009 {

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

1011 }

1012 else

1013 {

1015 rsize;

1016 char *buf;

1017

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

1020

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

1022

1023

1024 if (rsize > bsize)

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

1026

1027

1028

1029

1030

1031

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

1033

1035 }

1036

1037

1039

1040 return result;

1041}

1042

1045{

1048 char *keydata;

1049 int keylen;

1052

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

1061

1063

1065 {

1068 }

1069 else

1070 {

1072 rsize;

1073 char *buf;

1074

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

1077

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

1079

1080

1081 if (rsize > bsize)

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

1083

1084

1085

1086

1087

1088

1091

1093 }

1094

1096

1097 return result;

1098}

1099

1100

1101

1102

1103

1104

1105

1106

1107

1108static int

1110{

1111 int result;

1112 int len1,

1113 len2;

1114

1117

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}

1128

1129

1132{

1135 int result;

1136

1138

1141

1143}

1144

1145

1148{

1151 int result;

1152

1154

1157

1159}

1160

1161

1164{

1167 int result;

1168

1170

1173

1175}

1176

1177

1180{

1183 int result;

1184

1186

1189

1191}

1192

1193

1196{

1199 int result;

1200

1202

1205

1207}

1208

1209

1212{

1215

1217

1218

1220

1222

1224}

#define PG_GETARG_ARRAYTYPE_P(n)

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

#define TextDatumGetCString(d)

#define OidIsValid(objectId)

Size toast_raw_datum_size(Datum value)

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

int errcode(int sqlerrcode)

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

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

#define ereport(elevel,...)

#define PG_FREE_IF_COPY(ptr, n)

#define PG_GETARG_CHAR(n)

#define PG_GETARG_POINTER(n)

#define PG_RETURN_CSTRING(x)

#define PG_GETARG_DATUM(n)

#define PG_GETARG_CSTRING(n)

#define PG_GETARG_INT64(n)

#define PG_GETARG_NAME(n)

#define PG_GETARG_BPCHAR_PP(n)

#define PG_GETARG_VARCHAR_PP(n)

#define PG_RETURN_BPCHAR_P(x)

#define PG_RETURN_INT32(x)

#define PG_RETURN_NAME(x)

#define PG_GETARG_INT32(n)

#define PG_GETARG_BOOL(n)

#define PG_RETURN_POINTER(x)

#define PG_GET_COLLATION()

#define PG_RETURN_VARCHAR_P(x)

#define PG_RETURN_BOOL(x)

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

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

Assert(PointerIsAligned(start, uint64))

int pg_mbstrlen_with_len(const char *mbstr, int limit)

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

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

int pg_database_encoding_max_length(void)

void pfree(void *pointer)

void * palloc0(Size size)

int32 exprTypmod(const Node *expr)

Node * relabel_to_typmod(Node *expr, int32 typmod)

#define IsA(nodeptr, _type_)

static MemoryContext MemoryContextSwitchTo(MemoryContext context)

static int list_length(const List *l)

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

pg_locale_t pg_newlocale_from_collation(Oid collid)

static rewind_source * source

static int32 DatumGetInt32(Datum X)

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

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

struct SortSupportData * SortSupport

StringInfoData * StringInfo

#define SET_VARSIZE(PTR, len)

#define VARSIZE_ANY_EXHDR(PTR)

Datum bpcharrecv(PG_FUNCTION_ARGS)

Datum bpcharne(PG_FUNCTION_ARGS)

Datum varchar_support(PG_FUNCTION_ARGS)

static int bcTruelen(BpChar *arg)

Datum bpchar_larger(PG_FUNCTION_ARGS)

Datum bpchar_pattern_lt(PG_FUNCTION_ARGS)

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

Datum varcharrecv(PG_FUNCTION_ARGS)

Datum varcharout(PG_FUNCTION_ARGS)

int bpchartruelen(char *s, int len)

Datum bpchar_pattern_le(PG_FUNCTION_ARGS)

Datum bpcharsend(PG_FUNCTION_ARGS)

Datum varcharsend(PG_FUNCTION_ARGS)

Datum bpcharlen(PG_FUNCTION_ARGS)

Datum bpchar(PG_FUNCTION_ARGS)

Datum name_bpchar(PG_FUNCTION_ARGS)

Datum bpchar_sortsupport(PG_FUNCTION_ARGS)

Datum bpchargt(PG_FUNCTION_ARGS)

Datum btbpchar_pattern_sortsupport(PG_FUNCTION_ARGS)

static char * anychar_typmodout(int32 typmod)

Datum bpcharge(PG_FUNCTION_ARGS)

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

Datum bpchar_pattern_ge(PG_FUNCTION_ARGS)

static void check_collation_set(Oid collid)

Datum bpchartypmodout(PG_FUNCTION_ARGS)

Datum varcharin(PG_FUNCTION_ARGS)

Datum bpchartypmodin(PG_FUNCTION_ARGS)

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

Datum varchar(PG_FUNCTION_ARGS)

Datum bpcharlt(PG_FUNCTION_ARGS)

Datum hashbpcharextended(PG_FUNCTION_ARGS)

Datum bpchar_smaller(PG_FUNCTION_ARGS)

Datum bpcharout(PG_FUNCTION_ARGS)

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

Datum bpcharcmp(PG_FUNCTION_ARGS)

Datum bpchareq(PG_FUNCTION_ARGS)

Datum btbpchar_pattern_cmp(PG_FUNCTION_ARGS)

Datum bpchar_name(PG_FUNCTION_ARGS)

Datum bpcharin(PG_FUNCTION_ARGS)

Datum varchartypmodin(PG_FUNCTION_ARGS)

Datum varchartypmodout(PG_FUNCTION_ARGS)

Datum bpcharle(PG_FUNCTION_ARGS)

Datum bpcharoctetlen(PG_FUNCTION_ARGS)

Datum bpchar_pattern_gt(PG_FUNCTION_ARGS)

Datum char_bpchar(PG_FUNCTION_ARGS)

Datum hashbpchar(PG_FUNCTION_ARGS)

Datum textsend(PG_FUNCTION_ARGS)

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

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

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

text * cstring_to_text(const char *s)