makefuncs.h File Reference

#include "nodes/execnodes.h"
#include "nodes/parsenodes.h"

Include dependency graph for makefuncs.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
A_Expr *	makeA_Expr (A_Expr_Kind kind, List *name, Node *lexpr, Node *rexpr, int location)
A_Expr *	makeSimpleA_Expr (A_Expr_Kind kind, char *name, Node *lexpr, Node *rexpr, int location)
Var *	makeVar (int varno, AttrNumber varattno, Oid vartype, int32 vartypmod, Oid varcollid, Index varlevelsup)
Var *	makeVarFromTargetEntry (int varno, TargetEntry *tle)
Var *	makeWholeRowVar (RangeTblEntry *rte, int varno, Index varlevelsup, bool allowScalar)
TargetEntry *	makeTargetEntry (Expr *expr, AttrNumber resno, char *resname, bool resjunk)
TargetEntry *	flatCopyTargetEntry (TargetEntry *src_tle)
FromExpr *	makeFromExpr (List *fromlist, Node *quals)
Const *	makeConst (Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
Const *	makeNullConst (Oid consttype, int32 consttypmod, Oid constcollid)
Node *	makeBoolConst (bool value, bool isnull)
Expr *	makeBoolExpr (BoolExprType boolop, List *args, int location)
Alias *	makeAlias (const char *aliasname, List *colnames)
RelabelType *	makeRelabelType (Expr *arg, Oid rtype, int32 rtypmod, Oid rcollid, CoercionForm rformat)
RangeVar *	makeRangeVar (char *schemaname, char *relname, int location)
Constraint *	makeNotNullConstraint (String *colname)
TypeName *	makeTypeName (char *typnam)
TypeName *	makeTypeNameFromNameList (List *names)
TypeName *	makeTypeNameFromOid (Oid typeOid, int32 typmod)
ColumnDef *	makeColumnDef (const char *colname, Oid typeOid, int32 typmod, Oid collOid)
FuncExpr *	makeFuncExpr (Oid funcid, Oid rettype, List *args, Oid funccollid, Oid inputcollid, CoercionForm fformat)
FuncCall *	makeFuncCall (List *name, List *args, CoercionForm funcformat, int location)
Expr *	make_opclause (Oid opno, Oid opresulttype, bool opretset, Expr *leftop, Expr *rightop, Oid opcollid, Oid inputcollid)
Expr *	make_andclause (List *andclauses)
Expr *	make_orclause (List *orclauses)
Expr *	make_notclause (Expr *notclause)
Node *	make_and_qual (Node *qual1, Node *qual2)
Expr *	make_ands_explicit (List *andclauses)
List *	make_ands_implicit (Expr *clause)
IndexInfo *	makeIndexInfo (int numattrs, int numkeyattrs, Oid amoid, List *expressions, List *predicates, bool unique, bool nulls_not_distinct, bool isready, bool concurrent, bool summarizing, bool withoutoverlaps)
Node *	makeStringConst (char *str, int location)
DefElem *	makeDefElem (char *name, Node *arg, int location)
DefElem *	makeDefElemExtended (char *nameSpace, char *name, Node *arg, DefElemAction defaction, int location)
GroupingSet *	makeGroupingSet (GroupingSetKind kind, List *content, int location)
VacuumRelation *	makeVacuumRelation (RangeVar *relation, Oid oid, List *va_cols)
JsonFormat *	makeJsonFormat (JsonFormatType type, JsonEncoding encoding, int location)
JsonValueExpr *	makeJsonValueExpr (Expr *raw_expr, Expr *formatted_expr, JsonFormat *format)
Node *	makeJsonKeyValue (Node *key, Node *value)
Node *	makeJsonIsPredicate (Node *expr, JsonFormat *format, JsonValueType item_type, bool unique_keys, int location)
JsonBehavior *	makeJsonBehavior (JsonBehaviorType btype, Node *expr, int location)
JsonTablePath *	makeJsonTablePath (Const *pathvalue, char *pathname)
JsonTablePathSpec *	makeJsonTablePathSpec (char *string, char *name, int string_location, int name_location)

Function Documentation

flatCopyTargetEntry()

TargetEntry * flatCopyTargetEntry

(

TargetEntry *

src_tle

)

Definition at line 322 of file makefuncs.c.

{
    TargetEntry *tle = makeNode(TargetEntry);
 
    Assert(IsA(src_tle, TargetEntry));
    memcpy(tle, src_tle, sizeof(TargetEntry));
    return tle;
}

References Assert(), IsA, and makeNode.

Referenced by expand_insert_targetlist(), process_matched_tle(), rewriteTargetListIU(), set_dummy_tlist_references(), and set_upper_references().

make_and_qual()

Node * make_and_qual	(	Node *	qual1,
		Node *	qual2
	)

Definition at line 780 of file makefuncs.c.

{
    if (qual1 == NULL)
        return qual2;
    if (qual2 == NULL)
        return qual1;
    return (Node *) make_andclause(list_make2(qual1, qual2));
}

References list_make2, and make_andclause().

Referenced by AddQual(), subquery_push_qual(), and transform_MERGE_to_join().

make_andclause()

Expr * make_andclause

(

List *

andclauses

)

Definition at line 727 of file makefuncs.c.

{
    BoolExpr   *expr = makeNode(BoolExpr);
 
    expr->boolop = AND_EXPR;
    expr->args = andclauses;
    expr->location = -1;
    return (Expr *) expr;
}

References AND_EXPR, BoolExpr::args, BoolExpr::boolop, BoolExpr::location, and makeNode.

Referenced by eval_const_expressions_mutator(), ExplainNode(), find_duplicate_ors(), find_simplified_clause(), make_and_qual(), make_ands_explicit(), make_sub_restrictinfos(), negate_clause(), process_duplicate_ors(), process_sublinks_mutator(), and pull_up_sublinks_qual_recurse().

make_ands_explicit()

Expr * make_ands_explicit

(

List *

andclauses

)

Definition at line 799 of file makefuncs.c.

{
    if (andclauses == NIL)
        return (Expr *) makeBoolConst(true, false);
    else if (list_length(andclauses) == 1)
        return (Expr *) linitial(andclauses);
    else
        return make_andclause(andclauses);
}

References linitial, list_length(), make_andclause(), makeBoolConst(), and NIL.

Referenced by ATExecAttachPartition(), check_default_partition_contents(), convert_EXISTS_to_ANY(), create_bitmap_subplan(), DetachAddConstraintIfNeeded(), ExecInitCheck(), extract_or_clause(), get_proposed_default_constraint(), get_qual_for_list(), show_qual(), and UpdateIndexRelation().

make_ands_implicit()

List * make_ands_implicit

(

Expr *

clause

)

Definition at line 810 of file makefuncs.c.

{
    /*
     * NB: because the parser sets the qual field to NULL in a query that has
     * no WHERE clause, we must consider a NULL input clause as TRUE, even
     * though one might more reasonably think it FALSE.
     */
    if (clause == NULL)
        return NIL;             /* NULL -> NIL list == TRUE */
    else if (is_andclause(clause))
        return ((BoolExpr *) clause)->args;
    else if (IsA(clause, Const) &&
             !((Const *) clause)->constisnull &&
             DatumGetBool(((Const *) clause)->constvalue))
        return NIL;             /* constant TRUE input -> NIL list */
    else
        return list_make1(clause);
}

References DatumGetBool(), is_andclause(), IsA, list_make1, and NIL.

Referenced by apply_child_basequals(), ConstraintImpliedByRelConstraint(), convert_EXISTS_to_ANY(), cost_subplan(), DefineIndex(), DoCopy(), get_proposed_default_constraint(), get_relation_constraints(), index_concurrently_create_copy(), preprocess_expression(), RelationGetIndexPredicate(), test_predtest(), and TriggerEnabled().

make_notclause()

Expr * make_notclause

(

Expr *

notclause

)

Definition at line 759 of file makefuncs.c.

{
    BoolExpr   *expr = makeNode(BoolExpr);
 
    expr->boolop = NOT_EXPR;
    expr->args = list_make1(notclause);
    expr->location = -1;
    return (Expr *) expr;
}

References BoolExpr::args, BoolExpr::boolop, list_make1, BoolExpr::location, makeNode, and NOT_EXPR.

Referenced by negate_clause().

make_opclause()

Expr * make_opclause	(	Oid	opno,
		Oid	opresulttype,
		bool	opretset,
		Expr *	leftop,
		Expr *	rightop,
		Oid	opcollid,
		Oid	inputcollid
	)

Definition at line 701 of file makefuncs.c.

{
    OpExpr     *expr = makeNode(OpExpr);
 
    expr->opno = opno;
    expr->opfuncid = InvalidOid;
    expr->opresulttype = opresulttype;
    expr->opretset = opretset;
    expr->opcollid = opcollid;
    expr->inputcollid = inputcollid;
    if (rightop)
        expr->args = list_make2(leftop, rightop);
    else
        expr->args = list_make1(leftop);
    expr->location = -1;
    return (Expr *) expr;
}

References OpExpr::args, InvalidOid, list_make1, list_make2, OpExpr::location, makeNode, and OpExpr::opno.

Referenced by build_bound_expr(), build_implied_join_equality(), convert_EXISTS_to_ANY(), create_one_window_path(), expand_indexqual_rowcompare(), make_partition_op_expr(), match_boolean_index_clause(), match_clause_to_partition_key(), match_network_subset(), match_pattern_prefix(), operator_predicate_proof(), process_implied_equality(), and rewriteSearchAndCycle().

make_orclause()

Expr * make_orclause

(

List *

orclauses

)

Definition at line 743 of file makefuncs.c.

{
    BoolExpr   *expr = makeNode(BoolExpr);
 
    expr->boolop = OR_EXPR;
    expr->args = orclauses;
    expr->location = -1;
    return (Expr *) expr;
}

References BoolExpr::args, BoolExpr::boolop, BoolExpr::location, makeNode, and OR_EXPR.

Referenced by create_bitmap_subplan(), create_tidscan_plan(), eval_const_expressions_mutator(), ExplainNode(), extract_or_clause(), group_similar_or_args(), make_sub_restrictinfos(), negate_clause(), pgoutput_row_filter_init(), process_duplicate_ors(), and process_sublinks_mutator().

makeA_Expr()

A_Expr * makeA_Expr	(	A_Expr_Kind	kind,
		List *	name,
		Node *	lexpr,
		Node *	rexpr,
		int	location
	)

Definition at line 30 of file makefuncs.c.

{
    A_Expr     *a = makeNode(A_Expr);
 
    a->kind = kind;
    a->name = name;
    a->lexpr = lexpr;
    a->rexpr = rexpr;
    a->location = location;
    return a;
}

References a, makeNode, and name.

makeAlias()

Alias * makeAlias	(	const char *	aliasname,
		List *	colnames
	)

Definition at line 438 of file makefuncs.c.

{
    Alias      *a = makeNode(Alias);
 
    a->aliasname = pstrdup(aliasname);
    a->colnames = colnames;
 
    return a;
}

References a, makeNode, and pstrdup().

Referenced by addNSItemForReturning(), addRangeTableEntry(), addRangeTableEntryForCTE(), addRangeTableEntryForENR(), addRangeTableEntryForFunction(), addRangeTableEntryForGroup(), addRangeTableEntryForJoin(), addRangeTableEntryForRelation(), addRangeTableEntryForSubquery(), addRangeTableEntryForTableFunc(), addRangeTableEntryForValues(), check_sql_stmt_retval(), convert_ANY_sublink_to_join(), CreateTriggerFiringOn(), deparse_context_for(), expand_generated_columns_in_expr(), expand_single_inheritance_child(), pg_get_triggerdef_worker(), pull_up_simple_values(), replace_empty_jointree(), rewriteSearchAndCycle(), rewriteTargetView(), transform_MERGE_to_join(), transformInsertStmt(), transformOnConflictClause(), transformRuleStmt(), and transformSetOperationTree().

makeBoolConst()

Node * makeBoolConst	(	bool	value,
		bool	isnull
	)

Definition at line 408 of file makefuncs.c.

{
    /* note that pg_type.h hardwires size of bool as 1 ... duplicate it */
    return (Node *) makeConst(BOOLOID, -1, InvalidOid, 1,
                              BoolGetDatum(value), isnull, true);
}

References BoolGetDatum(), InvalidOid, makeConst(), and value.

Referenced by add_base_clause_to_rel(), add_join_clause_to_rels(), create_append_plan(), eval_const_expressions_mutator(), find_duplicate_ors(), find_simplified_clause(), get_qual_for_range(), make_ands_explicit(), make_row_distinct_op(), match_boolean_index_clause(), match_boolean_partition_clause(), negate_clause(), process_duplicate_ors(), and reconsider_outer_join_clauses().

makeBoolExpr()

Expr * makeBoolExpr	(	BoolExprType	boolop,
		List *	args,
		int	location
	)

Definition at line 420 of file makefuncs.c.

{
    BoolExpr   *b = makeNode(BoolExpr);
 
    b->boolop = boolop;
    b->args = args;
    b->location = location;
 
    return (Expr *) b;
}

References generate_unaccent_rules::args, b, boolop(), and makeNode.

Referenced by add_security_quals(), add_with_check_options(), get_partition_qual_relid(), get_proposed_default_constraint(), get_qual_for_list(), get_qual_for_range(), make_partition_op_expr(), make_row_comparison_op(), make_row_distinct_op(), match_clause_to_partition_key(), transformAExprBetween(), transformAExprDistinct(), transformAExprIn(), transformBoolExpr(), and transformJoinUsingClause().

makeColumnDef()

ColumnDef * makeColumnDef	(	const char *	colname,
		Oid	typeOid,
		int32	typmod,
		Oid	collOid
	)

Definition at line 565 of file makefuncs.c.

{
    ColumnDef  *n = makeNode(ColumnDef);
 
    n->colname = pstrdup(colname);
    n->typeName = makeTypeNameFromOid(typeOid, typmod);
    n->inhcount = 0;
    n->is_local = true;
    n->is_not_null = false;
    n->is_from_type = false;
    n->storage = 0;
    n->raw_default = NULL;
    n->cooked_default = NULL;
    n->collClause = NULL;
    n->collOid = collOid;
    n->constraints = NIL;
    n->fdwoptions = NIL;
    n->location = -1;
 
    return n;
}

References ColumnDef::collClause, ColumnDef::collOid, ColumnDef::colname, ColumnDef::constraints, ColumnDef::cooked_default, ColumnDef::fdwoptions, ColumnDef::inhcount, ColumnDef::is_from_type, ColumnDef::is_local, ColumnDef::is_not_null, ColumnDef::location, makeNode, makeTypeNameFromOid(), NIL, pstrdup(), ColumnDef::raw_default, ColumnDef::storage, and ColumnDef::typeName.

Referenced by create_ctas_nodata(), DefineSequence(), DefineVirtualRelation(), intorel_startup(), MergeAttributes(), transformOfType(), and transformTableLikeClause().

makeConst()

Const * makeConst	(	Oid	consttype,
		int32	consttypmod,
		Oid	constcollid,
		int	constlen,
		Datum	constvalue,
		bool	constisnull,
		bool	constbyval
	)

Definition at line 350 of file makefuncs.c.

{
    Const      *cnst = makeNode(Const);
 
    /*
     * If it's a varlena value, force it to be in non-expanded (non-toasted)
     * format; this avoids any possible dependency on external values and
     * improves consistency of representation, which is important for equal().
     */
    if (!constisnull && constlen == -1)
        constvalue = PointerGetDatum(PG_DETOAST_DATUM(constvalue));
 
    cnst->consttype = consttype;
    cnst->consttypmod = consttypmod;
    cnst->constcollid = constcollid;
    cnst->constlen = constlen;
    cnst->constvalue = constvalue;
    cnst->constisnull = constisnull;
    cnst->constbyval = constbyval;
    cnst->location = -1;        /* "unknown" */
 
    return cnst;
}

References Const::consttype, makeNode, PG_DETOAST_DATUM, and PointerGetDatum().

Referenced by add_security_quals(), add_with_check_options(), array_subscript_transform(), build_bound_expr(), build_coercion_expression(), build_minmax_path(), check_sql_stmt_retval(), coerce_null_to_domain(), create_final_distinct_paths(), create_partial_distinct_paths(), eval_const_expressions_mutator(), evaluate_expr(), expand_insert_targetlist(), get_qual_for_hash(), get_qual_for_list(), get_typdefault(), GetJsonBehaviorConst(), getJsonEncodingConst(), make_const(), make_SAOP_expr(), makeBoolConst(), makeJsonTablePathScan(), makeNullConst(), match_clause_to_partition_key(), match_network_subset(), pattern_fixed_prefix(), RelationGetDummyIndexExpressions(), rewriteSearchAndCycle(), scalararraysel(), set_fn_opclass_options(), string_to_bytea_const(), string_to_const(), and transformJsonBehavior().

makeDefElem()

DefElem * makeDefElem	(	char *	name,
		Node *	arg,
		int	location
	)

Definition at line 637 of file makefuncs.c.

{
    DefElem    *res = makeNode(DefElem);
 
    res->defnamespace = NULL;
    res->defname = name;
    res->arg = arg;
    res->defaction = DEFELEM_UNSPEC;
    res->location = location;
 
    return res;
}

References arg, DefElem::arg, DefElem::defaction, DEFELEM_UNSPEC, DefElem::defname, DefElem::defnamespace, DefElem::location, makeNode, and name.

Referenced by buildDefItem(), copy_table(), DefineView(), fileGetForeignPaths(), generateSerialExtraStmts(), get_file_fdw_attribute_options(), pg_logical_slot_get_changes_guts(), sequence_options(), transformAlterTableStmt(), and untransformRelOptions().

makeDefElemExtended()

DefElem * makeDefElemExtended	(	char *	nameSpace,
		char *	name,
		Node *	arg,
		DefElemAction	defaction,
		int	location
	)

Definition at line 655 of file makefuncs.c.

{
    DefElem    *res = makeNode(DefElem);
 
    res->defnamespace = nameSpace;
    res->defname = name;
    res->arg = arg;
    res->defaction = defaction;
    res->location = location;
 
    return res;
}

References arg, DefElem::arg, DefElem::defaction, DefElem::defname, DefElem::defnamespace, DefElem::location, makeNode, and name.

makeFromExpr()

FromExpr * makeFromExpr	(	List *	fromlist,
		Node *	quals
	)

Definition at line 336 of file makefuncs.c.

{
    FromExpr   *f = makeNode(FromExpr);
 
    f->fromlist = fromlist;
    f->quals = quals;
    return f;
}

References FromExpr::fromlist, makeNode, and FromExpr::quals.

Referenced by check_sql_stmt_retval(), pull_up_sublinks(), pull_up_sublinks_jointree_recurse(), remove_useless_results_recurse(), rewriteSearchAndCycle(), transform_MERGE_to_join(), transformDeleteStmt(), transformMergeStmt(), transformPLAssignStmt(), transformReturnStmt(), transformRuleStmt(), transformSelectStmt(), transformSetOperationStmt(), transformUpdateStmt(), and transformValuesClause().

makeFuncCall()

FuncCall * makeFuncCall	(	List *	name,
		List *	args,
		CoercionForm	funcformat,
		int	location
	)

Definition at line 676 of file makefuncs.c.

{
    FuncCall   *n = makeNode(FuncCall);
 
    n->funcname = name;
    n->args = args;
    n->agg_order = NIL;
    n->agg_filter = NULL;
    n->over = NULL;
    n->agg_within_group = false;
    n->agg_star = false;
    n->agg_distinct = false;
    n->func_variadic = false;
    n->funcformat = funcformat;
    n->location = location;
    return n;
}

References FuncCall::agg_distinct, FuncCall::agg_filter, FuncCall::agg_order, FuncCall::agg_star, FuncCall::agg_within_group, generate_unaccent_rules::args, FuncCall::args, FuncCall::func_variadic, FuncCall::funcformat, FuncCall::funcname, FuncCall::location, makeNode, name, NIL, and FuncCall::over.

Referenced by test_rls_hooks_permissive(), test_rls_hooks_restrictive(), transformColumnDefinition(), and transformRangeFunction().

makeFuncExpr()

FuncExpr * makeFuncExpr	(	Oid	funcid,
		Oid	rettype,
		List *	args,
		Oid	funccollid,
		Oid	inputcollid,
		CoercionForm	fformat
	)

Definition at line 594 of file makefuncs.c.

{
    FuncExpr   *funcexpr;
 
    funcexpr = makeNode(FuncExpr);
    funcexpr->funcid = funcid;
    funcexpr->funcresulttype = rettype;
    funcexpr->funcretset = false;   /* only allowed case here */
    funcexpr->funcvariadic = false; /* only allowed case here */
    funcexpr->funcformat = fformat;
    funcexpr->funccollid = funccollid;
    funcexpr->inputcollid = inputcollid;
    funcexpr->args = args;
    funcexpr->location = -1;
 
    return funcexpr;
}

References generate_unaccent_rules::args, FuncExpr::args, FuncExpr::funcid, FuncExpr::location, and makeNode.

Referenced by build_aggregate_deserialfn_expr(), build_aggregate_finalfn_expr(), build_aggregate_serialfn_expr(), build_aggregate_transfn_expr(), build_coercion_expression(), coerceJsonFuncExpr(), get_qual_for_hash(), make_path_cat_expr(), makeJsonByteaToTextConversion(), rewriteSearchAndCycle(), and transformJsonValueExpr().

makeGroupingSet()

GroupingSet * makeGroupingSet	(	GroupingSetKind	kind,
		List *	content,
		int	location
	)

Definition at line 892 of file makefuncs.c.

{
    GroupingSet *n = makeNode(GroupingSet);
 
    n->kind = kind;
    n->content = content;
    n->location = location;
    return n;
}

References GroupingSet::content, GroupingSet::location, and makeNode.

Referenced by flatten_grouping_sets(), transformGroupClause(), and transformGroupingSet().

makeIndexInfo()

IndexInfo * makeIndexInfo	(	int	numattrs,
		int	numkeyattrs,
		Oid	amoid,
		List *	expressions,
		List *	predicates,
		bool	unique,
		bool	nulls_not_distinct,
		bool	isready,
		bool	concurrent,
		bool	summarizing,
		bool	withoutoverlaps
	)

Definition at line 834 of file makefuncs.c.

{
    IndexInfo  *n = makeNode(IndexInfo);
 
    n->ii_NumIndexAttrs = numattrs;
    n->ii_NumIndexKeyAttrs = numkeyattrs;
    Assert(n->ii_NumIndexKeyAttrs != 0);
    Assert(n->ii_NumIndexKeyAttrs <= n->ii_NumIndexAttrs);
    n->ii_Unique = unique;
    n->ii_NullsNotDistinct = nulls_not_distinct;
    n->ii_ReadyForInserts = isready;
    n->ii_CheckedUnchanged = false;
    n->ii_IndexUnchanged = false;
    n->ii_Concurrent = concurrent;
    n->ii_Summarizing = summarizing;
    n->ii_WithoutOverlaps = withoutoverlaps;
 
    /* summarizing indexes cannot contain non-key attributes */
    Assert(!summarizing || (numkeyattrs == numattrs));
 
    /* expressions */
    n->ii_Expressions = expressions;
    n->ii_ExpressionsState = NIL;
 
    /* predicates  */
    n->ii_Predicate = predicates;
    n->ii_PredicateState = NULL;
 
    /* exclusion constraints */
    n->ii_ExclusionOps = NULL;
    n->ii_ExclusionProcs = NULL;
    n->ii_ExclusionStrats = NULL;
 
    /* speculative inserts */
    n->ii_UniqueOps = NULL;
    n->ii_UniqueProcs = NULL;
    n->ii_UniqueStrats = NULL;
 
    /* initialize index-build state to default */
    n->ii_BrokenHotChain = false;
    n->ii_ParallelWorkers = 0;
 
    /* set up for possible use by index AM */
    n->ii_Am = amoid;
    n->ii_AmCache = NULL;
    n->ii_Context = CurrentMemoryContext;
 
    return n;
}

References Assert(), CurrentMemoryContext, IndexInfo::ii_Am, IndexInfo::ii_AmCache, IndexInfo::ii_BrokenHotChain, IndexInfo::ii_CheckedUnchanged, IndexInfo::ii_Concurrent, IndexInfo::ii_Context, IndexInfo::ii_ExclusionOps, IndexInfo::ii_ExclusionProcs, IndexInfo::ii_ExclusionStrats, IndexInfo::ii_Expressions, IndexInfo::ii_ExpressionsState, IndexInfo::ii_IndexUnchanged, IndexInfo::ii_NullsNotDistinct, IndexInfo::ii_NumIndexAttrs, IndexInfo::ii_NumIndexKeyAttrs, IndexInfo::ii_ParallelWorkers, IndexInfo::ii_Predicate, IndexInfo::ii_PredicateState, IndexInfo::ii_ReadyForInserts, IndexInfo::ii_Summarizing, IndexInfo::ii_Unique, IndexInfo::ii_UniqueOps, IndexInfo::ii_UniqueProcs, IndexInfo::ii_UniqueStrats, IndexInfo::ii_WithoutOverlaps, makeNode, and NIL.

Referenced by BuildDummyIndexInfo(), BuildIndexInfo(), CheckIndexCompatible(), DefineIndex(), and index_concurrently_create_copy().

makeJsonBehavior()

JsonBehavior * makeJsonBehavior	(	JsonBehaviorType	btype,
		Node *	expr,
		int	location
	)

Definition at line 955 of file makefuncs.c.

{
    JsonBehavior *behavior = makeNode(JsonBehavior);
 
    behavior->btype = btype;
    behavior->expr = expr;
    behavior->location = location;
 
    return behavior;
}

References JsonBehavior::btype, JsonBehavior::expr, JsonBehavior::location, and makeNode.

Referenced by transformJsonBehavior().

makeJsonFormat()

JsonFormat * makeJsonFormat	(	JsonFormatType	type,
		JsonEncoding	encoding,
		int	location
	)

Definition at line 922 of file makefuncs.c.

{
    JsonFormat *jf = makeNode(JsonFormat);
 
    jf->format_type = type;
    jf->encoding = encoding;
    jf->location = location;
 
    return jf;
}

References encoding, JsonFormat::encoding, JsonFormat::format_type, JsonFormat::location, makeNode, and type.

Referenced by transformJsonOutput(), transformJsonReturning(), transformJsonSerializeExpr(), and transformJsonTableColumn().

makeJsonIsPredicate()

Node * makeJsonIsPredicate	(	Node *	expr,
		JsonFormat *	format,
		JsonValueType	item_type,
		bool	unique_keys,
		int	location
	)

Definition at line 986 of file makefuncs.c.

{
    JsonIsPredicate *n = makeNode(JsonIsPredicate);
 
    n->expr = expr;
    n->format = format;
    n->item_type = item_type;
    n->unique_keys = unique_keys;
    n->location = location;
 
    return (Node *) n;
}

References JsonIsPredicate::expr, format, JsonIsPredicate::format, JsonIsPredicate::item_type, JsonIsPredicate::location, makeNode, and JsonIsPredicate::unique_keys.

Referenced by transformJsonIsPredicate().

makeJsonKeyValue()

Node * makeJsonKeyValue	(	Node *	key,
		Node *	value
	)

Definition at line 971 of file makefuncs.c.

{
    JsonKeyValue *n = makeNode(JsonKeyValue);
 
    n->key = (Expr *) key;
    n->value = castNode(JsonValueExpr, value);
 
    return (Node *) n;
}

References castNode, JsonKeyValue::key, sort-test::key, makeNode, JsonKeyValue::value, and value.

makeJsonTablePath()

JsonTablePath * makeJsonTablePath	(	Const *	pathvalue,
		char *	pathname
	)

Definition at line 1026 of file makefuncs.c.

{
    JsonTablePath *path = makeNode(JsonTablePath);
 
    Assert(IsA(pathvalue, Const));
    path->value = pathvalue;
    path->name = pathname;
 
    return path;
}

References Assert(), IsA, makeNode, JsonTablePath::name, and JsonTablePath::value.

Referenced by makeJsonTablePathScan().

makeJsonTablePathSpec()

JsonTablePathSpec * makeJsonTablePathSpec	(	char *	string,
		char *	name,
		int	string_location,
		int	name_location
	)

Definition at line 1005 of file makefuncs.c.

{
    JsonTablePathSpec *pathspec = makeNode(JsonTablePathSpec);
 
    Assert(string != NULL);
    pathspec->string = makeStringConst(string, string_location);
    if (name != NULL)
        pathspec->name = pstrdup(name);
 
    pathspec->name_location = name_location;
    pathspec->location = string_location;
 
    return pathspec;
}

References Assert(), JsonTablePathSpec::location, makeNode, makeStringConst(), name, JsonTablePathSpec::name, JsonTablePathSpec::name_location, pstrdup(), and JsonTablePathSpec::string.

makeJsonValueExpr()

JsonValueExpr * makeJsonValueExpr	(	Expr *	raw_expr,
		Expr *	formatted_expr,
		JsonFormat *	format
	)

Definition at line 938 of file makefuncs.c.

{
    JsonValueExpr *jve = makeNode(JsonValueExpr);
 
    jve->raw_expr = raw_expr;
    jve->formatted_expr = formatted_expr;
    jve->format = format;
 
    return jve;
}

References format, JsonValueExpr::format, JsonValueExpr::formatted_expr, makeNode, and JsonValueExpr::raw_expr.

Referenced by eval_const_expressions_mutator(), transformJsonArrayQueryConstructor(), transformJsonParseArg(), and transformJsonTableColumn().

makeNotNullConstraint()

Constraint * makeNotNullConstraint

(

String *

colname

)

Definition at line 493 of file makefuncs.c.

{
    Constraint *notnull;
 
    notnull = makeNode(Constraint);
    notnull->contype = CONSTR_NOTNULL;
    notnull->conname = NULL;
    notnull->is_no_inherit = false;
    notnull->deferrable = false;
    notnull->initdeferred = false;
    notnull->location = -1;
    notnull->keys = list_make1(colname);
    notnull->is_enforced = true;
    notnull->skip_validation = false;
    notnull->initially_valid = true;
 
    return notnull;
}

References Constraint::conname, CONSTR_NOTNULL, Constraint::contype, Constraint::deferrable, Constraint::initdeferred, Constraint::initially_valid, Constraint::is_enforced, Constraint::is_no_inherit, Constraint::keys, list_make1, Constraint::location, makeNode, and Constraint::skip_validation.

Referenced by ATExecSetNotNull(), ATPrepAddPrimaryKey(), transformColumnDefinition(), and transformIndexConstraint().

makeNullConst()

Const * makeNullConst	(	Oid	consttype,
		int32	consttypmod,
		Oid	constcollid
	)

Definition at line 388 of file makefuncs.c.

{
    int16       typLen;
    bool        typByVal;
 
    get_typlenbyval(consttype, &typLen, &typByVal);
    return makeConst(consttype,
                     consttypmod,
                     constcollid,
                     (int) typLen,
                     (Datum) 0,
                     true,
                     typByVal);
}

References get_typlenbyval(), and makeConst().

Referenced by adjust_appendrel_attrs_mutator(), ATExecAddColumn(), build_subplan(), BuildOnConflictExcludedTargetlist(), coerce_record_to_complex(), eval_const_expressions_mutator(), evaluate_function(), ExecInitExprRec(), expandRTE(), expandTupleDesc(), remove_unused_subquery_outputs(), rewriteValuesRTE(), rewriteValuesRTEToNulls(), set_plan_refs(), and transformAssignedExpr().

makeRangeVar()

RangeVar * makeRangeVar	(	char *	schemaname,
		char *	relname,
		int	location
	)

Definition at line 473 of file makefuncs.c.

{
    RangeVar   *r = makeNode(RangeVar);
 
    r->catalogname = NULL;
    r->schemaname = schemaname;
    r->relname = relname;
    r->inh = true;
    r->relpersistence = RELPERSISTENCE_PERMANENT;
    r->alias = NULL;
    r->location = location;
 
    return r;
}

References RangeVar::alias, RangeVar::catalogname, RangeVar::inh, RangeVar::location, makeNode, relname, RangeVar::relname, RangeVar::relpersistence, and RangeVar::schemaname.

Referenced by AlterTableNamespace(), ATParseTransformCmd(), autovacuum_do_vac_analyze(), boot_openrel(), BootstrapToastTable(), DoCopy(), ExpandColumnRefStar(), fetch_table_list(), generateSerialExtraStmts(), logicalrep_rel_open(), LookupTypeNameExtended(), makeRangeVarFromNameList(), plpgsql_parse_cwordtype(), transformAlterTableStmt(), and transformColumnRef().

makeRelabelType()

RelabelType * makeRelabelType	(	Expr *	arg,
		Oid	rtype,
		int32	rtypmod,
		Oid	rcollid,
		CoercionForm	rformat
	)

Definition at line 453 of file makefuncs.c.

{
    RelabelType *r = makeNode(RelabelType);
 
    r->arg = arg;
    r->resulttype = rtype;
    r->resulttypmod = rtypmod;
    r->resultcollid = rcollid;
    r->relabelformat = rformat;
    r->location = -1;
 
    return r;
}

References arg, RelabelType::arg, RelabelType::location, makeNode, and RelabelType::resulttype.

Referenced by assign_hypothetical_collations(), buildMergedJoinVar(), coerce_type(), and make_partition_op_expr().

makeSimpleA_Expr()

A_Expr * makeSimpleA_Expr	(	A_Expr_Kind	kind,
		char *	name,
		Node *	lexpr,
		Node *	rexpr,
		int	location
	)

Definition at line 48 of file makefuncs.c.

{
    A_Expr     *a = makeNode(A_Expr);
 
    a->kind = kind;
    a->name = list_make1(makeString(name));
    a->lexpr = lexpr;
    a->rexpr = rexpr;
    a->location = location;
    return a;
}

References a, list_make1, makeNode, makeString(), and name.

Referenced by test_rls_hooks_permissive(), test_rls_hooks_restrictive(), transformAExprBetween(), transformCaseExpr(), and transformJoinUsingClause().

makeStringConst()

Node * makeStringConst	(	char *	str,
		int	location
	)

Definition at line 618 of file makefuncs.c.

{
    A_Const    *n = makeNode(A_Const);
 
    n->val.sval.type = T_String;
    n->val.sval.sval = str;
    n->location = location;
 
    return (Node *) n;
}

References A_Const::location, makeNode, str, ValUnion::sval, String::sval, and A_Const::val.

Referenced by makeJsonTablePathSpec(), and transformJsonTableColumn().

makeTargetEntry()

TargetEntry * makeTargetEntry	(	Expr *	expr,
		AttrNumber	resno,
		char *	resname,
		bool	resjunk
	)

Definition at line 289 of file makefuncs.c.

{
    TargetEntry *tle = makeNode(TargetEntry);
 
    tle->expr = expr;
    tle->resno = resno;
    tle->resname = resname;
 
    /*
     * We always set these fields to 0. If the caller wants to change them he
     * must do so explicitly.  Few callers do that, so omitting these
     * arguments reduces the chance of error.
     */
    tle->ressortgroupref = 0;
    tle->resorigtbl = InvalidOid;
    tle->resorigcol = 0;
 
    tle->resjunk = resjunk;
 
    return tle;
}

References TargetEntry::expr, InvalidOid, makeNode, TargetEntry::resno, and TargetEntry::ressortgroupref.

Referenced by add_row_identity_var(), add_to_flat_tlist(), ApplyRetrieveRule(), build_index_tlist(), build_minmax_path(), build_path_tlist(), build_physical_tlist(), build_remote_returning(), BuildOnConflictExcludedTargetlist(), check_sql_stmt_retval(), coerce_fn_result_column(), convert_combining_aggrefs(), convert_EXISTS_to_ANY(), create_unique_plan(), determineRecursiveColTypes(), ExecInitSubPlan(), expand_generated_columns_internal(), expand_inherited_rtentry(), expand_insert_targetlist(), expand_virtual_generated_columns(), expandNSItemAttrs(), ExpandRowReference(), foreign_grouping_ok(), generate_append_tlist(), generate_setop_tlist(), make_tlist_from_pathtarget(), prepare_sort_from_pathkeys(), preprocess_targetlist(), pull_up_constant_function(), pull_up_simple_values(), rebuild_fdw_scan_tlist(), rewriteSearchAndCycle(), rewriteTargetListIU(), transformAggregateCall(), transformMergeStmt(), transformMultiAssignRef(), transformReturnStmt(), transformSetOperationStmt(), transformSetOperationTree(), and transformTargetEntry().

makeTypeName()

TypeName * makeTypeName

(

char *

typnam

)

Definition at line 519 of file makefuncs.c.

{
    return makeTypeNameFromNameList(list_make1(makeString(typnam)));
}

References list_make1, makeString(), and makeTypeNameFromNameList().

Referenced by plpgsql_parse_wordrowtype().

makeTypeNameFromNameList()

TypeName * makeTypeNameFromNameList

(

List *

names

)

Definition at line 531 of file makefuncs.c.

{
    TypeName   *n = makeNode(TypeName);
 
    n->names = names;
    n->typmods = NIL;
    n->typemod = -1;
    n->location = -1;
    return n;
}

References TypeName::location, makeNode, TypeName::names, NIL, TypeName::typemod, and TypeName::typmods.

Referenced by AlterDomainAddConstraint(), AlterDomainDefault(), AlterDomainDropConstraint(), AlterDomainNotNull(), AlterDomainValidateConstraint(), AlterEnum(), AlterType(), AlterTypeNamespace(), AlterTypeOwner(), defGetTypeName(), FuncNameAsType(), makeTypeName(), objectNamesToOids(), plpgsql_parse_cwordrowtype(), RebuildConstraintComment(), RenameConstraint(), and RenameType().

makeTypeNameFromOid()

TypeName * makeTypeNameFromOid	(	Oid	typeOid,
		int32	typmod
	)

Definition at line 547 of file makefuncs.c.

{
    TypeName   *n = makeNode(TypeName);
 
    n->typeOid = typeOid;
    n->typemod = typmod;
    n->location = -1;
    return n;
}

References TypeName::location, makeNode, TypeName::typemod, and TypeName::typeOid.

Referenced by generateSerialExtraStmts(), makeColumnDef(), and transformAlterTableStmt().

makeVacuumRelation()

VacuumRelation * makeVacuumRelation	(	RangeVar *	relation,
		Oid	oid,
		List *	va_cols
	)

Definition at line 907 of file makefuncs.c.

{
    VacuumRelation *v = makeNode(VacuumRelation);
 
    v->relation = relation;
    v->oid = oid;
    v->va_cols = va_cols;
    return v;
}

References makeNode, VacuumRelation::oid, VacuumRelation::relation, and VacuumRelation::va_cols.

Referenced by autovacuum_do_vac_analyze(), expand_vacuum_rel(), and get_all_vacuum_rels().

makeVar()

Var * makeVar	(	int	varno,
		AttrNumber	varattno,
		Oid	vartype,
		int32	vartypmod,
		Oid	varcollid,
		Index	varlevelsup
	)

Definition at line 66 of file makefuncs.c.

{
    Var        *var = makeNode(Var);
 
    var->varno = varno;
    var->varattno = varattno;
    var->vartype = vartype;
    var->vartypmod = vartypmod;
    var->varcollid = varcollid;
    var->varlevelsup = varlevelsup;
 
    /*
     * Only a few callers need to make Var nodes with varreturningtype
     * different from VAR_RETURNING_DEFAULT, non-null varnullingrels, or with
     * varnosyn/varattnosyn different from varno/varattno.  We don't provide
     * separate arguments for them, but just initialize them to sensible
     * default values.  This reduces code clutter and chance of error for most
     * callers.
     */
    var->varreturningtype = VAR_RETURNING_DEFAULT;
    var->varnullingrels = NULL;
    var->varnosyn = (Index) varno;
    var->varattnosyn = varattno;
 
    /* Likewise, we just set location to "unknown" here */
    var->location = -1;
 
    return var;
}

References Var::location, makeNode, VAR_RETURNING_DEFAULT, Var::varattno, Var::varlevelsup, Var::varno, and Var::varreturningtype.

Referenced by add_row_identity_columns(), ATPrepAlterColumnType(), build_index_tlist(), build_physical_tlist(), build_remote_returning(), buildGroupedVar(), BuildOnConflictExcludedTargetlist(), buildVarFromNSColumn(), eval_const_expressions_mutator(), expand_inherited_rtentry(), expand_single_inheritance_child(), expand_virtual_generated_columns(), expandNSItemVars(), expandRTE(), expandTupleDesc(), fix_indexqual_operand(), generate_append_tlist(), generate_setop_tlist(), get_qual_for_hash(), get_qual_for_list(), get_range_key_properties(), get_range_nulltest(), get_relation_constraints(), make_inh_translation_list(), make_path_cat_expr(), make_path_rowexpr(), makeVarFromTargetEntry(), makeWholeRowVar(), NotNullImpliedByRelConstraints(), PartConstraintImpliedByRelConstraint(), postgresAddForeignUpdateTargets(), preprocess_targetlist(), rewriteSearchAndCycle(), scanNSItemForColumn(), set_baserel_partition_key_exprs(), set_dummy_tlist_references(), transformAssignedExpr(), and transformSetOperationStmt().

makeVarFromTargetEntry()

Var * makeVarFromTargetEntry	(	int	varno,
		TargetEntry *	tle
	)

Definition at line 107 of file makefuncs.c.

{
    return makeVar(varno,
                   tle->resno,
                   exprType((Node *) tle->expr),
                   exprTypmod((Node *) tle->expr),
                   exprCollation((Node *) tle->expr),
                   0);
}

References TargetEntry::expr, exprCollation(), exprType(), exprTypmod(), makeVar(), and TargetEntry::resno.

Referenced by build_physical_tlist(), coerce_fn_result_column(), generate_subquery_vars(), make_setop_translation_list(), search_indexed_tlist_for_non_var(), search_indexed_tlist_for_phv(), search_indexed_tlist_for_sortgroupref(), and transformInsertStmt().

makeWholeRowVar()

Var * makeWholeRowVar	(	RangeTblEntry *	rte,
		int	varno,
		Index	varlevelsup,
		bool	allowScalar
	)

Definition at line 137 of file makefuncs.c.

{
    Var        *result;
    Oid         toid;
    Node       *fexpr;
 
    switch (rte->rtekind)
    {
        case RTE_RELATION:
            /* relation: the rowtype is a named composite type */
            toid = get_rel_type_id(rte->relid);
            if (!OidIsValid(toid))
                ereport(ERROR,
                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                         errmsg("relation \"%s\" does not have a composite type",
                                get_rel_name(rte->relid))));
            result = makeVar(varno,
                             InvalidAttrNumber,
                             toid,
                             -1,
                             InvalidOid,
                             varlevelsup);
            break;
 
        case RTE_SUBQUERY:
 
            /*
             * For a standard subquery, the Var should be of RECORD type.
             * However, if we're looking at a subquery that was expanded from
             * a view or SRF (only possible during planning), we must use the
             * appropriate rowtype, so that the resulting Var has the same
             * type that we would have produced from the original RTE.
             */
            if (OidIsValid(rte->relid))
            {
                /* Subquery was expanded from a view */
                toid = get_rel_type_id(rte->relid);
                if (!OidIsValid(toid))
                    ereport(ERROR,
                            (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                             errmsg("relation \"%s\" does not have a composite type",
                                    get_rel_name(rte->relid))));
            }
            else if (rte->functions)
            {
                /*
                 * Subquery was expanded from a set-returning function.  That
                 * would not have happened if there's more than one function
                 * or ordinality was requested.  We also needn't worry about
                 * the allowScalar case, since the planner doesn't use that.
                 * Otherwise this must match the RTE_FUNCTION code below.
                 */
                Assert(!allowScalar);
                fexpr = ((RangeTblFunction *) linitial(rte->functions))->funcexpr;
                toid = exprType(fexpr);
                if (!type_is_rowtype(toid))
                    toid = RECORDOID;
            }
            else
            {
                /* Normal subquery-in-FROM */
                toid = RECORDOID;
            }
            result = makeVar(varno,
                             InvalidAttrNumber,
                             toid,
                             -1,
                             InvalidOid,
                             varlevelsup);
            break;
 
        case RTE_FUNCTION:
 
            /*
             * If there's more than one function, or ordinality is requested,
             * force a RECORD result, since there's certainly more than one
             * column involved and it can't be a known named type.
             */
            if (rte->funcordinality || list_length(rte->functions) != 1)
            {
                /* always produces an anonymous RECORD result */
                result = makeVar(varno,
                                 InvalidAttrNumber,
                                 RECORDOID,
                                 -1,
                                 InvalidOid,
                                 varlevelsup);
                break;
            }
 
            fexpr = ((RangeTblFunction *) linitial(rte->functions))->funcexpr;
            toid = exprType(fexpr);
            if (type_is_rowtype(toid))
            {
                /* func returns composite; same as relation case */
                result = makeVar(varno,
                                 InvalidAttrNumber,
                                 toid,
                                 -1,
                                 InvalidOid,
                                 varlevelsup);
            }
            else if (allowScalar)
            {
                /* func returns scalar; just return its output as-is */
                result = makeVar(varno,
                                 1,
                                 toid,
                                 -1,
                                 exprCollation(fexpr),
                                 varlevelsup);
            }
            else
            {
                /* func returns scalar, but we want a composite result */
                result = makeVar(varno,
                                 InvalidAttrNumber,
                                 RECORDOID,
                                 -1,
                                 InvalidOid,
                                 varlevelsup);
            }
            break;
 
        default:
 
            /*
             * RTE is a join, tablefunc, VALUES, CTE, etc.  We represent these
             * cases as a whole-row Var of RECORD type.  (Note that in most
             * cases the Var will be expanded to a RowExpr during planning,
             * but that is not our concern here.)
             */
            result = makeVar(varno,
                             InvalidAttrNumber,
                             RECORDOID,
                             -1,
                             InvalidOid,
                             varlevelsup);
            break;
    }
 
    return result;
}

References Assert(), ereport, errcode(), errmsg(), ERROR, exprCollation(), exprType(), RangeTblEntry::funcordinality, RangeTblEntry::functions, get_rel_name(), get_rel_type_id(), InvalidAttrNumber, InvalidOid, linitial, list_length(), makeVar(), OidIsValid, RTE_FUNCTION, RTE_RELATION, RTE_SUBQUERY, RangeTblEntry::rtekind, and type_is_rowtype().

Referenced by ApplyRetrieveRule(), expand_inherited_rtentry(), preprocess_targetlist(), transform_MERGE_to_join(), and transformWholeRowRef().