diff options
Diffstat (limited to 'src/backend/executor/nodeMergejoin.c')
| -rw-r--r-- | src/backend/executor/nodeMergejoin.c | 164 |
1 files changed, 80 insertions, 84 deletions
diff --git a/src/backend/executor/nodeMergejoin.c b/src/backend/executor/nodeMergejoin.c index 6c49f9df690..1d85605c4a5 100644 --- a/src/backend/executor/nodeMergejoin.c +++ b/src/backend/executor/nodeMergejoin.c @@ -7,7 +7,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.21 1999/02/13 23:15:24 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.22 1999/02/22 19:40:10 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -26,12 +26,12 @@ * Skip Inner SKIPINNER * mark inner position JOINMARK * do forever { - - * while (outer ** inner) { JOINTEST + * while (outer == inner) { JOINTEST * join tuples JOINTUPLES * advance inner position NEXTINNER * } - * advance outer position NEXTOUTER - * if (outer ** mark) { TESTOUTER + * if (outer == mark) { TESTOUTER * restore inner position to mark TESTOUTER * continue - * } else { - @@ -42,7 +42,7 @@ * } - * * Skip Outer { SKIPOUTER - * if (inner ** outer) Join Tuples JOINTUPLES + * if (inner == outer) Join Tuples JOINTUPLES * while (outer < inner) SKIPOUTER * advance outer SKIPOUTER * if (outer > inner) SKIPOUTER @@ -50,7 +50,7 @@ * } - * * Skip Inner { SKIPINNER - * if (inner ** outer) Join Tuples JOINTUPLES + * if (inner == outer) Join Tuples JOINTUPLES * while (outer > inner) SKIPINNER * advance inner SKIPINNER * if (outer < inner) SKIPINNER @@ -475,13 +475,13 @@ ExecMergeJoin(MergeJoin *node) switch (mergestate->mj_JoinState) { - /* - * ******************************** EXEC_MJ_INITIALIZE + /* --------------------------------------------------- + * EXEC_MJ_INITIALIZE * means that this is the first time ExecMergeJoin() has * been called and so we have to initialize the inner, * outer and marked tuples as well as various stuff in the - * expression context. ******************************** - * + * expression context. + * --------------------------------------------------- */ case EXEC_MJ_INITIALIZE: MJ_printf("ExecMergeJoin: EXEC_MJ_INITIALIZE\n"); @@ -513,7 +513,7 @@ ExecMergeJoin(MergeJoin *node) econtext->ecxt_outertuple = outerTupleSlot; mergestate->mj_MarkedTupleSlot->ttc_tupleDescriptor = - innerTupleSlot->ttc_tupleDescriptor; + innerTupleSlot->ttc_tupleDescriptor; /* ---------------- * initialize merge join state to skip inner tuples. @@ -522,12 +522,12 @@ ExecMergeJoin(MergeJoin *node) mergestate->mj_JoinState = EXEC_MJ_SKIPINNER; break; - /* - * ******************************** EXEC_MJ_JOINMARK means - * we have just found a new outer tuple and a possible + /* --------------------------------------------------- + * EXEC_MJ_JOINMARK + * means we have just found a new outer tuple and a possible * matching inner tuple. This is the case after the - * INITIALIZE, SKIPOUTER or SKIPINNER states. ******************************** - * + * INITIALIZE, SKIPOUTER or SKIPINNER states. + * ---------------------------------------------------- */ case EXEC_MJ_JOINMARK: MJ_printf("ExecMergeJoin: EXEC_MJ_JOINMARK\n"); @@ -538,16 +538,16 @@ ExecMergeJoin(MergeJoin *node) mergestate->mj_JoinState = EXEC_MJ_JOINTEST; break; - /* - * ******************************** EXEC_MJ_JOINTEST means - * we have two tuples which might satisify the merge + /* ---------------------------------------------------- + * EXEC_MJ_JOINTEST + * means we have two tuples which might satisify the merge * clause, so we test them. * * If they do satisify, then we join them and move on to the * next inner tuple (EXEC_MJ_JOINTUPLES). * - * If they do not satisify then advance to next outer tuple. ******************************** - * + * If they do not satisify then advance to next outer tuple. + * ------------------------------------------------------ */ case EXEC_MJ_JOINTEST: MJ_printf("ExecMergeJoin: EXEC_MJ_JOINTEST\n"); @@ -561,12 +561,12 @@ ExecMergeJoin(MergeJoin *node) mergestate->mj_JoinState = EXEC_MJ_NEXTOUTER; break; - /* - * ******************************** EXEC_MJ_JOINTUPLES + /* ---------------------------------------------------- + * EXEC_MJ_JOINTUPLES * means we have two tuples which satisified the merge * clause so we join them and then proceed to get the next - * inner tuple (EXEC_NEXT_INNER). ******************************** - * + * inner tuple (EXEC_NEXT_INNER). + * ---------------------------------------------------- */ case EXEC_MJ_JOINTUPLES: MJ_printf("ExecMergeJoin: EXEC_MJ_JOINTUPLES\n"); @@ -596,12 +596,12 @@ ExecMergeJoin(MergeJoin *node) } break; - /* - * ******************************** EXEC_MJ_NEXTINNER + /* -------------------------------------------------- + * EXEC_MJ_NEXTINNER * means advance the inner scan to the next tuple. If the * tuple is not nil, we then proceed to test it against - * the join qualification. ******************************** - * + * the join qualification. + * ---------------------------------------------------- */ case EXEC_MJ_NEXTINNER: MJ_printf("ExecMergeJoin: EXEC_MJ_NEXTINNER\n"); @@ -620,18 +620,20 @@ ExecMergeJoin(MergeJoin *node) mergestate->mj_JoinState = EXEC_MJ_JOINTEST; break; - /* - * ******************************** EXEC_MJ_NEXTOUTER + /* -------------------------------------------------- + * EXEC_MJ_NEXTOUTER * means - * - * outer inner outer tuple - 5 5 - marked tuple 5 5 - * 6 6 - inner tuple 7 7 + * outer inner + * outer tuple - 5 5 - marked tuple + * 5 5 + * 6 6 - inner tuple + * 7 7 * * we know we just bumped into the first inner tuple > * current outer tuple so get a new outer tuple and then * proceed to test it against the marked tuple - * (EXEC_MJ_TESTOUTER) ******************************** - * + * (EXEC_MJ_TESTOUTER) + * ------------------------------------------------- */ case EXEC_MJ_NEXTOUTER: MJ_printf("ExecMergeJoin: EXEC_MJ_NEXTOUTER\n"); @@ -654,35 +656,40 @@ ExecMergeJoin(MergeJoin *node) mergestate->mj_JoinState = EXEC_MJ_TESTOUTER; break; - /* - * ******************************** EXEC_MJ_TESTOUTER If - * the new outer tuple and the marked tuple satisify the + /* --------------------------------------------------- + * EXEC_MJ_TESTOUTER + * If the new outer tuple and the marked tuple satisify the * merge clause then we know we have duplicates in the * outer scan so we have to restore the inner scan to the * marked tuple and proceed to join the new outer tuples * with the inner tuples (EXEC_MJ_JOINTEST) * * This is the case when + * outer inner + * 4 5 - marked tuple + * outer tuple - 5 5 + * new outer tuple - 5 5 + * 6 8 - inner tuple + * 7 12 * - * outer inner 4 5 - marked tuple outer tuple - 5 5 - * new outer tuple - 5 5 6 8 - inner tuple 7 12 + * new outer tuple = marked tuple * - * new outer tuple = marked tuple + * If the outer tuple fails the test, then we know we have + * to proceed to skip outer tuples until outer >= inner + * (EXEC_MJ_SKIPOUTER). * - * If the outer tuple fails the test, then we know we have to - * proceed to skip outer tuples until outer >= inner - * (EXEC_MJ_SKIPOUTER). + * This is the case when * - * This is the case when + * outer inner + * 5 5 - marked tuple + * outer tuple - 5 5 + * new outer tuple - 6 8 - inner tuple + * 7 12 * - * outer inner 5 5 - marked tuple outer tuple - 5 5 - * new outer tuple - 6 8 - inner tuple 7 12 - * - * new outer tuple > marked tuple - * - *************************** * + * new outer tuple > marked tuple * + * ----------------------------------------------------------- */ case EXEC_MJ_TESTOUTER: MJ_printf("ExecMergeJoin: EXEC_MJ_TESTOUTER\n"); @@ -746,27 +753,23 @@ ExecMergeJoin(MergeJoin *node) } break; - /* - * ******************************** EXEC_MJ_SKIPOUTER + /* -------------------------------------------------- + * EXEC_MJ_SKIPOUTER * means skip over tuples in the outer plan until we find * an outer tuple > current inner tuple. * * For example: * - * outer inner 5 5 5 5 outer tuple - 6 8 - - * inner tuple 7 12 8 14 + * outer inner + * 5 5 + * 5 5 + * outer tuple - 6 8 - inner tuple + * 7 12 + * 8 14 * - * we have to advance the outer scan until we find the outer + * We have to advance the outer scan until we find the outer * 8. - * - ************************** - * - * - * - * - * - * - * + * ------------------------------------------------ */ case EXEC_MJ_SKIPOUTER: MJ_printf("ExecMergeJoin: EXEC_MJ_SKIPOUTER\n"); @@ -848,27 +851,22 @@ ExecMergeJoin(MergeJoin *node) mergestate->mj_JoinState = EXEC_MJ_JOINMARK; break; - /* - * ******************************** EXEC_MJ_SKIPINNER + /* ------------------------------------------------ + * EXEC_MJ_SKIPINNER * means skip over tuples in the inner plan until we find * an inner tuple > current outer tuple. * * For example: + * outer inner + * 5 5 + * 5 5 + * outer tuple - 12 8 - inner tuple + * 14 10 + * 17 12 * - * outer inner 5 5 5 5 outer tuple - 12 8 - inner - * tuple 14 10 17 12 - * - * we have to advance the inner scan until we find the inner + * We have to advance the inner scan until we find the inner * 12. - * - ************************** - * - * - * - * - * - * - * + * --------------------------------------------------- */ case EXEC_MJ_SKIPINNER: MJ_printf("ExecMergeJoin: EXEC_MJ_SKIPINNER\n"); @@ -971,10 +969,8 @@ ExecMergeJoin(MergeJoin *node) break; /* - * ******************************** if we get here it - * means our code is fucked up and so we just end the join - * prematurely. ******************************** - * + * If we get here it means our code is messed up and so we + * just end the join prematurely. */ default: elog(NOTICE, "ExecMergeJoin: invalid join state. aborting"); |