Sort node for ORDER BY is suppressed if choosen index scan will

allways present tuples in the requested order.

Jan

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 8edcfcd4f02de2a9b991e41c29058917651fea4a..0008caddeead6927a72d30c47efd885668919f3c 100644 (file)
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.39 1999/02/02 17:46:14 momjian Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.40 1999/02/03 19:31:24 wieck Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -50,6 +50,12 @@
 
 #include "executor/executor.h"
 
+#include "utils/builtins.h"
+#include "utils/syscache.h"
+#include "access/genam.h"
+#include "parser/parse_oper.h"
+
+static bool need_sortplan(List *sortcls, Plan *plan);
 static Plan *make_sortplan(List *tlist, List *sortcls, Plan *plannode);
 extern Plan *make_groupPlan(List **tlist, bool tuplePerGroup,
               List *groupClause, Plan *subplan);
@@ -344,7 +350,7 @@ union_planner(Query *parse)
    }
    else
    {
-       if (parse->sortClause)
+       if (parse->sortClause && need_sortplan(parse->sortClause, result_plan))
            return (make_sortplan(tlist, parse->sortClause, result_plan));
        else
            return ((Plan *) result_plan);
@@ -572,3 +578,170 @@ pg_checkretval(Oid rettype, QueryTreeList *queryTreeList)
    /* success */
    return;
 }
+
+
+/* ----------
+ * Support function for need_sortplan
+ * ----------
+ */
+static TargetEntry *
+get_matching_tle(Plan *plan, Resdom *resdom)
+{
+   List        *i;
+   TargetEntry *tle;
+
+   foreach (i, plan->targetlist) {
+       tle = (TargetEntry *)lfirst(i);
+       if (tle->resdom->resno == resdom->resno)
+           return tle;
+   }
+   return NULL;
+}
+
+
+/* ----------
+ * Check if a user requested ORDER BY is already satisfied by
+ * the choosen index scan.
+ *
+ * Returns TRUE if sort is required, FALSE if can be omitted.
+ * ----------
+ */
+static bool
+need_sortplan(List *sortcls, Plan *plan)
+{
+   Relation    indexRel;
+   IndexScan   *indexScan;
+   Oid     indexId;
+   List        *i;
+   HeapTuple   htup;
+   Form_pg_index   index_tup;
+   int     key_no = 0;
+
+   /* ----------
+    * Must be an IndexScan
+    * ----------
+    */
+   if (nodeTag(plan) != T_IndexScan) {
+       return TRUE;
+   }
+
+   indexScan = (IndexScan *)plan;
+
+   /* ----------
+    * Should not have left- or righttree
+    * ----------
+    */
+   if (plan->lefttree != NULL) {
+       return TRUE;
+   }
+   if (plan->righttree != NULL) {
+       return TRUE;
+   }
+
+   /* ----------
+    * Must be a single index scan
+    * ----------
+    */
+   if (length(indexScan->indxid) != 1) {
+       return TRUE;
+   }
+
+   /* ----------
+    * Indices can only have up to 8 attributes. So an ORDER BY using
+    * more that 8 attributes could never be satisfied by an index.
+    * ----------
+    */
+   if (length(sortcls) > 8) {
+       return TRUE;
+   }
+
+   /* ----------
+    * The choosen Index must be a btree
+    * ----------
+    */
+   indexId = lfirsti(indexScan->indxid);
+
+   indexRel = index_open(indexId);
+   if (strcmp(nameout(&(indexRel->rd_am->amname)), "btree") != 0) {
+       heap_close(indexRel);
+       return TRUE;
+   }
+   heap_close(indexRel);
+
+   /* ----------
+    * Fetch the index tuple
+    * ----------
+    */
+   htup = SearchSysCacheTuple(INDEXRELID,
+           ObjectIdGetDatum(indexId), 0, 0, 0);
+   if (!HeapTupleIsValid(htup)) {
+       elog(ERROR, "cache lookup for index %d failed", indexId);
+   }
+   index_tup = (Form_pg_index) GETSTRUCT(htup);
+
+   /* ----------
+    * Check if all the sort clauses match the attributes in the index
+    * ----------
+    */
+   foreach (i, sortcls) {
+       SortClause  *sortcl;
+       Resdom      *resdom;
+       TargetEntry *tle;
+       Var     *var;
+
+       sortcl = (SortClause *) lfirst(i);
+
+       resdom = sortcl->resdom;
+       tle = get_matching_tle(plan, resdom);
+       if (tle == NULL) {
+           /* ----------
+            * Could this happen?
+            * ----------
+            */
+           return TRUE;
+       }
+       if (nodeTag(tle->expr) != T_Var) {
+           /* ----------
+            * The target list expression isn't a var, so it
+            * cannot be the indexed attribute
+            * ----------
+            */
+           return TRUE;
+       }
+       var = (Var *)(tle->expr);
+
+       if (var->varno != indexScan->scan.scanrelid) {
+           /* ----------
+            * This Var isn't from the scan relation. So it isn't
+            * that of the index
+            * ----------
+            */
+           return TRUE;
+       }
+
+       if (var->varattno != index_tup->indkey[key_no]) {
+           /* ----------
+            * It isn't the indexed attribute.
+            * ----------
+            */
+           return TRUE;
+       }
+
+       if (oprid(oper("<", resdom->restype, resdom->restype, FALSE)) != sortcl->opoid) {
+           /* ----------
+            * Sort order isn't in ascending order.
+            * ----------
+            */
+           return TRUE;
+       }
+
+       key_no++;
+   }
+
+   /* ----------
+    * Index matches ORDER BY - sort not required
+    * ----------
+    */
+   return FALSE;
+}
+