parse_type.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "catalog/namespace.h"
#include "catalog/pg_type.h"
#include "lib/stringinfo.h"
#include "nodes/makefuncs.h"
#include "parser/parse_type.h"
#include "parser/parser.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"

Include dependency graph for parse_type.c:

Go to the source code of this file.

Functions
static int32	typenameTypeMod (ParseState *pstate, const TypeName *typeName, Type typ)
Type	LookupTypeName (ParseState *pstate, const TypeName *typeName, int32 *typmod_p, bool missing_ok)
Type	LookupTypeNameExtended (ParseState *pstate, const TypeName *typeName, int32 *typmod_p, bool temp_ok, bool missing_ok)
Oid	LookupTypeNameOid (ParseState *pstate, const TypeName *typeName, bool missing_ok)
Type	typenameType (ParseState *pstate, const TypeName *typeName, int32 *typmod_p)
Oid	typenameTypeId (ParseState *pstate, const TypeName *typeName)
void	typenameTypeIdAndMod (ParseState *pstate, const TypeName *typeName, Oid *typeid_p, int32 *typmod_p)
static void	appendTypeNameToBuffer (const TypeName *typeName, StringInfo string)
char *	TypeNameToString (const TypeName *typeName)
char *	TypeNameListToString (List *typenames)
Oid	LookupCollation (ParseState *pstate, List *collnames, int location)
Oid	GetColumnDefCollation (ParseState *pstate, const ColumnDef *coldef, Oid typeOid)
Type	typeidType (Oid id)
Oid	typeTypeId (Type tp)
int16	typeLen (Type t)
bool	typeByVal (Type t)
char *	typeTypeName (Type t)
Oid	typeTypeRelid (Type typ)
Oid	typeTypeCollation (Type typ)
Datum	stringTypeDatum (Type tp, char *string, int32 atttypmod)
Oid	typeidTypeRelid (Oid type_id)
Oid	typeOrDomainTypeRelid (Oid type_id)
static void	pts_error_callback (void *arg)
TypeName *	typeStringToTypeName (const char *str, Node *escontext)
bool	parseTypeString (const char *str, Oid *typeid_p, int32 *typmod_p, Node *escontext)

Function Documentation

appendTypeNameToBuffer()

static void appendTypeNameToBuffer ( const TypeName *  typeName, StringInfo  string  )

static

Definition at line 439 of file parse_type.c.

{
    if (typeName->names != NIL)
    {
        /* Emit possibly-qualified name as-is */
        ListCell   *l;
 
        foreach(l, typeName->names)
        {
            if (l != list_head(typeName->names))
                appendStringInfoChar(string, '.');
            appendStringInfoString(string, strVal(lfirst(l)));
        }
    }
    else
    {
        /* Look up internally-specified type */
        appendStringInfoString(string, format_type_be(typeName->typeOid));
    }
 
    /*
     * Add decoration as needed, but only for fields considered by
     * LookupTypeName
     */
    if (typeName->pct_type)
        appendStringInfoString(string, "%TYPE");
 
    if (typeName->arrayBounds != NIL)
        appendStringInfoString(string, "[]");
}

References appendStringInfoChar(), appendStringInfoString(), TypeName::arrayBounds, format_type_be(), lfirst, list_head(), TypeName::names, NIL, TypeName::pct_type, strVal, and TypeName::typeOid.

Referenced by TypeNameListToString(), and TypeNameToString().

GetColumnDefCollation()

Oid GetColumnDefCollation	(	ParseState *	pstate,
		const ColumnDef *	coldef,
		Oid	typeOid
	)

Definition at line 540 of file parse_type.c.

{
    Oid         result;
    Oid         typcollation = get_typcollation(typeOid);
    int         location = coldef->location;
 
    if (coldef->collClause)
    {
        /* We have a raw COLLATE clause, so look up the collation */
        location = coldef->collClause->location;
        result = LookupCollation(pstate, coldef->collClause->collname,
                                 location);
    }
    else if (OidIsValid(coldef->collOid))
    {
        /* Precooked collation spec, use that */
        result = coldef->collOid;
    }
    else
    {
        /* Use the type's default collation if any */
        result = typcollation;
    }
 
    /* Complain if COLLATE is applied to an uncollatable type */
    if (OidIsValid(result) && !OidIsValid(typcollation))
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("collations are not supported by type %s",
                        format_type_be(typeOid)),
                 parser_errposition(pstate, location)));
 
    return result;
}

