Refine error messages of unsupported column type

Yifei-yang7 · Yifei-yang7 · commit 07767abcf0c0 · 2025-06-04T23:55:47.000Z
diff --git a/src/gpu_expression_executor.cpp b/src/gpu_expression_executor.cpp
@@ -45,7 +45,8 @@ GPUExpressionExecutor::HandleBinaryConstantExpression(shared_ptr<GPUColumn> colu
         double constant = expr.value.GetValue<double>();
         return ResolveTypeBinaryConstantExpression<double>(column, constant, gpuBufferManager, function_name);
       } default:
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleBinaryConstantExpression`: %d",
+                                      static_cast<int>(column->data_wrapper.type));
     }
 }
 
@@ -83,7 +84,8 @@ GPUExpressionExecutor::HandleBinaryExpression(shared_ptr<GPUColumn> column1, sha
       case ColumnType::FLOAT64:
         return ResolveTypeBinaryExpression<double>(column1, column2, gpuBufferManager, function_name);
       default:
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleBinaryExpression`: %d",
+                                      static_cast<int>(column1->data_wrapper.type));
     }
 }
 
@@ -145,7 +147,8 @@ GPUExpressionExecutor::HandleComparisonConstantExpression(shared_ptr<GPUColumn>
         ResolveTypeComparisonConstantExpression<uint8_t>(column, expr1, expr2, count, row_ids, expression_type);
         break;
       default:
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleComparisonConstantExpression`: %d",
+                                      static_cast<int>(column->data_wrapper.type));
     }
 }
 
@@ -195,7 +198,8 @@ GPUExpressionExecutor::HandleComparisonExpression(shared_ptr<GPUColumn> column1,
         ResolveTypeComparisonExpression<double>(column1, column2, count, row_ids, expression_type);
         break;
       default:
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleComparisonExpression`: %d",
+                                      static_cast<int>(column1->data_wrapper.type));
     }
 }
 
@@ -218,7 +222,8 @@ GPUExpressionExecutor::HandleRoundExpression(shared_ptr<GPUColumn> column, int d
         shared_ptr<GPUColumn> result = make_shared_ptr<GPUColumn>(size, column->data_wrapper.type, reinterpret_cast<uint8_t*>(c));
         return result;
       } default:
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleRoundExpression`: %d",
+                                      static_cast<int>(column->data_wrapper.type));
     }
 }
 
diff --git a/src/include/gpu_columns.hpp b/src/include/gpu_columns.hpp
@@ -46,7 +46,8 @@ inline ColumnType convertLogicalTypeToColumnType(LogicalType type) {
             column_type = ColumnType::VARCHAR;
             break;
         default:
-            throw InvalidInputException("Unsupported column type");
+            throw InvalidInputException("Unsupported column type in `convertLogicalTypeToColumnType`: %d",
+                                        static_cast<int>(type.id()));
             break;
     }
     return column_type;
diff --git a/src/operator/gpu_materialize.cpp b/src/operator/gpu_materialize.cpp
@@ -69,7 +69,8 @@ HandleMaterializeExpression(shared_ptr<GPUColumn> column, BoundReferenceExpressi
         case ColumnType::VARCHAR:
             return ResolveTypeMaterializeString(column, bound_ref, gpuBufferManager);
         default:
-            throw NotImplementedException("Unsupported column type");
+            throw NotImplementedException("Unsupported column type in `HandleMaterializeExpression`: {}",
+                                          static_cast<int>(column->data_wrapper.type));
     }
 }
 
diff --git a/src/operator/gpu_physical_grouped_aggregate.cpp b/src/operator/gpu_physical_grouped_aggregate.cpp
@@ -53,7 +53,8 @@ CombineColumns(shared_ptr<GPUColumn> column1, shared_ptr<GPUColumn> column2, GPU
 		return ResolveTypeCombineStrings(column1, column2, gpuBufferManager);
 		break;
 	  default:
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `CombineColumns: %d",
+																			static_cast<int>(column1->data_wrapper.type));
     }
 }
 
