[CBRD-26386] Evaluating analytic functions in qexec_end_one_iteration for OVER clauses without PARTITION BY or ORDER BY

src/parser/view_transform.c

@@ -425,7 +425,6 @@ static PT_NODE *mq_update_analytic_sort_spec_expr (PARSER_CONTEXT * parser, PT_N
 static PT_NODE *mq_inline_cte_pre (PARSER_CONTEXT * parser, PT_NODE * node, void *arg, int *continue_walk);
 static PT_NODE *mq_rewrite_cte_as_derived (PARSER_CONTEXT * parser, PT_NODE * node, void *arg, int *continue_walk);
 static PT_NODE *mq_count_cte_references (PARSER_CONTEXT * parser, PT_NODE * node, void *arg, int *continue_walk);
-static PT_NODE *mq_check_inline_cte (PARSER_CONTEXT * parser, PT_NODE * node, void *arg, int *continue_walk);
 static void mq_check_cte_inline_or_materialize (PARSER_CONTEXT * parser, PT_NODE * node);
 /*
  * mq_is_outer_join_spec () - determine if a spec is outer joined in a spec list
@@ -5292,7 +5291,7 @@ mq_check_cte_inline_or_materialize (PARSER_CONTEXT * parser, PT_NODE * node)
 {
   PT_NODE *cte;
   PT_HINT_ENUM hint;
-  bool is_inlinable = true;
+  bool has_click_counter = false;
 
   assert (node->node_type == PT_WITH_CLAUSE);
 
@@ -5311,14 +5310,14 @@ mq_check_cte_inline_or_materialize (PARSER_CONTEXT * parser, PT_NODE * node)
 	  continue;
 	}
 
-      is_inlinable = true;
+      has_click_counter = false;
       /* CTE containing functions like incr, rownum etc. cannot be rewritten as inline view
        * since it may change the query results. Handle it same as CTE with materialize hint. */
       (void) parser_walk_tree (parser, cte->info.cte.non_recursive_part,
-			       mq_check_inline_cte, &is_inlinable, NULL, NULL);
+			       mq_has_click_counter, &has_click_counter, NULL, NULL);
 
       /* false subquery cannot be rewritten as inline view */
