Enable segmentwise recompression for nullable order by columns with firstlast metadata index

Author: natalya-aksman

tsl/src/compression/api.c

@@ -715,18 +715,21 @@ decompress_chunk_impl(Chunk *uncompressed_chunk, bool if_compressed)
 }
 
 bool
-is_chunk_orderby_nonnullable(CompressionSettings *settings)
+is_chunk_orderby_nullhandling(CompressionSettings *settings)
 {
 	int num_orderby = ts_array_length(settings->fd.orderby);
 	const char *attname;
 	int attnum;
 	for (int i = 1; i <= num_orderby; i++)
 	{
-		attname = ts_array_get_element_text(settings->fd.orderby, i);
-		attnum = get_attnum(settings->fd.relid, attname);
-		if (!AttributeNumberIsValid(attnum) || !ts_get_attnotnull(settings->fd.relid, attnum))
+		if (orderby_sparse_kind(settings, i) != ORDERBY_SPARSE_FIRSTLAST)
 		{
-			return false;
+			attname = ts_array_get_element_text(settings->fd.orderby, i);
+			attnum = get_attnum(settings->fd.relid, attname);
+			if (!AttributeNumberIsValid(attnum) || !ts_get_attnotnull(settings->fd.relid, attnum))
+			{
+				return false;
+			}
 		}
 	}
 	return true;
@@ -777,19 +780,18 @@ recompress_chunk_impl(Chunk *chunk, bool recompress)
 
 		/* #9444: do not recompress when order by columns are nullable, do segmentwise
 		 * decompress/compress instead. It is due to compression min/max metadata not handling
-		 * NULLs. When we implement chunks with min/max NULL-handling metadata, this restriction can
-		 * be lifted.
+		 * NULLs. This restriction is lifted with first/last metadata index.
 		 */
-		bool nullable_orderby = !is_chunk_orderby_nonnullable(chunk_settings);
-		if (nullable_orderby)
+		bool orderby_not_handling_nulls = !is_chunk_orderby_nullhandling(chunk_settings);
+		if (orderby_not_handling_nulls)
 		{
 			elog(ts_guc_debug_compression_path_info ? INFO : DEBUG1,
-				 "in-memory recompression is disabled due to nullable order by, "
+				 "in-memory recompression is disabled due to nullable order by with no firstlast, "
 				 "performing segmentwise decompress/compress on chunk \"%s.%s\"",
 				 NameStr(chunk->fd.schema_name),
 				 NameStr(chunk->fd.table_name));
 		}
-		recompress_chunk_segmentwise_impl(chunk, nullable_orderby);
+		recompress_chunk_segmentwise_impl(chunk, orderby_not_handling_nulls);
 		recompressed = true;
 	}
 	else

tsl/src/compression/api.h

@@ -31,4 +31,4 @@ extern void compression_chunk_size_catalog_insert(int32 src_chunk_id, const Rela
 												  int64 rowcnt_frozen);
 extern Datum tsl_estimate_compressed_batch_size(PG_FUNCTION_ARGS);
 
-extern bool is_chunk_orderby_nonnullable(CompressionSettings *settings);
+extern bool is_chunk_orderby_nullhandling(CompressionSettings *settings);

tsl/src/compression/compression_dml.h

@@ -31,7 +31,7 @@ typedef struct tuple_filtering_constraints
 	bool vectorized_filtering;
 } tuple_filtering_constraints;
 
