duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

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

@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/encryption_state.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/helper.hpp"
+#include "duckdb/common/types/value.hpp"
+
+namespace duckdb {
+
+class EncryptionState {
+
+public:
+	DUCKDB_API EncryptionState();
+	DUCKDB_API virtual ~EncryptionState();
+
+public:
+	DUCKDB_API virtual bool IsOpenSSL();
+	DUCKDB_API virtual void InitializeEncryption(const_data_ptr_t iv, idx_t iv_len, const std::string *key);
+	DUCKDB_API virtual void InitializeDecryption(const_data_ptr_t iv, idx_t iv_len, const std::string *key);
+	DUCKDB_API virtual size_t Process(const_data_ptr_t in, idx_t in_len, data_ptr_t out, idx_t out_len);
+	DUCKDB_API virtual size_t Finalize(data_ptr_t out, idx_t out_len, data_ptr_t tag, idx_t tag_len);
+	DUCKDB_API virtual void GenerateRandomData(data_ptr_t data, idx_t len);
+
+public:
+	enum Mode { ENCRYPT, DECRYPT };
+};
+
+class EncryptionUtil {
+
+public:
+	DUCKDB_API explicit EncryptionUtil() {};
+
+public:
+	virtual shared_ptr<EncryptionState> CreateEncryptionState() const {
+		return make_shared_ptr<EncryptionState>();
+	}
+
+	virtual ~EncryptionUtil() {
+	}
+};
+
+} // namespace duckdb

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

@@ -60,6 +60,8 @@ enum class ArrowDateTimeType : uint8_t;
 
 enum class ArrowOffsetSize : uint8_t;
 
+enum class ArrowTypeInfoType : uint8_t;
+
 enum class ArrowVariableSizeType : uint8_t;
 
 enum class BinderType : uint8_t;
@@ -98,8 +100,12 @@ enum class ConflictManagerMode : uint8_t;
 
 enum class ConstraintType : uint8_t;
 
+enum class CopyFunctionReturnType : uint8_t;
+
 enum class CopyOverwriteMode : uint8_t;
 
+enum class CopyToType : uint8_t;
+
 enum class DataFileType : uint8_t;
 
 enum class DatePartSpecifier : uint8_t;
@@ -112,6 +118,8 @@ enum class DependencyEntryType : uint8_t;
 
 enum class DeprecatedIndexType : uint8_t;
 
+enum class DestroyBufferUpon : uint8_t;
+
 enum class DistinctType : uint8_t;
 
 enum class ErrorType : uint16_t;
@@ -120,6 +128,8 @@ enum class ExceptionFormatValueType : uint8_t;
 
 enum class ExceptionType : uint8_t;
 
+enum class ExplainFormat : uint8_t;
+
 enum class ExplainOutputType : uint8_t;
 
 enum class ExplainType : uint8_t;
@@ -130,6 +140,8 @@ enum class ExpressionClass : uint8_t;
 
 enum class ExpressionType : uint8_t;
 
+enum class ExtensionABIType : uint8_t;
+
 enum class ExtensionInstallMode : uint8_t;
 
 enum class ExtensionLoadResult : uint8_t;
@@ -158,6 +170,8 @@ enum class FunctionNullHandling : uint8_t;
 
 enum class FunctionStability : uint8_t;
 
+enum class GateStatus : uint8_t;
+
 enum class HLLStorageType : uint8_t;
 
 enum class IndexConstraintType : uint8_t;
@@ -188,6 +202,10 @@ enum class MapInvalidReason : uint8_t;
 
 enum class MemoryTag : uint8_t;
 
+enum class MetaPipelineType : uint8_t;
+
+enum class MetricsType : uint8_t;
+
 enum class NType : uint8_t;
 
 enum class NewLineIdentifier : uint8_t;
@@ -294,6 +312,8 @@ enum class StatsInfo : uint8_t;
 
 enum class StrTimeSpecifier : uint8_t;
 
+enum class StreamExecutionResult : uint8_t;
+
 enum class SubqueryType : uint8_t;
 
 enum class TableColumnType : uint8_t;
@@ -310,6 +330,8 @@ enum class TaskExecutionResult : uint8_t;
 
 enum class TimestampCastResult : uint8_t;
 
+enum class TransactionModifierType : uint8_t;
+
 enum class TransactionType : uint8_t;
 
 enum class TupleDataPinProperties : uint8_t;