@@ -259,7 +260,8 @@ HandleGroupByAggregateExpression(vector<shared_ptr<GPUColumn>> &group_by_keys, v
 		} else if (aggregate_type == ColumnType::FLOAT64) {
 			ResolveTypeGroupByString<double>(group_by_keys, aggregate_keys, gpuBufferManager, aggregates, num_group_keys);
 		} else {
-			throw NotImplementedException("Unsupported column type");
+			throw NotImplementedException("Unsupported column type in `HandleGroupByAggregateExpression`: {}",
+																		static_cast<int>(aggregate_type));
 		}
 	} else {
 		//check if all the group by keys are all integers
@@ -274,12 +276,13 @@ HandleGroupByAggregateExpression(vector<shared_ptr<GPUColumn>> &group_by_keys, v
 				ResolveTypeGroupByAggregateExpression<uint64_t, uint64_t>(group_by_keys, aggregate_keys, gpuBufferManager, aggregates, num_group_keys);
 			} else if (aggregate_type == ColumnType::FLOAT64) {
 				ResolveTypeGroupByAggregateExpression<uint64_t, double>(group_by_keys, aggregate_keys, gpuBufferManager, aggregates, num_group_keys);
-			} else throw NotImplementedException("Unsupported column type");
+			} else throw NotImplementedException("Unsupported column type in `HandleGroupByAggregateExpression`: {}",
+																					 static_cast<int>(aggregate_type));
 			break;
 		case ColumnType::FLOAT64:
-			throw NotImplementedException("Unsupported column type");
 		default:
-			throw NotImplementedException("Unsupported column type");
+			throw NotImplementedException("Unsupported column type in `HandleGroupByAggregateExpression`: {}",
+																		static_cast<int>(group_by_keys[0]->data_wrapper.type));
 		}
 	}
 }
@@ -349,9 +352,9 @@ void HandleDuplicateElimination(vector<shared_ptr<GPUColumn>> &group_by_keys, GP
 	  	ResolveTypeDuplicateElimination<uint64_t>(group_by_keys, gpuBufferManager, num_group_keys);
 		break;
       case ColumnType::FLOAT64:
-	  	throw NotImplementedException("Unsupported column type");
       default:
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleDuplicateElimination`: %d",
+																			static_cast<int>(group_by_keys[0]->data_wrapper.type));
     }
 }
 
@@ -414,12 +417,13 @@ void HandleDistinctGroupBy(vector<shared_ptr<GPUColumn>> &group_by_keys, vector<
       case ColumnType::INT64: {
 	  	if (aggregate_keys[0]->data_wrapper.type == ColumnType::INT64) {
 			ResolveTypeDistinctGroupBy<uint64_t, uint64_t>(group_by_keys, aggregate_keys, gpuBufferManager, distinct_info, num_group_keys);
-		} else throw NotImplementedException("Unsupported column type");
+		} else throw NotImplementedException("Unsupported column type in `HandleDistinctGroupBy`: %d",
+																				 static_cast<int>(aggregate_keys[0]->data_wrapper.type));
 		break;
 	  } case ColumnType::FLOAT64:
-	  	throw NotImplementedException("Unsupported column type");
       default:
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleDistinctGroupBy`: %d",
+																			static_cast<int>(group_by_keys[0]->data_wrapper.type));
     }
 }
 
diff --git a/src/operator/gpu_physical_hash_join.cpp b/src/operator/gpu_physical_hash_join.cpp
@@ -72,7 +72,8 @@ HandleProbeExpression(vector<shared_ptr<GPUColumn>> &probe_keys, uint64_t* &coun
 	  	ResolveTypeProbeExpression(probe_keys, count, row_ids_left, row_ids_right, ht, ht_len, conditions, join_type, unique_build_keys, gpuBufferManager);
 		break;
       default:
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleProbeExpression`: %d",
+																			static_cast<int>(probe_keys[0]->data_wrapper.type));
     }
 }
 
@@ -112,9 +113,9 @@ HandleMarkExpression(vector<shared_ptr<GPUColumn>> &probe_keys, uint8_t* &output
 		ResolveTypeMarkExpression(probe_keys, output, ht, ht_len, conditions, gpuBufferManager);
 		break;
       case ColumnType::FLOAT64:
-	  	throw NotImplementedException("Unsupported column type");
       default:
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleMarkExpression`: %d",
+																			static_cast<int>(probe_keys[0]->data_wrapper.type));
     }
 }
 
