Fix now() plantime constification with BETWEEN

Previously when using BETWEEN ... AND additional constraints in a
WHERE clause, the BETWEEN was not handled correctly because it was
wrapped in a BoolExpr node, which prevented plantime exclusion.
The flattening of such expressions happens in `eval_const_expressions`
which gets called after our constify_now code.
This commit fixes the handling of this case to allow chunk exclusion to
take place at planning time.
Also, make sure we use our mock timestamp in all places in tests.
Previously we were using a mix of current_timestamp_mock and now(),
which was returning unexpected/incorrect results.

sql/updates/latest-dev.sql

@@ -397,3 +397,6 @@ CREATE FUNCTION _timescaledb_functions.constraint_clone(constraint_oid OID,targe
 DROP FUNCTION IF EXISTS _timescaledb_functions.chunks_in;
 DROP FUNCTION IF EXISTS _timescaledb_internal.chunks_in;
 
+
+CREATE FUNCTION _timescaledb_functions.ts_replace_now_mock()
+RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_replace_now_mock' LANGUAGE C STABLE STRICT PARALLEL SAFE;

sql/updates/reverse-dev.sql

@@ -770,3 +770,4 @@ AS 'BEGIN END' LANGUAGE PLPGSQL SET search_path TO pg_catalog,pg_temp;
 
 DROP FUNCTION IF EXISTS _timescaledb_functions.get_orderby_defaults(regclass,text[]);
 DROP FUNCTION IF EXISTS _timescaledb_functions.get_segmentby_defaults(regclass);
+DROP FUNCTION IF EXISTS _timescaledb_functions.ts_replace_now_mock();

sql/util_time.sql

@@ -46,3 +46,6 @@ RETURNS INT8 AS '@MODULE_PATHNAME@', 'ts_continuous_agg_watermark_materialized'
 
 CREATE OR REPLACE FUNCTION _timescaledb_functions.subtract_integer_from_now( hypertable_relid REGCLASS, lag INT8 )
 RETURNS INT8 AS '@MODULE_PATHNAME@', 'ts_subtract_integer_from_now' LANGUAGE C STABLE STRICT;
+
+CREATE OR REPLACE FUNCTION _timescaledb_functions.ts_replace_now_mock()
+RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_replace_now_mock' LANGUAGE C STABLE STRICT PARALLEL SAFE;

src/planner/constify_now.c

@@ -44,7 +44,7 @@ get_hypertable_dimension(Oid relid, int flags)
 	return hyperspace_get_open_dimension(ht->space, 0);
 }
 
-static bool
+bool
 is_valid_now_func(Node *node)
 {
 	if (IsA(node, FuncExpr) && castNode(FuncExpr, node)->funcid == F_NOW)
@@ -147,7 +147,6 @@ make_now_const()
 					 FLOAT8PASSBYVAL);
 }
 
-/* returns a copy of the expression with the now() call constified */
 /*
  * op will be OpExpr with Var > now() - Expr
  */
@@ -249,17 +248,11 @@ ts_constify_now(PlannerInfo *root, List *rtable, Node *node)
 
 			foreach (lc, be->args)
 			{
-				if (IsA(lfirst(lc), OpExpr) && is_valid_now_expr(lfirst_node(OpExpr, lc), rtable))
-				{
-					OpExpr *op = lfirst_node(OpExpr, lc);
-					additions = lappend(additions, constify_now_expr(root, op));
-				}
+				additions = lappend(additions, ts_constify_now(root, rtable, (Node *) lfirst(lc)));
 			}
 
 			if (additions)
-			{
-				be->args = list_concat(be->args, additions);
-			}
+				be->args = additions;
 
 			break;
 		}

src/planner/planner.c

@@ -37,6 +37,7 @@
 #include <optimizer/plancat.h>
 #include <parser/analyze.h>
 #include <tcop/tcopprot.h>
