duckdb 1.3.2 → 1.3.3-dev4.0

package/src/duckdb/src/include/duckdb/common/enum_util.hpp

@@ -64,8 +64,12 @@ enum class AlterViewType : uint8_t;
 
 enum class AppenderType : uint8_t;
 
+enum class ArrowArrayPhysicalType : uint8_t;
+
 enum class ArrowDateTimeType : uint8_t;
 
+enum class ArrowFormatVersion : uint8_t;
+
 enum class ArrowOffsetSize : uint8_t;
 
 enum class ArrowTypeInfoType : uint8_t;
@@ -78,6 +82,8 @@ enum class BindingMode : uint8_t;
 
 enum class BitpackingMode : uint8_t;
 
+enum class BlockIteratorStateType : int8_t;
+
 enum class BlockState : uint8_t;
 
 enum class CAPIResultSetType : uint8_t;
@@ -200,6 +206,8 @@ enum class HTTPStatusCode : uint16_t;
 
 enum class IndexAppendMode : uint8_t;
 
+enum class IndexBindState : uint8_t;
+
 enum class IndexConstraintType : uint8_t;
 
 enum class InsertColumnOrder : uint8_t;
@@ -238,6 +246,10 @@ enum class MapInvalidReason : uint8_t;
 
 enum class MemoryTag : uint8_t;
 
+enum class MergeActionCondition : uint8_t;
+
+enum class MergeActionType : uint8_t;
+
 enum class MetaPipelineType : uint8_t;
 
 enum class MetricsType : uint8_t;
@@ -270,6 +282,8 @@ enum class OrderPreservationType : uint8_t;
 
 enum class OrderType : uint8_t;
 
+enum class OrdinalityType : uint8_t;
+
 enum class OutputStream : uint8_t;
 
 enum class ParseInfoType : uint8_t;
@@ -298,6 +312,8 @@ enum class PreserveOrderType : uint8_t;
 
 enum class ProfilerPrintFormat : uint8_t;
 
+enum class ProfilingCoverage : uint8_t;
+
 enum class QuantileSerializationType : uint8_t;
 
 enum class QueryNodeType : uint8_t;
@@ -348,6 +364,8 @@ enum class SinkNextBatchType : uint8_t;
 
 enum class SinkResultType : uint8_t;
 
+enum class SortKeyType : uint8_t;
+
 enum class SourceResultType : uint8_t;
 
 enum class StarExpressionType : uint8_t;
@@ -384,18 +402,28 @@ enum class TemporaryBufferSize : uint64_t;
 
 enum class TemporaryCompressionLevel : int;
 
+enum class ThreadPinMode : uint8_t;
+
 enum class TimestampCastResult : uint8_t;
 
 enum class TransactionModifierType : uint8_t;
 
 enum class TransactionType : uint8_t;
 
+enum class TupleDataNestednessType : uint8_t;
+
 enum class TupleDataPinProperties : uint8_t;
 
+enum class TupleDataValidityType : uint8_t;
+
 enum class UndoFlags : uint32_t;
 
 enum class UnionInvalidReason : uint8_t;
 
+enum class VariantChildLookupMode : uint8_t;
+
+enum class VariantLogicalType : uint8_t;
+
 enum class VectorAuxiliaryDataType : uint8_t;
 
 enum class VectorBufferType : uint8_t;
@@ -414,6 +442,8 @@ enum class WindowBoundary : uint8_t;
 
 enum class WindowExcludeMode : uint8_t;
 
+enum class WindowMergeSortStage : uint8_t;
+
 
 template<>
 const char* EnumUtil::ToChars<ARTConflictType>(ARTConflictType value);
@@ -463,9 +493,15 @@ const char* EnumUtil::ToChars<AlterViewType>(AlterViewType value);
 template<>
 const char* EnumUtil::ToChars<AppenderType>(AppenderType value);
 
+template<>
+const char* EnumUtil::ToChars<ArrowArrayPhysicalType>(ArrowArrayPhysicalType value);
+
 template<>
 const char* EnumUtil::ToChars<ArrowDateTimeType>(ArrowDateTimeType value);
 