@@ -162,7 +163,8 @@ HandleBuildExpression(vector<shared_ptr<GPUColumn>> &build_keys, unsigned long l
 	  	ResolveTypeBuildExpression(build_keys, ht, ht_len, conditions, join_type, gpuBufferManager);
 		break;
       default:
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleBuildExpression`: %d",
+																			static_cast<int>(build_keys[0]->data_wrapper.type));
     }
 }
 
diff --git a/src/operator/gpu_physical_nested_loop_join.cpp b/src/operator/gpu_physical_nested_loop_join.cpp
@@ -67,7 +67,8 @@ HandleNestedLoopJoin(vector<shared_ptr<GPUColumn>> &left_keys, vector<shared_ptr
 	  	ResolveTypeNestedLoopJoin<double>(left_keys, right_keys, count, row_ids_left, row_ids_right, conditions, join_type, gpuBufferManager);
 		break;
       default:
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleNestedLoopJoin`: %d",
+																			static_cast<int>(left_keys[0]->data_wrapper.type));
     }
 }
 
diff --git a/src/operator/gpu_physical_result_collector.cpp b/src/operator/gpu_physical_result_collector.cpp
@@ -155,7 +155,8 @@ GPUPhysicalMaterializedCollector::FinalMaterialize(GPUIntermediateRelation input
 		FinalMaterializeString(input_relation, output_relation, col);
 		break;
 	default:
-		throw NotImplementedException("Unsupported column type");
+		throw NotImplementedException("Unsupported column type in `FinalMaterialize`: %d",
+																	static_cast<int>(input_relation.columns[col]->data_wrapper.type));
 	}
 	// output_relation.length = output_relation.columns[col]->column_length;
 	// SIRIUS_LOG_DEBUG("Final materialize size {} bytes", size_bytes);
@@ -177,7 +178,8 @@ LogicalType ColumnTypeToLogicalType(ColumnType type) {
 		case ColumnType::VARCHAR:
 			return LogicalType::VARCHAR;
 		default:
-			throw NotImplementedException("Unsupported column type");
+			throw NotImplementedException("Unsupported column type in `ColumnTypeToLogicalType`: %d",
+																		static_cast<int>(type));
 	}
 }
 
@@ -195,7 +197,8 @@ Vector rawDataToVector(uint8_t* host_data, size_t vector_offset, ColumnType type
 		case ColumnType::BOOLEAN:
 			sizeof_type = sizeof(uint8_t); break;
 		default:
-			throw NotImplementedException("Unsupported column type");
+			throw NotImplementedException("Unsupported column type in `rawDataToVector`: %d",
+																		static_cast<int>(type));
 	}
 	uint8_t* data = host_data + vector_offset * STANDARD_VECTOR_SIZE * sizeof_type;
 	return Vector(ColumnTypeToLogicalType(type), data);
diff --git a/src/operator/gpu_physical_result_collector_opt.cpp b/src/operator/gpu_physical_result_collector_opt.cpp
@@ -160,7 +160,8 @@ GPUPhysicalMaterializedCollector::FinalMaterialize(GPUIntermediateRelation input
 		FinalMaterializeString(input_relation, output_relation, col);
 		break;
 	default:
-		throw NotImplementedException("Unsupported column type");
+		throw NotImplementedException("Unsupported column type in `FinalMaterialize`: %d",
+																	static_cast<int>(input_relation.columns[col]->data_wrapper.type));
 	}
 	// output_relation.length = output_relation.columns[col]->column_length;
 	// SIRIUS_LOG_DEBUG("Final materialize size {} bytes", size_bytes);
@@ -182,7 +183,8 @@ LogicalType ColumnTypeToLogicalType(ColumnType type) {
 		case ColumnType::VARCHAR:
 			return LogicalType::VARCHAR;
 		default:
-			throw NotImplementedException("Unsupported column type");
+			throw NotImplementedException("Unsupported column type in `ColumnTypeToLogicalType`: %d",
+																		static_cast<int>(type));
 	}
 }
 
@@ -200,7 +202,8 @@ Vector rawDataToVector(uint8_t* host_data, size_t vector_offset, ColumnType type
 		case ColumnType::BOOLEAN:
 			sizeof_type = sizeof(uint8_t); break;
 		default:
-			throw NotImplementedException("Unsupported column type");
+			throw NotImplementedException("Unsupported column type in `rawDataToVector`: %d",
+																		static_cast<int>(type));
 	}
 	uint8_t* data = host_data + vector_offset * STANDARD_VECTOR_SIZE * sizeof_type;
 	return Vector(ColumnTypeToLogicalType(type), data);
