diff options
Diffstat (limited to 'src/backend/nodes/equalfuncs.c')
| -rw-r--r-- | src/backend/nodes/equalfuncs.c | 1149 |
1 files changed, 583 insertions, 566 deletions
diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c index 4a8a072d33f..792c8783f99 100644 --- a/src/backend/nodes/equalfuncs.c +++ b/src/backend/nodes/equalfuncs.c @@ -1,13 +1,13 @@ /*------------------------------------------------------------------------- * * equalfuncs.c-- - * equal functions to compare the nodes + * equal functions to compare the nodes * * Copyright (c) 1994, Regents of the University of California * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.6 1997/08/19 21:31:36 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.7 1997/09/07 04:42:44 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -26,700 +26,717 @@ #include "utils/elog.h" #include "storage/itemptr.h" -static bool equali(List *a, List *b); +static bool equali(List * a, List * b); /* - * Stuff from primnodes.h + * Stuff from primnodes.h */ /* - * Resdom is a subclass of Node. + * Resdom is a subclass of Node. */ -static bool -_equalResdom(Resdom *a, Resdom *b) +static bool +_equalResdom(Resdom * a, Resdom * b) { - if (a->resno != b->resno) - return (false); - if (a->restype != b->restype) - return (false); - if (a->reslen != b->reslen) - return (false); - if (strcmp(a->resname, b->resname) != 0) - return (false); - if (a->reskey != b->reskey) - return (false); - if (a->reskeyop != b->reskeyop) - return (false); - - return (true); + if (a->resno != b->resno) + return (false); + if (a->restype != b->restype) + return (false); + if (a->reslen != b->reslen) + return (false); + if (strcmp(a->resname, b->resname) != 0) + return (false); + if (a->reskey != b->reskey) + return (false); + if (a->reskeyop != b->reskeyop) + return (false); + + return (true); } -static bool -_equalFjoin(Fjoin *a, Fjoin *b) +static bool +_equalFjoin(Fjoin * a, Fjoin * b) { - int nNodes; - - if (a->fj_initialized != b->fj_initialized) - return (false); - if (a->fj_nNodes != b->fj_nNodes) - return (false); - if (!equal(a->fj_innerNode, b->fj_innerNode)) - return (false); - - nNodes = a->fj_nNodes; - if (memcmp(a->fj_results, b->fj_results, nNodes*sizeof(Datum)) != 0) - return (false); - if (memcmp(a->fj_alwaysDone, b->fj_alwaysDone, nNodes*sizeof(bool)) != 0) - return (false); - - return(true); + int nNodes; + + if (a->fj_initialized != b->fj_initialized) + return (false); + if (a->fj_nNodes != b->fj_nNodes) + return (false); + if (!equal(a->fj_innerNode, b->fj_innerNode)) + return (false); + + nNodes = a->fj_nNodes; + if (memcmp(a->fj_results, b->fj_results, nNodes * sizeof(Datum)) != 0) + return (false); + if (memcmp(a->fj_alwaysDone, b->fj_alwaysDone, nNodes * sizeof(bool)) != 0) + return (false); + + return (true); } /* - * Expr is a subclass of Node. + * Expr is a subclass of Node. */ -static bool -_equalExpr(Expr *a, Expr *b) +static bool +_equalExpr(Expr * a, Expr * b) { - if (a->opType != b->opType) - return (false); - if (!equal(a->oper, b->oper)) - return (false); - if (!equal(a->args, b->args)) - return (false); - - return (true); + if (a->opType != b->opType) + return (false); + if (!equal(a->oper, b->oper)) + return (false); + if (!equal(a->args, b->args)) + return (false); + + return (true); } -static bool -_equalIter(Iter *a, Iter *b) +static bool +_equalIter(Iter * a, Iter * b) { - return (equal(a->iterexpr, b->iterexpr)); + return (equal(a->iterexpr, b->iterexpr)); } -static bool -_equalStream(Stream *a, Stream *b) +static bool +_equalStream(Stream * a, Stream * b) { - if (a->clausetype != b->clausetype) - return(false); - if (a->groupup != b->groupup) - return(false); - if (a->groupcost != b->groupcost) - return(false); - if (a->groupsel != b->groupsel) - return(false); - if (!equal(a->pathptr, b->pathptr)) - return(false); - if (!equal(a->cinfo, b->cinfo)) - return(false); - if (!equal(a->upstream, b->upstream)) - return(false); - return(equal(a->downstream, b->downstream)); + if (a->clausetype != b->clausetype) + return (false); + if (a->groupup != b->groupup) + return (false); + if (a->groupcost != b->groupcost) + return (false); + if (a->groupsel != b->groupsel) + return (false); + if (!equal(a->pathptr, b->pathptr)) + return (false); + if (!equal(a->cinfo, b->cinfo)) + return (false); + if (!equal(a->upstream, b->upstream)) + return (false); + return (equal(a->downstream, b->downstream)); } /* - * Var is a subclass of Expr. + * Var is a subclass of Expr. */ -static bool -_equalVar(Var *a, Var *b) +static bool +_equalVar(Var * a, Var * b) { - if (a->varno != b->varno) - return (false); - if (a->varattno != b->varattno) - return (false); - if (a->vartype != b->vartype) - return (false); - if (a->varnoold != b->varnoold) - return (false); - if (a->varoattno != b->varoattno) - return (false); - - return (true); + if (a->varno != b->varno) + return (false); + if (a->varattno != b->varattno) + return (false); + if (a->vartype != b->vartype) + return (false); + if (a->varnoold != b->varnoold) + return (false); + if (a->varoattno != b->varoattno) + return (false); + + return (true); } -static bool -_equalArray(Array *a, Array *b) +static bool +_equalArray(Array * a, Array * b) { - if (a->arrayelemtype != b->arrayelemtype) - return (false); - if (a->arrayndim != b->arrayndim) - return (false); - if (a->arraylow.indx[0] != b->arraylow.indx[0]) - return (false); - if (a->arrayhigh.indx[0] != b->arrayhigh.indx[0]) - return (false); - if (a->arraylen != b->arraylen) - return (false); - return(TRUE); + if (a->arrayelemtype != b->arrayelemtype) + return (false); + if (a->arrayndim != b->arrayndim) + return (false); + if (a->arraylow.indx[0] != b->arraylow.indx[0]) + return (false); + if (a->arrayhigh.indx[0] != b->arrayhigh.indx[0]) + return (false); + if (a->arraylen != b->arraylen) + return (false); + return (TRUE); } -static bool -_equalArrayRef(ArrayRef *a, ArrayRef *b) +static bool +_equalArrayRef(ArrayRef * a, ArrayRef * b) { - if (a->refelemtype != b->refelemtype) - return (false); - if (a->refattrlength != b->refattrlength) - return (false); - if (a->refelemlength != b->refelemlength) - return (false); - if (a->refelembyval != b->refelembyval) - return (false); - if (!equal(a->refupperindexpr, b->refupperindexpr)) - return (false); - if (!equal(a->reflowerindexpr, b->reflowerindexpr)) - return (false); - if (!equal(a->refexpr, b->refexpr)) - return (false); - return (equal(a->refassgnexpr, b->refassgnexpr)); + if (a->refelemtype != b->refelemtype) + return (false); + if (a->refattrlength != b->refattrlength) + return (false); + if (a->refelemlength != b->refelemlength) + return (false); + if (a->refelembyval != b->refelembyval) + return (false); + if (!equal(a->refupperindexpr, b->refupperindexpr)) + return (false); + if (!equal(a->reflowerindexpr, b->reflowerindexpr)) + return (false); + if (!equal(a->refexpr, b->refexpr)) + return (false); + return (equal(a->refassgnexpr, b->refassgnexpr)); } /* - * Oper is a subclass of Expr. + * Oper is a subclass of Expr. */ -static bool -_equalOper(Oper *a, Oper *b) +static bool +_equalOper(Oper * a, Oper * b) { - if (a->opno != b->opno) - return (false); - if (a->opresulttype != b->opresulttype) - return (false); - - return (true); + if (a->opno != b->opno) + return (false); + if (a->opresulttype != b->opresulttype) + return (false); + + return (true); } /* - * Const is a subclass of Expr. + * Const is a subclass of Expr. */ -static bool -_equalConst(Const *a, Const *b) +static bool +_equalConst(Const * a, Const * b) { - /* - ** this function used to do a pointer compare on a and b. That's - ** ridiculous. -- JMH, 7/11/92 - */ - if (a->consttype != b->consttype) - return(false); - if (a->constlen != b->constlen) - return(false); - if (a->constisnull != b->constisnull) - return(false); - if (a->constbyval != b->constbyval) - return(false); - return(datumIsEqual(a->constvalue, b->constvalue, - a->consttype, a->constbyval, a->constlen)); + + /* + * * this function used to do a pointer compare on a and b. That's * + * ridiculous. -- JMH, 7/11/92 + */ + if (a->consttype != b->consttype) + return (false); + if (a->constlen != b->constlen) + return (false); + if (a->constisnull != b->constisnull) + return (false); + if (a->constbyval != b->constbyval) + return (false); + return (datumIsEqual(a->constvalue, b->constvalue, + a->consttype, a->constbyval, a->constlen)); } /* - * Param is a subclass of Expr. + * Param is a subclass of Expr. */ -static bool -_equalParam(Param *a, Param *b) +static bool +_equalParam(Param * a, Param * b) { - if (a->paramkind != b->paramkind) - return (false); - if (a->paramtype != b->paramtype) - return (false); - if (!equal(a->param_tlist, b->param_tlist)) - return (false); - - switch (a->paramkind) { - case PARAM_NAMED: - case PARAM_NEW: - case PARAM_OLD: - if (strcmp(a->paramname, b->paramname) != 0) - return (false); - break; - case PARAM_NUM: - if (a->paramid != b->paramid) - return (false); - break; - case PARAM_INVALID: - /* - * XXX: Hmmm... What are we supposed to return - * in this case ?? - */ - return(true); - break; - default: - elog(WARN, "_equalParam: Invalid paramkind value: %d", - a->paramkind); - } - - return (true); + if (a->paramkind != b->paramkind) + return (false); + if (a->paramtype != b->paramtype) + return (false); + if (!equal(a->param_tlist, b->param_tlist)) + return (false); + + switch (a->paramkind) + { + case PARAM_NAMED: + case PARAM_NEW: + case PARAM_OLD: + if (strcmp(a->paramname, b->paramname) != 0) + return (false); + break; + case PARAM_NUM: + if (a->paramid != b->paramid) + return (false); + break; + case PARAM_INVALID: + + /* + * XXX: Hmmm... What are we supposed to return in this case ?? + */ + return (true); + break; + default: + elog(WARN, "_equalParam: Invalid paramkind value: %d", + a->paramkind); + } + + return (true); } /* - * Func is a subclass of Expr. + * Func is a subclass of Expr. */ -static bool -_equalFunc(Func *a, Func *b) +static bool +_equalFunc(Func * a, Func * b) { - if (a->funcid != b->funcid) - return (false); - if (a->functype != b->functype) - return (false); - if (a->funcisindex != b->funcisindex) - return (false); - if (a->funcsize != b->funcsize) - return (false); - if (!equal(a->func_tlist, b->func_tlist)) - return (false); - if (!equal(a->func_planlist, b->func_planlist)) - return (false); - - return (true); + if (a->funcid != b->funcid) + return (false); + if (a->functype != b->functype) + return (false); + if (a->funcisindex != b->funcisindex) + return (false); + if (a->funcsize != b->funcsize) + return (false); + if (!equal(a->func_tlist, b->func_tlist)) + return (false); + if (!equal(a->func_planlist, b->func_planlist)) + return (false); + + return (true); } /* * CInfo is a subclass of Node. */ -static bool -_equalCInfo(CInfo *a, CInfo *b) +static bool +_equalCInfo(CInfo * a, CInfo * b) { - Assert(IsA(a,CInfo)); - Assert(IsA(b,CInfo)); - - if (!equal(a->clause, b->clause)) - return(false); - if (a->selectivity != b->selectivity) - return(false); - if (a->notclause != b->notclause) - return(false); + Assert(IsA(a, CInfo)); + Assert(IsA(b, CInfo)); + + if (!equal(a->clause, b->clause)) + return (false); + if (a->selectivity != b->selectivity) + return (false); + if (a->notclause != b->notclause) + return (false); #ifdef EqualMergeOrderExists - if (!EqualMergeOrder(a->mergesortorder,b->mergesortorder)) - return(false); + if (!EqualMergeOrder(a->mergesortorder, b->mergesortorder)) + return (false); #endif - if(a->hashjoinoperator != b->hashjoinoperator) - return(false); - return(equal((a->indexids), - (b->indexids))); + if (a->hashjoinoperator != b->hashjoinoperator) + return (false); + return (equal((a->indexids), + (b->indexids))); } -static bool -_equalJoinMethod(JoinMethod *a, JoinMethod *b) +static bool +_equalJoinMethod(JoinMethod * a, JoinMethod * b) { - Assert(IsA(a,JoinMethod)); - Assert(IsA(b,JoinMethod)); - - if (!equal((a->jmkeys), - (b->jmkeys))) - return(false); - if (!equal((a->clauses), - (b->clauses))) - return(false); - return(true); + Assert(IsA(a, JoinMethod)); + Assert(IsA(b, JoinMethod)); + + if (!equal((a->jmkeys), + (b->jmkeys))) + return (false); + if (!equal((a->clauses), + (b->clauses))) + return (false); + return (true); } -static bool -_equalPath(Path *a, Path *b) +static bool +_equalPath(Path * a, Path * b) { - if (a->pathtype != b->pathtype) - return(false); - if (a->parent != b->parent) - return(false); - /* - if (a->path_cost != b->path_cost) - return(false); - */ - if (a->p_ordering.ordtype == SORTOP_ORDER) { - int i = 0; - if (a->p_ordering.ord.sortop==NULL || - b->p_ordering.ord.sortop==NULL) { - - if (a->p_ordering.ord.sortop != b->p_ordering.ord.sortop) - return false; - } else { - while(a->p_ordering.ord.sortop[i]!=0 && - b->p_ordering.ord.sortop[i]!=0) { - if (a->p_ordering.ord.sortop[i] != b->p_ordering.ord.sortop[i]) - return false; - i++; - } - if (a->p_ordering.ord.sortop[i]!=0 || - b->p_ordering.ord.sortop[i]!=0) - return false; + if (a->pathtype != b->pathtype) + return (false); + if (a->parent != b->parent) + return (false); + + /* + * if (a->path_cost != b->path_cost) return(false); + */ + if (a->p_ordering.ordtype == SORTOP_ORDER) + { + int i = 0; + + if (a->p_ordering.ord.sortop == NULL || + b->p_ordering.ord.sortop == NULL) + { + + if (a->p_ordering.ord.sortop != b->p_ordering.ord.sortop) + return false; + } + else + { + while (a->p_ordering.ord.sortop[i] != 0 && + b->p_ordering.ord.sortop[i] != 0) + { + if (a->p_ordering.ord.sortop[i] != b->p_ordering.ord.sortop[i]) + return false; + i++; + } + if (a->p_ordering.ord.sortop[i] != 0 || + b->p_ordering.ord.sortop[i] != 0) + return false; + } + } + else + { + if (!equal((a->p_ordering.ord.merge), + (b->p_ordering.ord.merge))) + return (false); } - } else { - if (!equal((a->p_ordering.ord.merge), - (b->p_ordering.ord.merge))) - return(false); - } - if (!equal((a->keys), - (b->keys))) - return(false); - /* - if (a->outerjoincost != b->outerjoincost) - return(false); - */ - if (!equali((a->joinid), - (b->joinid))) - return(false); - return(true); + if (!equal((a->keys), + (b->keys))) + return (false); + + /* + * if (a->outerjoincost != b->outerjoincost) return(false); + */ + if (!equali((a->joinid), + (b->joinid))) + return (false); + return (true); } -static bool -_equalIndexPath(IndexPath *a, IndexPath *b) +static bool +_equalIndexPath(IndexPath * a, IndexPath * b) { - if (!_equalPath((Path*)a,(Path*)b)) - return(false); - if (!equali((a->indexid), (b->indexid))) - return(false); - if (!equal((a->indexqual), (b->indexqual))) - return(false); - return(true); + if (!_equalPath((Path *) a, (Path *) b)) + return (false); + if (!equali((a->indexid), (b->indexid))) + return (false); + if (!equal((a->indexqual), (b->indexqual))) + return (false); + return (true); } -static bool -_equalJoinPath(JoinPath *a,JoinPath *b) +static bool +_equalJoinPath(JoinPath * a, JoinPath * b) { - Assert(IsA_JoinPath(a)); - Assert(IsA_JoinPath(b)); - - if (!_equalPath((Path*)a,(Path*)b)) - return(false); - if (!equal((a->pathclauseinfo), (b->pathclauseinfo))) - return(false); - if (!equal((a->outerjoinpath), (b->outerjoinpath))) - return(false); - if (!equal((a->innerjoinpath), (b->innerjoinpath))) - return(false); - return(true); + Assert(IsA_JoinPath(a)); + Assert(IsA_JoinPath(b)); + + if (!_equalPath((Path *) a, (Path *) b)) + return (false); + if (!equal((a->pathclauseinfo), (b->pathclauseinfo))) + return (false); + if (!equal((a->outerjoinpath), (b->outerjoinpath))) + return (false); + if (!equal((a->innerjoinpath), (b->innerjoinpath))) + return (false); + return (true); } -static bool -_equalMergePath(MergePath *a, MergePath *b) +static bool +_equalMergePath(MergePath * a, MergePath * b) { - Assert(IsA(a,MergePath)); - Assert(IsA(b,MergePath)); - - if (!_equalJoinPath((JoinPath*)a,(JoinPath*)b)) - return(false); - if (!equal((a->path_mergeclauses), (b->path_mergeclauses))) - return(false); - if (!equal((a->outersortkeys), (b->outersortkeys))) - return(false); - if (!equal((a->innersortkeys), (b->innersortkeys))) - return(false); - return(true); + Assert(IsA(a, MergePath)); + Assert(IsA(b, MergePath)); + + if (!_equalJoinPath((JoinPath *) a, (JoinPath *) b)) + return (false); + if (!equal((a->path_mergeclauses), (b->path_mergeclauses))) + return (false); + if (!equal((a->outersortkeys), (b->outersortkeys))) + return (false); + if (!equal((a->innersortkeys), (b->innersortkeys))) + return (false); + return (true); } -static bool -_equalHashPath(HashPath *a, HashPath *b) +static bool +_equalHashPath(HashPath * a, HashPath * b) { - Assert(IsA(a,HashPath)); - Assert(IsA(b,HashPath)); - - if (!_equalJoinPath((JoinPath*)a,(JoinPath*)b)) - return(false); - if (!equal((a->path_hashclauses), (b->path_hashclauses))) - return(false); - if (!equal((a->outerhashkeys), (b->outerhashkeys))) - return(false); - if (!equal((a->innerhashkeys), (b->innerhashkeys))) - return(false); - return(true); + Assert(IsA(a, HashPath)); + Assert(IsA(b, HashPath)); + + if (!_equalJoinPath((JoinPath *) a, (JoinPath *) b)) + return (false); + if (!equal((a->path_hashclauses), (b->path_hashclauses))) + return (false); + if (!equal((a->outerhashkeys), (b->outerhashkeys))) + return (false); + if (!equal((a->innerhashkeys), (b->innerhashkeys))) + return (false); + return (true); } -static bool -_equalJoinKey(JoinKey *a, JoinKey *b) +static bool +_equalJoinKey(JoinKey * a, JoinKey * b) { - Assert(IsA(a,JoinKey)); - Assert(IsA(b,JoinKey)); - - if (!equal((a->outer),(b->outer))) - return(false); - if (!equal((a->inner),(b->inner))) - return(false); - return(true); + Assert(IsA(a, JoinKey)); + Assert(IsA(b, JoinKey)); + + if (!equal((a->outer), (b->outer))) + return (false); + if (!equal((a->inner), (b->inner))) + return (false); + return (true); } -static bool -_equalMergeOrder(MergeOrder *a, MergeOrder *b) +static bool +_equalMergeOrder(MergeOrder * a, MergeOrder * b) { - if (a == (MergeOrder*)NULL && b == (MergeOrder*)NULL) - return(true); - Assert(IsA(a,MergeOrder)); - Assert(IsA(b,MergeOrder)); - - if (a->join_operator != b->join_operator) - return(false); - if (a->left_operator != b->left_operator) - return(false); - if (a->right_operator != b->right_operator) - return(false); - if (a->left_type != b->left_type) - return(false); - if (a->right_type != b->right_type) - return(false); - return(true); + if (a == (MergeOrder *) NULL && b == (MergeOrder *) NULL) + return (true); + Assert(IsA(a, MergeOrder)); + Assert(IsA(b, MergeOrder)); + + if (a->join_operator != b->join_operator) + return (false); + if (a->left_operator != b->left_operator) + return (false); + if (a->right_operator != b->right_operator) + return (false); + if (a->left_type != b->left_type) + return (false); + if (a->right_type != b->right_type) + return (false); + return (true); } -static bool -_equalHInfo(HInfo *a, HInfo *b) +static bool +_equalHInfo(HInfo * a, HInfo * b) { - Assert(IsA(a,HInfo)); - Assert(IsA(b,HInfo)); - - if (a->hashop != b->hashop) - return(false); - return(true); + Assert(IsA(a, HInfo)); + Assert(IsA(b, HInfo)); + + if (a->hashop != b->hashop) + return (false); + return (true); } -/* XXX This equality function is a quick hack, should be - * fixed to compare all fields. +/* XXX This equality function is a quick hack, should be + * fixed to compare all fields. */ -static bool -_equalIndexScan(IndexScan *a, IndexScan *b) +static bool +_equalIndexScan(IndexScan * a, IndexScan * b) { - Assert(IsA(a,IndexScan)); - Assert(IsA(b,IndexScan)); - - /* - if(a->scan.plan.cost != b->scan.plan.cost) - return(false); - */ - - if (!equal((a->indxqual),(b->indxqual))) - return(false); - - if (a->scan.scanrelid != b->scan.scanrelid) - return(false); - - if (!equali((a->indxid),(b->indxid))) - return(false); - return(true); + Assert(IsA(a, IndexScan)); + Assert(IsA(b, IndexScan)); + + /* + * if(a->scan.plan.cost != b->scan.plan.cost) return(false); + */ + + if (!equal((a->indxqual), (b->indxqual))) + return (false); + + if (a->scan.scanrelid != b->scan.scanrelid) + return (false); + + if (!equali((a->indxid), (b->indxid))) + return (false); + return (true); } -static bool -_equalJInfo(JInfo *a, JInfo *b) +static bool +_equalJInfo(JInfo * a, JInfo * b) { - Assert(IsA(a,JInfo)); - Assert(IsA(b,JInfo)); - if (!equal((a->otherrels),(b->otherrels))) - return(false); - if (!equal((a->jinfoclauseinfo),(b->jinfoclauseinfo))) - return(false); - if (a->mergesortable != b->mergesortable) - return(false); - if (a->hashjoinable != b->hashjoinable) - return(false); - return(true); + Assert(IsA(a, JInfo)); + Assert(IsA(b, JInfo)); + if (!equal((a->otherrels), (b->otherrels))) + return (false); + if (!equal((a->jinfoclauseinfo), (b->jinfoclauseinfo))) + return (false); + if (a->mergesortable != b->mergesortable) + return (false); + if (a->hashjoinable != b->hashjoinable) + return (false); + return (true); } /* - * Stuff from execnodes.h + * Stuff from execnodes.h */ /* - * EState is a subclass of Node. + * EState is a subclass of Node. */ -static bool -_equalEState(EState *a, EState *b) +static bool +_equalEState(EState * a, EState * b) { - if (a->es_direction != b->es_direction) - return (false); - - if (!equal(a->es_range_table, b->es_range_table)) - return (false); - - if (a->es_result_relation_info != b->es_result_relation_info) - return (false); - - return (true); + if (a->es_direction != b->es_direction) + return (false); + + if (!equal(a->es_range_table, b->es_range_table)) + return (false); + + if (a->es_result_relation_info != b->es_result_relation_info) + return (false); + + return (true); } -static bool -_equalTargetEntry(TargetEntry *a, TargetEntry *b) +static bool +_equalTargetEntry(TargetEntry * a, TargetEntry * b) { - if (!equal(a->resdom,b->resdom)) - return(false); - if (!equal(a->fjoin,b->fjoin)) - return(false); - if (!equal(a->expr,b->expr)) - return(false); - - return(true); + if (!equal(a->resdom, b->resdom)) + return (false); + if (!equal(a->fjoin, b->fjoin)) + return (false); + if (!equal(a->expr, b->expr)) + return (false); + + return (true); } /* - * equal -- are two lists equal? + * equal -- are two lists equal? * - * This is a comparison by value. It would be simpler to write it - * to be recursive, but it should run faster if we iterate. + * This is a comparison by value. It would be simpler to write it + * to be recursive, but it should run faster if we iterate. */ -static bool -_equalValue(Value *a, Value *b) +static bool +_equalValue(Value * a, Value * b) { - if (a->type != b->type) - return (false); - - switch(a->type) { - case T_String: - return strcmp(a->val.str, b->val.str); - case T_Integer: - return (a->val.ival==b->val.ival); - case T_Float: - return (a->val.dval==b->val.dval); - default: - break; - } - - return (true); + if (a->type != b->type) + return (false); + + switch (a->type) + { + case T_String: + return strcmp(a->val.str, b->val.str); + case T_Integer: + return (a->val.ival == b->val.ival); + case T_Float: + return (a->val.dval == b->val.dval); + default: + break; + } + + return (true); } /* * equal-- - * returns whether two nodes are equal + * returns whether two nodes are equal */ bool equal(void *a, void *b) { - bool retval=false; - - if (a == b) - return(true); - /* - * note that a!=b, so only one of them can be NULL - */ - if (a==NULL || b==NULL) - return (false); - /* - * are they the same type of nodes? - */ - if (nodeTag(a)!=nodeTag(b)) - return (false); - - switch(nodeTag(a)) { - case T_Resdom: - retval = _equalResdom(a, b); - break; - case T_Fjoin: - retval = _equalFjoin(a, b); - break; - case T_Expr: - retval = _equalExpr(a, b); - break; - case T_TargetEntry: - retval = _equalTargetEntry(a,b); - break; - case T_Iter: - retval = _equalIter(a, b); - break; - case T_Stream: - retval = _equalStream(a, b); - break; - case T_Var: - retval = _equalVar(a, b); - break; - case T_Array: - retval = _equalArray(a, b); - break; - case T_ArrayRef: - retval = _equalArrayRef(a, b); - break; - case T_Oper: - retval = _equalOper(a, b); - break; - case T_Const: - retval = _equalConst(a, b); - break; - case T_Param: - retval = _equalParam(a, b); - break; - case T_Func: - retval = _equalFunc(a, b); - break; - case T_CInfo: - retval = _equalCInfo(a, b); - break; - case T_JoinMethod: - retval = _equalJoinMethod(a, b); - break; - case T_Path: - retval = _equalPath(a, b); - break; - case T_IndexPath: - retval = _equalIndexPath(a, b); - break; - case T_JoinPath: - retval = _equalJoinPath(a, b); - break; - case T_MergePath: - retval = _equalMergePath(a, b); - break; - case T_HashPath: - retval = _equalHashPath(a, b); - break; - case T_JoinKey: - retval = _equalJoinKey(a, b); - break; - case T_MergeOrder: - retval = _equalMergeOrder(a, b); - break; - case T_HInfo: - retval = _equalHInfo(a, b); - break; - case T_IndexScan: - retval = _equalIndexScan(a, b); - break; - case T_JInfo: - retval = _equalJInfo(a, b); - break; - case T_EState: - retval = _equalEState(a, b); - break; - case T_Integer: case T_String: case T_Float: - retval = _equalValue(a, b); - break; - case T_List: - { - List *la = (List*)a; - List *lb = (List*)b; - List *l; + bool retval = false; - if (a==NULL && b==NULL) + if (a == b) return (true); - if (length(a)!=length(b)) + + /* + * note that a!=b, so only one of them can be NULL + */ + if (a == NULL || b == NULL) return (false); - foreach(l, la) { - if (!equal(lfirst(l), lfirst(lb))) - return (false); - lb = lnext(lb); - } - retval = true; + + /* + * are they the same type of nodes? + */ + if (nodeTag(a) != nodeTag(b)) + return (false); + + switch (nodeTag(a)) + { + case T_Resdom: + retval = _equalResdom(a, b); + break; + case T_Fjoin: + retval = _equalFjoin(a, b); + break; + case T_Expr: + retval = _equalExpr(a, b); + break; + case T_TargetEntry: + retval = _equalTargetEntry(a, b); + break; + case T_Iter: + retval = _equalIter(a, b); + break; + case T_Stream: + retval = _equalStream(a, b); + break; + case T_Var: + retval = _equalVar(a, b); + break; + case T_Array: + retval = _equalArray(a, b); + break; + case T_ArrayRef: + retval = _equalArrayRef(a, b); + break; + case T_Oper: + retval = _equalOper(a, b); + break; + case T_Const: + retval = _equalConst(a, b); + break; + case T_Param: + retval = _equalParam(a, b); + break; + case T_Func: + retval = _equalFunc(a, b); + break; + case T_CInfo: + retval = _equalCInfo(a, b); + break; + case T_JoinMethod: + retval = _equalJoinMethod(a, b); + break; + case T_Path: + retval = _equalPath(a, b); + break; + case T_IndexPath: + retval = _equalIndexPath(a, b); + break; + case T_JoinPath: + retval = _equalJoinPath(a, b); + break; + case T_MergePath: + retval = _equalMergePath(a, b); + break; + case T_HashPath: + retval = _equalHashPath(a, b); + break; + case T_JoinKey: + retval = _equalJoinKey(a, b); + break; + case T_MergeOrder: + retval = _equalMergeOrder(a, b); + break; + case T_HInfo: + retval = _equalHInfo(a, b); + break; + case T_IndexScan: + retval = _equalIndexScan(a, b); + break; + case T_JInfo: + retval = _equalJInfo(a, b); + break; + case T_EState: + retval = _equalEState(a, b); + break; + case T_Integer: + case T_String: + case T_Float: + retval = _equalValue(a, b); + break; + case T_List: + { + List *la = (List *) a; + List *lb = (List *) b; + List *l; + + if (a == NULL && b == NULL) + return (true); + if (length(a) != length(b)) + return (false); + foreach(l, la) + { + if (!equal(lfirst(l), lfirst(lb))) + return (false); + lb = lnext(lb); + } + retval = true; + } + break; + default: + elog(NOTICE, "equal: don't know whether nodes of type %d are equal", + nodeTag(a)); + break; } - break; - default: - elog(NOTICE, "equal: don't know whether nodes of type %d are equal", - nodeTag(a)); - break; - } - - return retval; + + return retval; } /* * equali-- - * compares two lists of integers + * compares two lists of integers * * XXX temp hack. needs something like T_IntList */ -static bool -equali(List *a, List *b) -{ - List *la = (List*)a; - List *lb = (List*)b; - List *l; - - if (a==NULL && b==NULL) - return (true); - if (length(a)!=length(b)) - return (false); - foreach(l, la) { - if (lfirsti(l) != lfirsti(lb)) - return (false); - lb = lnext(lb); - } - return true; +static bool +equali(List * a, List * b) +{ + List *la = (List *) a; + List *lb = (List *) b; + List *l; + + if (a == NULL && b == NULL) + return (true); + if (length(a) != length(b)) + return (false); + foreach(l, la) + { + if (lfirsti(l) != lfirsti(lb)) + return (false); + lb = lnext(lb); + } + return true; } |