open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add const qualifiers to node inspection functions

Browse Source 
Thomas Munro
pull/1/head
Peter Eisentraut 14 years ago
parent 0d0ec527af
commit d5f23af6bf
12 changed files with 913 additions and 913 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 518
      src/backend/nodes/copyfuncs.c
  2. 364
      src/backend/nodes/equalfuncs.c
  3. 74
      src/backend/nodes/list.c
  4. 306
      src/backend/nodes/nodeFuncs.c
  5. 440
      src/backend/nodes/outfuncs.c
  6. 34
      src/backend/nodes/print.c
  7. 8
      src/backend/optimizer/util/clauses.c
  8. 12
      src/include/nodes/nodeFuncs.h
  9. 8
      src/include/nodes/nodes.h
  10. 44
      src/include/nodes/pg_list.h
  11. 14
      src/include/nodes/print.h
  12. 4
      src/include/optimizer/clauses.h

518
src/backend/nodes/copyfuncs.c
View File

File diff suppressed because it is too large Load Diff

364
src/backend/nodes/equalfuncs.c
View File

File diff suppressed because it is too large Load Diff

74
src/backend/nodes/list.c
Unescape View File

@ -31,7 +31,7 @@
* Check that the specified List is valid (so far as we can tell).
*/
static void
check_list_invariants(List *list)
check_list_invariants(const List *list)
{
if (list == NIL)
return;
@ -383,7 +383,7 @@ list_truncate(List *list, int new_size)
* failure if there is no such cell.
*/
static ListCell *
list_nth_cell(List *list, int n)
list_nth_cell(const List *list, int n)
{
ListCell *match;
@ -407,7 +407,7 @@ list_nth_cell(List *list, int n)
* specified list. (List elements begin at 0.)
*/
void *
list_nth(List *list, int n)
list_nth(const List *list, int n)
{
Assert(IsPointerList(list));
return lfirst(list_nth_cell(list, n));
@ -418,7 +418,7 @@ list_nth(List *list, int n)
* specified list.
*/
int
list_nth_int(List *list, int n)
list_nth_int(const List *list, int n)
{
Assert(IsIntegerList(list));
return lfirst_int(list_nth_cell(list, n));
@ -429,7 +429,7 @@ list_nth_int(List *list, int n)
* list.
*/
Oid
list_nth_oid(List *list, int n)
list_nth_oid(const List *list, int n)
{
Assert(IsOidList(list));
return lfirst_oid(list_nth_cell(list, n));
@ -441,9 +441,9 @@ list_nth_oid(List *list, int n)
* Node as 'datum'.
*/
bool
list_member(List *list, void *datum)
list_member(const List *list, const void *datum)
{
ListCell *cell;
const ListCell *cell;
Assert(IsPointerList(list));
check_list_invariants(list);
@ -462,9 +462,9 @@ list_member(List *list, void *datum)
* determined by using simple pointer comparison.
*/
bool
list_member_ptr(List *list, void *datum)
list_member_ptr(const List *list, const void *datum)
{
ListCell *cell;
const ListCell *cell;
Assert(IsPointerList(list));
check_list_invariants(list);
@ -482,9 +482,9 @@ list_member_ptr(List *list, void *datum)
* Return true iff the integer 'datum' is a member of the list.
*/
bool
list_member_int(List *list, int datum)
list_member_int(const List *list, int datum)
{
ListCell *cell;
const ListCell *cell;
Assert(IsIntegerList(list));
check_list_invariants(list);
@ -502,9 +502,9 @@ list_member_int(List *list, int datum)
* Return true iff the OID 'datum' is a member of the list.
*/
bool
list_member_oid(List *list, Oid datum)
list_member_oid(const List *list, Oid datum)
{
ListCell *cell;
const ListCell *cell;
Assert(IsOidList(list));
check_list_invariants(list);
@ -694,10 +694,10 @@ list_delete_first(List *list)
* performance bottleneck.
*/
List *
list_union(List *list1, List *list2)
list_union(const List *list1, const List *list2)
{
List *result;
ListCell *cell;
const ListCell *cell;
Assert(IsPointerList(list1));
Assert(IsPointerList(list2));
@ -718,10 +718,10 @@ list_union(List *list1, List *list2)
* pointer comparison.
*/
List *
list_union_ptr(List *list1, List *list2)
list_union_ptr(const List *list1, const List *list2)
{
List *result;
ListCell *cell;
const ListCell *cell;
Assert(IsPointerList(list1));
Assert(IsPointerList(list2));
@ -741,10 +741,10 @@ list_union_ptr(List *list1, List *list2)
* This variant of list_union() operates upon lists of integers.
*/
List *
list_union_int(List *list1, List *list2)
list_union_int(const List *list1, const List *list2)
{
List *result;
ListCell *cell;
const ListCell *cell;
Assert(IsIntegerList(list1));
Assert(IsIntegerList(list2));
@ -764,10 +764,10 @@ list_union_int(List *list1, List *list2)
* This variant of list_union() operates upon lists of OIDs.
*/
List *
list_union_oid(List *list1, List *list2)
list_union_oid(const List *list1, const List *list2)
{
List *result;
ListCell *cell;
const ListCell *cell;
Assert(IsOidList(list1));
Assert(IsOidList(list2));
@ -797,10 +797,10 @@ list_union_oid(List *list1, List *list2)
* to in the result.
*/
List *
list_intersection(List *list1, List *list2)
list_intersection(const List *list1, const List *list2)
{
List *result;
ListCell *cell;
const ListCell *cell;
if (list1 == NIL || list2 == NIL)
return NIL;
@ -829,9 +829,9 @@ list_intersection(List *list1, List *list2)
* membership via equal()
*/
List *
list_difference(List *list1, List *list2)
list_difference(const List *list1, const List *list2)
{
ListCell *cell;
const ListCell *cell;
List *result = NIL;
Assert(IsPointerList(list1));
@ -855,9 +855,9 @@ list_difference(List *list1, List *list2)
* simple pointer equality.
*/
List *
list_difference_ptr(List *list1, List *list2)
list_difference_ptr(const List *list1, const List *list2)
{
ListCell *cell;
const ListCell *cell;
List *result = NIL;
Assert(IsPointerList(list1));
@ -880,9 +880,9 @@ list_difference_ptr(List *list1, List *list2)
* This variant of list_difference() operates upon lists of integers.
*/
List *
list_difference_int(List *list1, List *list2)
list_difference_int(const List *list1, const List *list2)
{
ListCell *cell;
const ListCell *cell;
List *result = NIL;
Assert(IsIntegerList(list1));
@ -905,9 +905,9 @@ list_difference_int(List *list1, List *list2)
* This variant of list_difference() operates upon lists of OIDs.
*/
List *
list_difference_oid(List *list1, List *list2)
list_difference_oid(const List *list1, const List *list2)
{
ListCell *cell;
const ListCell *cell;
List *result = NIL;
Assert(IsOidList(list1));
@ -1131,7 +1131,7 @@ list_free_deep(List *list)
* Return a shallow copy of the specified list.
*/
List *
list_copy(List *oldlist)
list_copy(const List *oldlist)
{
List *newlist;
ListCell *newlist_prev;
@ -1174,7 +1174,7 @@ list_copy(List *oldlist)
* Return a shallow copy of the specified list, without the first N elements.
*/
List *
list_copy_tail(List *oldlist, int nskip)
list_copy_tail(const List *oldlist, int nskip)
{
List *newlist;
ListCell *newlist_prev;
@ -1230,7 +1230,7 @@ list_copy_tail(List *oldlist, int nskip)
#ifndef USE_INLINE
ListCell *
list_head(List *l)
list_head(const List *l)
{
return l ? l->head : NULL;
}
@ -1242,7 +1242,7 @@ list_tail(List *l)
}
int
list_length(List *l)
list_length(const List *l)
{
return l ? l->length : 0;
}
@ -1264,10 +1264,10 @@ list_length(List *l)
* list_length() macro in order to avoid the overhead of a function
* call.
*/
int length(List *list);
int length(const List *list);
int
length(List *list)
length(const List *list)
{
return list_length(list);
}

306
src/backend/nodes/nodeFuncs.c
Unescape View File

@ -32,7 +32,7 @@ static int leftmostLoc(int loc1, int loc2);
* returns the Oid of the type of the expression's result.
*/
Oid
exprType(Node *expr)
exprType(const Node *expr)
{
Oid type;
@ -42,23 +42,23 @@ exprType(Node *expr)
switch (nodeTag(expr))
{
case T_Var:
type = ((Var *) expr)->vartype;
type = ((const Var *) expr)->vartype;
break;
case T_Const:
type = ((Const *) expr)->consttype;
type = ((const Const *) expr)->consttype;
break;
case T_Param:
type = ((Param *) expr)->paramtype;
type = ((const Param *) expr)->paramtype;
break;
case T_Aggref:
type = ((Aggref *) expr)->aggtype;
type = ((const Aggref *) expr)->aggtype;
break;
case T_WindowFunc:
type = ((WindowFunc *) expr)->wintype;
type = ((const WindowFunc *) expr)->wintype;
break;
case T_ArrayRef:
{
ArrayRef *arrayref = (ArrayRef *) expr;
const ArrayRef *arrayref = (const ArrayRef *) expr;
/* slice and/or store operations yield the array type */
if (arrayref->reflowerindexpr || arrayref->refassgnexpr)
@ -68,19 +68,19 @@ exprType(Node *expr)
}
break;
case T_FuncExpr:
type = ((FuncExpr *) expr)->funcresulttype;
type = ((const FuncExpr *) expr)->funcresulttype;
break;
case T_NamedArgExpr:
type = exprType((Node *) ((NamedArgExpr *) expr)->arg);
type = exprType((Node *) ((const NamedArgExpr *) expr)->arg);
break;
case T_OpExpr:
type = ((OpExpr *) expr)->opresulttype;
type = ((const OpExpr *) expr)->opresulttype;
break;
case T_DistinctExpr:
type = ((DistinctExpr *) expr)->opresulttype;
type = ((const DistinctExpr *) expr)->opresulttype;
break;
case T_NullIfExpr:
type = ((NullIfExpr *) expr)->opresulttype;
type = ((const NullIfExpr *) expr)->opresulttype;
break;
case T_ScalarArrayOpExpr:
type = BOOLOID;
@ -90,7 +90,7 @@ exprType(Node *expr)
break;
case T_SubLink:
{
SubLink *sublink = (SubLink *) expr;
const SubLink *sublink = (const SubLink *) expr;
if (sublink->subLinkType == EXPR_SUBLINK ||
sublink->subLinkType == ARRAY_SUBLINK)
@ -124,7 +124,7 @@ exprType(Node *expr)
break;
case T_SubPlan:
{
SubPlan *subplan = (SubPlan *) expr;
const SubPlan *subplan = (const SubPlan *) expr;
if (subplan->subLinkType == EXPR_SUBLINK ||
subplan->subLinkType == ARRAY_SUBLINK)
@ -150,58 +150,58 @@ exprType(Node *expr)
break;
case T_AlternativeSubPlan:
{
AlternativeSubPlan *asplan = (AlternativeSubPlan *) expr;
const AlternativeSubPlan *asplan = (const AlternativeSubPlan *) expr;
/* subplans should all return the same thing */
type = exprType((Node *) linitial(asplan->subplans));
}
break;
case T_FieldSelect:
type = ((FieldSelect *) expr)->resulttype;
type = ((const FieldSelect *) expr)->resulttype;
break;
case T_FieldStore:
type = ((FieldStore *) expr)->resulttype;
type = ((const FieldStore *) expr)->resulttype;
break;
case T_RelabelType:
type = ((RelabelType *) expr)->resulttype;
type = ((const RelabelType *) expr)->resulttype;
break;
case T_CoerceViaIO:
type = ((CoerceViaIO *) expr)->resulttype;
type = ((const CoerceViaIO *) expr)->resulttype;
break;
case T_ArrayCoerceExpr:
type = ((ArrayCoerceExpr *) expr)->resulttype;
type = ((const ArrayCoerceExpr *) expr)->resulttype;
break;
case T_ConvertRowtypeExpr:
type = ((ConvertRowtypeExpr *) expr)->resulttype;
type = ((const ConvertRowtypeExpr *) expr)->resulttype;
break;
case T_CollateExpr:
type = exprType((Node *) ((CollateExpr *) expr)->arg);
type = exprType((Node *) ((const CollateExpr *) expr)->arg);
break;
case T_CaseExpr:
type = ((CaseExpr *) expr)->casetype;
type = ((const CaseExpr *) expr)->casetype;
break;
case T_CaseTestExpr:
type = ((CaseTestExpr *) expr)->typeId;
type = ((const CaseTestExpr *) expr)->typeId;
break;
case T_ArrayExpr:
type = ((ArrayExpr *) expr)->array_typeid;
type = ((const ArrayExpr *) expr)->array_typeid;
break;
case T_RowExpr:
type = ((RowExpr *) expr)->row_typeid;
type = ((const RowExpr *) expr)->row_typeid;
break;
case T_RowCompareExpr:
type = BOOLOID;
break;
case T_CoalesceExpr:
type = ((CoalesceExpr *) expr)->coalescetype;
type = ((const CoalesceExpr *) expr)->coalescetype;
break;
case T_MinMaxExpr:
type = ((MinMaxExpr *) expr)->minmaxtype;
type = ((const MinMaxExpr *) expr)->minmaxtype;
break;
case T_XmlExpr:
if (((XmlExpr *) expr)->op == IS_DOCUMENT)
if (((const XmlExpr *) expr)->op == IS_DOCUMENT)
type = BOOLOID;
else if (((XmlExpr *) expr)->op == IS_XMLSERIALIZE)
else if (((const XmlExpr *) expr)->op == IS_XMLSERIALIZE)
type = TEXTOID;
else
type = XMLOID;
@ -213,19 +213,19 @@ exprType(Node *expr)
type = BOOLOID;
break;
case T_CoerceToDomain:
type = ((CoerceToDomain *) expr)->resulttype;
type = ((const CoerceToDomain *) expr)->resulttype;
break;
case T_CoerceToDomainValue:
type = ((CoerceToDomainValue *) expr)->typeId;
type = ((const CoerceToDomainValue *) expr)->typeId;
break;
case T_SetToDefault:
type = ((SetToDefault *) expr)->typeId;
type = ((const SetToDefault *) expr)->typeId;
break;
case T_CurrentOfExpr:
type = BOOLOID;
break;
case T_PlaceHolderVar:
type = exprType((Node *) ((PlaceHolderVar *) expr)->phexpr);
type = exprType((Node *) ((const PlaceHolderVar *) expr)->phexpr);
break;
default:
elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr));
@ -241,7 +241,7 @@ exprType(Node *expr)
* if it can be determined. In many cases, it can't and we return -1.
*/
int32
exprTypmod(Node *expr)
exprTypmod(const Node *expr)
{
if (!expr)
return -1;
@ -249,14 +249,14 @@ exprTypmod(Node *expr)
switch (nodeTag(expr))
{
case T_Var:
return ((Var *) expr)->vartypmod;
return ((const Var *) expr)->vartypmod;
case T_Const:
return ((Const *) expr)->consttypmod;
return ((const Const *) expr)->consttypmod;
case T_Param:
return ((Param *) expr)->paramtypmod;
return ((const Param *) expr)->paramtypmod;
case T_ArrayRef:
/* typmod is the same for array or element */
return ((ArrayRef *) expr)->reftypmod;
return ((const ArrayRef *) expr)->reftypmod;
case T_FuncExpr:
{
int32 coercedTypmod;
@ -267,21 +267,21 @@ exprTypmod(Node *expr)
}
break;
case T_NamedArgExpr:
return exprTypmod((Node *) ((NamedArgExpr *) expr)->arg);
return exprTypmod((Node *) ((const NamedArgExpr *) expr)->arg);
case T_NullIfExpr:
{
/*
* Result is either first argument or NULL, so we can report
* first argument's typmod if known.
*/
NullIfExpr *nexpr = (NullIfExpr *) expr;
const NullIfExpr *nexpr = (const NullIfExpr *) expr;
return exprTypmod((Node *) linitial(nexpr->args));
}
break;
case T_SubLink:
{
SubLink *sublink = (SubLink *) expr;
const SubLink *sublink = (const SubLink *) expr;
if (sublink->subLinkType == EXPR_SUBLINK ||
sublink->subLinkType == ARRAY_SUBLINK)
@ -302,7 +302,7 @@ exprTypmod(Node *expr)
break;
case T_SubPlan:
{
SubPlan *subplan = (SubPlan *) expr;
const SubPlan *subplan = (const SubPlan *) expr;
if (subplan->subLinkType == EXPR_SUBLINK ||
subplan->subLinkType == ARRAY_SUBLINK)
@ -320,27 +320,27 @@ exprTypmod(Node *expr)
break;
case T_AlternativeSubPlan:
{
AlternativeSubPlan *asplan = (AlternativeSubPlan *) expr;
const AlternativeSubPlan *asplan = (const AlternativeSubPlan *) expr;
/* subplans should all return the same thing */
return exprTypmod((Node *) linitial(asplan->subplans));
}
break;
case T_FieldSelect:
return ((FieldSelect *) expr)->resulttypmod;
return ((const FieldSelect *) expr)->resulttypmod;
case T_RelabelType:
return ((RelabelType *) expr)->resulttypmod;
return ((const RelabelType *) expr)->resulttypmod;
case T_ArrayCoerceExpr:
return ((ArrayCoerceExpr *) expr)->resulttypmod;
return ((const ArrayCoerceExpr *) expr)->resulttypmod;
case T_CollateExpr:
return exprTypmod((Node *) ((CollateExpr *) expr)->arg);
return exprTypmod((Node *) ((const CollateExpr *) expr)->arg);
case T_CaseExpr:
{
/*
* If all the alternatives agree on type/typmod, return that
* typmod, else use -1
*/
CaseExpr *cexpr = (CaseExpr *) expr;
const CaseExpr *cexpr = (const CaseExpr *) expr;
Oid casetype = cexpr->casetype;
int32 typmod;
ListCell *arg;
@ -366,14 +366,14 @@ exprTypmod(Node *expr)
}
break;
case T_CaseTestExpr:
return ((CaseTestExpr *) expr)->typeMod;
return ((const CaseTestExpr *) expr)->typeMod;
case T_ArrayExpr:
{
/*
* If all the elements agree on type/typmod, return that
* typmod, else use -1
*/
ArrayExpr *arrayexpr = (ArrayExpr *) expr;
const ArrayExpr *arrayexpr = (const ArrayExpr *) expr;
Oid commontype;
int32 typmod;
ListCell *elem;
@ -405,7 +405,7 @@ exprTypmod(Node *expr)
* If all the alternatives agree on type/typmod, return that
* typmod, else use -1
*/
CoalesceExpr *cexpr = (CoalesceExpr *) expr;
const CoalesceExpr *cexpr = (const CoalesceExpr *) expr;
Oid coalescetype = cexpr->coalescetype;
int32 typmod;
ListCell *arg;
@ -433,7 +433,7 @@ exprTypmod(Node *expr)
* If all the alternatives agree on type/typmod, return that
* typmod, else use -1
*/
MinMaxExpr *mexpr = (MinMaxExpr *) expr;
const MinMaxExpr *mexpr = (const MinMaxExpr *) expr;
Oid minmaxtype = mexpr->minmaxtype;
int32 typmod;
ListCell *arg;
@ -456,13 +456,13 @@ exprTypmod(Node *expr)
}
break;
case T_CoerceToDomain:
return ((CoerceToDomain *) expr)->resulttypmod;
return ((const CoerceToDomain *) expr)->resulttypmod;
case T_CoerceToDomainValue:
return ((CoerceToDomainValue *) expr)->typeMod;
return ((const CoerceToDomainValue *) expr)->typeMod;
case T_SetToDefault:
return ((SetToDefault *) expr)->typeMod;
return ((const SetToDefault *) expr)->typeMod;
case T_PlaceHolderVar:
return exprTypmod((Node *) ((PlaceHolderVar *) expr)->phexpr);
return exprTypmod((Node *) ((const PlaceHolderVar *) expr)->phexpr);
default:
break;
}
@ -481,7 +481,7 @@ exprTypmod(Node *expr)
* length coercion by this routine.
*/
bool
exprIsLengthCoercion(Node *expr, int32 *coercedTypmod)
exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod)
{
if (coercedTypmod != NULL)
*coercedTypmod = -1; /* default result on failure */
@ -492,7 +492,7 @@ exprIsLengthCoercion(Node *expr, int32 *coercedTypmod)
*/
if (expr && IsA(expr, FuncExpr))
{
FuncExpr *func = (FuncExpr *) expr;
const FuncExpr *func = (const FuncExpr *) expr;
int nargs;
Const *second_arg;
@ -529,7 +529,7 @@ exprIsLengthCoercion(Node *expr, int32 *coercedTypmod)
if (expr && IsA(expr, ArrayCoerceExpr))
{
ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) expr;
const ArrayCoerceExpr *acoerce = (const ArrayCoerceExpr *) expr;
/* It's not a length coercion unless there's a nondefault typmod */
if (acoerce->resulttypmod < 0)
@ -632,7 +632,7 @@ expression_returns_set_walker(Node *node, void *context)
* or vice versa, the two are different.
*/
Oid
exprCollation(Node *expr)
exprCollation(const Node *expr)
{
Oid coll;
@ -642,37 +642,37 @@ exprCollation(Node *expr)
switch (nodeTag(expr))
{
case T_Var:
coll = ((Var *) expr)->varcollid;
coll = ((const Var *) expr)->varcollid;
break;
case T_Const:
coll = ((Const *) expr)->constcollid;
coll = ((const Const *) expr)->constcollid;
break;
case T_Param:
coll = ((Param *) expr)->paramcollid;
coll = ((const Param *) expr)->paramcollid;
break;
case T_Aggref:
coll = ((Aggref *) expr)->aggcollid;
coll = ((const Aggref *) expr)->aggcollid;
break;
case T_WindowFunc:
coll = ((WindowFunc *) expr)->wincollid;
coll = ((const WindowFunc *) expr)->wincollid;
break;
case T_ArrayRef:
coll = ((ArrayRef *) expr)->refcollid;
coll = ((const ArrayRef *) expr)->refcollid;
break;
case T_FuncExpr:
coll = ((FuncExpr *) expr)->funccollid;
coll = ((const FuncExpr *) expr)->funccollid;
break;
case T_NamedArgExpr:
coll = exprCollation((Node *) ((NamedArgExpr *) expr)->arg);
coll = exprCollation((Node *) ((const NamedArgExpr *) expr)->arg);
break;
case T_OpExpr:
coll = ((OpExpr *) expr)->opcollid;
coll = ((const OpExpr *) expr)->opcollid;
break;
case T_DistinctExpr:
coll = ((DistinctExpr *) expr)->opcollid;
coll = ((const DistinctExpr *) expr)->opcollid;
break;
case T_NullIfExpr:
coll = ((NullIfExpr *) expr)->opcollid;
coll = ((const NullIfExpr *) expr)->opcollid;
break;
case T_ScalarArrayOpExpr:
coll = InvalidOid; /* result is always boolean */
@ -682,7 +682,7 @@ exprCollation(Node *expr)
break;
case T_SubLink:
{
SubLink *sublink = (SubLink *) expr;
const SubLink *sublink = (const SubLink *) expr;
if (sublink->subLinkType == EXPR_SUBLINK ||
sublink->subLinkType == ARRAY_SUBLINK)
@ -708,7 +708,7 @@ exprCollation(Node *expr)
break;
case T_SubPlan:
{
SubPlan *subplan = (SubPlan *) expr;
const SubPlan *subplan = (const SubPlan *) expr;
if (subplan->subLinkType == EXPR_SUBLINK ||
subplan->subLinkType == ARRAY_SUBLINK)
@ -726,41 +726,41 @@ exprCollation(Node *expr)
break;
case T_AlternativeSubPlan:
{
AlternativeSubPlan *asplan = (AlternativeSubPlan *) expr;
const AlternativeSubPlan *asplan = (const AlternativeSubPlan *) expr;
/* subplans should all return the same thing */
coll = exprCollation((Node *) linitial(asplan->subplans));
}
break;
case T_FieldSelect:
coll = ((FieldSelect *) expr)->resultcollid;
coll = ((const FieldSelect *) expr)->resultcollid;
break;
case T_FieldStore:
coll = InvalidOid; /* result is always composite */
break;
case T_RelabelType:
coll = ((RelabelType *) expr)->resultcollid;
coll = ((const RelabelType *) expr)->resultcollid;
break;
case T_CoerceViaIO:
coll = ((CoerceViaIO *) expr)->resultcollid;
coll = ((const CoerceViaIO *) expr)->resultcollid;
break;
case T_ArrayCoerceExpr:
coll = ((ArrayCoerceExpr *) expr)->resultcollid;
coll = ((const ArrayCoerceExpr *) expr)->resultcollid;
break;
case T_ConvertRowtypeExpr:
coll = InvalidOid; /* result is always composite */
break;
case T_CollateExpr:
coll = ((CollateExpr *) expr)->collOid;
coll = ((const CollateExpr *) expr)->collOid;
break;
case T_CaseExpr:
coll = ((CaseExpr *) expr)->casecollid;
coll = ((const CaseExpr *) expr)->casecollid;
break;
case T_CaseTestExpr:
coll = ((CaseTestExpr *) expr)->collation;
coll = ((const CaseTestExpr *) expr)->collation;
break;
case T_ArrayExpr:
coll = ((ArrayExpr *) expr)->array_collid;
coll = ((const ArrayExpr *) expr)->array_collid;
break;
case T_RowExpr:
coll = InvalidOid; /* result is always composite */
@ -769,10 +769,10 @@ exprCollation(Node *expr)
coll = InvalidOid; /* result is always boolean */
break;
case T_CoalesceExpr:
coll = ((CoalesceExpr *) expr)->coalescecollid;
coll = ((const CoalesceExpr *) expr)->coalescecollid;
break;
case T_MinMaxExpr:
coll = ((MinMaxExpr *) expr)->minmaxcollid;
coll = ((const MinMaxExpr *) expr)->minmaxcollid;
break;
case T_XmlExpr:
@ -781,7 +781,7 @@ exprCollation(Node *expr)
* collation is always default. The other cases return boolean or
* XML, which are non-collatable.
*/
if (((XmlExpr *) expr)->op == IS_XMLSERIALIZE)
if (((const XmlExpr *) expr)->op == IS_XMLSERIALIZE)
coll = DEFAULT_COLLATION_OID;
else
coll = InvalidOid;
@ -793,19 +793,19 @@ exprCollation(Node *expr)
coll = InvalidOid; /* result is always boolean */
break;
case T_CoerceToDomain:
coll = ((CoerceToDomain *) expr)->resultcollid;
coll = ((const CoerceToDomain *) expr)->resultcollid;
break;
case T_CoerceToDomainValue:
coll = ((CoerceToDomainValue *) expr)->collation;
coll = ((const CoerceToDomainValue *) expr)->collation;
break;
case T_SetToDefault:
coll = ((SetToDefault *) expr)->collation;
coll = ((const SetToDefault *) expr)->collation;
break;
case T_CurrentOfExpr:
coll = InvalidOid; /* result is always boolean */
break;
case T_PlaceHolderVar:
coll = exprCollation((Node *) ((PlaceHolderVar *) expr)->phexpr);
coll = exprCollation((Node *) ((const PlaceHolderVar *) expr)->phexpr);
break;
default:
elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr));
@ -822,7 +822,7 @@ exprCollation(Node *expr)
* Result is InvalidOid if the node type doesn't store this information.
*/
Oid
exprInputCollation(Node *expr)
exprInputCollation(const Node *expr)
{
Oid coll;
@ -832,28 +832,28 @@ exprInputCollation(Node *expr)
switch (nodeTag(expr))
{
case T_Aggref:
coll = ((Aggref *) expr)->inputcollid;
coll = ((const Aggref *) expr)->inputcollid;
break;
case T_WindowFunc:
coll = ((WindowFunc *) expr)->inputcollid;
coll = ((const WindowFunc *) expr)->inputcollid;
break;
case T_FuncExpr:
coll = ((FuncExpr *) expr)->inputcollid;
coll = ((const FuncExpr *) expr)->inputcollid;
break;
case T_OpExpr:
coll = ((OpExpr *) expr)->inputcollid;
coll = ((const OpExpr *) expr)->inputcollid;
break;
case T_DistinctExpr:
coll = ((DistinctExpr *) expr)->inputcollid;
coll = ((const DistinctExpr *) expr)->inputcollid;
break;
case T_NullIfExpr:
coll = ((NullIfExpr *) expr)->inputcollid;
coll = ((const NullIfExpr *) expr)->inputcollid;
break;
case T_ScalarArrayOpExpr:
coll = ((ScalarArrayOpExpr *) expr)->inputcollid;
coll = ((const ScalarArrayOpExpr *) expr)->inputcollid;
break;
case T_MinMaxExpr:
coll = ((MinMaxExpr *) expr)->inputcollid;
coll = ((const MinMaxExpr *) expr)->inputcollid;
break;
default:
coll = InvalidOid;
@ -1078,7 +1078,7 @@ exprSetInputCollation(Node *expr, Oid inputcollation)
* known and unknown locations in a tree.
*/
int
exprLocation(Node *expr)
exprLocation(const Node *expr)
{
int loc;
@ -1087,32 +1087,32 @@ exprLocation(Node *expr)
switch (nodeTag(expr))
{
case T_RangeVar:
loc = ((RangeVar *) expr)->location;
loc = ((const RangeVar *) expr)->location;
break;
case T_Var:
loc = ((Var *) expr)->location;
loc = ((const Var *) expr)->location;
break;
case T_Const:
loc = ((Const *) expr)->location;
loc = ((const Const *) expr)->location;
break;
case T_Param:
loc = ((Param *) expr)->location;
loc = ((const Param *) expr)->location;
break;
case T_Aggref:
/* function name should always be the first thing */
loc = ((Aggref *) expr)->location;
loc = ((const Aggref *) expr)->location;
break;
case T_WindowFunc:
/* function name should always be the first thing */
loc = ((WindowFunc *) expr)->location;
loc = ((const WindowFunc *) expr)->location;
break;
case T_ArrayRef:
/* just use array argument's location */
loc = exprLocation((Node *) ((ArrayRef *) expr)->refexpr);
loc = exprLocation((Node *) ((const ArrayRef *) expr)->refexpr);
break;
case T_FuncExpr:
{
FuncExpr *fexpr = (FuncExpr *) expr;
const FuncExpr *fexpr = (const FuncExpr *) expr;
/* consider both function name and leftmost arg */
loc = leftmostLoc(fexpr->location,
@ -1121,7 +1121,7 @@ exprLocation(Node *expr)
break;
case T_NamedArgExpr:
{
NamedArgExpr *na = (NamedArgExpr *) expr;
const NamedArgExpr *na = (const NamedArgExpr *) expr;
/* consider both argument name and value */
loc = leftmostLoc(na->location,
@ -1132,7 +1132,7 @@ exprLocation(Node *expr)
case T_DistinctExpr: /* struct-equivalent to OpExpr */
case T_NullIfExpr: /* struct-equivalent to OpExpr */
{
OpExpr *opexpr = (OpExpr *) expr;
const OpExpr *opexpr = (const OpExpr *) expr;
/* consider both operator name and leftmost arg */
loc = leftmostLoc(opexpr->location,
@ -1141,7 +1141,7 @@ exprLocation(Node *expr)
break;
case T_ScalarArrayOpExpr:
{
ScalarArrayOpExpr *saopexpr = (ScalarArrayOpExpr *) expr;
const ScalarArrayOpExpr *saopexpr = (const ScalarArrayOpExpr *) expr;
/* consider both operator name and leftmost arg */
loc = leftmostLoc(saopexpr->location,
@ -1150,7 +1150,7 @@ exprLocation(Node *expr)
break;
case T_BoolExpr:
{
BoolExpr *bexpr = (BoolExpr *) expr;
const BoolExpr *bexpr = (const BoolExpr *) expr;
/*
* Same as above, to handle either NOT or AND/OR. We can't
@ -1163,7 +1163,7 @@ exprLocation(Node *expr)
break;
case T_SubLink:
{
SubLink *sublink = (SubLink *) expr;
const SubLink *sublink = (const SubLink *) expr;
/* check the testexpr, if any, and the operator/keyword */
loc = leftmostLoc(exprLocation(sublink->testexpr),
@ -1172,15 +1172,15 @@ exprLocation(Node *expr)
break;
case T_FieldSelect:
/* just use argument's location */
loc = exprLocation((Node *) ((FieldSelect *) expr)->arg);
loc = exprLocation((Node *) ((const FieldSelect *) expr)->arg);
break;
case T_FieldStore:
/* just use argument's location */
loc = exprLocation((Node *) ((FieldStore *) expr)->arg);
loc = exprLocation((Node *) ((const FieldStore *) expr)->arg);
break;
case T_RelabelType:
{
RelabelType *rexpr = (RelabelType *) expr;
const RelabelType *rexpr = (const RelabelType *) expr;
/* Much as above */
loc = leftmostLoc(rexpr->location,
@ -1189,7 +1189,7 @@ exprLocation(Node *expr)
break;
case T_CoerceViaIO:
{
CoerceViaIO *cexpr = (CoerceViaIO *) expr;
const CoerceViaIO *cexpr = (const CoerceViaIO *) expr;
/* Much as above */
loc = leftmostLoc(cexpr->location,
@ -1198,7 +1198,7 @@ exprLocation(Node *expr)
break;
case T_ArrayCoerceExpr:
{
ArrayCoerceExpr *cexpr = (ArrayCoerceExpr *) expr;
const ArrayCoerceExpr *cexpr = (const ArrayCoerceExpr *) expr;
/* Much as above */
loc = leftmostLoc(cexpr->location,
@ -1207,7 +1207,7 @@ exprLocation(Node *expr)
break;
case T_ConvertRowtypeExpr:
{
ConvertRowtypeExpr *cexpr = (ConvertRowtypeExpr *) expr;
const ConvertRowtypeExpr *cexpr = (const ConvertRowtypeExpr *) expr;
/* Much as above */
loc = leftmostLoc(cexpr->location,
@ -1216,39 +1216,39 @@ exprLocation(Node *expr)
break;
case T_CollateExpr:
/* just use argument's location */
loc = exprLocation((Node *) ((CollateExpr *) expr)->arg);
loc = exprLocation((Node *) ((const CollateExpr *) expr)->arg);
break;
case T_CaseExpr:
/* CASE keyword should always be the first thing */
loc = ((CaseExpr *) expr)->location;
loc = ((const CaseExpr *) expr)->location;
break;
case T_CaseWhen:
/* WHEN keyword should always be the first thing */
loc = ((CaseWhen *) expr)->location;
loc = ((const CaseWhen *) expr)->location;
break;
case T_ArrayExpr:
/* the location points at ARRAY or [, which must be leftmost */
loc = ((ArrayExpr *) expr)->location;
loc = ((const ArrayExpr *) expr)->location;
break;
case T_RowExpr:
/* the location points at ROW or (, which must be leftmost */
loc = ((RowExpr *) expr)->location;
loc = ((const RowExpr *) expr)->location;
break;
case T_RowCompareExpr:
/* just use leftmost argument's location */
loc = exprLocation((Node *) ((RowCompareExpr *) expr)->largs);
loc = exprLocation((Node *) ((const RowCompareExpr *) expr)->largs);
break;
case T_CoalesceExpr:
/* COALESCE keyword should always be the first thing */
loc = ((CoalesceExpr *) expr)->location;
loc = ((const CoalesceExpr *) expr)->location;
break;
case T_MinMaxExpr:
/* GREATEST/LEAST keyword should always be the first thing */
loc = ((MinMaxExpr *) expr)->location;
loc = ((const MinMaxExpr *) expr)->location;
break;
case T_XmlExpr:
{
XmlExpr *xexpr = (XmlExpr *) expr;
const XmlExpr *xexpr = (const XmlExpr *) expr;
/* consider both function name and leftmost arg */
loc = leftmostLoc(xexpr->location,
@ -1257,15 +1257,15 @@ exprLocation(Node *expr)
break;
case T_NullTest:
/* just use argument's location */
loc = exprLocation((Node *) ((NullTest *) expr)->arg);
loc = exprLocation((Node *) ((const NullTest *) expr)->arg);
break;
case T_BooleanTest:
/* just use argument's location */
loc = exprLocation((Node *) ((BooleanTest *) expr)->arg);
loc = exprLocation((Node *) ((const BooleanTest *) expr)->arg);
break;
case T_CoerceToDomain:
{
CoerceToDomain *cexpr = (CoerceToDomain *) expr;
const CoerceToDomain *cexpr = (const CoerceToDomain *) expr;
/* Much as above */
loc = leftmostLoc(cexpr->location,
@ -1273,18 +1273,18 @@ exprLocation(Node *expr)
}
break;
case T_CoerceToDomainValue:
loc = ((CoerceToDomainValue *) expr)->location;
loc = ((const CoerceToDomainValue *) expr)->location;
break;
case T_SetToDefault:
loc = ((SetToDefault *) expr)->location;
loc = ((const SetToDefault *) expr)->location;
break;
case T_TargetEntry:
/* just use argument's location */
loc = exprLocation((Node *) ((TargetEntry *) expr)->expr);
loc = exprLocation((Node *) ((const TargetEntry *) expr)->expr);
break;
case T_IntoClause:
/* use the contained RangeVar's location --- close enough */
loc = exprLocation((Node *) ((IntoClause *) expr)->rel);
loc = exprLocation((Node *) ((const IntoClause *) expr)->rel);
break;
case T_List:
{
@ -1292,7 +1292,7 @@ exprLocation(Node *expr)
ListCell *lc;
loc = -1; /* just to suppress compiler warning */
foreach(lc, (List *) expr)
foreach(lc, (const List *) expr)
{
loc = exprLocation((Node *) lfirst(lc));
if (loc >= 0)
@ -1302,7 +1302,7 @@ exprLocation(Node *expr)
break;
case T_A_Expr:
{
A_Expr *aexpr = (A_Expr *) expr;
const A_Expr *aexpr = (const A_Expr *) expr;
/* use leftmost of operator or left operand (if any) */
/* we assume right operand can't be to left of operator */
@ -1311,17 +1311,17 @@ exprLocation(Node *expr)
}
break;
case T_ColumnRef:
loc = ((ColumnRef *) expr)->location;
loc = ((const ColumnRef *) expr)->location;
break;
case T_ParamRef:
loc = ((ParamRef *) expr)->location;
loc = ((const ParamRef *) expr)->location;
break;
case T_A_Const:
loc = ((A_Const *) expr)->location;
loc = ((const A_Const *) expr)->location;
break;
case T_FuncCall:
{
FuncCall *fc = (FuncCall *) expr;
const FuncCall *fc = (const FuncCall *) expr;
/* consider both function name and leftmost arg */
/* (we assume any ORDER BY nodes must be to right of name) */
@ -1331,15 +1331,15 @@ exprLocation(Node *expr)
break;
case T_A_ArrayExpr:
/* the location points at ARRAY or [, which must be leftmost */
loc = ((A_ArrayExpr *) expr)->location;
loc = ((const A_ArrayExpr *) expr)->location;
break;
case T_ResTarget:
/* we need not examine the contained expression (if any) */
loc = ((ResTarget *) expr)->location;
loc = ((const ResTarget *) expr)->location;
break;
case T_TypeCast:
{
TypeCast *tc = (TypeCast *) expr;
const TypeCast *tc = (const TypeCast *) expr;
/*
* This could represent CAST(), ::, or TypeName 'literal', so
@ -1352,34 +1352,34 @@ exprLocation(Node *expr)
break;
case T_CollateClause:
/* just use argument's location */
loc = exprLocation(((CollateClause *) expr)->arg);
loc = exprLocation(((const CollateClause *) expr)->arg);
break;
case T_SortBy:
/* just use argument's location (ignore operator, if any) */
loc = exprLocation(((SortBy *) expr)->node);
loc = exprLocation(((const SortBy *) expr)->node);
break;
case T_WindowDef:
loc = ((WindowDef *) expr)->location;
loc = ((const WindowDef *) expr)->location;
break;
case T_TypeName:
loc = ((TypeName *) expr)->location;
loc = ((const TypeName *) expr)->location;
break;
case T_Constraint:
loc = ((Constraint *) expr)->location;
loc = ((const Constraint *) expr)->location;
break;
case T_XmlSerialize:
/* XMLSERIALIZE keyword should always be the first thing */
loc = ((XmlSerialize *) expr)->location;
loc = ((const XmlSerialize *) expr)->location;
break;
case T_WithClause:
loc = ((WithClause *) expr)->location;
loc = ((const WithClause *) expr)->location;
break;
case T_CommonTableExpr:
loc = ((CommonTableExpr *) expr)->location;
loc = ((const CommonTableExpr *) expr)->location;
break;
case T_PlaceHolderVar:
/* just use argument's location */
loc = exprLocation((Node *) ((PlaceHolderVar *) expr)->phexpr);
loc = exprLocation((Node *) ((const PlaceHolderVar *) expr)->phexpr);
break;
default:
/* for any other node type it's just unknown... */

440
src/backend/nodes/outfuncs.c
View File

File diff suppressed because it is too large Load Diff

34
src/backend/nodes/print.c
Unescape View File

@ -31,7 +31,7 @@
* print contents of Node to stdout
*/
void
print(void *obj)
print(const void *obj)
{
char *s;
char *f;
@ -49,7 +49,7 @@ print(void *obj)
* pretty-print contents of Node to stdout
*/
void
pprint(void *obj)
pprint(const void *obj)
{
char *s;
char *f;
@ -67,7 +67,7 @@ pprint(void *obj)
* send pretty-printed contents of Node to postmaster log
*/
void
elog_node_display(int lev, const char *title, void *obj, bool pretty)
elog_node_display(int lev, const char *title, const void *obj, bool pretty)
{
char *s;
char *f;
@ -249,9 +249,9 @@ pretty_format_node_dump(const char *dump)
* print contents of range table
*/
void
print_rt(List *rtable)
print_rt(const List *rtable)
{
ListCell *l;
const ListCell *l;
int i = 1;
printf("resno\trefname \trelid\tinFromCl\n");
@ -304,7 +304,7 @@ print_rt(List *rtable)
* print an expression
*/
void
print_expr(Node *expr, List *rtable)
print_expr(const Node *expr, const List *rtable)
{
if (expr == NULL)
{
@ -314,7 +314,7 @@ print_expr(Node *expr, List *rtable)
if (IsA(expr, Var))
{
Var *var = (Var *) expr;
const Var *var = (const Var *) expr;
char *relname,
*attname;
@ -348,7 +348,7 @@ print_expr(Node *expr, List *rtable)
}
else if (IsA(expr, Const))
{
Const *c = (Const *) expr;
const Const *c = (const Const *) expr;
Oid typoutput;
bool typIsVarlena;
char *outputstr;
@ -368,26 +368,26 @@ print_expr(Node *expr, List *rtable)
}
else if (IsA(expr, OpExpr))
{
OpExpr *e = (OpExpr *) expr;
const OpExpr *e = (const OpExpr *) expr;
char *opname;
opname = get_opname(e->opno);
if (list_length(e->args) > 1)
{
print_expr(get_leftop((Expr *) e), rtable);
print_expr(get_leftop((const Expr *) e), rtable);
printf(" %s ", ((opname != NULL) ? opname : "(invalid operator)"));
print_expr(get_rightop((Expr *) e), rtable);
print_expr(get_rightop((const Expr *) e), rtable);
}
else
{
/* we print prefix and postfix ops the same... */
printf("%s ", ((opname != NULL) ? opname : "(invalid operator)"));
print_expr(get_leftop((Expr *) e), rtable);
print_expr(get_leftop((const Expr *) e), rtable);
}
}
else if (IsA(expr, FuncExpr))
{
FuncExpr *e = (FuncExpr *) expr;
const FuncExpr *e = (const FuncExpr *) expr;
char *funcname;
ListCell *l;
@ -410,9 +410,9 @@ print_expr(Node *expr, List *rtable)
* pathkeys list of PathKeys
*/
void
print_pathkeys(List *pathkeys, List *rtable)
print_pathkeys(const List *pathkeys, const List *rtable)
{
ListCell *i;
const ListCell *i;
printf("(");
foreach(i, pathkeys)
@ -450,9 +450,9 @@ print_pathkeys(List *pathkeys, List *rtable)
* print targetlist in a more legible way.
*/
void
print_tl(List *tlist, List *rtable)
print_tl(const List *tlist, const List *rtable)
{
ListCell *tl;
const ListCell *tl;
printf("(\n");
foreach(tl, tlist)

8
src/backend/optimizer/util/clauses.c
Unescape View File

@ -181,9 +181,9 @@ make_opclause(Oid opno, Oid opresulttype, bool opretset,
* or (op expr)
*/
Node *
get_leftop(Expr *clause)
get_leftop(const Expr *clause)
{
OpExpr *expr = (OpExpr *) clause;
const OpExpr *expr = (const OpExpr *) clause;
if (expr->args != NIL)
return linitial(expr->args);
@ -198,9 +198,9 @@ get_leftop(Expr *clause)
* NB: result will be NULL if applied to a unary op clause.
*/
Node *
get_rightop(Expr *clause)
get_rightop(const Expr *clause)
{
OpExpr *expr = (OpExpr *) clause;
const OpExpr *expr = (const OpExpr *) clause;
if (list_length(expr->args) >= 2)
return lsecond(expr->args);

12
src/include/nodes/nodeFuncs.h
Unescape View File

@ -26,17 +26,17 @@
#define QTW_DONT_COPY_QUERY 0x20 /* do not copy top Query */
extern Oid exprType(Node *expr);
extern int32 exprTypmod(Node *expr);
extern bool exprIsLengthCoercion(Node *expr, int32 *coercedTypmod);
extern Oid exprType(const Node *expr);
extern int32 exprTypmod(const Node *expr);
extern bool exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod);
extern bool expression_returns_set(Node *clause);
extern Oid exprCollation(Node *expr);
extern Oid exprInputCollation(Node *expr);
extern Oid exprCollation(const Node *expr);
extern Oid exprInputCollation(const Node *expr);
extern void exprSetCollation(Node *expr, Oid collation);
extern void exprSetInputCollation(Node *expr, Oid inputcollation);
extern int exprLocation(Node *expr);
extern int exprLocation(const Node *expr);
extern bool expression_tree_walker(Node *node, bool (*walker) (),
void *context);

8
src/include/nodes/nodes.h
Unescape View File

@ -431,7 +431,7 @@ typedef struct Node
NodeTag type;
} Node;
#define nodeTag(nodeptr) (((Node*)(nodeptr))->type)
#define nodeTag(nodeptr) (((const Node*)(nodeptr))->type)
/*
* newNode -
@ -487,7 +487,7 @@ extern PGDLLIMPORT Node *newNodeMacroHolder;
/*
* nodes/{outfuncs.c,print.c}
*/
extern char *nodeToString(void *obj);
extern char *nodeToString(const void *obj);
/*
* nodes/{readfuncs.c,read.c}
@ -497,12 +497,12 @@ extern void *stringToNode(char *str);
/*
* nodes/copyfuncs.c
*/
extern void *copyObject(void *obj);
extern void *copyObject(const void *obj);
/*
* nodes/equalfuncs.c
*/
extern bool equal(void *a, void *b);
extern bool equal(const void *a, const void *b);
/*

44
src/include/nodes/pg_list.h
Unescape View File

@ -77,7 +77,7 @@ struct ListCell
#ifdef USE_INLINE
static inline ListCell *
list_head(List *l)
list_head(const List *l)
{
return l ? l->head : NULL;
}
@ -89,15 +89,15 @@ list_tail(List *l)
}
static inline int
list_length(List *l)
list_length(const List *l)
{
return l ? l->length : 0;
}
#else
extern ListCell *list_head(List *l);
extern ListCell *list_head(const List *l);
extern ListCell *list_tail(List *l);
extern int list_length(List *l);
extern int list_length(const List *l);
#endif /* USE_INLINE */
/*
@ -206,14 +206,14 @@ extern List *lcons_oid(Oid datum, List *list);
extern List *list_concat(List *list1, List *list2);
extern List *list_truncate(List *list, int new_size);
extern void *list_nth(List *list, int n);
extern int list_nth_int(List *list, int n);
extern Oid list_nth_oid(List *list, int n);
extern void *list_nth(const List *list, int n);
extern int list_nth_int(const List *list, int n);
extern Oid list_nth_oid(const List *list, int n);
extern bool list_member(List *list, void *datum);
extern bool list_member_ptr(List *list, void *datum);
extern bool list_member_int(List *list, int datum);
extern bool list_member_oid(List *list, Oid datum);
extern bool list_member(const List *list, const void *datum);
extern bool list_member_ptr(const List *list, const void *datum);
extern bool list_member_int(const List *list, int datum);
extern bool list_member_oid(const List *list, Oid datum);
extern List *list_delete(List *list, void *datum);
extern List *list_delete_ptr(List *list, void *datum);
@ -222,19 +222,19 @@ extern List *list_delete_oid(List *list, Oid datum);
extern List *list_delete_first(List *list);
extern List *list_delete_cell(List *list, ListCell *cell, ListCell *prev);
extern List *list_union(List *list1, List *list2);
extern List *list_union_ptr(List *list1, List *list2);
extern List *list_union_int(List *list1, List *list2);
extern List *list_union_oid(List *list1, List *list2);
extern List *list_union(const List *list1, const List *list2);
extern List *list_union_ptr(const List *list1, const List *list2);
extern List *list_union_int(const List *list1, const List *list2);
extern List *list_union_oid(const List *list1, const List *list2);
extern List *list_intersection(List *list1, List *list2);
extern List *list_intersection(const List *list1, const List *list2);
/* currently, there's no need for list_intersection_int etc */
extern List *list_difference(List *list1, List *list2);
extern List *list_difference_ptr(List *list1, List *list2);
extern List *list_difference_int(List *list1, List *list2);
extern List *list_difference_oid(List *list1, List *list2);
extern List *list_difference(const List *list1, const List *list2);
extern List *list_difference_ptr(const List *list1, const List *list2);
extern List *list_difference_int(const List *list1, const List *list2);
extern List *list_difference_oid(const List *list1, const List *list2);
extern List *list_append_unique(List *list, void *datum);
extern List *list_append_unique_ptr(List *list, void *datum);
@ -249,8 +249,8 @@ extern List *list_concat_unique_oid(List *list1, List *list2);
extern void list_free(List *list);
extern void list_free_deep(List *list);
extern List *list_copy(List *list);
extern List *list_copy_tail(List *list, int nskip);
extern List *list_copy(const List *list);
extern List *list_copy_tail(const List *list, int nskip);
/*
* To ease migration to the new list API, a set of compatibility

14
src/include/nodes/print.h
Unescape View File

@ -19,16 +19,16 @@
#define nodeDisplay(x) pprint(x)
extern void print(void *obj);
extern void pprint(void *obj);
extern void print(const void *obj);
extern void pprint(const void *obj);
extern void elog_node_display(int lev, const char *title,
void *obj, bool pretty);
const void *obj, bool pretty);
extern char *format_node_dump(const char *dump);
extern char *pretty_format_node_dump(const char *dump);
extern void print_rt(List *rtable);
extern void print_expr(Node *expr, List *rtable);
extern void print_pathkeys(List *pathkeys, List *rtable);
extern void print_tl(List *tlist, List *rtable);
extern void print_rt(const List *rtable);
extern void print_expr(const Node *expr, const List *rtable);
extern void print_pathkeys(const List *pathkeys, const List *rtable);
extern void print_tl(const List *tlist, const List *rtable);
extern void print_slot(TupleTableSlot *slot);
#endif /* PRINT_H */

4
src/include/optimizer/clauses.h
Unescape View File

@ -31,8 +31,8 @@ typedef struct
extern Expr *make_opclause(Oid opno, Oid opresulttype, bool opretset,
Expr *leftop, Expr *rightop,
Oid opcollid, Oid inputcollid);
extern Node *get_leftop(Expr *clause);
extern Node *get_rightop(Expr *clause);
extern Node *get_leftop(const Expr *clause);
extern Node *get_rightop(const Expr *clause);
extern bool not_clause(Node *clause);
extern Expr *make_notclause(Expr *notclause);

Write Preview
Loading…
Cancel
Save