-bool slot_key_test(TupleTableSlot *slot, ScanKey skey);
+bool slot_key_test(TupleTableSlot *slot, ScanKey skey, bool nulls_first);
 
 ScanKeyData *build_mem_scankeys_from_slot(Oid ht_relid, CompressionSettings *settings,
 										  Relation out_rel,

tsl/src/compression/compression_scankey.c

@@ -27,11 +27,15 @@ static bool create_segment_filter_scankey(Relation in_rel, char *segment_filter_
  *
  * Unlike HeapKeyTest, this function takes into account SK_ISNULL
  * and works correctly when looking for null values.
+ *
+ * If slot attribute is NULL and key is NOT NULL,
+ * (key >= NULL) returns True for nulls_first
+ * and (key <= NULL) returns True for !nulls_first (i.e. for NULLS LAST).
  */
 bool
-slot_key_test(TupleTableSlot *compressed_slot, ScanKey key)
+slot_key_test(TupleTableSlot *compressed_slot, ScanKey key, bool nulls_first)
 {
-	/* No need to get the datum if we are only checking for NULLs */
+	/* No need to get the datum if we are only checking for NULL key */
 	if (key->sk_flags & SK_ISNULL)
 	{
 		return slot_attisnull(compressed_slot, key->sk_attno);
@@ -43,6 +47,20 @@ slot_key_test(TupleTableSlot *compressed_slot, ScanKey key)
 
 	if (is_null)
 	{
+		/* NULL < key i.e. NULL sorts before key argument */
+		if (nulls_first && (key->sk_strategy == BTLessStrategyNumber ||
+							key->sk_strategy == BTLessEqualStrategyNumber))
+		{
+			return true;
+		}
+
+		/* NULL > key i.e. NULL sorts after key argument */
+		if (!nulls_first && (key->sk_strategy == BTGreaterStrategyNumber ||
+							 key->sk_strategy == BTGreaterEqualStrategyNumber))
+		{
+			return true;
+		}
+
 		return false;
 	}
 

tsl/src/compression/recompress.c

@@ -122,16 +122,16 @@ tsl_recompress_chunk_segmentwise(PG_FUNCTION_ARGS)
 							"compression with no "
 							"order by")));
 		}
-		bool nullable_orderby = !is_chunk_orderby_nonnullable(settings);
-		if (nullable_orderby)
+		bool orderby_not_handling_nulls = !is_chunk_orderby_nullhandling(settings);
+		if (orderby_not_handling_nulls)
 		{
 			elog(ts_guc_debug_compression_path_info ? INFO : DEBUG1,
-				 "in-memory recompression is disabled due to nullable order by, "
+				 "in-memory recompression is disabled due to nullable order by with no firstlast, "
 				 "performing segmentwise decompress/compress on chunk \"%s.%s\"",
 				 NameStr(chunk->fd.schema_name),
 				 NameStr(chunk->fd.table_name));
 		}
-		recompress_chunk_segmentwise_impl(chunk, nullable_orderby);
+		recompress_chunk_segmentwise_impl(chunk, orderby_not_handling_nulls);
 	}
 
 	PG_RETURN_OID(uncompressed_relid);
@@ -1063,6 +1063,7 @@ update_orderby_scankeys(Datum *values, bool *isnulls, int num_segmentby, int num
 static enum Batch_match_result
 handle_null_scan(int key_flags, bool nulls_first, enum Batch_match_result result)
 {
+	/* uncompressed tuple key is NULL */
 	if (key_flags & SK_ISNULL)
 	{
 		return nulls_first ? Tuple_before : Tuple_after;
@@ -1086,18 +1087,17 @@ match_tuple_batch(TupleTableSlot *compressed_slot, int num_orderby, ScanKey orde
 	if (num_orderby >= 1)
 	{
 		ScanKey key = &orderby_scankeys[0];
-		if (!slot_key_test(compressed_slot, key))
+		if (!slot_key_test(compressed_slot, key, nulls_first[0]))
 		{
 			return handle_null_scan(key->sk_flags, nulls_first[0], Tuple_before);
 		}
 
 		key = &orderby_scankeys[1];
-		if (!slot_key_test(compressed_slot, key))
+		if (!slot_key_test(compressed_slot, key, nulls_first[0]))
 		{
 			return handle_null_scan(key->sk_flags, nulls_first[0], Tuple_after);
 		}
 	}
-
 	return Tuple_match;
 }