References ereport, errcode(), errmsg, ERROR, fb(), format_type_be(), get_typcollation(), LookupCollation(), OidIsValid, parser_errposition(), and result.

Referenced by addRangeTableEntryForFunction(), ATExecAddColumn(), ATExecAlterColumnType(), ATPrepAlterColumnType(), BuildDescForRelation(), MergeChildAttribute(), and MergeInheritedAttribute().

LookupCollation()

Oid LookupCollation	(	ParseState *	pstate,
		List *	collnames,
		int	location
	)

Definition at line 515 of file parse_type.c.

{
    Oid         colloid;
    ParseCallbackState pcbstate;
 
    if (pstate)
        setup_parser_errposition_callback(&pcbstate, pstate, location);
 
    colloid = get_collation_oid(collnames, false);
 
    if (pstate)
        cancel_parser_errposition_callback(&pcbstate);
 
    return colloid;
}

References cancel_parser_errposition_callback(), fb(), get_collation_oid(), and setup_parser_errposition_callback().

Referenced by GetColumnDefCollation(), resolve_unique_index_expr(), transformCollateClause(), and transformColumnType().

LookupTypeName()

Type LookupTypeName	(	ParseState *	pstate,
		const TypeName *	typeName,
		int32 *	typmod_p,
		bool	missing_ok
	)

Definition at line 38 of file parse_type.c.

{
    return LookupTypeNameExtended(pstate,
                                  typeName, typmod_p, true, missing_ok);
}

References fb(), and LookupTypeNameExtended().

Referenced by AlterTypeOwner(), compute_return_type(), get_object_address_type(), interpret_function_parameter_list(), LookupTypeNameOid(), parseTypeString(), and typenameType().

LookupTypeNameExtended()

Type LookupTypeNameExtended	(	ParseState *	pstate,
		const TypeName *	typeName,
		int32 *	typmod_p,
		bool	temp_ok,
		bool	missing_ok
	)

Definition at line 73 of file parse_type.c.

{
    Oid         typoid;
    HeapTuple   tup;
    int32       typmod;
 
    if (typeName->names == NIL)
    {
        /* We have the OID already if it's an internally generated TypeName */
        typoid = typeName->typeOid;
    }
    else if (typeName->pct_type)
    {
        /* Handle %TYPE reference to type of an existing field */
        RangeVar   *rel = makeRangeVar(NULL, NULL, typeName->location);
        char       *field = NULL;
        Oid         relid;
        AttrNumber  attnum;
 
        /* deconstruct the name list */
        switch (list_length(typeName->names))
        {
            case 1:
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("improper %%TYPE reference (too few dotted names): %s",
                                NameListToString(typeName->names)),
                         parser_errposition(pstate, typeName->location)));
                break;
            case 2:
                rel->relname = strVal(linitial(typeName->names));
                field = strVal(lsecond(typeName->names));
                break;
            case 3:
                rel->schemaname = strVal(linitial(typeName->names));
                rel->relname = strVal(lsecond(typeName->names));
                field = strVal(lthird(typeName->names));
                break;
            case 4:
                rel->catalogname = strVal(linitial(typeName->names));
                rel->schemaname = strVal(lsecond(typeName->names));
                rel->relname = strVal(lthird(typeName->names));
                field = strVal(lfourth(typeName->names));
                break;
            default:
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("improper %%TYPE reference (too many dotted names): %s",
                                NameListToString(typeName->names)),
                         parser_errposition(pstate, typeName->location)));
                break;
        }
 
        /*
         * Look up the field.
         *
         * XXX: As no lock is taken here, this might fail in the presence of
         * concurrent DDL.  But taking a lock would carry a performance
         * penalty and would also require a permissions check.
         */
        relid = RangeVarGetRelid(rel, NoLock, missing_ok);
        attnum = get_attnum(relid, field);
        if (attnum == InvalidAttrNumber)
        {
            if (missing_ok)
                typoid = InvalidOid;
            else
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_COLUMN),
                         errmsg("column \"%s\" of relation \"%s\" does not exist",
                                field, rel->relname),
                         parser_errposition(pstate, typeName->location)));
        }
        else
        {
            typoid = get_atttype(relid, attnum);
 
            /* this construct should never have an array indicator */
            Assert(typeName->arrayBounds == NIL);
 
            /* emit nuisance notice (intentionally not errposition'd) */
            ereport(NOTICE,
                    (errmsg("type reference %s converted to %s",
                            TypeNameToString(typeName),
                            format_type_be(typoid))));
        }
    }
    else
    {
        /* Normal reference to a type name */
        char       *schemaname;
        char       *typname;
 
        /* deconstruct the name list */
        DeconstructQualifiedName(typeName->names, &schemaname, &typname);
 
        if (schemaname)
        {
            /* Look in specific schema only */
            Oid         namespaceId;
            ParseCallbackState pcbstate;
 
            setup_parser_errposition_callback(&pcbstate, pstate, typeName->location);
 
            namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
            if (OidIsValid(namespaceId))
                typoid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
                                         PointerGetDatum(typname),
                                         ObjectIdGetDatum(namespaceId));
            else
                typoid = InvalidOid;
 
            cancel_parser_errposition_callback(&pcbstate);
        }
        else
        {
            /* Unqualified type name, so search the search path */
            typoid = TypenameGetTypidExtended(typname, temp_ok);
        }
 
        /* If an array reference, return the array type instead */
        if (typeName->arrayBounds != NIL)
            typoid = get_array_type(typoid);
    }
 
    if (!OidIsValid(typoid))
    {
        if (typmod_p)
            *typmod_p = -1;
        return NULL;
    }
 
    tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typoid));
    if (!HeapTupleIsValid(tup)) /* should not happen */
        elog(ERROR, "cache lookup failed for type %u", typoid);
 
    typmod = typenameTypeMod(pstate, typeName, (Type) tup);
 
    if (typmod_p)
        *typmod_p = typmod;
 
    return (Type) tup;
}

