mirror of
https://github.com/postgres/postgres.git
synced 2025-11-10 17:42:29 +03:00
Re-apply Darren's char2-16 removal code.
This commit is contained in:
Bruce Momjian
@@ -3,16 +3,12 @@
|
||||
* char.c--
|
||||
* Functions for the built-in type "char".
|
||||
* Functions for the built-in type "cid".
|
||||
* Functions for the built-in type "char2".
|
||||
* Functions for the built-in type "char4".
|
||||
* Functions for the built-in type "char8".
|
||||
* Functions for the built-in type "char16".
|
||||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/adt/char.c,v 1.17 1998/04/07 18:11:25 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/adt/char.c,v 1.18 1998/04/26 04:07:28 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -87,42 +83,6 @@ cidout(int32 c)
|
||||
return (result);
|
||||
}
|
||||
|
||||
/*
|
||||
* char16in - converts "..." to internal reprsentation
|
||||
*
|
||||
* Note:
|
||||
* Currently if strlen(s) < 14, the extra chars are nulls
|
||||
*/
|
||||
char *
|
||||
char16in(char *s)
|
||||
{
|
||||
char *result;
|
||||
|
||||
if (s == NULL)
|
||||
return (NULL);
|
||||
result = (char *) palloc(16);
|
||||
strncpy(result, s, 16);
|
||||
return (result);
|
||||
}
|
||||
|
||||
/*
|
||||
* char16out - converts internal reprsentation to "..."
|
||||
*/
|
||||
char *
|
||||
char16out(char *s)
|
||||
{
|
||||
char *result = (char *) palloc(17);
|
||||
|
||||
if (s == NULL)
|
||||
{
|
||||
result[0] = '-';
|
||||
result[1] = '\0';
|
||||
}
|
||||
else
|
||||
StrNCpy(result, s, 17);
|
||||
return (result);
|
||||
}
|
||||
|
||||
|
||||
/*****************************************************************************
|
||||
* PUBLIC ROUTINES *
|
||||
@@ -193,283 +153,3 @@ cideq(int8 arg1, int8 arg2)
|
||||
{
|
||||
return (arg1 == arg2);
|
||||
}
|
||||
|
||||
/*
|
||||
* char16eq - returns 1 iff arguments are equal
|
||||
* char16ne - returns 1 iff arguments are not equal
|
||||
*
|
||||
* BUGS:
|
||||
* Assumes that "xy\0\0a" should be equal to "xy\0b".
|
||||
* If not, can do the comparison backwards for efficiency.
|
||||
*
|
||||
* char16lt - returns 1 iff a < b
|
||||
* char16le - returns 1 iff a <= b
|
||||
* char16gt - returns 1 iff a < b
|
||||
* char16ge - returns 1 iff a <= b
|
||||
*
|
||||
*/
|
||||
bool
|
||||
char16eq(char *arg1, char *arg2)
|
||||
{
|
||||
if (arg1 == NULL || arg2 == NULL)
|
||||
return ((bool) 0);
|
||||
return (strncmp(arg1, arg2, 16) == 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char16ne(char *arg1, char *arg2)
|
||||
{
|
||||
if (arg1 == NULL || arg2 == NULL)
|
||||
return ((bool) 0);
|
||||
return (strncmp(arg1, arg2, 16) != 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char16lt(char *arg1, char *arg2)
|
||||
{
|
||||
if (arg1 == NULL || arg2 == NULL)
|
||||
return ((bool) 0);
|
||||
return (strncmp(arg1, arg2, 16) < 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char16le(char *arg1, char *arg2)
|
||||
{
|
||||
if (arg1 == NULL || arg2 == NULL)
|
||||
return ((bool) 0);
|
||||
return (strncmp(arg1, arg2, 16) <= 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char16gt(char *arg1, char *arg2)
|
||||
{
|
||||
if (arg1 == NULL || arg2 == NULL)
|
||||
return ((bool) 0);
|
||||
|
||||
return (strncmp(arg1, arg2, 16) > 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char16ge(char *arg1, char *arg2)
|
||||
{
|
||||
if (arg1 == NULL || arg2 == NULL)
|
||||
return ((bool) 0);
|
||||
|
||||
return (strncmp(arg1, arg2, 16) >= 0);
|
||||
}
|
||||
|
||||
|
||||
/* ============================== char2 ============================== */
|
||||
uint16
|
||||
char2in(char *s)
|
||||
{
|
||||
uint16 res;
|
||||
|
||||
if (s == NULL)
|
||||
return (0);
|
||||
|
||||
strncpy((char *) &res, s, 2);
|
||||
return (res);
|
||||
}
|
||||
|
||||
char *
|
||||
char2out(uint16 s)
|
||||
{
|
||||
char *result = (char *) palloc(3);
|
||||
|
||||
StrNCpy(result, (char *) &s, 3);
|
||||
|
||||
return (result);
|
||||
}
|
||||
|
||||
bool
|
||||
char2eq(uint16 a, uint16 b)
|
||||
{
|
||||
return (strncmp((char *) &a, (char *) &b, 2) == 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char2ne(uint16 a, uint16 b)
|
||||
{
|
||||
return (strncmp((char *) &a, (char *) &b, 2) != 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char2lt(uint16 a, uint16 b)
|
||||
{
|
||||
return (strncmp((char *) &a, (char *) &b, 2) < 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char2le(uint16 a, uint16 b)
|
||||
{
|
||||
return (strncmp((char *) &a, (char *) &b, 2) <= 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char2gt(uint16 a, uint16 b)
|
||||
{
|
||||
return (strncmp((char *) &a, (char *) &b, 2) > 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char2ge(uint16 a, uint16 b)
|
||||
{
|
||||
return (strncmp((char *) &a, (char *) &b, 2) >= 0);
|
||||
}
|
||||
|
||||
int32
|
||||
char2cmp(uint16 a, uint16 b)
|
||||
{
|
||||
return (strncmp((char *) &a, (char *) &b, 2));
|
||||
}
|
||||
|
||||
/* ============================== char4 ============================== */
|
||||
uint32
|
||||
char4in(char *s)
|
||||
{
|
||||
uint32 res;
|
||||
|
||||
if (s == NULL)
|
||||
return (0);
|
||||
|
||||
strncpy((char *) &res, s, 4);
|
||||
|
||||
return (res);
|
||||
}
|
||||
|
||||
char *
|
||||
char4out(s)
|
||||
uint32 s;
|
||||
{
|
||||
char *result = (char *) palloc(5);
|
||||
|
||||
StrNCpy(result, (char *) &s, 5);
|
||||
|
||||
return (result);
|
||||
}
|
||||
|
||||
bool
|
||||
char4eq(uint32 a, uint32 b)
|
||||
{
|
||||
return (strncmp((char *) &a, (char *) &b, 4) == 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char4ne(uint32 a, uint32 b)
|
||||
{
|
||||
return (strncmp((char *) &a, (char *) &b, 4) != 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char4lt(uint32 a, uint32 b)
|
||||
{
|
||||
return (strncmp((char *) &a, (char *) &b, 4) < 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char4le(uint32 a, uint32 b)
|
||||
{
|
||||
return (strncmp((char *) &a, (char *) &b, 4) <= 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char4gt(uint32 a, uint32 b)
|
||||
{
|
||||
return (strncmp((char *) &a, (char *) &b, 4) > 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char4ge(uint32 a, uint32 b)
|
||||
{
|
||||
return (strncmp((char *) &a, (char *) &b, 4) >= 0);
|
||||
}
|
||||
|
||||
int32
|
||||
char4cmp(uint32 a, uint32 b)
|
||||
{
|
||||
return (strncmp((char *) &a, (char *) &b, 4));
|
||||
}
|
||||
|
||||
/* ============================== char8 ============================== */
|
||||
char *
|
||||
char8in(char *s)
|
||||
{
|
||||
char *result;
|
||||
|
||||
if (s == NULL)
|
||||
return ((char *) NULL);
|
||||
|
||||
result = (char *) palloc(8);
|
||||
strncpy(result, s, 8);
|
||||
return (result);
|
||||
}
|
||||
|
||||
char *
|
||||
char8out(char *s)
|
||||
{
|
||||
char *result = (char *) palloc(9);
|
||||
|
||||
if (s == NULL)
|
||||
{
|
||||
result[0] = '-';
|
||||
result[1] = '\0';
|
||||
}
|
||||
else
|
||||
StrNCpy(result, s, 9);
|
||||
return (result);
|
||||
}
|
||||
|
||||
bool
|
||||
char8eq(char *arg1, char *arg2)
|
||||
{
|
||||
if (arg1 == NULL || arg2 == NULL)
|
||||
return ((bool) 0);
|
||||
return (strncmp(arg1, arg2, 8) == 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char8ne(char *arg1, char *arg2)
|
||||
{
|
||||
if (arg1 == NULL || arg2 == NULL)
|
||||
return ((bool) 0);
|
||||
return (strncmp(arg1, arg2, 8) != 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char8lt(char *arg1, char *arg2)
|
||||
{
|
||||
if (arg1 == NULL || arg2 == NULL)
|
||||
return ((bool) 0);
|
||||
return (strncmp(arg1, arg2, 8) < 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char8le(char *arg1, char *arg2)
|
||||
{
|
||||
if (arg1 == NULL || arg2 == NULL)
|
||||
return ((bool) 0);
|
||||
return (strncmp(arg1, arg2, 8) <= 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char8gt(char *arg1, char *arg2)
|
||||
{
|
||||
if (arg1 == NULL || arg2 == NULL)
|
||||
return ((bool) 0);
|
||||
return (strncmp(arg1, arg2, 8) > 0);
|
||||
}
|
||||
|
||||
bool
|
||||
char8ge(char *arg1, char *arg2)
|
||||
{
|
||||
if (arg1 == NULL || arg2 == NULL)
|
||||
return ((bool) 0);
|
||||
return (strncmp(arg1, arg2, 8) >= 0);
|
||||
}
|
||||
|
||||
int32
|
||||
char8cmp(char *arg1, char *arg2)
|
||||
{
|
||||
return (strncmp(arg1, arg2, 8));
|
||||
}
|
||||
|
||||
@@ -82,58 +82,6 @@ fixedlen_like(char *s, struct varlena * p, int charlen)
|
||||
return ((bool) result);
|
||||
}
|
||||
|
||||
bool
|
||||
char2like(uint16 arg1, struct varlena * p)
|
||||
{
|
||||
char *s = (char *) &arg1;
|
||||
|
||||
return (fixedlen_like(s, p, 2));
|
||||
}
|
||||
|
||||
bool
|
||||
char2nlike(uint16 arg1, struct varlena * p)
|
||||
{
|
||||
return (!char2like(arg1, p));
|
||||
}
|
||||
|
||||
bool
|
||||
char4like(uint32 arg1, struct varlena * p)
|
||||
{
|
||||
char *s = (char *) &arg1;
|
||||
|
||||
return (fixedlen_like(s, p, 4));
|
||||
}
|
||||
|
||||
bool
|
||||
char4nlike(uint32 arg1, struct varlena * p)
|
||||
{
|
||||
return (!char4like(arg1, p));
|
||||
}
|
||||
|
||||
bool
|
||||
char8like(char *s, struct varlena * p)
|
||||
{
|
||||
return (fixedlen_like(s, p, 8));
|
||||
}
|
||||
|
||||
bool
|
||||
char8nlike(char *s, struct varlena * p)
|
||||
{
|
||||
return (!char8like(s, p));
|
||||
}
|
||||
|
||||
bool
|
||||
char16like(char *s, struct varlena * p)
|
||||
{
|
||||
return (fixedlen_like(s, p, 16));
|
||||
}
|
||||
|
||||
bool
|
||||
char16nlike(char *s, struct varlena * p)
|
||||
{
|
||||
return (!char16like(s, p));
|
||||
}
|
||||
|
||||
bool
|
||||
namelike(NameData *n, struct varlena * p)
|
||||
{
|
||||
@@ -163,7 +111,7 @@ textnlike(struct varlena * s, struct varlena * p)
|
||||
}
|
||||
|
||||
|
||||
/* $Revision: 1.15 $
|
||||
/* $Revision: 1.16 $
|
||||
** "like.c" A first attempt at a LIKE operator for Postgres95.
|
||||
**
|
||||
** Originally written by Rich $alz, mirror!rs, Wed Nov 26 19:03:17 EST 1986.
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/adt/regexp.c,v 1.16 1998/04/07 18:11:32 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/adt/regexp.c,v 1.17 1998/04/26 04:07:48 momjian Exp $
|
||||
*
|
||||
* Alistair Crooks added the code for the regex caching
|
||||
* agc - cached the regular expressions used - there's a good chance
|
||||
@@ -203,58 +203,6 @@ fixedlen_regexeq(char *s, struct varlena * p, int charlen, int cflags)
|
||||
/*
|
||||
* routines that use the regexp stuff
|
||||
*/
|
||||
bool
|
||||
char2regexeq(uint16 arg1, struct varlena * p)
|
||||
{
|
||||
char *s = (char *) &arg1;
|
||||
|
||||
return (fixedlen_regexeq(s, p, 2, REG_EXTENDED));
|
||||
}
|
||||
|
||||
bool
|
||||
char2regexne(uint16 arg1, struct varlena * p)
|
||||
{
|
||||
return (!char2regexeq(arg1, p));
|
||||
}
|
||||
|
||||
bool
|
||||
char4regexeq(uint32 arg1, struct varlena * p)
|
||||
{
|
||||
char *s = (char *) &arg1;
|
||||
|
||||
return (fixedlen_regexeq(s, p, 4, REG_EXTENDED));
|
||||
}
|
||||
|
||||
bool
|
||||
char4regexne(uint32 arg1, struct varlena * p)
|
||||
{
|
||||
return (!char4regexeq(arg1, p));
|
||||
}
|
||||
|
||||
bool
|
||||
char8regexeq(char *s, struct varlena * p)
|
||||
{
|
||||
return (fixedlen_regexeq(s, p, 8, REG_EXTENDED));
|
||||
}
|
||||
|
||||
bool
|
||||
char8regexne(char *s, struct varlena * p)
|
||||
{
|
||||
return (!char8regexeq(s, p));
|
||||
}
|
||||
|
||||
bool
|
||||
char16regexeq(char *s, struct varlena * p)
|
||||
{
|
||||
return (fixedlen_regexeq(s, p, 16, REG_EXTENDED));
|
||||
}
|
||||
|
||||
bool
|
||||
char16regexne(char *s, struct varlena * p)
|
||||
{
|
||||
return (!char16regexeq(s, p));
|
||||
}
|
||||
|
||||
bool
|
||||
nameregexeq(NameData *n, struct varlena * p)
|
||||
{
|
||||
@@ -288,59 +236,6 @@ textregexne(struct varlena * s, struct varlena * p)
|
||||
* routines that use the regexp stuff, but ignore the case.
|
||||
* for this, we use the REG_ICASE flag to pg95_regcomp
|
||||
*/
|
||||
bool
|
||||
char2icregexeq(uint16 arg1, struct varlena * p)
|
||||
{
|
||||
char *s = (char *) &arg1;
|
||||
|
||||
return (fixedlen_regexeq(s, p, 2, REG_ICASE | REG_EXTENDED));
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
char2icregexne(uint16 arg1, struct varlena * p)
|
||||
{
|
||||
return (!char2icregexeq(arg1, p));
|
||||
}
|
||||
|
||||
bool
|
||||
char4icregexeq(uint32 arg1, struct varlena * p)
|
||||
{
|
||||
char *s = (char *) &arg1;
|
||||
|
||||
return (fixedlen_regexeq(s, p, 4, REG_ICASE | REG_EXTENDED));
|
||||
}
|
||||
|
||||
bool
|
||||
char4icregexne(uint32 arg1, struct varlena * p)
|
||||
{
|
||||
return (!char4icregexeq(arg1, p));
|
||||
}
|
||||
|
||||
bool
|
||||
char8icregexeq(char *s, struct varlena * p)
|
||||
{
|
||||
return (fixedlen_regexeq(s, p, 8, REG_ICASE | REG_EXTENDED));
|
||||
}
|
||||
|
||||
bool
|
||||
char8icregexne(char *s, struct varlena * p)
|
||||
{
|
||||
return (!char8icregexeq(s, p));
|
||||
}
|
||||
|
||||
bool
|
||||
char16icregexeq(char *s, struct varlena * p)
|
||||
{
|
||||
return (fixedlen_regexeq(s, p, 16, REG_ICASE | REG_EXTENDED));
|
||||
}
|
||||
|
||||
bool
|
||||
char16icregexne(char *s, struct varlena * p)
|
||||
{
|
||||
return (!char16icregexeq(s, p));
|
||||
}
|
||||
|
||||
bool
|
||||
texticregexeq(struct varlena * s, struct varlena * p)
|
||||
{
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.17 1998/04/07 18:11:34 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.18 1998/04/26 04:07:55 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -52,7 +52,7 @@ regprocin(char *proname)
|
||||
ScanKeyEntryInitialize(&key,
|
||||
(bits16) 0,
|
||||
(AttrNumber) 1,
|
||||
(RegProcedure) F_CHAR16EQ,
|
||||
(RegProcedure) F_NAMEEQ,
|
||||
(Datum) proname);
|
||||
|
||||
procscan = heap_beginscan(proc, 0, false, 1, &key);
|
||||
|
||||
Reference in New Issue
Block a user