duckdb 0.7.2-dev717.0 → 0.7.2-dev865.0

package/src/duckdb/src/common/enums/expression_type.cpp

@@ -1,150 +1,17 @@
 #include "duckdb/common/enums/expression_type.hpp"
 
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/serializer/enum_serializer.hpp"
 
 namespace duckdb {
 
-// LCOV_EXCL_START
 string ExpressionTypeToString(ExpressionType type) {
-	switch (type) {
-	case ExpressionType::OPERATOR_CAST:
-		return "CAST";
-	case ExpressionType::OPERATOR_NOT:
-		return "NOT";
-	case ExpressionType::OPERATOR_IS_NULL:
-		return "IS_NULL";
-	case ExpressionType::OPERATOR_IS_NOT_NULL:
-		return "IS_NOT_NULL";
-	case ExpressionType::COMPARE_EQUAL:
-		return "EQUAL";
-	case ExpressionType::COMPARE_NOTEQUAL:
-		return "NOTEQUAL";
-	case ExpressionType::COMPARE_LESSTHAN:
-		return "LESSTHAN";
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return "GREATERTHAN";
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return "LESSTHANOREQUALTO";
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return "GREATERTHANOREQUALTO";
-	case ExpressionType::COMPARE_IN:
-		return "IN";
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		return "DISTINCT_FROM";
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-		return "NOT_DISTINCT_FROM";
-	case ExpressionType::CONJUNCTION_AND:
-		return "AND";
-	case ExpressionType::CONJUNCTION_OR:
-		return "OR";
-	case ExpressionType::VALUE_CONSTANT:
-		return "CONSTANT";
-	case ExpressionType::VALUE_PARAMETER:
-		return "PARAMETER";
-	case ExpressionType::VALUE_TUPLE:
-		return "TUPLE";
-	case ExpressionType::VALUE_TUPLE_ADDRESS:
-		return "TUPLE_ADDRESS";
-	case ExpressionType::VALUE_NULL:
-		return "NULL";
-	case ExpressionType::VALUE_VECTOR:
-		return "VECTOR";
-	case ExpressionType::VALUE_SCALAR:
-		return "SCALAR";
-	case ExpressionType::AGGREGATE:
-		return "AGGREGATE";
-	case ExpressionType::WINDOW_AGGREGATE:
-		return "WINDOW_AGGREGATE";
-	case ExpressionType::WINDOW_RANK:
-		return "RANK";
-	case ExpressionType::WINDOW_RANK_DENSE:
-		return "RANK_DENSE";
-	case ExpressionType::WINDOW_PERCENT_RANK:
-		return "PERCENT_RANK";
-	case ExpressionType::WINDOW_ROW_NUMBER:
-		return "ROW_NUMBER";
-	case ExpressionType::WINDOW_FIRST_VALUE:
-		return "FIRST_VALUE";
-	case ExpressionType::WINDOW_LAST_VALUE:
-		return "LAST_VALUE";
-	case ExpressionType::WINDOW_NTH_VALUE:
-		return "NTH_VALUE";
-	case ExpressionType::WINDOW_CUME_DIST:
-		return "CUME_DIST";
-	case ExpressionType::WINDOW_LEAD:
-		return "LEAD";
-	case ExpressionType::WINDOW_LAG:
-		return "LAG";
-	case ExpressionType::WINDOW_NTILE:
-		return "NTILE";
-	case ExpressionType::FUNCTION:
-		return "FUNCTION";
-	case ExpressionType::CASE_EXPR:
-		return "CASE";
-	case ExpressionType::OPERATOR_NULLIF:
-		return "NULLIF";
-	case ExpressionType::OPERATOR_COALESCE:
-		return "COALESCE";
-	case ExpressionType::ARRAY_EXTRACT:
-		return "ARRAY_EXTRACT";
-	case ExpressionType::ARRAY_SLICE:
-		return "ARRAY_SLICE";
-	case ExpressionType::STRUCT_EXTRACT:
-		return "STRUCT_EXTRACT";
-	case ExpressionType::SUBQUERY:
-		return "SUBQUERY";
-	case ExpressionType::STAR:
-		return "STAR";
-	case ExpressionType::PLACEHOLDER:
-		return "PLACEHOLDER";
-	case ExpressionType::COLUMN_REF:
-		return "COLUMN_REF";
-	case ExpressionType::FUNCTION_REF:
-		return "FUNCTION_REF";
-	case ExpressionType::TABLE_REF:
-		return "TABLE_REF";
-	case ExpressionType::CAST:
-		return "CAST";
-	case ExpressionType::COMPARE_NOT_IN:
-		return "COMPARE_NOT_IN";
-	case ExpressionType::COMPARE_BETWEEN:
-		return "COMPARE_BETWEEN";
-	case ExpressionType::COMPARE_NOT_BETWEEN:
-		return "COMPARE_NOT_BETWEEN";
-	case ExpressionType::VALUE_DEFAULT:
-		return "VALUE_DEFAULT";
-	case ExpressionType::BOUND_REF:
-		return "BOUND_REF";
-	case ExpressionType::BOUND_COLUMN_REF:
-		return "BOUND_COLUMN_REF";
-	case ExpressionType::BOUND_FUNCTION:
-		return "BOUND_FUNCTION";
-	case ExpressionType::BOUND_AGGREGATE:
-		return "BOUND_AGGREGATE";
-	case ExpressionType::GROUPING_FUNCTION:
-		return "GROUPING";
-	case ExpressionType::ARRAY_CONSTRUCTOR:
-		return "ARRAY_CONSTRUCTOR";
-	case ExpressionType::TABLE_STAR:
-		return "TABLE_STAR";
-	case ExpressionType::BOUND_UNNEST:
-		return "BOUND_UNNEST";
-	case ExpressionType::COLLATE:
-		return "COLLATE";
-	case ExpressionType::POSITIONAL_REFERENCE:
-		return "POSITIONAL_REFERENCE";
-	case ExpressionType::BOUND_LAMBDA_REF:
-		return "BOUND_LAMBDA_REF";
-	case ExpressionType::LAMBDA:
-		return "LAMBDA";
-	case ExpressionType::ARROW:
-		return "ARROW";
-	case ExpressionType::INVALID:
-		break;
-	}
-	return "INVALID";
+	return EnumSerializer::EnumToString(type);
+}
+
+string ExpressionClassToString(ExpressionClass type) {
+	return EnumSerializer::EnumToString(type);
 }
-// LCOV_EXCL_STOP
 
 string ExpressionTypeToOperator(ExpressionType type) {
 	switch (type) {
@@ -173,7 +40,7 @@ string ExpressionTypeToOperator(ExpressionType type) {
 	}
 }
 
-ExpressionType NegateComparisionExpression(ExpressionType type) {
+ExpressionType NegateComparisonExpression(ExpressionType type) {
 	ExpressionType negated_type = ExpressionType::INVALID;
 	switch (type) {
 	case ExpressionType::COMPARE_EQUAL:
@@ -200,7 +67,7 @@ ExpressionType NegateComparisionExpression(ExpressionType type) {
 	return negated_type;
 }
 
-ExpressionType FlipComparisionExpression(ExpressionType type) {
+ExpressionType FlipComparisonExpression(ExpressionType type) {
 	ExpressionType flipped_type = ExpressionType::INVALID;
 	switch (type) {
 	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
@@ -244,85 +111,4 @@ ExpressionType OperatorToExpressionType(const string &op) {
 	return ExpressionType::INVALID;
 }
 
-string ExpressionClassToString(ExpressionClass type) {
-	switch (type) {
-	case ExpressionClass::INVALID:
-		return "INVALID";
-	case ExpressionClass::AGGREGATE:
-		return "AGGREGATE";
-	case ExpressionClass::CASE:
-		return "CASE";
-	case ExpressionClass::CAST:
-		return "CAST";
-	case ExpressionClass::COLUMN_REF:
-		return "COLUMN_REF";
-	case ExpressionClass::COMPARISON:
-		return "COMPARISON";
-	case ExpressionClass::CONJUNCTION:
-		return "CONJUNCTION";
-	case ExpressionClass::CONSTANT:
-		return "CONSTANT";
-	case ExpressionClass::DEFAULT:
-		return "DEFAULT";
-	case ExpressionClass::FUNCTION:
-		return "FUNCTION";
-	case ExpressionClass::OPERATOR:
-		return "OPERATOR";
-	case ExpressionClass::STAR:
-		return "STAR";
-	case ExpressionClass::SUBQUERY:
-		return "SUBQUERY";
-	case ExpressionClass::WINDOW:
-		return "WINDOW";
-	case ExpressionClass::PARAMETER:
-		return "PARAMETER";
-	case ExpressionClass::COLLATE:
-		return "COLLATE";
-	case ExpressionClass::LAMBDA:
-		return "LAMBDA";
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		return "POSITIONAL_REFERENCE";
-	case ExpressionClass::BETWEEN:
-		return "BETWEEN";
-	case ExpressionClass::BOUND_AGGREGATE:
-		return "BOUND_AGGREGATE";
-	case ExpressionClass::BOUND_CASE:
-		return "BOUND_CASE";
-	case ExpressionClass::BOUND_CAST:
-		return "BOUND_CAST";
-	case ExpressionClass::BOUND_COLUMN_REF:
-		return "BOUND_COLUMN_REF";
-	case ExpressionClass::BOUND_COMPARISON:
-		return "BOUND_COMPARISON";
-	case ExpressionClass::BOUND_CONJUNCTION:
-		return "BOUND_CONJUNCTION";
-	case ExpressionClass::BOUND_CONSTANT:
-		return "BOUND_CONSTANT";
-	case ExpressionClass::BOUND_DEFAULT:
-		return "BOUND_DEFAULT";
-	case ExpressionClass::BOUND_FUNCTION:
-		return "BOUND_FUNCTION";
-	case ExpressionClass::BOUND_OPERATOR:
-		return "BOUND_OPERATOR";
-	case ExpressionClass::BOUND_PARAMETER:
-		return "BOUND_PARAMETER";
-	case ExpressionClass::BOUND_REF:
-		return "BOUND_REF";
-	case ExpressionClass::BOUND_SUBQUERY:
-		return "BOUND_SUBQUERY";
-	case ExpressionClass::BOUND_WINDOW:
-		return "BOUND_WINDOW";
-	case ExpressionClass::BOUND_BETWEEN:
-		return "BOUND_BETWEEN";
-	case ExpressionClass::BOUND_UNNEST:
-		return "BOUND_UNNEST";
-	case ExpressionClass::BOUND_LAMBDA:
-		return "BOUND_LAMBDA";
-	case ExpressionClass::BOUND_EXPRESSION:
-		return "BOUND_EXPRESSION";
-	default:
-		return "ExpressionClass::!!UNIMPLEMENTED_CASE!!";
-	}
-}
-
 } // namespace duckdb

package/src/duckdb/src/common/enums/join_type.cpp

@@ -1,30 +1,11 @@
 #include "duckdb/common/enums/join_type.hpp"
+#include "duckdb/common/serializer/enum_serializer.hpp"
 
 namespace duckdb {
 
 string JoinTypeToString(JoinType type) {
-	switch (type) {
-	case JoinType::LEFT:
-		return "LEFT";
-	case JoinType::RIGHT:
-		return "RIGHT";
-	case JoinType::INNER:
-		return "INNER";
-	case JoinType::OUTER:
-		return "FULL";
-	case JoinType::SEMI:
-		return "SEMI";
-	case JoinType::ANTI:
-		return "ANTI";
-	case JoinType::SINGLE:
-		return "SINGLE";
-	case JoinType::MARK:
-		return "MARK";
-	case JoinType::INVALID: // LCOV_EXCL_START
-		break;
-	}
-	return "INVALID";
-} // LCOV_EXCL_STOP
+	return EnumSerializer::EnumToString(type);
+}
 
 bool IsLeftOuterJoin(JoinType type) {
 	return type == JoinType::LEFT || type == JoinType::OUTER;

package/src/duckdb/src/common/exception.cpp

@@ -149,6 +149,7 @@ const HTTPException &Exception::AsHTTPException() const {
 	D_ASSERT(type == ExceptionType::HTTP);
 	const auto &e = static_cast<const HTTPException *>(this);
 	D_ASSERT(e->GetStatusCode() != 0);
+	D_ASSERT(e->GetHeaders().size() > 0);
 	return *e;
 }
 
@@ -202,8 +203,7 @@ void Exception::ThrowAsTypeWithMessage(ExceptionType type, const string &message
 	case ExceptionType::DEPENDENCY:
 		throw DependencyException(message);
 	case ExceptionType::HTTP: {
-		auto exc = original->AsHTTPException();
-		throw HTTPException(exc.GetStatusCode(), exc.GetResponse(), exc.what());
+		original->AsHTTPException().Throw();
 	}
 	default:
 		throw Exception(type, message);