References TypeName::arrayBounds, Assert, attnum, cancel_parser_errposition_callback(), RangeVar::catalogname, DeconstructQualifiedName(), elog, ereport, errcode(), errmsg, ERROR, fb(), format_type_be(), get_array_type(), get_attnum(), get_atttype(), GetSysCacheOid2, HeapTupleIsValid, InvalidAttrNumber, InvalidOid, lfourth, linitial, list_length(), TypeName::location, LookupExplicitNamespace(), lsecond, lthird, makeRangeVar(), NameListToString(), TypeName::names, NIL, NoLock, NOTICE, ObjectIdGetDatum(), OidIsValid, parser_errposition(), TypeName::pct_type, PointerGetDatum, RangeVarGetRelid, RangeVar::relname, RangeVar::schemaname, SearchSysCache1(), setup_parser_errposition_callback(), strVal, TypenameGetTypidExtended(), TypeNameToString(), typenameTypeMod(), TypeName::typeOid, and typname.

Referenced by FuncNameAsType(), and LookupTypeName().

LookupTypeNameOid()

Oid LookupTypeNameOid	(	ParseState *	pstate,
		const TypeName *	typeName,
		bool	missing_ok
	)

Definition at line 232 of file parse_type.c.

{
    Oid         typoid;
    Type        tup;
 
    tup = LookupTypeName(pstate, typeName, NULL, missing_ok);
    if (tup == NULL)
    {
        if (!missing_ok)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("type \"%s\" does not exist",
                            TypeNameToString(typeName)),
                     parser_errposition(pstate, typeName->location)));
 
        return InvalidOid;
    }
 
    typoid = ((Form_pg_type) GETSTRUCT(tup))->oid;
    ReleaseSysCache(tup);
 
    return typoid;
}

References ereport, errcode(), errmsg, ERROR, fb(), Form_pg_type, GETSTRUCT(), InvalidOid, TypeName::location, LookupTypeName(), parser_errposition(), ReleaseSysCache(), and TypeNameToString().

Referenced by get_object_address(), LookupFuncWithArgs(), LookupOperWithArgs(), and type_in_list_does_not_exist_skipping().

parseTypeString()

bool parseTypeString	(	const char *	str,
		Oid *	typeid_p,
		int32 *	typmod_p,
		Node *	escontext
	)