@@ -379,6 +401,9 @@ const char* EnumUtil::ToChars<ArrowDateTimeType>(ArrowDateTimeType value);
 template<>
 const char* EnumUtil::ToChars<ArrowOffsetSize>(ArrowOffsetSize value);
 
+template<>
+const char* EnumUtil::ToChars<ArrowTypeInfoType>(ArrowTypeInfoType value);
+
 template<>
 const char* EnumUtil::ToChars<ArrowVariableSizeType>(ArrowVariableSizeType value);
 
@@ -436,9 +461,15 @@ const char* EnumUtil::ToChars<ConflictManagerMode>(ConflictManagerMode value);
 template<>
 const char* EnumUtil::ToChars<ConstraintType>(ConstraintType value);
 
+template<>
+const char* EnumUtil::ToChars<CopyFunctionReturnType>(CopyFunctionReturnType value);
+
 template<>
 const char* EnumUtil::ToChars<CopyOverwriteMode>(CopyOverwriteMode value);
 
+template<>
+const char* EnumUtil::ToChars<CopyToType>(CopyToType value);
+
 template<>
 const char* EnumUtil::ToChars<DataFileType>(DataFileType value);
 
@@ -457,6 +488,9 @@ const char* EnumUtil::ToChars<DependencyEntryType>(DependencyEntryType value);
 template<>
 const char* EnumUtil::ToChars<DeprecatedIndexType>(DeprecatedIndexType value);
 
+template<>
+const char* EnumUtil::ToChars<DestroyBufferUpon>(DestroyBufferUpon value);
+
 template<>
 const char* EnumUtil::ToChars<DistinctType>(DistinctType value);
 