+#include <utils/fmgrprotos.h>
 #include "compat/compat-msvc-exit.h"
 
 #include <math.h>
@@ -279,6 +280,47 @@ typedef struct
 	PlannerInfo *root;
 } PreprocessQueryContext;
 
+void
+replace_now_mock_walker(PlannerInfo *root, Node *clause, Oid funcid)
+{
+	// whenever we encounter a FuncExpr with now(), replace it with the supplied funcid
+	switch (nodeTag(clause))
+	{
+		case T_FuncExpr:
+		{
+			if (is_valid_now_func(clause))
+			{
+				FuncExpr *fe = castNode(FuncExpr, clause);
+				fe->funcid = funcid;
+				return;
+			}
+			break; // keep compiler happy
+		}
+		case T_OpExpr:
+		{
+			ListCell *lc;
+			OpExpr *oe = castNode(OpExpr, clause);
+			foreach (lc, oe->args)
+			{
+				replace_now_mock_walker(root, (Node *) lfirst(lc), funcid);
+			}
+			break;
+		}
+		case T_BoolExpr:
+		{
+			ListCell *lc;
+			BoolExpr *be = castNode(BoolExpr, clause);
+			foreach (lc, be->args)
+			{
+				replace_now_mock_walker(root, (Node *) lfirst(lc), funcid);
+			}
+			break;
+		}
+		default:
+			return;
+	}
+}
+
 /*
  * Preprocess the query tree, including, e.g., subqueries.
  *
@@ -310,6 +352,20 @@ preprocess_query(Node *node, PreprocessQueryContext *context)
 			{
 				from->quals =
 					ts_constify_now(context->root, context->current_query->rtable, from->quals);
+#ifdef TS_DEBUG
+				/*
+				 * only replace if GUC is also set. This is used for testing purposes only,
+				 * so no need to change the output for other tests in DEBUG builds
+				 */
+				if (ts_current_timestamp_mock != NULL && strlen(ts_current_timestamp_mock) != 0)
+				{
+					Oid funcid_mock;
+					const char *funcname = "_timescaledb_functions.ts_replace_now_mock()";
+					funcid_mock = DatumGetObjectId(
+						DirectFunctionCall1(regprocedurein, CStringGetDatum(funcname)));
+					replace_now_mock_walker(context->root, from->quals, funcid_mock);
+				}
+#endif
 			}
 			/*
 			 * We only amend space constraints for UPDATE/DELETE and SELECT FOR UPDATE

src/time_utils.c

@@ -567,3 +567,24 @@ ts_get_mock_time_or_current_time(void)
 	return res;
 }
 #endif
+
+TS_FUNCTION_INFO_V1(ts_replace_now_mock);
+
+/* return mock time for testing */
+Datum
+ts_replace_now_mock(PG_FUNCTION_ARGS)
+{
+	Datum res;
+#ifdef TS_DEBUG
+	if (ts_current_timestamp_mock != NULL && strlen(ts_current_timestamp_mock) != 0)
+	{
+		res = DirectFunctionCall3(timestamptz_in,
+								  CStringGetDatum(ts_current_timestamp_mock),
+								  0,
+								  Int32GetDatum(-1));
+		return res;
+	}
+#endif
+	res = TimestampTzGetDatum(GetCurrentTimestamp());
+	return res;
+}

src/time_utils.h

@@ -91,3 +91,5 @@ extern TSDLLEXPORT int64 ts_subtract_integer_from_now_saturating(Oid now_func, i
 #ifdef TS_DEBUG
 extern TSDLLEXPORT Datum ts_get_mock_time_or_current_time(void);
 #endif
+
+bool is_valid_now_func(Node *node);

src/utils.h

@@ -246,3 +246,5 @@ ts_get_relation_relid(char const *schema_name, char const *relation_name, bool r
 		return InvalidOid;
 	}
 }
+
+void replace_now_mock_walker(PlannerInfo *root, Node *clause, Oid funcid);