Definition at line 785 of file parse_type.c.

{
    TypeName   *typeName;
    Type        tup;
 
    typeName = typeStringToTypeName(str, escontext);
    if (typeName == NULL)
        return false;
 
    tup = LookupTypeName(NULL, typeName, typmod_p,
                         (escontext && IsA(escontext, ErrorSaveContext)));
    if (tup == NULL)
    {
        ereturn(escontext, false,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("type \"%s\" does not exist",
                        TypeNameToString(typeName))));
    }
    else
    {
        Form_pg_type typ = (Form_pg_type) GETSTRUCT(tup);
 
        if (!typ->typisdefined)
        {
            ReleaseSysCache(tup);
            ereturn(escontext, false,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("type \"%s\" is only a shell",
                            TypeNameToString(typeName))));
        }
        *typeid_p = typ->oid;
        ReleaseSysCache(tup);
    }
 
    return true;
}

References ereturn, errcode(), errmsg, fb(), Form_pg_type, GETSTRUCT(), IsA, LookupTypeName(), ReleaseSysCache(), str, TypeNameToString(), and typeStringToTypeName().

Referenced by parseNameAndArgTypes(), pg_input_is_valid_common(), plperl_spi_prepare(), pltcl_SPI_prepare(), PLy_spi_prepare(), regtypein(), and to_regtypemod().

pts_error_callback()

static void pts_error_callback ( void *  arg )

static

Definition at line 719 of file parse_type.c.

{
    const char *str = (const char *) arg;
 
    errcontext("invalid type name \"%s\"", str);
}

References arg, errcontext, and str.

Referenced by typeStringToTypeName().

stringTypeDatum()

Datum stringTypeDatum	(	Type	tp,
		char *	string,
		int32	atttypmod
	)

Definition at line 654 of file parse_type.c.

{
    Form_pg_type typform = (Form_pg_type) GETSTRUCT(tp);
    Oid         typinput = typform->typinput;
    Oid         typioparam = getTypeIOParam(tp);
 
    return OidInputFunctionCall(typinput, string, typioparam, atttypmod);
}

References fb(), Form_pg_type, GETSTRUCT(), getTypeIOParam(), and OidInputFunctionCall().

Referenced by coerce_type().

typeByVal()

bool typeByVal

(

Type

t

)

Definition at line 609 of file parse_type.c.

{
    Form_pg_type typ;
 
    typ = (Form_pg_type) GETSTRUCT(t);
    return typ->typbyval;
}

References fb(), Form_pg_type, and GETSTRUCT().

Referenced by coerce_type().

typeidType()

Type typeidType

(

Oid

id

)

Definition at line 578 of file parse_type.c.

{
    HeapTuple   tup;
 
    tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(id));
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for type %u", id);
    return (Type) tup;
}

References elog, ERROR, fb(), HeapTupleIsValid, ObjectIdGetDatum(), and SearchSysCache1().

Referenced by coerce_type(), and find_typmod_coercion_function().

typeidTypeRelid()

Oid typeidTypeRelid

(

Oid

type_id

)

Definition at line 668 of file parse_type.c.

{
    HeapTuple   typeTuple;
    Form_pg_type type;
    Oid         result;
 
    typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id));
    if (!HeapTupleIsValid(typeTuple))
        elog(ERROR, "cache lookup failed for type %u", type_id);
    type = (Form_pg_type) GETSTRUCT(typeTuple);
    result = type->typrelid;
    ReleaseSysCache(typeTuple);
    return result;
}

References elog, ERROR, fb(), Form_pg_type, GETSTRUCT(), HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), result, SearchSysCache1(), and type.

Referenced by transformAssignmentIndirection(), and typeInheritsFrom().

typeLen()

int16 typeLen

(

Type

t

)

Definition at line 599 of file parse_type.c.

{
    Form_pg_type typ;
 
    typ = (Form_pg_type) GETSTRUCT(t);
    return typ->typlen;
}

References fb(), Form_pg_type, and GETSTRUCT().

Referenced by coerce_type().

TypeNameListToString()

char * TypeNameListToString

(

List *

typenames

)

Definition at line 492 of file parse_type.c.

