#include "postgres.h"
#include <ctype.h>
#include <math.h>
#include "catalog/namespace.h"
#include "commands/defrem.h"
#include "nodes/makefuncs.h"
#include "parser/parse_type.h"
#include "parser/scansup.h"
#include "utils/builtins.h"

Include dependency graph for define.c:

Functions
char *	defGetString (DefElem *def)

double	defGetNumeric (DefElem *def)

bool	defGetBoolean (DefElem *def)

int32	defGetInt32 (DefElem *def)

int64	defGetInt64 (DefElem *def)

List *	defGetQualifiedName (DefElem *def)

TypeName *	defGetTypeName (DefElem *def)

int	defGetTypeLength (DefElem *def)

List *	defGetStringList (DefElem *def)

void	errorConflictingDefElem (DefElem defel, ParseState pstate)

Function Documentation

◆ defGetBoolean()

bool defGetBoolean ( DefElem * def )

Definition at line 106 of file define.c.

 {
     /*
      * If no parameter given, assume "true" is meant.
      */
     if (def->arg == NULL)
         return true;
  
     /*
      * Allow 0, 1, "true", "false", "on", "off"
      */
     switch (nodeTag(def->arg))
     {
         case T_Integer:
             switch (intVal(def->arg))
             {
                 case 0:
                     return false;
                 case 1:
                     return true;
                 default:
                     /* otherwise, error out below */
                     break;
             }
             break;
         default:
             {
                 char       *sval = defGetString(def);
  
                 /*
                  * The set of strings accepted here should match up with the
                  * grammar's opt_boolean_or_string production.
                  */
                 if (pg_strcasecmp(sval, "true") == 0)
                     return true;
                 if (pg_strcasecmp(sval, "false") == 0)
                     return false;
                 if (pg_strcasecmp(sval, "on") == 0)
                     return true;
                 if (pg_strcasecmp(sval, "off") == 0)
                     return false;
             }
             break;
     }
     ereport(ERROR,
             (errcode(ERRCODE_SYNTAX_ERROR),
              errmsg("%s requires a Boolean value",
                     def->defname)));
     return false;               /* keep compiler quiet */
 }

References DefElem::arg, defGetString(), DefElem::defname, ereport, errcode(), errmsg(), ERROR, intVal, nodeTag, pg_strcasecmp(), and T_Integer.

Referenced by AlterDatabase(), apply_server_options(), apply_table_options(), cluster(), createdb(), CreateExtension(), DefineAggregate(), DefineCollation(), DefineOperator(), DefineType(), dintdict_init(), dsimple_init(), dsynonym_init(), dxsyn_init(), ExecReindex(), ExecVacuum(), ExplainQuery(), file_fdw_validator(), get_file_fdw_attribute_options(), get_vacoptval_from_boolean(), GetCommandLogLevel(), make_new_connection(), parse_basebackup_options(), parse_output_parameters(), parse_publication_options(), parse_subscription_options(), parseCreateReplSlotOptions(), postgres_fdw_validator(), postgresExecForeignTruncate(), postgresImportForeignSchema(), postgresIsForeignRelUpdatable(), ProcessCopyOptions(), transformRelOptions(), and UserMappingPasswordRequired().

◆ defGetInt32()

int32 defGetInt32 ( DefElem * def )

Definition at line 161 of file define.c.

 {
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires an integer value",
                         def->defname)));
     switch (nodeTag(def->arg))
     {
         case T_Integer:
             return (int32) intVal(def->arg);
         default:
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("%s requires an integer value",
                             def->defname)));
     }
     return 0;                   /* keep compiler quiet */
 }

References DefElem::arg, DefElem::defname, ereport, errcode(), errmsg(), ERROR, intVal, nodeTag, and T_Integer.

Referenced by AlterDatabase(), ATExecSetIdentity(), createdb(), DefineAggregate(), and ExecVacuum().

◆ defGetInt64()

int64 defGetInt64 ( DefElem * def )

Definition at line 185 of file define.c.

 {
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a numeric value",
                         def->defname)));
     switch (nodeTag(def->arg))
     {
         case T_Integer:
             return (int64) intVal(def->arg);
         case T_Float:
  
             /*
              * Values too large for int4 will be represented as Float
              * constants by the lexer.  Accept these if they are valid int8
              * strings.
              */
             return DatumGetInt64(DirectFunctionCall1(int8in,
                                                      CStringGetDatum(castNode(Float, def->arg)->val)));
         default:
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("%s requires a numeric value",
                             def->defname)));
     }
     return 0;                   /* keep compiler quiet */
 }

References DefElem::arg, castNode, CStringGetDatum, DatumGetInt64, DefElem::defname, DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, int8in(), intVal, nodeTag, T_Float, and T_Integer.

Referenced by init_params(), and parse_basebackup_options().

◆ defGetNumeric()

double defGetNumeric ( DefElem * def )

Definition at line 80 of file define.c.

 {
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a numeric value",
                         def->defname)));
     switch (nodeTag(def->arg))
     {
         case T_Integer:
             return (double) intVal(def->arg);
         case T_Float:
             return floatVal(def->arg);
         default:
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("%s requires a numeric value",
                             def->defname)));
     }
     return 0;                   /* keep compiler quiet */
 }

References DefElem::arg, DefElem::defname, ereport, errcode(), errmsg(), ERROR, floatVal, intVal, nodeTag, T_Float, and T_Integer.

Referenced by AlterFunction(), and compute_function_attributes().

◆ defGetQualifiedName()

List* defGetQualifiedName ( DefElem * def )

Definition at line 218 of file define.c.

 {
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a parameter",
                         def->defname)));
     switch (nodeTag(def->arg))
     {
         case T_TypeName:
             return ((TypeName *) def->arg)->names;
         case T_List:
             return (List *) def->arg;
         case T_String:
             /* Allow quoted name for backwards compatibility */
             return list_make1(def->arg);
         default:
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("argument of %s must be a name",
                             def->defname)));
     }
     return NIL;                 /* keep compiler quiet */
 }

References DefElem::arg, DefElem::defname, ereport, errcode(), errmsg(), ERROR, list_make1, NIL, nodeTag, T_List, T_String, and T_TypeName.

Referenced by AlterOperator(), AlterType(), DefineAggregate(), DefineCollation(), DefineOperator(), DefineRange(), DefineTSConfiguration(), DefineTSDictionary(), DefineType(), get_ts_parser_func(), get_ts_template_func(), init_params(), and interpret_func_support().

◆ defGetString()

char* defGetString ( DefElem * def )

Definition at line 49 of file define.c.

 {
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a parameter",
                         def->defname)));
     switch (nodeTag(def->arg))
     {
         case T_Integer:
             return psprintf("%ld", (long) intVal(def->arg));
         case T_Float:
             return castNode(Float, def->arg)->val;
         case T_String:
             return strVal(def->arg);
         case T_TypeName:
             return TypeNameToString((TypeName *) def->arg);
         case T_List:
             return NameListToString((List *) def->arg);
         case T_A_Star:
             return pstrdup("*");
         default:
             elog(ERROR, "unrecognized node type: %d", (int) nodeTag(def->arg));
     }
     return NULL;                /* keep compiler quiet */
 }

References DefElem::arg, castNode, DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, intVal, NameListToString(), nodeTag, psprintf(), pstrdup(), strVal, T_A_Star, T_Float, T_Integer, T_List, T_String, T_TypeName, and TypeNameToString().

Referenced by AlterDatabase(), AlterType(), apply_server_options(), apply_table_options(), check_selective_binary_conversion(), createdb(), CreateExtension(), defGetBoolean(), defGetTypeLength(), DefineAggregate(), DefineCollation(), DefineType(), deparseAnalyzeSql(), deparseColumnRef(), deparseRelation(), dintdict_init(), dispell_init(), dsimple_init(), dsnowball_init(), dsynonym_init(), dxsyn_init(), ExecReindex(), ExecVacuum(), ExplainQuery(), ExplainResultDesc(), ExtractConnectionOptions(), extractModify(), file_fdw_validator(), fileGetOptions(), get_batch_size_option(), optionListToArray(), parse_basebackup_options(), parse_publication_options(), parse_subscription_options(), parseCreateReplSlotOptions(), postgres_fdw_validator(), postgresAcquireSampleRowsFunc(), ProcessCopyOptions(), prsd_headline(), serialize_deflist(), thesaurus_init(), transformRelOptions(), and unaccent_init().

◆ defGetStringList()

List* defGetStringList ( DefElem * def )

Definition at line 322 of file define.c.

 {
     ListCell   *cell;
  
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a parameter",
                         def->defname)));
     if (nodeTag(def->arg) != T_List)
         elog(ERROR, "unrecognized node type: %d", (int) nodeTag(def->arg));
  
     foreach(cell, (List *) def->arg)
     {
         Node       *str = (Node *) lfirst(cell);
  
         if (!IsA(str, String))
             elog(ERROR, "unexpected node type in name list: %d",
                  (int) nodeTag(str));
     }
  
     return (List *) def->arg;
 }

References DefElem::arg, DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, IsA, lfirst, nodeTag, generate_unaccent_rules::str, and T_List.

◆ defGetTypeLength()

int defGetTypeLength ( DefElem * def )

Definition at line 278 of file define.c.

 {
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a parameter",
                         def->defname)));
     switch (nodeTag(def->arg))
     {
         case T_Integer:
             return intVal(def->arg);
         case T_Float:
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("%s requires an integer value",
                             def->defname)));
             break;
         case T_String:
             if (pg_strcasecmp(strVal(def->arg), "variable") == 0)
                 return -1;      /* variable length */
             break;
         case T_TypeName:
             /* cope if grammar chooses to believe "variable" is a typename */
             if (pg_strcasecmp(TypeNameToString((TypeName *) def->arg),
                               "variable") == 0)
                 return -1;      /* variable length */
             break;
         case T_List:
             /* must be an operator name */
             break;
         default:
             elog(ERROR, "unrecognized node type: %d", (int) nodeTag(def->arg));
     }
     ereport(ERROR,
             (errcode(ERRCODE_SYNTAX_ERROR),
              errmsg("invalid argument for %s: \"%s\"",
                     def->defname, defGetString(def))));
     return 0;                   /* keep compiler quiet */
 }

References DefElem::arg, defGetString(), DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, intVal, nodeTag, pg_strcasecmp(), strVal, T_Float, T_Integer, T_List, T_String, T_TypeName, and TypeNameToString().

Referenced by DefineType().

◆ defGetTypeName()

TypeName* defGetTypeName ( DefElem * def )

Definition at line 250 of file define.c.

 {
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a parameter",
                         def->defname)));
     switch (nodeTag(def->arg))
     {
         case T_TypeName:
             return (TypeName *) def->arg;
         case T_String:
             /* Allow quoted typename for backwards compatibility */
             return makeTypeNameFromNameList(list_make1(def->arg));
         default:
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("argument of %s must be a type name",
                             def->defname)));
     }
     return NULL;                /* keep compiler quiet */
 }

References DefElem::arg, DefElem::defname, ereport, errcode(), errmsg(), ERROR, list_make1, makeTypeNameFromNameList(), nodeTag, T_String, and T_TypeName.

Referenced by DefineAggregate(), DefineOperator(), DefineRange(), DefineType(), and init_params().

◆ errorConflictingDefElem()

void errorConflictingDefElem	(	DefElem *	defel,
		ParseState *	pstate
	)

Definition at line 350 of file define.c.

 {
     ereport(ERROR,
             errcode(ERRCODE_SYNTAX_ERROR),
             errmsg("conflicting or redundant options"),
             parser_errposition(pstate, defel->location));
 }

References ereport, errcode(), errmsg(), ERROR, DefElem::location, and parser_errposition().

Referenced by AlterDatabase(), AlterRole(), compute_common_attribute(), compute_function_attributes(), createdb(), CreateExtension(), CreateRole(), DefineCollation(), DefineRange(), DefineType(), ExecAlterDefaultPrivilegesStmt(), ExecAlterExtensionStmt(), ExecuteDoStmt(), generateSerialExtraStmts(), init_params(), parse_func_options(), parse_publication_options(), parse_subscription_options(), and ProcessCopyOptions().

Functions