granicus.if.org Git - postgresql/blob - src/backend/utils/adt/char.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * char.c
   4  *        Functions for the built-in type "char".
   5  *        Functions for the built-in type "cid" (what's that doing here?)
   6  *
   7  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
   8  * Portions Copyright (c) 1994, Regents of the University of California
   9  *
  10  *
  11  * IDENTIFICATION
  12  *        $Header: /cvsroot/pgsql/src/backend/utils/adt/char.c,v 1.28 2000/06/05 07:28:51 tgl Exp $
  13  *
  14  *-------------------------------------------------------------------------
  15  */
  16 #include "postgres.h"
  17
  18 #include "utils/builtins.h"
  19
  20 /*****************************************************************************
  21  *       USER I/O ROUTINES                                                                                                               *
  22  *****************************************************************************/
  23
  24 /*
  25  *              charin                  - converts "x" to 'x'
  26  */
  27 Datum
  28 charin(PG_FUNCTION_ARGS)
  29 {
  30         char       *ch = PG_GETARG_CSTRING(0);
  31
  32         PG_RETURN_CHAR(ch[0]);
  33 }
  34
  35 /*
  36  *              charout                 - converts 'x' to "x"
  37  */
  38 Datum
  39 charout(PG_FUNCTION_ARGS)
  40 {
  41         char            ch = PG_GETARG_CHAR(0);
  42         char       *result = (char *) palloc(2);
  43
  44         result[0] = ch;
  45         result[1] = '\0';
  46         PG_RETURN_CSTRING(result);
  47 }
  48
  49 /*****************************************************************************
  50  *       PUBLIC ROUTINES                                                                                                                 *
  51  *****************************************************************************/
  52
  53 /*
  54  * NOTE: comparisons are done as though char is unsigned (uint8).
  55  * Arithmetic is done as though char is signed (int8).
  56  *
  57  * You wanted consistency?
  58  */
  59
  60 Datum
  61 chareq(PG_FUNCTION_ARGS)
  62 {
  63         char            arg1 = PG_GETARG_CHAR(0);
  64         char            arg2 = PG_GETARG_CHAR(1);
  65
  66         PG_RETURN_BOOL(arg1 == arg2);
  67 }
  68
  69 Datum
  70 charne(PG_FUNCTION_ARGS)
  71 {
  72         char            arg1 = PG_GETARG_CHAR(0);
  73         char            arg2 = PG_GETARG_CHAR(1);
  74
  75         PG_RETURN_BOOL(arg1 != arg2);
  76 }
  77
  78 Datum
  79 charlt(PG_FUNCTION_ARGS)
  80 {
  81         char            arg1 = PG_GETARG_CHAR(0);
  82         char            arg2 = PG_GETARG_CHAR(1);
  83
  84         PG_RETURN_BOOL((uint8) arg1 < (uint8) arg2);
  85 }
  86
  87 Datum
  88 charle(PG_FUNCTION_ARGS)
  89 {
  90         char            arg1 = PG_GETARG_CHAR(0);
  91         char            arg2 = PG_GETARG_CHAR(1);
  92
  93         PG_RETURN_BOOL((uint8) arg1 <= (uint8) arg2);
  94 }
  95
  96 Datum
  97 chargt(PG_FUNCTION_ARGS)
  98 {
  99         char            arg1 = PG_GETARG_CHAR(0);
 100         char            arg2 = PG_GETARG_CHAR(1);
 101
 102         PG_RETURN_BOOL((uint8) arg1 > (uint8) arg2);
 103 }
 104
 105 Datum
 106 charge(PG_FUNCTION_ARGS)
 107 {
 108         char            arg1 = PG_GETARG_CHAR(0);
 109         char            arg2 = PG_GETARG_CHAR(1);
 110
 111         PG_RETURN_BOOL((uint8) arg1 >= (uint8) arg2);
 112 }
 113
 114 Datum
 115 charpl(PG_FUNCTION_ARGS)
 116 {
 117         char            arg1 = PG_GETARG_CHAR(0);
 118         char            arg2 = PG_GETARG_CHAR(1);
 119
 120         PG_RETURN_CHAR((int8) arg1 + (int8) arg2);
 121 }
 122
 123 Datum
 124 charmi(PG_FUNCTION_ARGS)
 125 {
 126         char            arg1 = PG_GETARG_CHAR(0);
 127         char            arg2 = PG_GETARG_CHAR(1);
 128
 129         PG_RETURN_CHAR((int8) arg1 - (int8) arg2);
 130 }
 131
 132 Datum
 133 charmul(PG_FUNCTION_ARGS)
 134 {
 135         char            arg1 = PG_GETARG_CHAR(0);
 136         char            arg2 = PG_GETARG_CHAR(1);
 137
 138         PG_RETURN_CHAR((int8) arg1 * (int8) arg2);
 139 }
 140
 141 Datum
 142 chardiv(PG_FUNCTION_ARGS)
 143 {
 144         char            arg1 = PG_GETARG_CHAR(0);
 145         char            arg2 = PG_GETARG_CHAR(1);
 146
 147         PG_RETURN_CHAR((int8) arg1 / (int8) arg2);
 148 }
 149
 150 Datum
 151 text_char(PG_FUNCTION_ARGS)
 152 {
 153         text       *arg1 = PG_GETARG_TEXT_P(0);
 154
 155         /* XXX what if arg1 has length zero? */
 156         PG_RETURN_CHAR(*(VARDATA(arg1)));
 157 }
 158
 159 Datum
 160 char_text(PG_FUNCTION_ARGS)
 161 {
 162         char            arg1 = PG_GETARG_CHAR(0);
 163         text       *result = palloc(VARHDRSZ + 1);
 164
 165         VARSIZE(result) = VARHDRSZ + 1;
 166         *(VARDATA(result)) = arg1;
 167
 168         PG_RETURN_TEXT_P(result);
 169 }
 170
 171
 172 /*****************************************************************************
 173  *       USER I/O ROUTINES                                                                                                               *
 174  *****************************************************************************/
 175
 176 /*
 177  *              cidin   - converts CommandId to internal representation.
 178  */
 179 Datum
 180 cidin(PG_FUNCTION_ARGS)
 181 {
 182         char       *s = PG_GETARG_CSTRING(0);
 183         CommandId       c;
 184
 185         c = atoi(s);
 186
 187         /* XXX assume that CommandId is 32 bits... */
 188         PG_RETURN_INT32((int32) c);
 189 }
 190
 191 /*
 192  *              cidout  - converts a cid to external representation.
 193  */
 194 Datum
 195 cidout(PG_FUNCTION_ARGS)
 196 {
 197         /* XXX assume that CommandId is 32 bits... */
 198         CommandId       c = PG_GETARG_INT32(0);
 199         char       *result = (char *) palloc(16);
 200
 201         sprintf(result, "%u", (unsigned int) c);
 202         PG_RETURN_CSTRING(result);
 203 }
 204
 205 /*****************************************************************************
 206  *       PUBLIC ROUTINES                                                                                                                 *
 207  *****************************************************************************/
 208
 209 Datum
 210 cideq(PG_FUNCTION_ARGS)
 211 {
 212         /* XXX assume that CommandId is 32 bits... */
 213         CommandId       arg1 = PG_GETARG_INT32(0);
 214         CommandId       arg2 = PG_GETARG_INT32(1);
 215
 216         PG_RETURN_BOOL(arg1 == arg2);
 217 }