{
    StringInfoData string;
    ListCell   *l;
 
    initStringInfo(&string);
    foreach(l, typenames)
    {
        TypeName   *typeName = lfirst_node(TypeName, l);
 
        if (l != list_head(typenames))
            appendStringInfoChar(&string, ',');
        appendTypeNameToBuffer(typeName, &string);
    }
    return string.data;
}

References appendStringInfoChar(), appendTypeNameToBuffer(), initStringInfo(), lfirst_node, list_head(), and typenames.

Referenced by does_not_exist_skipping().

TypeNameToString()

char * TypeNameToString

(

const TypeName *

typeName

)

Definition at line 478 of file parse_type.c.

{
    StringInfoData string;
 
    initStringInfo(&string);
    appendTypeNameToBuffer(typeName, &string);
    return string.data;
}

References appendTypeNameToBuffer(), and initStringInfo().

Referenced by AlterDomainDropConstraint(), AlterDomainValidateConstraint(), AlterTypeOwner(), compute_return_type(), CreateCast(), CreateTransform(), defGetString(), defGetTypeLength(), DefineAggregate(), DefineDomain(), DefineOpClass(), does_not_exist_skipping(), get_object_address_opf_member(), get_object_address_type(), interpret_function_parameter_list(), LookupTypeNameExtended(), LookupTypeNameOid(), parseTypeString(), type_in_list_does_not_exist_skipping(), typenameType(), and typenameTypeMod().

typenameType()

Type typenameType	(	ParseState *	pstate,
		const TypeName *	typeName,
		int32 *	typmod_p
	)

Definition at line 264 of file parse_type.c.

{
    Type        tup;
 
    tup = LookupTypeName(pstate, typeName, typmod_p, false);
    if (tup == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("type \"%s\" does not exist",
                        TypeNameToString(typeName)),
                 parser_errposition(pstate, typeName->location)));
    if (!((Form_pg_type) GETSTRUCT(tup))->typisdefined)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("type \"%s\" is only a shell",
                        TypeNameToString(typeName)),
                 parser_errposition(pstate, typeName->location)));
    return tup;
}

References ereport, errcode(), errmsg, ERROR, fb(), Form_pg_type, GETSTRUCT(), TypeName::location, LookupTypeName(), parser_errposition(), and TypeNameToString().

Referenced by AlterType(), ATExecAddOf(), ATExecAlterColumnType(), DefineDomain(), DefineType(), transformColumnDefinition(), transformColumnType(), transformOfType(), typenameTypeId(), and typenameTypeIdAndMod().

typenameTypeId()

Oid typenameTypeId	(	ParseState *	pstate,
		const TypeName *	typeName
	)

Definition at line 291 of file parse_type.c.

{
    Oid         typoid;
    Type        tup;
 
    tup = typenameType(pstate, typeName, NULL);
    typoid = ((Form_pg_type) GETSTRUCT(tup))->oid;
    ReleaseSysCache(tup);
 
    return typoid;
}

References fb(), Form_pg_type, GETSTRUCT(), ReleaseSysCache(), and typenameType().

Referenced by AlterDomainAddConstraint(), AlterDomainDefault(), AlterDomainDropConstraint(), AlterDomainNotNull(), AlterDomainValidateConstraint(), AlterEnum(), AlterTypeNamespace(), check_object_ownership(), CreateCast(), CreateFunction(), CreateTransform(), DefineAggregate(), DefineOpClass(), DefineOperator(), DefineRange(), DefineRelation(), DefineType(), init_params(), PrepareQuery(), processTypesSpec(), RenameConstraint(), RenameType(), transformAlterTableStmt(), and transformIndexConstraint().

typenameTypeIdAndMod()

void typenameTypeIdAndMod	(	ParseState *	pstate,
		const TypeName *	typeName,
		Oid *	typeid_p,
		int32 *	typmod_p
	)

Definition at line 310 of file parse_type.c.

{
    Type        tup;
 
    tup = typenameType(pstate, typeName, typmod_p);
    *typeid_p = ((Form_pg_type) GETSTRUCT(tup))->oid;
    ReleaseSysCache(tup);
}

References fb(), Form_pg_type, GETSTRUCT(), ReleaseSysCache(), and typenameType().