-      if (is_inlinable && pt_is_query (cte->info.cte.non_recursive_part))
+      if (!has_click_counter && pt_is_query (cte->info.cte.non_recursive_part))
 	{
 	  hint = pt_get_hint_from_query (parser, cte->info.cte.non_recursive_part);
 
@@ -5398,16 +5397,16 @@ mq_count_cte_references (PARSER_CONTEXT * parser, PT_NODE * node, void *arg, int
 }
 
 /*
- * mq_check_inline_cte () -
+ * mq_has_click_counter () -
  *   return:
  *   parser(in):
  *   node(in):
  *   arg(in):
  */
-static PT_NODE *
-mq_check_inline_cte (PARSER_CONTEXT * parser, PT_NODE * node, void *arg, int *continue_walk)
+PT_NODE *
+mq_has_click_counter (PARSER_CONTEXT * parser, PT_NODE * node, void *arg, int *continue_walk)
 {
-  bool *can_inlining = (bool *) arg;
+  bool *has_click_counter = (bool *) arg;
 
   if (node == NULL)
     {
@@ -5416,11 +5415,10 @@ mq_check_inline_cte (PARSER_CONTEXT * parser, PT_NODE * node, void *arg, int *co
 
   switch (node->node_type)
     {
-      /* CTE cannot contain WITH clause inside, so we don't need to handle this case */
     case PT_EXPR:
       if (node->info.expr.op == PT_INCR || node->info.expr.op == PT_DECR)
 	{
-	  *can_inlining = false;
+	  *has_click_counter = true;
 	  *continue_walk = PT_STOP_WALK;
 	}
       break;

src/parser/view_transform.h

@@ -98,4 +98,6 @@ extern PT_NODE *mq_rewrite_aggregate_as_derived (PARSER_CONTEXT * parser, PT_NOD
 extern PT_NODE *mq_rewrite_query_as_derived (PARSER_CONTEXT * parser, PT_NODE * query);
 
 extern int mq_copypush_sargable_terms (PARSER_CONTEXT * parser, PT_NODE * statement, PT_NODE * spec);
+
+extern PT_NODE *mq_has_click_counter (PARSER_CONTEXT * parser, PT_NODE * node, void *arg, int *continue_walk);
 #endif /* _VIEW_TRANSFORM_H_ */

src/parser/xasl_generation.c

@@ -639,6 +639,8 @@ static PT_NODE *pt_check_corr_subquery_not_cachable_expr (PARSER_CONTEXT * parse
 static PT_NODE *pt_make_result_ref (PARSER_CONTEXT * parser, PT_NODE * node, PT_NODE * groupby_list,
 				    VAL_LIST * vallist);
 
+static int pt_check_analytic_limit_optimization (XASL_NODE * xasl, ANALYTIC_EVAL_TYPE * eval_list);
+
 static void
 pt_init_xasl_supp_info ()
 {
@@ -16595,6 +16597,17 @@ pt_to_buildlist_proc (PARSER_CONTEXT * parser, PT_NODE * select_node, QO_PLAN *
 	      goto analytic_exit_on_error;
 	    }
 
+	  int *attr_offsets;
+	  attr_offsets = pt_make_identity_offsets (select_list_ex);
+
+	  buildlist->a_scan_regu_list =
+	    pt_to_regu_variable_list (parser, select_list_ex, UNBOX_AS_VALUE, buildlist->a_val_list, attr_offsets);
+
+	  if (attr_offsets != NULL)
+	    {
+	      free_and_init (attr_offsets);
+	    }
+
 	  /* generate regu list (identity fetching from temp tuple) */
 	  buildlist->a_regu_list =
 	    pt_to_position_regu_variable_list (parser, select_list_ex, buildlist->a_val_list, NULL);
@@ -16640,6 +16653,52 @@ pt_to_buildlist_proc (PARSER_CONTEXT * parser, PT_NODE * select_node, QO_PLAN *
 	  /* optimize analytic function list */
 	  xasl->proc.buildlist.a_eval_list = pt_optimize_analytic_list (parser, &analytic_info, &no_optimization_done);
 
+	  if (pt_check_analytic_limit_optimization (xasl, xasl->proc.buildlist.a_eval_list) != NO_ERROR)
+	    {
+	      PT_ERRORm (parser, select_list_ex, MSGCAT_SET_PARSER_SEMANTIC, MSGCAT_SEMANTIC_OUT_OF_MEMORY);
+	      goto analytic_exit_on_error;
+	    }
+
+
+	  if (XASL_IS_FLAGED (xasl, XASL_ANALYTIC_USES_LIMIT_OPT))
+	    {
+	      PT_NODE *final_node = NULL;
+	      REGU_VARIABLE_LIST regu_list_new, prev = NULL;
+	      REGU_VARIABLE *regu_var_temp;
+
+	      for (final_node = select_list_final; final_node != NULL; final_node = final_node->next)
+		{
+		  if (pt_is_instnum (final_node))
+		    {
+		      buildlist->a_outptr_list_ex->valptr_cnt++;
+
+		      regu_alloc (regu_list_new);
+		      if (regu_list_new == NULL)
+			{
+			  goto analytic_exit_on_error;
+			}
+
+		      regu_var_temp = pt_make_regu_numbering (parser, final_node);
+		      regu_list_new->value = *regu_var_temp;
+
+		      if (prev == NULL)
+			{
+			  prev = regu_list_new;
+			  regu_list_new->next = buildlist->a_outptr_list_ex->valptrp;
+			  buildlist->a_outptr_list_ex->valptrp = regu_list_new;
+			}
+		      else
+			{
+			  regu_list_new->next = prev->next;
+			  prev->next = regu_list_new;
+			}
+		      prev = prev->next;
+		    }
+
+		  prev = (prev != NULL) ? prev->next : buildlist->a_outptr_list_ex->valptrp;
+		}
+	    }
+
 	  /* FIXME - Fix it with pt_build_analytic_eval_list (). */
 	  if (no_optimization_done == true)
 	    {
@@ -16739,7 +16798,14 @@ pt_to_buildlist_proc (PARSER_CONTEXT * parser, PT_NODE * select_node, QO_PLAN *
 	  select_list_ex = NULL;
 
 	  /* register initial outlist */
-	  xasl->outptr_list = buildlist->a_outptr_list_ex;
+	  if (XASL_IS_FLAGED (xasl, XASL_ANALYTIC_USES_LIMIT_OPT))
+	    {
+	      xasl->outptr_list = buildlist->a_outptr_list;
+	    }
+	  else
+	    {
+	      xasl->outptr_list = buildlist->a_outptr_list_ex;
+	    }
 
 	  /* all done */
 	  goto analytic_exit;
@@ -16935,7 +17001,7 @@ pt_to_buildlist_proc (PARSER_CONTEXT * parser, PT_NODE * select_node, QO_PLAN *
 	}
 
       if ((xasl->instnum_pred != NULL || xasl->instnum_flag & XASL_INSTNUM_FLAG_EVAL_DEFER)
-	  && pt_has_analytic (parser, select_node))
+	  && pt_has_analytic (parser, select_node) && !XASL_IS_FLAGED (xasl, XASL_ANALYTIC_USES_LIMIT_OPT))
 	{
 	  /* we have an inst_num() which should not get evaluated in the initial fetch(processing stage)
 	   * qexec_execute_analytic(post-processing stage) will use it in the final sort */
@@ -24428,6 +24494,11 @@ pt_to_analytic_final_node (PARSER_CONTEXT * parser, PT_NODE * tree, PT_NODE ** e
       return NULL;
     }
 
+  if (PT_IS_VALUE_NODE (tree))
+    {
+      return tree;
+    }
+
   if (PT_IS_ANALYTIC_NODE (tree))
     {
       /* select ntile(select stddev(...)...)... from ... is allowed */
@@ -25050,6 +25121,11 @@ pt_substitute_analytic_references (PARSER_CONTEXT * parser, PT_NODE * node, PT_N
       return node;
     }
 
+  if (PT_IS_VALUE_NODE (node))
+    {
+      return node;
+    }
+
   if (PT_IS_POINTER_REF_NODE (node))
     {
       PT_NODE *real_node = node->info.pointer.node;
@@ -28241,3 +28317,62 @@ pt_make_result_ref (PARSER_CONTEXT * parser, PT_NODE * node, PT_NODE * groupby_l
 
   return new_node;
 }
+
+/*
+ * pt_check_analytic_limit_optimization () -
+ *   Check if analytic functions are optimizable for limit optimization.
+ *   If optimizable, set the XASL_ANALYTIC_USES_LIMIT_OPT flag.
+ * 
+ * return :
+ * xasl (in)  :
+ * eval_list (in) :
+ */
+static int
+pt_check_analytic_limit_optimization (XASL_NODE * xasl, ANALYTIC_EVAL_TYPE * eval_list)
+{
+  ANALYTIC_EVAL_TYPE *eval;
+  ANALYTIC_TYPE *a_func_list;
+  bool is_optimizable = false;
+
+  if (!xasl->instnum_pred && !xasl->instnum_val)
+    {
+      return NO_ERROR;
+    }
+
+  /* NOTE: If eval->sort_list is NULL, eval_list length is always 1.
+   *       If eval_list length >= 2, all eval entries have non-NULL sort_list.
+   *       Since we check sort_list == NULL here, checking only one eval is sufficient. */
+  for (eval = eval_list; eval != NULL; eval = eval->next)
+    {
+      is_optimizable = !(eval->sort_list) ? true : false;
+
+      for (a_func_list = eval->head; a_func_list && is_optimizable; a_func_list = a_func_list->next)
+	{
+	  switch (a_func_list->function)
+	    {
+	    case PT_FIRST_VALUE:
+	      if (a_func_list->ignore_nulls)
+		{
+		  is_optimizable = false;
+		  break;
+		}
+
+	    case PT_ROW_NUMBER:
+	    case PT_RANK:
+	    case PT_DENSE_RANK:
+	      break;
+
+	    default:
+	      is_optimizable = false;
+	      break;
+	    }
+	}
+    }
+
+  if (is_optimizable)
+    {
+      XASL_SET_FLAG (xasl, XASL_ANALYTIC_USES_LIMIT_OPT);
+    }
+
+  return NO_ERROR;
+}

src/query/parallel/px_heap_scan/px_heap_scan_checker.cpp

@@ -503,7 +503,14 @@ namespace parallel_heap_scan
 	  }
 	if (xasl->proc.buildlist.a_eval_list)
 	  {
-	    result = CHECK_RESULT::PARALLEL_LIST_MERGE;
+	    if (XASL_IS_FLAGED (xasl, XASL_ANALYTIC_USES_LIMIT_OPT))
+	      {
+		result = CHECK_RESULT::PARALLEL_PAGE_BY_PAGE;
+	      }
+	    else
+	      {
+		result = CHECK_RESULT::PARALLEL_LIST_MERGE;
+	      }
 	  }
 	break;
       case BUILDVALUE_PROC: