define.c File Reference

#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:

Go to the source code of this file.

Functions
char *	defGetString (DefElem *def)
double	defGetNumeric (DefElem *def)
bool	defGetBoolean (DefElem *def)
int32	defGetInt32 (DefElem *def)
int64	defGetInt64 (DefElem *def)
Oid	defGetObjectId (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 108 of file define.c.

{
    /*
     * If no parameter value 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, and pg_strcasecmp().

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 163 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, and nodeTag.

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

defGetInt64()

int64 defGetInt64

(

DefElem *

def

)

Definition at line 187 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)->fval)));
        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, and nodeTag.

Referenced by init_params(), and parse_basebackup_options().

defGetNumeric()

double defGetNumeric

(

DefElem *

def

)

Definition at line 82 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, and nodeTag.

Referenced by AlterFunction(), and compute_function_attributes().

defGetObjectId()

Oid defGetObjectId

(

DefElem *

def

)

Definition at line 220 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 (Oid) 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 OID
             * strings.
             */
            return DatumGetObjectId(DirectFunctionCall1(oidin,
                                                        CStringGetDatum(castNode(Float, def->arg)->fval)));
        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(), DatumGetObjectId(), DefElem::defname, DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, intVal, nodeTag, and oidin().

Referenced by createdb().

defGetQualifiedName()

List* defGetQualifiedName

(

DefElem *

def

)

Definition at line 253 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, and nodeTag.

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)->fval;
        case T_Boolean:
            return boolVal(def->arg) ? "true" : "false";
        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, boolVal, castNode, DefElem::defname, elog(), ereport, errcode(), errmsg(), ERROR, intVal, NameListToString(), nodeTag, psprintf(), pstrdup(), strVal, and TypeNameToString().

Referenced by AlterDatabase(), AlterType(), apply_server_options(), apply_table_options(), check_selective_binary_conversion(), createdb(), CreateExtension(), defGetBoolean(), defGetCopyHeaderChoice(), 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(), GrantRole(), optionListToArray(), parse_basebackup_options(), parse_output_parameters(), 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 357 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, and generate_unaccent_rules::str.

defGetTypeLength()

int defGetTypeLength

(

DefElem *

def

)

Definition at line 313 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, and TypeNameToString().

Referenced by DefineType().

defGetTypeName()

TypeName* defGetTypeName

(

DefElem *

def

)

Definition at line 285 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(), and nodeTag.

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

errorConflictingDefElem()

void errorConflictingDefElem	(	DefElem *	defel,
		ParseState *	pstate
	)

Definition at line 385 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().