diff --git a/src/operator/gpu_physical_table_scan.cpp b/src/operator/gpu_physical_table_scan.cpp
@@ -117,7 +117,8 @@ void HandleComparisonConstantExpression(shared_ptr<GPUColumn> column, uint64_t*
         ResolveStringExpression(column, count, row_ids, filter_constant, expression_type);
         break;
       default:
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleComparisonConstantExpression`: %d",
+                                      static_cast<int>(column->data_wrapper.type));
     }
 }
 
@@ -176,7 +177,8 @@ void HandleBetweenExpression(shared_ptr<GPUColumn> column, uint64_t* &count, uin
         ResolveStringBetweenExpression(column, count, row_ids, filter_constant1, filter_constant2);
         break;
       default:
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleBetweenExpression`: %d",
+                                      static_cast<int>(column->data_wrapper.type));
     }
 }
 
@@ -242,7 +244,8 @@ HandleMaterializeExpression(shared_ptr<GPUColumn> column, GPUBufferManager* gpuB
         case ColumnType::VARCHAR:
             return ResolveStringMateralizeExpression(column, gpuBufferManager);
         default:
-            throw NotImplementedException("Unsupported column type");
+            throw NotImplementedException("Unsupported column type in `HandleMaterializeExpression`: %d",
+                                          static_cast<int>(column->data_wrapper.type));
     }
 }
 
@@ -304,7 +307,8 @@ void HandleArbitraryConstantExpression(vector<shared_ptr<GPUColumn>> &column, ui
         data_type[expr] = VARCHAR;
         break;
       } default: {
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleArbitraryConstantExpression`: %d",
+                                      static_cast<int>(column[expr]->data_wrapper.type));
       }
     }
   }
@@ -348,7 +352,8 @@ void HandleArbitraryConstantExpression(vector<shared_ptr<GPUColumn>> &column, ui
         init_offset += lower_string.size();
         break;
       } default: {
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleArbitraryConstantExpression`: %d",
+                                      column[expr]->data_wrapper.type);
       }
     }
   }