Referenced by addRangeTableEntryForFunction(), appendJsonTableColumns(), ATExecAddColumn(), ATPrepAlterColumnType(), BuildDescForRelation(), flatten_set_variable_args(), MergeChildAttribute(), MergeInheritedAttribute(), revalidate_rectypeid(), transformJsonOutput(), transformRangeTableFunc(), transformTypeCast(), and transformXmlSerialize().

typenameTypeMod()

static int32 typenameTypeMod ( ParseState *  pstate, const TypeName *  typeName, Type  typ  )

static

Definition at line 332 of file parse_type.c.

{
    int32       result;
    Oid         typmodin;
    Datum      *datums;
    int         n;
    ListCell   *l;
    ArrayType  *arrtypmod;
    ParseCallbackState pcbstate;
 
    /* Return prespecified typmod if no typmod expressions */
    if (typeName->typmods == NIL)
        return typeName->typemod;
 
    /*
     * Else, type had better accept typmods.  We give a special error message
     * for the shell-type case, since a shell couldn't possibly have a
     * typmodin function.
     */
    if (!((Form_pg_type) GETSTRUCT(typ))->typisdefined)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("type modifier cannot be specified for shell type \"%s\"",
                        TypeNameToString(typeName)),
                 parser_errposition(pstate, typeName->location)));
 
    typmodin = ((Form_pg_type) GETSTRUCT(typ))->typmodin;
 
    if (typmodin == InvalidOid)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("type modifier is not allowed for type \"%s\"",
                        TypeNameToString(typeName)),
                 parser_errposition(pstate, typeName->location)));
 
    /*
     * Convert the list of raw-grammar-output expressions to a cstring array.
     * Currently, we allow simple numeric constants, string literals, and
     * identifiers; possibly this list could be extended.
     */
    datums = palloc_array(Datum, list_length(typeName->typmods));
    n = 0;
    foreach(l, typeName->typmods)
    {
        Node       *tm = (Node *) lfirst(l);
        char       *cstr = NULL;
 
        if (IsA(tm, A_Const))
        {
            A_Const    *ac = (A_Const *) tm;
 
            if (IsA(&ac->val, Integer))
            {
                cstr = psprintf("%d", intVal(&ac->val));
            }
            else if (IsA(&ac->val, Float))
            {
                /* we can just use the string representation directly. */
                cstr = ac->val.fval.fval;
            }
            else if (IsA(&ac->val, String))
            {
                /* we can just use the string representation directly. */
                cstr = strVal(&ac->val);
            }
        }
        else if (IsA(tm, ColumnRef))
        {
            ColumnRef  *cr = (ColumnRef *) tm;
 
            if (list_length(cr->fields) == 1 &&
                IsA(linitial(cr->fields), String))
                cstr = strVal(linitial(cr->fields));
        }
        if (!cstr)
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("type modifiers must be simple constants or identifiers"),
                     parser_errposition(pstate, typeName->location)));
        datums[n++] = CStringGetDatum(cstr);
    }
 
    arrtypmod = construct_array_builtin(datums, n, CSTRINGOID);
 
    /* arrange to report location if type's typmodin function fails */
    setup_parser_errposition_callback(&pcbstate, pstate, typeName->location);
 
    result = DatumGetInt32(OidFunctionCall1(typmodin,
                                            PointerGetDatum(arrtypmod)));
 
    cancel_parser_errposition_callback(&pcbstate);
 
    pfree(datums);
    pfree(arrtypmod);
 
    return result;
}

References cancel_parser_errposition_callback(), construct_array_builtin(), CStringGetDatum(), DatumGetInt32(), ereport, errcode(), errmsg, ERROR, fb(), Form_pg_type, GETSTRUCT(), intVal, InvalidOid, IsA, lfirst, linitial, list_length(), TypeName::location, NIL, OidFunctionCall1, palloc_array, parser_errposition(), pfree(), PointerGetDatum, psprintf(), result, setup_parser_errposition_callback(), strVal, tm, TypeName::typemod, TypeNameToString(), and TypeName::typmods.

Referenced by LookupTypeNameExtended().

typeOrDomainTypeRelid()

Oid typeOrDomainTypeRelid

(

Oid

type_id

)

Definition at line 689 of file parse_type.c.