@@ -469,6 +503,9 @@ const char* EnumUtil::ToChars<ExceptionFormatValueType>(ExceptionFormatValueType
 template<>
 const char* EnumUtil::ToChars<ExceptionType>(ExceptionType value);
 
+template<>
+const char* EnumUtil::ToChars<ExplainFormat>(ExplainFormat value);
+
 template<>
 const char* EnumUtil::ToChars<ExplainOutputType>(ExplainOutputType value);
 
@@ -484,6 +521,9 @@ const char* EnumUtil::ToChars<ExpressionClass>(ExpressionClass value);
 template<>
 const char* EnumUtil::ToChars<ExpressionType>(ExpressionType value);
 
+template<>
+const char* EnumUtil::ToChars<ExtensionABIType>(ExtensionABIType value);
+
 template<>
 const char* EnumUtil::ToChars<ExtensionInstallMode>(ExtensionInstallMode value);
 
@@ -526,6 +566,9 @@ const char* EnumUtil::ToChars<FunctionNullHandling>(FunctionNullHandling value);
 template<>
 const char* EnumUtil::ToChars<FunctionStability>(FunctionStability value);
 
+template<>
+const char* EnumUtil::ToChars<GateStatus>(GateStatus value);
+
 template<>
 const char* EnumUtil::ToChars<HLLStorageType>(HLLStorageType value);
 
@@ -571,6 +614,12 @@ const char* EnumUtil::ToChars<MapInvalidReason>(MapInvalidReason value);
 template<>
 const char* EnumUtil::ToChars<MemoryTag>(MemoryTag value);
 
+template<>
+const char* EnumUtil::ToChars<MetaPipelineType>(MetaPipelineType value);
+
+template<>
+const char* EnumUtil::ToChars<MetricsType>(MetricsType value);
+
 template<>
 const char* EnumUtil::ToChars<NType>(NType value);
 
@@ -730,6 +779,9 @@ const char* EnumUtil::ToChars<StatsInfo>(StatsInfo value);
 template<>
 const char* EnumUtil::ToChars<StrTimeSpecifier>(StrTimeSpecifier value);
 
+template<>
+const char* EnumUtil::ToChars<StreamExecutionResult>(StreamExecutionResult value);
+
 template<>
 const char* EnumUtil::ToChars<SubqueryType>(SubqueryType value);
 
@@ -754,6 +806,9 @@ const char* EnumUtil::ToChars<TaskExecutionResult>(TaskExecutionResult value);
 template<>
 const char* EnumUtil::ToChars<TimestampCastResult>(TimestampCastResult value);
 
+template<>
+const char* EnumUtil::ToChars<TransactionModifierType>(TransactionModifierType value);
+
 template<>
 const char* EnumUtil::ToChars<TransactionType>(TransactionType value);
 
@@ -836,6 +891,9 @@ ArrowDateTimeType EnumUtil::FromString<ArrowDateTimeType>(const char *value);
 template<>
 ArrowOffsetSize EnumUtil::FromString<ArrowOffsetSize>(const char *value);
 
+template<>
+ArrowTypeInfoType EnumUtil::FromString<ArrowTypeInfoType>(const char *value);
+
 template<>
 ArrowVariableSizeType EnumUtil::FromString<ArrowVariableSizeType>(const char *value);
 
@@ -893,9 +951,15 @@ ConflictManagerMode EnumUtil::FromString<ConflictManagerMode>(const char *value)
 template<>
 ConstraintType EnumUtil::FromString<ConstraintType>(const char *value);
 
+template<>
+CopyFunctionReturnType EnumUtil::FromString<CopyFunctionReturnType>(const char *value);
+
 template<>
 CopyOverwriteMode EnumUtil::FromString<CopyOverwriteMode>(const char *value);
 
+template<>
+CopyToType EnumUtil::FromString<CopyToType>(const char *value);
+
 template<>
 DataFileType EnumUtil::FromString<DataFileType>(const char *value);
 
@@ -914,6 +978,9 @@ DependencyEntryType EnumUtil::FromString<DependencyEntryType>(const char *value)
 template<>
 DeprecatedIndexType EnumUtil::FromString<DeprecatedIndexType>(const char *value);
 
+template<>
+DestroyBufferUpon EnumUtil::FromString<DestroyBufferUpon>(const char *value);
+
 template<>
 DistinctType EnumUtil::FromString<DistinctType>(const char *value);
 
@@ -926,6 +993,9 @@ ExceptionFormatValueType EnumUtil::FromString<ExceptionFormatValueType>(const ch
 template<>
 ExceptionType EnumUtil::FromString<ExceptionType>(const char *value);
 
+template<>
+ExplainFormat EnumUtil::FromString<ExplainFormat>(const char *value);
+
 template<>
 ExplainOutputType EnumUtil::FromString<ExplainOutputType>(const char *value);
 
@@ -941,6 +1011,9 @@ ExpressionClass EnumUtil::FromString<ExpressionClass>(const char *value);
 template<>
 ExpressionType EnumUtil::FromString<ExpressionType>(const char *value);
 
+template<>
+ExtensionABIType EnumUtil::FromString<ExtensionABIType>(const char *value);
+
 template<>
 ExtensionInstallMode EnumUtil::FromString<ExtensionInstallMode>(const char *value);
 
@@ -983,6 +1056,9 @@ FunctionNullHandling EnumUtil::FromString<FunctionNullHandling>(const char *valu
 template<>
 FunctionStability EnumUtil::FromString<FunctionStability>(const char *value);
 
+template<>
+GateStatus EnumUtil::FromString<GateStatus>(const char *value);
+
 template<>
 HLLStorageType EnumUtil::FromString<HLLStorageType>(const char *value);
 
@@ -1028,6 +1104,12 @@ MapInvalidReason EnumUtil::FromString<MapInvalidReason>(const char *value);
 template<>
 MemoryTag EnumUtil::FromString<MemoryTag>(const char *value);
 
+template<>
+MetaPipelineType EnumUtil::FromString<MetaPipelineType>(const char *value);
+
+template<>
+MetricsType EnumUtil::FromString<MetricsType>(const char *value);
+
 template<>
 NType EnumUtil::FromString<NType>(const char *value);
 
@@ -1187,6 +1269,9 @@ StatsInfo EnumUtil::FromString<StatsInfo>(const char *value);
 template<>
 StrTimeSpecifier EnumUtil::FromString<StrTimeSpecifier>(const char *value);
 
+template<>
+StreamExecutionResult EnumUtil::FromString<StreamExecutionResult>(const char *value);
+
 template<>
 SubqueryType EnumUtil::FromString<SubqueryType>(const char *value);
 
@@ -1211,6 +1296,9 @@ TaskExecutionResult EnumUtil::FromString<TaskExecutionResult>(const char *value)
 template<>
 TimestampCastResult EnumUtil::FromString<TimestampCastResult>(const char *value);
 
+template<>
+TransactionModifierType EnumUtil::FromString<TransactionModifierType>(const char *value);
+
 template<>
 TransactionType EnumUtil::FromString<TransactionType>(const char *value);
 

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

@@ -22,8 +22,8 @@ enum class CheckpointWALAction {
 enum class CheckpointAction {
 	//! Checkpoint only if a checkpoint is required (i.e. the WAL has data in it that can be flushed)
 	CHECKPOINT_IF_REQUIRED,
-	//! Force a checkpoint regardless of whether or not there is data in the WAL to flush
-	FORCE_CHECKPOINT
+	//! Always checkpoint regardless of whether or not there is data in the WAL to flush
+	ALWAYS_CHECKPOINT
 };
 
 enum class CheckpointType {

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

@@ -13,6 +13,11 @@
 
 namespace duckdb {
 
-enum class CopyOverwriteMode : uint8_t { COPY_ERROR_ON_CONFLICT = 0, COPY_OVERWRITE = 1, COPY_OVERWRITE_OR_IGNORE = 2 };
+enum class CopyOverwriteMode : uint8_t {
+	COPY_ERROR_ON_CONFLICT = 0,
+	COPY_OVERWRITE = 1,
+	COPY_OVERWRITE_OR_IGNORE = 2,
+	COPY_APPEND = 3
+};
 
 } // namespace duckdb

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

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/destroy_buffer_upon.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+
+namespace duckdb {
+
+enum class DestroyBufferUpon : uint8_t {
+	BLOCK = 0,    //! Destroy the data buffer upon destroying the associated BlockHandle (block can be evicted)
+	EVICTION = 1, //! Destroy the data buffer upon eviction to storage (destroy instead of evict)
+	UNPIN = 2     //! Destroy the data buffer upon unpin (destroyed immediately, not added to eviction queue)
+};
+
+} // namespace duckdb

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

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/explain_format.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/typedefs.hpp"
+
+namespace duckdb {
+
+enum class ExplainFormat : uint8_t { DEFAULT, TEXT, JSON, HTML, GRAPHVIZ };
+
+} // namespace duckdb

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

@@ -16,4 +16,8 @@ enum class FileCompressionType : uint8_t { AUTO_DETECT = 0, UNCOMPRESSED = 1, GZ
 
 FileCompressionType FileCompressionTypeFromString(const string &input);
 
+string CompressionExtensionFromType(const FileCompressionType type);
+
+bool IsFileCompressed(string path, FileCompressionType type);
+
 } // namespace duckdb

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

@@ -29,8 +29,8 @@ enum class JoinType : uint8_t {
 	             // (and NULL if no partner is found)
 	RIGHT_SEMI = 9, // RIGHT SEMI join is created by the optimizer when the children of a semi join need to be switched
 	                // so that the build side can be the smaller table
-	RIGHT_ANTI = 10 // RIGHT ANTI join is created by the optimizer when the children of an anti join need to be switched
-	                // so that the build side can be the smaller table
+	RIGHT_ANTI = 10 // RIGHT ANTI join is created by the optimizer when the children of an anti join need to be
+	                // switched so that the build side can be the smaller table
 };
 
 //! True if join is left or full outer join

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

@@ -0,0 +1,88 @@
+//-------------------------------------------------------------------------
+//                         DuckDB
+//
+//
+// duckdb/common/enums/metrics_type.hpp
+// 
+// This file is automatically generated by scripts/generate_metric_enums.py
+// Do not edit this file manually, your changes will be overwritten
+//-------------------------------------------------------------------------
+
+#pragma once
+
+#include "duckdb/common/types/value.hpp"
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/constants.hpp"
+#include "duckdb/common/enum_util.hpp"
+#include "duckdb/common/enums/optimizer_type.hpp"
+
+namespace duckdb {
+
+enum class MetricsType : uint8_t {
+    QUERY_NAME,
+    BLOCKED_THREAD_TIME,
+    CPU_TIME,
+    EXTRA_INFO,
+    CUMULATIVE_CARDINALITY,
+    OPERATOR_TYPE,
+    OPERATOR_CARDINALITY,
+    CUMULATIVE_ROWS_SCANNED,
+    OPERATOR_ROWS_SCANNED,
+    OPERATOR_TIMING,
+    RESULT_SET_SIZE,
+    ALL_OPTIMIZERS,
+    CUMULATIVE_OPTIMIZER_TIMING,
+    PLANNER,
+    PLANNER_BINDING,
+    PHYSICAL_PLANNER,
+    PHYSICAL_PLANNER_COLUMN_BINDING,
+    PHYSICAL_PLANNER_RESOLVE_TYPES,
+    PHYSICAL_PLANNER_CREATE_PLAN,
+    OPTIMIZER_EXPRESSION_REWRITER,
+    OPTIMIZER_FILTER_PULLUP,
+    OPTIMIZER_FILTER_PUSHDOWN,
+    OPTIMIZER_CTE_FILTER_PUSHER,
+    OPTIMIZER_REGEX_RANGE,
+    OPTIMIZER_IN_CLAUSE,
+    OPTIMIZER_JOIN_ORDER,
+    OPTIMIZER_DELIMINATOR,
+    OPTIMIZER_UNNEST_REWRITER,
+    OPTIMIZER_UNUSED_COLUMNS,
+    OPTIMIZER_STATISTICS_PROPAGATION,
+    OPTIMIZER_COMMON_SUBEXPRESSIONS,
+    OPTIMIZER_COMMON_AGGREGATE,
+    OPTIMIZER_COLUMN_LIFETIME,
+    OPTIMIZER_BUILD_SIDE_PROBE_SIDE,
+    OPTIMIZER_LIMIT_PUSHDOWN,
+    OPTIMIZER_TOP_N,
+    OPTIMIZER_COMPRESSED_MATERIALIZATION,
+    OPTIMIZER_DUPLICATE_GROUPS,
+    OPTIMIZER_REORDER_FILTER,
+    OPTIMIZER_JOIN_FILTER_PUSHDOWN,
+    OPTIMIZER_EXTENSION,
+    OPTIMIZER_MATERIALIZED_CTE,
+};
+
+struct MetricsTypeHashFunction {
+	uint64_t operator()(const MetricsType &index) const {
+		return std::hash<uint8_t>()(static_cast<uint8_t>(index));
+	}
+};
+
+typedef unordered_set<MetricsType, MetricsTypeHashFunction> profiler_settings_t;
+typedef unordered_map<MetricsType, Value, MetricsTypeHashFunction> profiler_metrics_t;
+
+class MetricsUtils {
+public:
+    static profiler_settings_t GetOptimizerMetrics();
+    static profiler_settings_t GetPhaseTimingMetrics();
+
+    static MetricsType GetOptimizerMetricByType(OptimizerType type);
+    static OptimizerType GetOptimizerTypeByMetric(MetricsType type);
+
+    static bool IsOptimizerMetric(MetricsType type);
+    static bool IsPhaseTimingMetric(MetricsType type);
+};
+
+} // namespace duckdb

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

@@ -18,6 +18,7 @@ enum class OptimizerType : uint32_t {
 	EXPRESSION_REWRITER,
 	FILTER_PULLUP,
 	FILTER_PUSHDOWN,
+	CTE_FILTER_PUSHER,
 	REGEX_RANGE,
 	IN_CLAUSE,
 	JOIN_ORDER,
@@ -28,11 +29,15 @@ enum class OptimizerType : uint32_t {
 	COMMON_SUBEXPRESSIONS,
 	COMMON_AGGREGATE,
 	COLUMN_LIFETIME,
+	BUILD_SIDE_PROBE_SIDE,
+	LIMIT_PUSHDOWN,
 	TOP_N,
 	COMPRESSED_MATERIALIZATION,
 	DUPLICATE_GROUPS,
 	REORDER_FILTER,
-	EXTENSION
+	JOIN_FILTER_PUSHDOWN,
+	EXTENSION,
+	MATERIALIZED_CTE,
 };
 
 string OptimizerTypeToString(OptimizerType type);

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

@@ -17,7 +17,8 @@ enum class PendingExecutionResult : uint8_t {
 	RESULT_NOT_READY,
 	EXECUTION_ERROR,
 	BLOCKED,
-	NO_TASKS_AVAILABLE
+	NO_TASKS_AVAILABLE,
+	EXECUTION_FINISHED
 };
 
 } // namespace duckdb

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

@@ -107,6 +107,7 @@ enum class PhysicalOperatorType : uint8_t {
 	VACUUM,
 	EXPORT,
 	SET,
+	SET_VARIABLE,
 	LOAD,
 	INOUT_FUNCTION,
 	RESULT_COLLECTOR,

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

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-enum class ProfilerPrintFormat : uint8_t { QUERY_TREE, JSON, QUERY_TREE_OPTIMIZER };
+enum class ProfilerPrintFormat : uint8_t { QUERY_TREE, JSON, QUERY_TREE_OPTIMIZER, NO_OUTPUT };
 
 } // namespace duckdb

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

@@ -41,7 +41,9 @@ enum class RelationType : uint8_t {
 	SUBQUERY_RELATION,
 	TABLE_FUNCTION_RELATION,
 	VIEW_RELATION,
-	QUERY_RELATION
+	QUERY_RELATION,
+	DELIM_JOIN_RELATION,
+	DELIM_GET_RELATION
 };
 
 string RelationTypeToString(RelationType type);

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

@@ -16,7 +16,8 @@ enum class SetScope : uint8_t {
 	AUTOMATIC = 0,
 	LOCAL = 1, /* unused */
 	SESSION = 2,
-	GLOBAL = 3
+	GLOBAL = 3,
+	VARIABLE = 4
 };
 
 } // namespace duckdb

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/constants.hpp"
+#include "duckdb/common/optional_idx.hpp"
 #include "duckdb/common/unordered_set.hpp"
 
 namespace duckdb {
@@ -59,6 +60,9 @@ enum class StatementReturnType : uint8_t {
 
 string StatementReturnTypeToString(StatementReturnType type);
 
+class Catalog;
+class ClientContext;
+
 //! A struct containing various properties of a SQL statement
 struct StatementProperties {
 	StatementProperties()
@@ -66,10 +70,23 @@ struct StatementProperties {
 	      return_type(StatementReturnType::QUERY_RESULT), parameter_count(0), always_require_rebind(false) {
 	}
 
+	struct CatalogIdentity {
+		idx_t catalog_oid;
+		optional_idx catalog_version;
+
+		bool operator==(const CatalogIdentity &rhs) const {
+			return catalog_oid == rhs.catalog_oid && catalog_version == rhs.catalog_version;
+		}
+
+		bool operator!=(const CatalogIdentity &rhs) const {
+			return !operator==(rhs);
+		}
+	};
+
 	//! The set of databases this statement will read from
-	unordered_set<string> read_databases;
+	unordered_map<string, CatalogIdentity> read_databases;
 	//! The set of databases this statement will modify
-	unordered_set<string> modified_databases;
+	unordered_map<string, CatalogIdentity> modified_databases;
 	//! Whether or not the statement requires a valid transaction. Almost all statements require this, with the
 	//! exception of ROLLBACK
 	bool requires_valid_transaction;
@@ -87,6 +104,10 @@ struct StatementProperties {
 	bool IsReadOnly() {
 		return modified_databases.empty();
 	}
+
+	void RegisterDBRead(Catalog &catalog, ClientContext &context);
+
+	void RegisterDBModify(Catalog &catalog, ClientContext &context);
 };
 
 } // namespace duckdb

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

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/stream_execution_result.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+
+namespace duckdb {
+
+enum class StreamExecutionResult : uint8_t {
+	CHUNK_READY,
+	CHUNK_NOT_READY,
+	EXECUTION_ERROR,
+	EXECUTION_CANCELLED,
+	BLOCKED,
+	NO_TASKS_AVAILABLE,
+	EXECUTION_FINISHED
+};
+
+} // namespace duckdb

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

@@ -26,7 +26,8 @@ enum class TableReferenceType : uint8_t {
 	EMPTY_FROM = 8,      // placeholder for empty FROM
 	PIVOT = 9,           // pivot statement
 	SHOW_REF = 10,       // SHOW statement
-	COLUMN_DATA = 11     // column data collection
+	COLUMN_DATA = 11,    // column data collection
+	DELIM_GET = 12       // Delim get ref
 };
 
 } // namespace duckdb

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

@@ -51,6 +51,7 @@ enum class WALType : uint8_t {
 	INSERT_TUPLE = 26,
 	DELETE_TUPLE = 27,
 	UPDATE_TUPLE = 28,
+	ROW_GROUP_DATA = 29,
 	// -----------------------------
 	// Flush
 	// -----------------------------