diff --git a/src/operator/gpu_physical_ungrouped_aggregate.cpp b/src/operator/gpu_physical_ungrouped_aggregate.cpp
@@ -98,7 +98,8 @@ HandleAggregateExpression(vector<shared_ptr<GPUColumn>> &aggregate_keys, GPUBuff
 	  	ResolveTypeAggregateExpression<double>(aggregate_keys, gpuBufferManager, aggregates);
 		break;
       default:
-        throw NotImplementedException("Unsupported column type");
+        throw NotImplementedException("Unsupported column type in `HandleAggregateExpression`: %d",
+																			static_cast<int>(aggregate_keys[0]->data_wrapper.type));
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,8 @@ GPUExpressionExecutor::HandleBinaryConstantExpression(shared_ptr<GPUColumn> colu`
`45`	`45`	`double constant = expr.value.GetValue<double>();`
`46`	`46`	`return ResolveTypeBinaryConstantExpression<double>(column, constant, gpuBufferManager, function_name);`
`47`	`47`	`} default:`
`48`		`- throw NotImplementedException("Unsupported column type");`
	`48`	+ throw NotImplementedException("Unsupported column type in `HandleBinaryConstantExpression`: %d",
	`49`	`+ static_cast<int>(column->data_wrapper.type));`
`49`	`50`	`}`
`50`	`51`	`}`
`51`	`52`
`@@ -83,7 +84,8 @@ GPUExpressionExecutor::HandleBinaryExpression(shared_ptr<GPUColumn> column1, sha`
`83`	`84`	`case ColumnType::FLOAT64:`
`84`	`85`	`return ResolveTypeBinaryExpression<double>(column1, column2, gpuBufferManager, function_name);`
`85`	`86`	`default:`
`86`		`- throw NotImplementedException("Unsupported column type");`
	`87`	+ throw NotImplementedException("Unsupported column type in `HandleBinaryExpression`: %d",
	`88`	`+ static_cast<int>(column1->data_wrapper.type));`
`87`	`89`	`}`
`88`	`90`	`}`
`89`	`91`
`@@ -145,7 +147,8 @@ GPUExpressionExecutor::HandleComparisonConstantExpression(shared_ptr<GPUColumn>`
`145`	`147`	`ResolveTypeComparisonConstantExpression<uint8_t>(column, expr1, expr2, count, row_ids, expression_type);`
`146`	`148`	`break;`
`147`	`149`	`default:`
`148`		`- throw NotImplementedException("Unsupported column type");`
	`150`	+ throw NotImplementedException("Unsupported column type in `HandleComparisonConstantExpression`: %d",
	`151`	`+ static_cast<int>(column->data_wrapper.type));`
`149`	`152`	`}`
`150`	`153`	`}`
`151`	`154`
`@@ -195,7 +198,8 @@ GPUExpressionExecutor::HandleComparisonExpression(shared_ptr<GPUColumn> column1,`
`195`	`198`	`ResolveTypeComparisonExpression<double>(column1, column2, count, row_ids, expression_type);`
`196`	`199`	`break;`
`197`	`200`	`default:`
`198`		`- throw NotImplementedException("Unsupported column type");`
	`201`	+ throw NotImplementedException("Unsupported column type in `HandleComparisonExpression`: %d",
	`202`	`+ static_cast<int>(column1->data_wrapper.type));`
`199`	`203`	`}`
`200`	`204`	`}`
`201`	`205`
`@@ -218,7 +222,8 @@ GPUExpressionExecutor::HandleRoundExpression(shared_ptr<GPUColumn> column, int d`
`218`	`222`	`shared_ptr<GPUColumn> result = make_shared_ptr<GPUColumn>(size, column->data_wrapper.type, reinterpret_cast<uint8_t*>(c));`
`219`	`223`	`return result;`
`220`	`224`	`} default:`
`221`		`- throw NotImplementedException("Unsupported column type");`
	`225`	+ throw NotImplementedException("Unsupported column type in `HandleRoundExpression`: %d",
	`226`	`+ static_cast<int>(column->data_wrapper.type));`
`222`	`227`	`}`
`223`	`228`	`}`
`224`	`229`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,8 @@ HandleMaterializeExpression(shared_ptr<GPUColumn> column, BoundReferenceExpressi`
`69`	`69`	`case ColumnType::VARCHAR:`
`70`	`70`	`return ResolveTypeMaterializeString(column, bound_ref, gpuBufferManager);`
`71`	`71`	`default:`
`72`		`- throw NotImplementedException("Unsupported column type");`
	`72`	+ throw NotImplementedException("Unsupported column type in `HandleMaterializeExpression`: {}",
	`73`	`+ static_cast<int>(column->data_wrapper.type));`
`73`	`74`	`}`
`74`	`75`	`}`
`75`	`76`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,8 @@ HandleProbeExpression(vector<shared_ptr<GPUColumn>> &probe_keys, uint64_t* &coun`
`72`	`72`	`ResolveTypeProbeExpression(probe_keys, count, row_ids_left, row_ids_right, ht, ht_len, conditions, join_type, unique_build_keys, gpuBufferManager);`
`73`	`73`	`break;`
`74`	`74`	`default:`
`75`		`- throw NotImplementedException("Unsupported column type");`
	`75`	+ throw NotImplementedException("Unsupported column type in `HandleProbeExpression`: %d",
	`76`	`+ static_cast<int>(probe_keys[0]->data_wrapper.type));`
`76`	`77`	`}`
`77`	`78`	`}`
`78`	`79`
`@@ -112,9 +113,9 @@ HandleMarkExpression(vector<shared_ptr<GPUColumn>> &probe_keys, uint8_t* &output`
`112`	`113`	`ResolveTypeMarkExpression(probe_keys, output, ht, ht_len, conditions, gpuBufferManager);`
`113`	`114`	`break;`
`114`	`115`	`case ColumnType::FLOAT64:`
`115`		`- throw NotImplementedException("Unsupported column type");`
`116`	`116`	`default:`
`117`		`- throw NotImplementedException("Unsupported column type");`
	`117`	+ throw NotImplementedException("Unsupported column type in `HandleMarkExpression`: %d",
	`118`	`+ static_cast<int>(probe_keys[0]->data_wrapper.type));`
`118`	`119`	`}`
`119`	`120`	`}`
`120`	`121`
`@@ -162,7 +163,8 @@ HandleBuildExpression(vector<shared_ptr<GPUColumn>> &build_keys, unsigned long l`
`162`	`163`	`ResolveTypeBuildExpression(build_keys, ht, ht_len, conditions, join_type, gpuBufferManager);`
`163`	`164`	`break;`
`164`	`165`	`default:`
`165`		`- throw NotImplementedException("Unsupported column type");`
	`166`	+ throw NotImplementedException("Unsupported column type in `HandleBuildExpression`: %d",
	`167`	`+ static_cast<int>(build_keys[0]->data_wrapper.type));`
`166`	`168`	`}`
`167`	`169`	`}`
`168`	`170`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,8 @@ HandleNestedLoopJoin(vector<shared_ptr<GPUColumn>> &left_keys, vector<shared_ptr`
`67`	`67`	`ResolveTypeNestedLoopJoin<double>(left_keys, right_keys, count, row_ids_left, row_ids_right, conditions, join_type, gpuBufferManager);`
`68`	`68`	`break;`
`69`	`69`	`default:`
`70`		`- throw NotImplementedException("Unsupported column type");`
	`70`	+ throw NotImplementedException("Unsupported column type in `HandleNestedLoopJoin`: %d",
	`71`	`+ static_cast<int>(left_keys[0]->data_wrapper.type));`
`71`	`72`	`}`
`72`	`73`	`}`
`73`	`74`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,8 @@ void HandleComparisonConstantExpression(shared_ptr<GPUColumn> column, uint64_t*`
`117`	`117`	`ResolveStringExpression(column, count, row_ids, filter_constant, expression_type);`
`118`	`118`	`break;`
`119`	`119`	`default:`
`120`		`- throw NotImplementedException("Unsupported column type");`
	`120`	+ throw NotImplementedException("Unsupported column type in `HandleComparisonConstantExpression`: %d",
	`121`	`+ static_cast<int>(column->data_wrapper.type));`
`121`	`122`	`}`
`122`	`123`	`}`
`123`	`124`
`@@ -176,7 +177,8 @@ void HandleBetweenExpression(shared_ptr<GPUColumn> column, uint64_t* &count, uin`
`176`	`177`	`ResolveStringBetweenExpression(column, count, row_ids, filter_constant1, filter_constant2);`
`177`	`178`	`break;`
`178`	`179`	`default:`
`179`		`- throw NotImplementedException("Unsupported column type");`
	`180`	+ throw NotImplementedException("Unsupported column type in `HandleBetweenExpression`: %d",
	`181`	`+ static_cast<int>(column->data_wrapper.type));`
`180`	`182`	`}`
`181`	`183`	`}`
`182`	`184`
`@@ -242,7 +244,8 @@ HandleMaterializeExpression(shared_ptr<GPUColumn> column, GPUBufferManager* gpuB`
`242`	`244`	`case ColumnType::VARCHAR:`
`243`	`245`	`return ResolveStringMateralizeExpression(column, gpuBufferManager);`
`244`	`246`	`default:`
`245`		`- throw NotImplementedException("Unsupported column type");`
	`247`	+ throw NotImplementedException("Unsupported column type in `HandleMaterializeExpression`: %d",
	`248`	`+ static_cast<int>(column->data_wrapper.type));`
`246`	`249`	`}`
`247`	`250`	`}`
`248`	`251`
`@@ -304,7 +307,8 @@ void HandleArbitraryConstantExpression(vector<shared_ptr<GPUColumn>> &column, ui`
`304`	`307`	`data_type[expr] = VARCHAR;`
`305`	`308`	`break;`
`306`	`309`	`} default: {`
`307`		`- throw NotImplementedException("Unsupported column type");`
	`310`	+ throw NotImplementedException("Unsupported column type in `HandleArbitraryConstantExpression`: %d",
	`311`	`+ static_cast<int>(column[expr]->data_wrapper.type));`
`308`	`312`	`}`
`309`	`313`	`}`
`310`	`314`	`}`
`@@ -348,7 +352,8 @@ void HandleArbitraryConstantExpression(vector<shared_ptr<GPUColumn>> &column, ui`
`348`	`352`	`init_offset += lower_string.size();`
`349`	`353`	`break;`
`350`	`354`	`} default: {`
`351`		`- throw NotImplementedException("Unsupported column type");`
	`355`	+ throw NotImplementedException("Unsupported column type in `HandleArbitraryConstantExpression`: %d",
	`356`	`+ column[expr]->data_wrapper.type);`
`352`	`357`	`}`
`353`	`358`	`}`
`354`	`359`	`}`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,8 @@ HandleAggregateExpression(vector<shared_ptr<GPUColumn>> &aggregate_keys, GPUBuff`
`98`	`98`	`ResolveTypeAggregateExpression<double>(aggregate_keys, gpuBufferManager, aggregates);`
`99`	`99`	`break;`
`100`	`100`	`default:`
`101`		`- throw NotImplementedException("Unsupported column type");`
	`101`	+ throw NotImplementedException("Unsupported column type in `HandleAggregateExpression`: %d",
	`102`	`+ static_cast<int>(aggregate_keys[0]->data_wrapper.type));`
`102`	`103`	`}`
`103`	`104`	`}`
`104`	`105`