{
    HeapTuple   typeTuple;
    Form_pg_type type;
    Oid         result;
 
    for (;;)
    {
        typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id));
        if (!HeapTupleIsValid(typeTuple))
            elog(ERROR, "cache lookup failed for type %u", type_id);
        type = (Form_pg_type) GETSTRUCT(typeTuple);
        if (type->typtype != TYPTYPE_DOMAIN)
        {
            /* Not a domain, so done looking through domains */
            break;
        }
        /* It is a domain, so examine the base type instead */
        type_id = type->typbasetype;
        ReleaseSysCache(typeTuple);
    }
    result = type->typrelid;
    ReleaseSysCache(typeTuple);
    return result;
}

References elog, ERROR, fb(), Form_pg_type, GETSTRUCT(), HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), result, SearchSysCache1(), and type.

Referenced by typeInheritsFrom(), and typeIsOfTypedTable().

typeStringToTypeName()

TypeName * typeStringToTypeName	(	const char *	str,
		Node *	escontext
	)

Definition at line 738 of file parse_type.c.

{
    List       *raw_parsetree_list;
    TypeName   *typeName;
    ErrorContextCallback ptserrcontext;
 
    /* make sure we give useful error for empty input */
    if (strspn(str, " \t\n\r\f\v") == strlen(str))
        goto fail;
 
    /*
     * Setup error traceback support in case of ereport() during parse
     */
    ptserrcontext.callback = pts_error_callback;
    ptserrcontext.arg = unconstify(char *, str);
    ptserrcontext.previous = error_context_stack;
    error_context_stack = &ptserrcontext;
 
    raw_parsetree_list = raw_parser(str, RAW_PARSE_TYPE_NAME);
 
    error_context_stack = ptserrcontext.previous;
 
    /* We should get back exactly one TypeName node. */
    Assert(list_length(raw_parsetree_list) == 1);
    typeName = linitial_node(TypeName, raw_parsetree_list);
 
    /* The grammar allows SETOF in TypeName, but we don't want that here. */
    if (typeName->setof)
        goto fail;
 
    return typeName;
 
fail:
    ereturn(escontext, NULL,
            (errcode(ERRCODE_SYNTAX_ERROR),
             errmsg("invalid type name \"%s\"", str)));
}

References Assert, ErrorContextCallback::callback, ereturn, errcode(), errmsg, error_context_stack, fb(), linitial_node, list_length(), ErrorContextCallback::previous, pts_error_callback(), RAW_PARSE_TYPE_NAME, raw_parser(), TypeName::setof, str, and unconstify.

Referenced by parseTypeString(), and pg_get_object_address().

typeTypeCollation()

Oid typeTypeCollation

(

Type

typ

)

Definition at line 640 of file parse_type.c.

{
    Form_pg_type typtup;
 
    typtup = (Form_pg_type) GETSTRUCT(typ);
    return typtup->typcollation;
}

References fb(), Form_pg_type, and GETSTRUCT().

Referenced by coerce_type().

typeTypeId()

Oid typeTypeId

(

Type

tp

)

Definition at line 590 of file parse_type.c.

{
    if (tp == NULL)             /* probably useless */
        elog(ERROR, "typeTypeId() called with NULL type struct");
    return ((Form_pg_type) GETSTRUCT(tp))->oid;
}

References elog, ERROR, fb(), Form_pg_type, and GETSTRUCT().

Referenced by AlterType(), AlterTypeOwner(), compute_return_type(), FuncNameAsType(), get_object_address_type(), and interpret_function_parameter_list().

typeTypeName()

char * typeTypeName

(

Type

t

)

Definition at line 619 of file parse_type.c.

{
    Form_pg_type typ;
 
    typ = (Form_pg_type) GETSTRUCT(t);
    /* pstrdup here because result may need to outlive the syscache entry */
    return pstrdup(NameStr(typ->typname));
}

References fb(), Form_pg_type, GETSTRUCT(), NameStr, and pstrdup().

Referenced by coerce_type().

typeTypeRelid()

Oid typeTypeRelid

(

Type

typ

)

Definition at line 630 of file parse_type.c.

{
    Form_pg_type typtup;
 
    typtup = (Form_pg_type) GETSTRUCT(typ);
    return typtup->typrelid;
}

References fb(), Form_pg_type, and GETSTRUCT().

Referenced by FuncNameAsType().