src/backend/access/common/reloptions.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * reloptions.c
   4  *        Core support for relation options (pg_class.reloptions)
   5  *
   6  * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        $PostgreSQL$
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15
  16 #include "postgres.h"
  17
  18 #include "access/reloptions.h"
  19 #include "catalog/pg_type.h"
  20 #include "commands/defrem.h"
  21 #include "nodes/makefuncs.h"
  22 #include "utils/array.h"
  23 #include "utils/builtins.h"
  24 #include "utils/guc.h"
  25 #include "utils/rel.h"
  26
  27
  28 /*
  29  * Transform a relation options list (list of DefElem) into the text array
  30  * format that is kept in pg_class.reloptions.
  31  *
  32  * This is used for three cases: CREATE TABLE/INDEX, ALTER TABLE SET, and
  33  * ALTER TABLE RESET.  In the ALTER cases, oldOptions is the existing
  34  * reloptions value (possibly NULL), and we replace or remove entries
  35  * as needed.
  36  *
  37  * If ignoreOids is true, then we should ignore any occurrence of "oids"
  38  * in the list (it will be or has been handled by interpretOidsOption()).
  39  *
  40  * Note that this is not responsible for determining whether the options
  41  * are valid.
  42  *
  43  * Both oldOptions and the result are text arrays (or NULL for "default"),
  44  * but we declare them as Datums to avoid including array.h in reloptions.h.
  45  */
  46 Datum
  47 transformRelOptions(Datum oldOptions, List *defList,
  48                                         bool ignoreOids, bool isReset)
  49 {
  50         Datum           result;
  51         ArrayBuildState *astate;
  52         ListCell   *cell;
  53
  54         /* no change if empty list */
  55         if (defList == NIL)
  56                 return oldOptions;
  57
  58         /* We build new array using accumArrayResult */
  59         astate = NULL;
  60
  61         /* Copy any oldOptions that aren't to be replaced */
  62         if (PointerIsValid(DatumGetPointer(oldOptions)))
  63         {
  64                 ArrayType  *array = DatumGetArrayTypeP(oldOptions);
  65                 Datum      *oldoptions;
  66                 int                     noldoptions;
  67                 int                     i;
  68
  69                 Assert(ARR_ELEMTYPE(array) == TEXTOID);
  70
  71                 deconstruct_array(array, TEXTOID, -1, false, 'i',
  72                                                   &oldoptions, NULL, &noldoptions);
  73
  74                 for (i = 0; i < noldoptions; i++)
  75                 {
  76                         text       *oldoption = DatumGetTextP(oldoptions[i]);
  77                         char       *text_str = VARDATA(oldoption);
  78                         int                     text_len = VARSIZE(oldoption) - VARHDRSZ;
  79
  80                         /* Search for a match in defList */
  81                         foreach(cell, defList)
  82                         {
  83                                 DefElem    *def = lfirst(cell);
  84                                 int                     kw_len = strlen(def->defname);
  85
  86                                 if (text_len > kw_len && text_str[kw_len] == '=' &&
  87                                         pg_strncasecmp(text_str, def->defname, kw_len) == 0)
  88                                         break;
  89                         }
  90                         if (!cell)
  91                         {
  92                                 /* No match, so keep old option */
  93                                 astate = accumArrayResult(astate, oldoptions[i],
  94                                                                                   false, TEXTOID,
  95                                                                                   CurrentMemoryContext);
  96                         }
  97                 }
  98         }
  99
 100         /*
 101          * If CREATE/SET, add new options to array; if RESET, just check that the
 102          * user didn't say RESET (option=val).  (Must do this because the grammar
 103          * doesn't enforce it.)
 104          */
 105         foreach(cell, defList)
 106         {
 107                 DefElem    *def = lfirst(cell);
 108
 109                 if (isReset)
 110                 {
 111                         if (def->arg != NULL)
 112                                 ereport(ERROR,
 113                                                 (errcode(ERRCODE_SYNTAX_ERROR),
 114                                         errmsg("RESET must not include values for parameters")));
 115                 }
 116                 else
 117                 {
 118                         text       *t;
 119                         const char *value;
 120                         Size            len;
 121
 122                         if (ignoreOids && pg_strcasecmp(def->defname, "oids") == 0)
 123                                 continue;
 124
 125                         /*
 126                          * Flatten the DefElem into a text string like "name=arg". If we
 127                          * have just "name", assume "name=true" is meant.
 128                          */
 129                         if (def->arg != NULL)
 130                                 value = defGetString(def);
 131                         else
 132                                 value = "true";
 133                         len = VARHDRSZ + strlen(def->defname) + 1 + strlen(value);
 134                         /* +1 leaves room for sprintf's trailing null */
 135                         t = (text *) palloc(len + 1);
 136                         SET_VARSIZE(t, len);
 137                         sprintf(VARDATA(t), "%s=%s", def->defname, value);
 138
 139                         astate = accumArrayResult(astate, PointerGetDatum(t),
 140                                                                           false, TEXTOID,
 141                                                                           CurrentMemoryContext);
 142                 }
 143         }
 144
 145         if (astate)
 146                 result = makeArrayResult(astate, CurrentMemoryContext);
 147         else
 148                 result = (Datum) 0;
 149
 150         return result;
 151 }
 152
 153
 154 /*
 155  * Convert the text-array format of reloptions into a List of DefElem.
 156  * This is the inverse of transformRelOptions().
 157  */
 158 List *
 159 untransformRelOptions(Datum options)
 160 {
 161         List       *result = NIL;
 162         ArrayType  *array;
 163         Datum      *optiondatums;
 164         int                     noptions;
 165         int                     i;
 166
 167         /* Nothing to do if no options */
 168         if (!PointerIsValid(DatumGetPointer(options)))
 169                 return result;
 170
 171         array = DatumGetArrayTypeP(options);
 172
 173         Assert(ARR_ELEMTYPE(array) == TEXTOID);
 174
 175         deconstruct_array(array, TEXTOID, -1, false, 'i',
 176                                           &optiondatums, NULL, &noptions);
 177
 178         for (i = 0; i < noptions; i++)
 179         {
 180                 char       *s;
 181                 char       *p;
 182                 Node       *val = NULL;
 183
 184                 s = TextDatumGetCString(optiondatums[i]);
 185                 p = strchr(s, '=');
 186                 if (p)
 187                 {
 188                         *p++ = '\0';
 189                         val = (Node *) makeString(pstrdup(p));
 190                 }
 191                 result = lappend(result, makeDefElem(pstrdup(s), val));
 192         }
 193
 194         return result;
 195 }
 196
 197
 198 /*
 199  * Interpret reloptions that are given in text-array format.
 200  *
 201  *      options: array of "keyword=value" strings, as built by transformRelOptions
 202  *      numkeywords: number of legal keywords
 203  *      keywords: the allowed keywords
 204  *      values: output area
 205  *      validate: if true, throw error for unrecognized keywords.
 206  *
 207  * The keywords and values arrays must both be of length numkeywords.
 208  * The values entry corresponding to a keyword is set to a palloc'd string
 209  * containing the corresponding value, or NULL if the keyword does not appear.
 210  */
 211 void
 212 parseRelOptions(Datum options, int numkeywords, const char *const * keywords,
 213                                 char **values, bool validate)
 214 {
 215         ArrayType  *array;
 216         Datum      *optiondatums;
 217         int                     noptions;
 218         int                     i;
 219
 220         /* Initialize to "all defaulted" */
 221         MemSet(values, 0, numkeywords * sizeof(char *));
 222
 223         /* Done if no options */
 224         if (!PointerIsValid(DatumGetPointer(options)))
 225                 return;
 226
 227         array = DatumGetArrayTypeP(options);
 228
 229         Assert(ARR_ELEMTYPE(array) == TEXTOID);
 230
 231         deconstruct_array(array, TEXTOID, -1, false, 'i',
 232                                           &optiondatums, NULL, &noptions);
 233
 234         for (i = 0; i < noptions; i++)
 235         {
 236                 text       *optiontext = DatumGetTextP(optiondatums[i]);
 237                 char       *text_str = VARDATA(optiontext);
 238                 int                     text_len = VARSIZE(optiontext) - VARHDRSZ;
 239                 int                     j;
 240
 241                 /* Search for a match in keywords */
 242                 for (j = 0; j < numkeywords; j++)
 243                 {
 244                         int                     kw_len = strlen(keywords[j]);
 245
 246                         if (text_len > kw_len && text_str[kw_len] == '=' &&
 247                                 pg_strncasecmp(text_str, keywords[j], kw_len) == 0)
 248                         {
 249                                 char       *value;
 250                                 int                     value_len;
 251
 252                                 if (values[j] && validate)
 253                                         ereport(ERROR,
 254                                                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 255                                                   errmsg("parameter \"%s\" specified more than once",
 256                                                                  keywords[j])));
 257                                 value_len = text_len - kw_len - 1;
 258                                 value = (char *) palloc(value_len + 1);
 259                                 memcpy(value, text_str + kw_len + 1, value_len);
 260                                 value[value_len] = '\0';
 261                                 values[j] = value;
 262                                 break;
 263                         }
 264                 }
 265                 if (j >= numkeywords && validate)
 266                 {
 267                         char       *s;
 268                         char       *p;
 269
 270                         s = TextDatumGetCString(optiondatums[i]);
 271                         p = strchr(s, '=');
 272                         if (p)
 273                                 *p = '\0';
 274                         ereport(ERROR,
 275                                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 276                                          errmsg("unrecognized parameter \"%s\"", s)));
 277                 }
 278         }
 279 }
 280
 281
 282 /*
 283  * Parse reloptions for anything using StdRdOptions (ie, fillfactor only)
 284  */
 285 bytea *
 286 default_reloptions(Datum reloptions, bool validate,
 287                                    int minFillfactor, int defaultFillfactor)
 288 {
 289         static const char *const default_keywords[1] = {"fillfactor"};
 290         char       *values[1];
 291         int                     fillfactor;
 292         StdRdOptions *result;
 293
 294         parseRelOptions(reloptions, 1, default_keywords, values, validate);
 295
 296         /*
 297          * If no options, we can just return NULL rather than doing anything.
 298          * (defaultFillfactor is thus not used, but we require callers to pass it
 299          * anyway since we would need it if more options were added.)
 300          */
 301         if (values[0] == NULL)
 302                 return NULL;
 303
 304         if (!parse_int(values[0], &fillfactor, 0, NULL))
 305         {
 306                 if (validate)
 307                         ereport(ERROR,
 308                                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 309                                          errmsg("fillfactor must be an integer: \"%s\"",
 310                                                         values[0])));
 311                 return NULL;
 312         }
 313
 314         if (fillfactor < minFillfactor || fillfactor > 100)
 315         {
 316                 if (validate)
 317                         ereport(ERROR,
 318                                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 319                                          errmsg("fillfactor=%d is out of range (should be between %d and 100)",
 320                                                         fillfactor, minFillfactor)));
 321                 return NULL;
 322         }
 323
 324         result = (StdRdOptions *) palloc(sizeof(StdRdOptions));
 325         SET_VARSIZE(result, sizeof(StdRdOptions));
 326
 327         result->fillfactor = fillfactor;
 328
 329         return (bytea *) result;
 330 }
 331
 332
 333 /*
 334  * Parse options for heaps (and perhaps someday toast tables).
 335  */
 336 bytea *
 337 heap_reloptions(char relkind, Datum reloptions, bool validate)
 338 {
 339         return default_reloptions(reloptions, validate,
 340                                                           HEAP_MIN_FILLFACTOR,
 341                                                           HEAP_DEFAULT_FILLFACTOR);
 342 }
 343
 344
 345 /*
 346  * Parse options for indexes.
 347  *
 348  *      amoptions       Oid of option parser
 349  *      reloptions      options as text[] datum
 350  *      validate        error flag
 351  */
 352 bytea *
 353 index_reloptions(RegProcedure amoptions, Datum reloptions, bool validate)
 354 {
 355         FmgrInfo        flinfo;
 356         FunctionCallInfoData fcinfo;
 357         Datum           result;
 358
 359         Assert(RegProcedureIsValid(amoptions));
 360
 361         /* Assume function is strict */
 362         if (!PointerIsValid(DatumGetPointer(reloptions)))
 363                 return NULL;
 364
 365         /* Can't use OidFunctionCallN because we might get a NULL result */
 366         fmgr_info(amoptions, &flinfo);
 367
 368         InitFunctionCallInfoData(fcinfo, &flinfo, 2, NULL, NULL);
 369
 370         fcinfo.arg[0] = reloptions;
 371         fcinfo.arg[1] = BoolGetDatum(validate);
 372         fcinfo.argnull[0] = false;
 373         fcinfo.argnull[1] = false;
 374
 375         result = FunctionCallInvoke(&fcinfo);
 376
 377         if (fcinfo.isnull || DatumGetPointer(result) == NULL)
 378                 return NULL;
 379
 380         return DatumGetByteaP(result);
 381 }