Remove pre-order and post-order traversal logic for red-black trees.

This code isn't used, and there's no clear reason why anybody would ever
want to use it.  These traversal mechanisms don't yield a visitation order
that is semantically meaningful for any external purpose, nor are they
any faster or simpler than the left-to-right or right-to-left traversals.
(In fact, some rough testing suggests they are slower :-(.)  Moreover,
these mechanisms are impossible to test in any arm's-length fashion; doing
so requires knowledge of the red-black tree's internal implementation.
Hence, let's just jettison them.

Discussion: https://postgr.es/m/17735.1505003111@sss.pgh.pa.us

diff --git a/src/backend/lib/rbtree.c b/src/backend/lib/rbtree.c
index 3d80090a8cd4ac9b1714f766660f01a2a42a91d1..5362acc6ff96c081688d92434ec8c91c12992e89 100644 (file)
--- a/src/backend/lib/rbtree.c
+++ b/src/backend/lib/rbtree.c
@@ -62,17 +62,6 @@ struct RBTree
 
 static RBNode sentinel = {RBBLACK, RBNIL, RBNIL, NULL};
 
-/*
- * Values used in the RBTreeIterator.next_state field, with an
- * InvertedWalk iterator.
- */
-typedef enum InvertedWalkNextStep
-{
-       NextStepBegin,
-       NextStepUp,
-       NextStepLeft,
-       NextStepRight
-} InvertedWalkNextStep;
 
 /*
  * rb_create: create an empty RBTree
@@ -567,6 +556,7 @@ rb_delete_node(RBTree *rb, RBNode *z)
        RBNode     *x,
                           *y;
 
+       /* This is just paranoia: we should only get called on a valid node */
        if (!z || z == RBNIL)
                return;
 
@@ -730,114 +720,6 @@ rb_right_left_iterator(RBTreeIterator *iter)
        return iter->last_visited;
 }
 
-static RBNode *
-rb_direct_iterator(RBTreeIterator *iter)
-{
-       if (iter->last_visited == NULL)
-       {
-               iter->last_visited = iter->rb->root;
-               return iter->last_visited;
-       }
-
-       if (iter->last_visited->left != RBNIL)
-       {
-               iter->last_visited = iter->last_visited->left;
-               return iter->last_visited;
-       }
-
-       do
-       {
-               if (iter->last_visited->right != RBNIL)
-               {
-                       iter->last_visited = iter->last_visited->right;
-                       break;
-               }
-
-               /* go up and one step right */
-               for (;;)
-               {
-                       RBNode     *came_from = iter->last_visited;
-
-                       iter->last_visited = iter->last_visited->parent;
-                       if (iter->last_visited == NULL)
-                       {
-                               iter->is_over = true;
-                               break;
-                       }
-
-                       if ((iter->last_visited->right != came_from) && (iter->last_visited->right != RBNIL))
-                       {
-                               iter->last_visited = iter->last_visited->right;
-                               return iter->last_visited;
-                       }
-               }
-       }
-       while (iter->last_visited != NULL);
-
-       return iter->last_visited;
-}
-
-static RBNode *
-rb_inverted_iterator(RBTreeIterator *iter)
-{
-       RBNode     *came_from;
-       RBNode     *current;
-
-       current = iter->last_visited;
-
-loop:
-       switch ((InvertedWalkNextStep) iter->next_step)
-       {
-                       /* First call, begin from root */
-               case NextStepBegin:
-                       current = iter->rb->root;
-                       iter->next_step = NextStepLeft;
-                       goto loop;
-
-               case NextStepLeft:
-                       while (current->left != RBNIL)
-                               current = current->left;
-
-                       iter->next_step = NextStepRight;
-                       goto loop;
-
-               case NextStepRight:
-                       if (current->right != RBNIL)
-                       {
-                               current = current->right;
-                               iter->next_step = NextStepLeft;
-                               goto loop;
-                       }
-                       else                            /* not moved - return current, then go up */
-                               iter->next_step = NextStepUp;
-                       break;
-
-               case NextStepUp:
-                       came_from = current;
-                       current = current->parent;
-                       if (current == NULL)
-                       {
-                               iter->is_over = true;
-                               break;                  /* end of iteration */
-                       }
-                       else if (came_from == current->right)
-                       {
-                               /* return current, then continue to go up */
-                               break;
-                       }
-                       else
-                       {
-                               /* otherwise we came from the left */
-                               Assert(came_from == current->left);
-                               iter->next_step = NextStepRight;
-                               goto loop;
-                       }
-       }
-
-       iter->last_visited = current;
-       return current;
-}
-
 /*
  * rb_begin_iterate: prepare to traverse the tree in any of several orders
  *
@@ -849,7 +731,7 @@ loop:
  * tree are allowed.
  *
  * The iterator state is stored in the 'iter' struct.  The caller should
- * treat it as opaque struct.
+ * treat it as an opaque struct.
  */
 void
 rb_begin_iterate(RBTree *rb, RBOrderControl ctrl, RBTreeIterator *iter)
@@ -867,13 +749,6 @@ rb_begin_iterate(RBTree *rb, RBOrderControl ctrl, RBTreeIterator *iter)
                case RightLeftWalk:             /* visit right, then self, then left */
                        iter->iterate = rb_right_left_iterator;
                        break;
-               case DirectWalk:                /* visit self, then left, then right */
-                       iter->iterate = rb_direct_iterator;
-                       break;
-               case InvertedWalk:              /* visit left, then right, then self */
-                       iter->iterate = rb_inverted_iterator;
-                       iter->next_step = NextStepBegin;
-                       break;
                default:
                        elog(ERROR, "unrecognized rbtree iteration order: %d", ctrl);
        }

diff --git a/src/include/lib/rbtree.h b/src/include/lib/rbtree.h
index a7183bb0b48fe91b4c74c61854436aa724a66ce1..a4288d4fc49eaa4dfe8a790add5e2aa0f3bea772 100644 (file)
--- a/src/include/lib/rbtree.h
+++ b/src/include/lib/rbtree.h
@@ -35,9 +35,7 @@ typedef struct RBTree RBTree;
 typedef enum RBOrderControl
 {
        LeftRightWalk,                          /* inorder: left child, node, right child */
-       RightLeftWalk,                          /* reverse inorder: right, node, left */
-       DirectWalk,                                     /* preorder: node, left child, right child */
-       InvertedWalk                            /* postorder: left child, right child, node */
+       RightLeftWalk                           /* reverse inorder: right, node, left */
 } RBOrderControl;
 
 /*
@@ -52,7 +50,6 @@ struct RBTreeIterator
        RBTree     *rb;
        RBNode     *(*iterate) (RBTreeIterator *iter);
        RBNode     *last_visited;
-       char            next_step;
        bool            is_over;
 };