+template<>
+const char* EnumUtil::ToChars<ArrowFormatVersion>(ArrowFormatVersion value);
+
 template<>
 const char* EnumUtil::ToChars<ArrowOffsetSize>(ArrowOffsetSize value);
 
@@ -484,6 +520,9 @@ const char* EnumUtil::ToChars<BindingMode>(BindingMode value);
 template<>
 const char* EnumUtil::ToChars<BitpackingMode>(BitpackingMode value);
 
+template<>
+const char* EnumUtil::ToChars<BlockIteratorStateType>(BlockIteratorStateType value);
+
 template<>
 const char* EnumUtil::ToChars<BlockState>(BlockState value);
 
@@ -667,6 +706,9 @@ const char* EnumUtil::ToChars<HTTPStatusCode>(HTTPStatusCode value);
 template<>
 const char* EnumUtil::ToChars<IndexAppendMode>(IndexAppendMode value);
 
+template<>
+const char* EnumUtil::ToChars<IndexBindState>(IndexBindState value);
+
 template<>
 const char* EnumUtil::ToChars<IndexConstraintType>(IndexConstraintType value);
 
@@ -724,6 +766,12 @@ const char* EnumUtil::ToChars<MapInvalidReason>(MapInvalidReason value);
 template<>
 const char* EnumUtil::ToChars<MemoryTag>(MemoryTag value);
 
+template<>
+const char* EnumUtil::ToChars<MergeActionCondition>(MergeActionCondition value);
+
+template<>
+const char* EnumUtil::ToChars<MergeActionType>(MergeActionType value);
+
 template<>
 const char* EnumUtil::ToChars<MetaPipelineType>(MetaPipelineType value);
 
@@ -772,6 +820,9 @@ const char* EnumUtil::ToChars<OrderPreservationType>(OrderPreservationType value
 template<>
 const char* EnumUtil::ToChars<OrderType>(OrderType value);
 
+template<>
+const char* EnumUtil::ToChars<OrdinalityType>(OrdinalityType value);
+
 template<>
 const char* EnumUtil::ToChars<OutputStream>(OutputStream value);
 
@@ -814,6 +865,9 @@ const char* EnumUtil::ToChars<PreserveOrderType>(PreserveOrderType value);
 template<>
 const char* EnumUtil::ToChars<ProfilerPrintFormat>(ProfilerPrintFormat value);
 
+template<>
+const char* EnumUtil::ToChars<ProfilingCoverage>(ProfilingCoverage value);
+
 template<>
 const char* EnumUtil::ToChars<QuantileSerializationType>(QuantileSerializationType value);
 
@@ -889,6 +943,9 @@ const char* EnumUtil::ToChars<SinkNextBatchType>(SinkNextBatchType value);
 template<>
 const char* EnumUtil::ToChars<SinkResultType>(SinkResultType value);
 
+template<>
+const char* EnumUtil::ToChars<SortKeyType>(SortKeyType value);
+
 template<>
 const char* EnumUtil::ToChars<SourceResultType>(SourceResultType value);
 
@@ -943,6 +1000,9 @@ const char* EnumUtil::ToChars<TemporaryBufferSize>(TemporaryBufferSize value);
 template<>
 const char* EnumUtil::ToChars<TemporaryCompressionLevel>(TemporaryCompressionLevel value);
 
+template<>
+const char* EnumUtil::ToChars<ThreadPinMode>(ThreadPinMode value);
+
 template<>
 const char* EnumUtil::ToChars<TimestampCastResult>(TimestampCastResult value);
 
@@ -952,15 +1012,27 @@ const char* EnumUtil::ToChars<TransactionModifierType>(TransactionModifierType v
 template<>
 const char* EnumUtil::ToChars<TransactionType>(TransactionType value);
 
+template<>
+const char* EnumUtil::ToChars<TupleDataNestednessType>(TupleDataNestednessType value);
+
 template<>
 const char* EnumUtil::ToChars<TupleDataPinProperties>(TupleDataPinProperties value);
 
+template<>
+const char* EnumUtil::ToChars<TupleDataValidityType>(TupleDataValidityType value);
+
 template<>
 const char* EnumUtil::ToChars<UndoFlags>(UndoFlags value);
 
 template<>
 const char* EnumUtil::ToChars<UnionInvalidReason>(UnionInvalidReason value);
 
+template<>
+const char* EnumUtil::ToChars<VariantChildLookupMode>(VariantChildLookupMode value);
+
+template<>
+const char* EnumUtil::ToChars<VariantLogicalType>(VariantLogicalType value);
+
 template<>
 const char* EnumUtil::ToChars<VectorAuxiliaryDataType>(VectorAuxiliaryDataType value);
 
@@ -988,6 +1060,9 @@ const char* EnumUtil::ToChars<WindowBoundary>(WindowBoundary value);
 template<>
 const char* EnumUtil::ToChars<WindowExcludeMode>(WindowExcludeMode value);
 
+template<>
+const char* EnumUtil::ToChars<WindowMergeSortStage>(WindowMergeSortStage value);
+
 
 template<>
 ARTConflictType EnumUtil::FromString<ARTConflictType>(const char *value);
@@ -1037,9 +1112,15 @@ AlterViewType EnumUtil::FromString<AlterViewType>(const char *value);
 template<>
 AppenderType EnumUtil::FromString<AppenderType>(const char *value);
 
+template<>
+ArrowArrayPhysicalType EnumUtil::FromString<ArrowArrayPhysicalType>(const char *value);
+
 template<>
 ArrowDateTimeType EnumUtil::FromString<ArrowDateTimeType>(const char *value);
 
+template<>
+ArrowFormatVersion EnumUtil::FromString<ArrowFormatVersion>(const char *value);
+
 template<>
 ArrowOffsetSize EnumUtil::FromString<ArrowOffsetSize>(const char *value);
 
@@ -1058,6 +1139,9 @@ BindingMode EnumUtil::FromString<BindingMode>(const char *value);
 template<>
 BitpackingMode EnumUtil::FromString<BitpackingMode>(const char *value);
 
+template<>
+BlockIteratorStateType EnumUtil::FromString<BlockIteratorStateType>(const char *value);
+
 template<>
 BlockState EnumUtil::FromString<BlockState>(const char *value);
 
@@ -1241,6 +1325,9 @@ HTTPStatusCode EnumUtil::FromString<HTTPStatusCode>(const char *value);
 template<>
 IndexAppendMode EnumUtil::FromString<IndexAppendMode>(const char *value);
 
+template<>
+IndexBindState EnumUtil::FromString<IndexBindState>(const char *value);
+
 template<>
 IndexConstraintType EnumUtil::FromString<IndexConstraintType>(const char *value);
 
@@ -1298,6 +1385,12 @@ MapInvalidReason EnumUtil::FromString<MapInvalidReason>(const char *value);
 template<>
 MemoryTag EnumUtil::FromString<MemoryTag>(const char *value);
 
+template<>
+MergeActionCondition EnumUtil::FromString<MergeActionCondition>(const char *value);
+
+template<>
+MergeActionType EnumUtil::FromString<MergeActionType>(const char *value);
+
 template<>
 MetaPipelineType EnumUtil::FromString<MetaPipelineType>(const char *value);
 
@@ -1346,6 +1439,9 @@ OrderPreservationType EnumUtil::FromString<OrderPreservationType>(const char *va
 template<>
 OrderType EnumUtil::FromString<OrderType>(const char *value);
 
+template<>
+OrdinalityType EnumUtil::FromString<OrdinalityType>(const char *value);
+
 template<>
 OutputStream EnumUtil::FromString<OutputStream>(const char *value);
 
@@ -1388,6 +1484,9 @@ PreserveOrderType EnumUtil::FromString<PreserveOrderType>(const char *value);
 template<>
 ProfilerPrintFormat EnumUtil::FromString<ProfilerPrintFormat>(const char *value);
 
+template<>
+ProfilingCoverage EnumUtil::FromString<ProfilingCoverage>(const char *value);
+
 template<>
 QuantileSerializationType EnumUtil::FromString<QuantileSerializationType>(const char *value);
 
@@ -1463,6 +1562,9 @@ SinkNextBatchType EnumUtil::FromString<SinkNextBatchType>(const char *value);
 template<>
 SinkResultType EnumUtil::FromString<SinkResultType>(const char *value);
 
+template<>
+SortKeyType EnumUtil::FromString<SortKeyType>(const char *value);
+
 template<>
 SourceResultType EnumUtil::FromString<SourceResultType>(const char *value);
 
@@ -1517,6 +1619,9 @@ TemporaryBufferSize EnumUtil::FromString<TemporaryBufferSize>(const char *value)
 template<>
 TemporaryCompressionLevel EnumUtil::FromString<TemporaryCompressionLevel>(const char *value);
 
+template<>
+ThreadPinMode EnumUtil::FromString<ThreadPinMode>(const char *value);
+
 template<>
 TimestampCastResult EnumUtil::FromString<TimestampCastResult>(const char *value);
 
@@ -1526,15 +1631,27 @@ TransactionModifierType EnumUtil::FromString<TransactionModifierType>(const char
 template<>
 TransactionType EnumUtil::FromString<TransactionType>(const char *value);
 
+template<>
+TupleDataNestednessType EnumUtil::FromString<TupleDataNestednessType>(const char *value);
+
 template<>
 TupleDataPinProperties EnumUtil::FromString<TupleDataPinProperties>(const char *value);
 
+template<>
+TupleDataValidityType EnumUtil::FromString<TupleDataValidityType>(const char *value);
+
 template<>
 UndoFlags EnumUtil::FromString<UndoFlags>(const char *value);
 
 template<>
 UnionInvalidReason EnumUtil::FromString<UnionInvalidReason>(const char *value);
 
+template<>
+VariantChildLookupMode EnumUtil::FromString<VariantChildLookupMode>(const char *value);
+
+template<>
+VariantLogicalType EnumUtil::FromString<VariantLogicalType>(const char *value);
+
 template<>
 VectorAuxiliaryDataType EnumUtil::FromString<VectorAuxiliaryDataType>(const char *value);
 
@@ -1562,5 +1679,8 @@ WindowBoundary EnumUtil::FromString<WindowBoundary>(const char *value);
 template<>
 WindowExcludeMode EnumUtil::FromString<WindowExcludeMode>(const char *value);
 
+template<>
+WindowMergeSortStage EnumUtil::FromString<WindowMergeSortStage>(const char *value);
+
 
 }

package/src/duckdb/src/include/duckdb/common/enums/arrow_format_version.hpp

@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/arrow_format_version.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+
+namespace duckdb {
+
+enum class ArrowOffsetSize : uint8_t { REGULAR, LARGE };
+
+enum class ArrowFormatVersion : uint8_t {
+	//! Base Version
+	V1_0 = 10,
+	//! Added 256-bit Decimal type.
+	V1_1 = 11,
+	//! Added MonthDayNano interval type.
+	V1_2 = 12,
+	//! Added Run-End Encoded Layout.
+	V1_3 = 13,
+	//! Added Variable-size Binary View Layout and the associated BinaryView and Utf8View types.
+	//! Added ListView Layout and the associated ListView and LargeListView types. Added Variadic buffers.
+	V1_4 = 14,
+	//! Expanded Decimal type bit widths to allow 32-bit and 64-bit types.
+	V1_5 = 15
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/checkpoint_abort.hpp

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/checkpoint_abort.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+
+namespace duckdb {
+
+enum class CheckpointAbort : uint8_t {
+	NO_ABORT = 0,
+	DEBUG_ABORT_BEFORE_TRUNCATE = 1,
+	DEBUG_ABORT_BEFORE_HEADER = 2,
+	DEBUG_ABORT_AFTER_FREE_LIST_WRITE = 3
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/checkpoint_type.hpp

@@ -32,7 +32,9 @@ enum class CheckpointType {
 	FULL_CHECKPOINT,
 	//! Concurrent checkpoints write committed data to disk but do less clean-up
 	//! They can be run even when active transactions need to read old data
-	CONCURRENT_CHECKPOINT
+	CONCURRENT_CHECKPOINT,
+	//! Only run vacuum - this can be triggered for in-memory tables
+	VACUUM_ONLY
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/copy_option_mode.hpp

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/copy_option_mode.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+
+namespace duckdb {
+
+enum class CopyOptionMode { WRITE_ONLY, READ_ONLY, READ_WRITE };
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/debug_vector_verification.hpp

@@ -18,7 +18,8 @@ enum class DebugVectorVerification : uint8_t {
 	DICTIONARY_OPERATOR,
 	CONSTANT_OPERATOR,
 	SEQUENCE_OPERATOR,
-	NESTED_SHUFFLE
+	NESTED_SHUFFLE,
+	VARIANT_VECTOR
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/explain_format.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-enum class ExplainFormat : uint8_t { DEFAULT, TEXT, JSON, HTML, GRAPHVIZ };
+enum class ExplainFormat : uint8_t { DEFAULT, TEXT, JSON, HTML, GRAPHVIZ, YAML };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/expression_type.hpp

@@ -102,6 +102,7 @@ enum class ExpressionType : uint8_t {
 	WINDOW_LEAD = 132,
 	WINDOW_LAG = 133,
 	WINDOW_NTH_VALUE = 134,
+	WINDOW_FILL = 135,
 
 	// -----------------------------
 	// Functions

package/src/duckdb/src/include/duckdb/common/enums/file_glob_options.hpp

@@ -12,9 +12,17 @@
 
 namespace duckdb {
 
-enum class FileGlobOptions : uint8_t {
-	DISALLOW_EMPTY = 0,
-	ALLOW_EMPTY = 1,
+enum class FileGlobOptions : uint8_t { DISALLOW_EMPTY = 0, ALLOW_EMPTY = 1, FALLBACK_GLOB = 2 };
+
+struct FileGlobInput {
+	FileGlobInput(FileGlobOptions options) // NOLINT: allow implicit conversion from FileGlobOptions
+	    : behavior(options) {
+	}
+	FileGlobInput(FileGlobOptions options, string extension_p) : behavior(options), extension(std::move(extension_p)) {
+	}
+
+	FileGlobOptions behavior;
+	string extension;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/logical_operator_type.hpp

@@ -67,6 +67,7 @@ enum class LogicalOperatorType : uint8_t {
 	LOGICAL_INSERT = 100,
 	LOGICAL_DELETE = 101,
 	LOGICAL_UPDATE = 102,
+	LOGICAL_MERGE_INTO = 103,
 
 	// -----------------------------
 	// Schema

package/src/duckdb/src/include/duckdb/common/enums/merge_action_type.hpp

@@ -0,0 +1,19 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/merge_action_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+
+namespace duckdb {
+
+enum class MergeActionType : uint8_t { MERGE_UPDATE, MERGE_DELETE, MERGE_INSERT, MERGE_DO_NOTHING, MERGE_ERROR };
+
+enum class MergeActionCondition : uint8_t { WHEN_MATCHED, WHEN_NOT_MATCHED_BY_SOURCE, WHEN_NOT_MATCHED_BY_TARGET };
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/metric_type.hpp

@@ -36,6 +36,8 @@ enum class MetricsType : uint8_t {
     OPERATOR_NAME,
     SYSTEM_PEAK_BUFFER_MEMORY,
     SYSTEM_PEAK_TEMP_DIR_SIZE,
+    TOTAL_BYTES_READ,
+    TOTAL_BYTES_WRITTEN,
     ALL_OPTIMIZERS,
     CUMULATIVE_OPTIMIZER_TIMING,
     PLANNER,
@@ -71,6 +73,7 @@ enum class MetricsType : uint8_t {
     OPTIMIZER_MATERIALIZED_CTE,
     OPTIMIZER_SUM_REWRITER,
     OPTIMIZER_LATE_MATERIALIZATION,
+    OPTIMIZER_CTE_INLINING,
 };
 
 struct MetricsTypeHashFunction {

package/src/duckdb/src/include/duckdb/common/enums/optimizer_type.hpp

@@ -41,7 +41,8 @@ enum class OptimizerType : uint32_t {
 	EXTENSION,
 	MATERIALIZED_CTE,
 	SUM_REWRITER,
-	LATE_MATERIALIZATION
+	LATE_MATERIALIZATION,
+	CTE_INLINING
 };
 
 string OptimizerTypeToString(OptimizerType type);

package/src/duckdb/src/include/duckdb/common/enums/ordinality_request_type.hpp

@@ -0,0 +1,16 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/ordinality_request_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+#include "duckdb/common/typedefs.hpp"
+
+namespace duckdb {
+
+enum class OrdinalityType : uint8_t { WITHOUT_ORDINALITY = 0, WITH_ORDINALITY = 1 };
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/physical_operator_type.hpp

@@ -79,6 +79,7 @@ enum class PhysicalOperatorType : uint8_t {
 	BATCH_INSERT,
 	DELETE_OPERATOR,
 	UPDATE,
+	MERGE_INTO,
 
 	// -----------------------------
 	// Schema

package/src/duckdb/src/include/duckdb/common/enums/statement_type.hpp

@@ -48,6 +48,7 @@ enum class StatementType : uint8_t {
 	MULTI_STATEMENT,
 	COPY_DATABASE_STATEMENT,
 	UPDATE_EXTENSIONS_STATEMENT,
+	MERGE_INTO_STATEMENT
 };
 
 DUCKDB_API string StatementTypeToString(StatementType type);

package/src/duckdb/src/include/duckdb/common/enums/tableref_type.hpp

@@ -27,7 +27,8 @@ enum class TableReferenceType : uint8_t {
 	PIVOT = 9,           // pivot statement
 	SHOW_REF = 10,       // SHOW statement
 	COLUMN_DATA = 11,    // column data collection
-	DELIM_GET = 12       // Delim get ref
+	DELIM_GET = 12,      // Delim get ref
+	BOUND_TABLE_REF = 13 // Bound table ref
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/thread_pin_mode.hpp

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/thread_pin_mode.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+
+namespace duckdb {
+
+enum class ThreadPinMode : uint8_t { OFF = 0, ON = 1, AUTO = 2 };
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/tuple_data_layout_enums.hpp

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/tuple_data_layout_enums.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+
+namespace duckdb {
+
+enum class TupleDataValidityType : uint8_t {
+	CAN_HAVE_NULL_VALUES = 0,
+	CANNOT_HAVE_NULL_VALUES = 1,
+};
+
+enum class TupleDataNestednessType : uint8_t {
+	TOP_LEVEL_LAYOUT = 0,
+	NESTED_STRUCT_LAYOUT = 1,
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/undo_flags.hpp

@@ -18,7 +18,8 @@ enum class UndoFlags : uint32_t { // far too big but aligned (TM)
 	INSERT_TUPLE = 2,
 	DELETE_TUPLE = 3,
 	UPDATE_TUPLE = 4,
-	SEQUENCE_VALUE = 5
+	SEQUENCE_VALUE = 5,
+	ATTACHED_DATABASE = 6
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/error_data.hpp

@@ -22,14 +22,14 @@ public:
 	//! From std::exception
 	DUCKDB_API ErrorData(const std::exception &ex); // NOLINT: allow implicit construction from exception
 	//! From a raw string and exception type
-	DUCKDB_API explicit ErrorData(ExceptionType type, const string &raw_message);
+	DUCKDB_API ErrorData(ExceptionType type, const string &raw_message);
 	//! From a raw string
 	DUCKDB_API explicit ErrorData(const string &raw_message);
 
 public:
 	//! Throw the error
 	[[noreturn]] DUCKDB_API void Throw(const string &prepended_message = "") const;
-	//! Get the internal exception type of the error
+	//! Get the internal exception type of the error.
 	DUCKDB_API const ExceptionType &Type() const;
 	//! Used in clients like C-API, creates the final message and returns a reference to it
 	DUCKDB_API const string &Message() const {
@@ -38,8 +38,10 @@ public:
 	DUCKDB_API const string &RawMessage() const {
 		return raw_message;
 	}
+	DUCKDB_API void Merge(const ErrorData &other);
 	DUCKDB_API bool operator==(const ErrorData &other) const;
 
+	//! Returns true, if this error data contains an exception, else false.
 	inline bool HasError() const {
 		return initialized;
 	}