duckdb 0.9.3-dev0.0 → 0.9.3-dev14.0

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

@@ -33,8 +33,8 @@ AdbcStatusCode ConnectionInit(struct AdbcConnection *connection, struct AdbcData
 
 AdbcStatusCode ConnectionRelease(struct AdbcConnection *connection, struct AdbcError *error);
 
-AdbcStatusCode ConnectionGetInfo(struct AdbcConnection *connection, uint32_t *info_codes, size_t info_codes_length,
-                                 struct ArrowArrayStream *out, struct AdbcError *error);
+AdbcStatusCode ConnectionGetInfo(struct AdbcConnection *connection, const uint32_t *info_codes,
+                                 size_t info_codes_length, struct ArrowArrayStream *out, struct AdbcError *error);
 
 AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth, const char *catalog,
                                     const char *db_schema, const char *table_name, const char **table_type,
@@ -84,10 +84,10 @@ AdbcStatusCode StatementExecutePartitions(struct AdbcStatement *statement, struc
                                           struct AdbcPartitions *partitions, int64_t *rows_affected,
                                           struct AdbcError *error);
 
-//! This method should only be called when the string is guaranteed to not be NULL
-void SetError(struct AdbcError *error, const std::string &message);
-void SetError(struct AdbcError *error, const char *message);
-
 void InitializeADBCError(AdbcError *error);
 
 } // namespace duckdb_adbc
+
+//! This method should only be called when the string is guaranteed to not be NULL
+void SetError(struct AdbcError *error, const std::string &message);
+// void SetError(struct AdbcError *error, const char *message);

package/src/duckdb/src/include/duckdb/common/adbc/driver_manager.h

@@ -25,7 +25,6 @@ extern "C" {
 
 #ifndef ADBC_DRIVER_MANAGER_H
 #define ADBC_DRIVER_MANAGER_H
-namespace duckdb_adbc {
 /// \brief Common entry point for drivers via the driver manager.
 ///
 /// The driver manager can fill in default implementations of some
@@ -81,4 +80,3 @@ const char *AdbcStatusCodeMessage(AdbcStatusCode code);
 #ifdef __cplusplus
 }
 #endif
-} // namespace duckdb_adbc

package/src/duckdb/src/include/duckdb/common/adbc/options.h

@@ -0,0 +1,64 @@
+////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////
+// THIS FILE IS GENERATED BY apache/arrow, DO NOT EDIT MANUALLY //
+////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////
+
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+/// Common options that haven't yet been formally standardized.
+/// https://github.com/apache/arrow-adbc/issues/1055
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/adbc/options.h
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// \brief The catalog of the table for bulk insert.
+///
+/// The type is char*.
+#define ADBC_INGEST_OPTION_TARGET_CATALOG "adbc.ingest.target_catalog"
+
+/// \brief The schema of the table for bulk insert.
+///
+/// The type is char*.
+#define ADBC_INGEST_OPTION_TARGET_DB_SCHEMA "adbc.ingest.target_db_schema"
+
+/// \brief Use a temporary table for ingestion.
+///
+/// The value should be ADBC_OPTION_VALUE_ENABLED or
+/// ADBC_OPTION_VALUE_DISABLED (the default).
+///
+/// This is not supported with ADBC_INGEST_OPTION_TARGET_CATALOG and
+/// ADBC_INGEST_OPTION_TARGET_DB_SCHEMA.
+///
+/// The type is char*.
+#define ADBC_INGEST_OPTION_TEMPORARY "adbc.ingest.temporary"
+
+#ifdef __cplusplus
+}
+#endif

package/src/duckdb/src/include/duckdb/common/adbc/single_batch_array_stream.hpp

@@ -1,3 +1,11 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// common/adbc/single_batch_array_stream.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
 #pragma once
 
 #include "duckdb/common/arrow/arrow.hpp"

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

@@ -22,7 +22,7 @@ extern "C" {
 #define ARROW_FLAG_MAP_KEYS_SORTED    4
 
 struct ArrowSchema {
-	// Array type description
+	//! Array type description
 	const char *format;
 	const char *name;
 	const char *metadata;
@@ -31,14 +31,22 @@ struct ArrowSchema {
 	struct ArrowSchema **children;
 	struct ArrowSchema *dictionary;
 
-	// Release callback
+	//! Release callback
 	void (*release)(struct ArrowSchema *);
-	// Opaque producer-specific data
+	//! Opaque producer-specific data
 	void *private_data;
+
+	//! Initialize all fields
+	void Init() {
+		flags = 0;
+		n_children = 0;
+		release = nullptr;
+		private_data = nullptr;
+	}
 };
 
 struct ArrowArray {
-	// Array data description
+	//! Array data description
 	int64_t length;
 	int64_t null_count;
 	int64_t offset;
@@ -48,10 +56,21 @@ struct ArrowArray {
 	struct ArrowArray **children;
 	struct ArrowArray *dictionary;
 
-	// Release callback
+	//! Release callback
 	void (*release)(struct ArrowArray *);
-	// Opaque producer-specific data
+	//! Opaque producer-specific data
 	void *private_data;
+
+	//! Initialize all fields
+	void Init() {
+		length = 0;
+		null_count = 0;
+		offset = 0;
+		n_buffers = 0;
+		n_children = 0;
+		release = nullptr;
+		private_data = nullptr;
+	}
 };
 #endif
 

package/src/duckdb/src/include/duckdb/common/arrow/arrow_wrapper.hpp

@@ -9,7 +9,7 @@
 #pragma once
 #include "duckdb/common/arrow/arrow.hpp"
 #include "duckdb/common/helper.hpp"
-#include "duckdb/common/preserved_error.hpp"
+#include "duckdb/common/error_data.hpp"
 #include "duckdb/main/chunk_scan_state.hpp"
 #include "duckdb/main/client_properties.hpp"
 
@@ -62,10 +62,10 @@ public:
 class ArrowUtil {
 public:
 	static bool TryFetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out,
-	                          idx_t &result_count, PreservedError &error);
+	                          idx_t &result_count, ErrorData &error);
 	static idx_t FetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out);
 
 private:
-	static bool TryFetchNext(QueryResult &result, unique_ptr<DataChunk> &out, PreservedError &error);
+	static bool TryFetchNext(QueryResult &result, unique_ptr<DataChunk> &out, ErrorData &error);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/result_arrow_wrapper.hpp

@@ -20,7 +20,7 @@ public:
 public:
 	ArrowArrayStream stream;
 	unique_ptr<QueryResult> result;
-	PreservedError last_error;
+	ErrorData last_error;
 	idx_t batch_size;
 	vector<LogicalType> column_types;
 	vector<string> column_names;

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/hugeint.hpp"
+#include "duckdb/common/uhugeint.hpp"
 
 #ifdef _MSC_VER
 #define __restrict__
@@ -138,4 +139,33 @@ struct CountZeros<hugeint_t> {
 	}
 };
 
+template <>
+struct CountZeros<uhugeint_t> {
+	inline static int Leading(uhugeint_t value) {
+		const uint64_t upper = (uint64_t)value.upper;
+		const uint64_t lower = value.lower;
+
+		if (upper) {
+			return __builtin_clzll(upper);
+		} else if (lower) {
+			return 64 + __builtin_clzll(lower);
+		} else {
+			return 128;
+		}
+	}
+
+	inline static int Trailing(uhugeint_t value) {
+		const uint64_t upper = (uint64_t)value.upper;
+		const uint64_t lower = value.lower;
+
+		if (lower) {
+			return __builtin_ctzll(lower);
+		} else if (upper) {
+			return 64 + __builtin_ctzll(upper);
+		} else {
+			return 128;
+		}
+	}
+};
+
 } // namespace duckdb

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

@@ -20,8 +20,8 @@ namespace duckdb {
 using bitpacking_width_t = uint8_t;
 
 struct HugeIntPacker {
-	static void Pack(const hugeint_t *__restrict in, uint32_t *__restrict out, bitpacking_width_t width);
-	static void Unpack(const uint32_t *__restrict in, hugeint_t *__restrict out, bitpacking_width_t width);
+	static void Pack(const uhugeint_t *__restrict in, uint32_t *__restrict out, bitpacking_width_t width);
+	static void Unpack(const uint32_t *__restrict in, uhugeint_t *__restrict out, bitpacking_width_t width);
 };
 
 class BitpackingPrimitives {
@@ -223,8 +223,8 @@ private:
 		} else if (std::is_same<T, int64_t>::value || std::is_same<T, uint64_t>::value) {
 			duckdb_fastpforlib::fastpack(reinterpret_cast<const uint64_t *>(values), reinterpret_cast<uint32_t *>(dst),
 			                             static_cast<uint32_t>(width));
-		} else if (std::is_same<T, hugeint_t>::value) {
-			HugeIntPacker::Pack(reinterpret_cast<const hugeint_t *>(values), reinterpret_cast<uint32_t *>(dst), width);
+		} else if (std::is_same<T, hugeint_t>::value || std::is_same<T, uhugeint_t>::value) {
+			HugeIntPacker::Pack(reinterpret_cast<const uhugeint_t *>(values), reinterpret_cast<uint32_t *>(dst), width);
 		} else {
 			throw InternalException("Unsupported type for bitpacking");
 		}
@@ -245,8 +245,8 @@ private:
 		} else if (std::is_same<T, int64_t>::value || std::is_same<T, uint64_t>::value) {
 			duckdb_fastpforlib::fastunpack(reinterpret_cast<const uint32_t *>(src), reinterpret_cast<uint64_t *>(dst),
 			                               static_cast<uint32_t>(width));
-		} else if (std::is_same<T, hugeint_t>::value) {
-			HugeIntPacker::Unpack(reinterpret_cast<const uint32_t *>(src), reinterpret_cast<hugeint_t *>(dst), width);
+		} else if (std::is_same<T, hugeint_t>::value || std::is_same<T, uhugeint_t>::value) {
+			HugeIntPacker::Unpack(reinterpret_cast<const uint32_t *>(src), reinterpret_cast<uhugeint_t *>(dst), width);
 		} else {
 			throw InternalException("Unsupported type for bitpacking");
 		}

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

@@ -13,6 +13,7 @@
 #include "duckdb/common/string.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/helper.hpp"
+#include "duckdb/common/map.hpp"
 
 namespace duckdb {
 
@@ -34,4 +35,13 @@ using case_insensitive_map_t =
 
 using case_insensitive_set_t = unordered_set<string, CaseInsensitiveStringHashFunction, CaseInsensitiveStringEquality>;
 
+struct CaseInsensitiveStringCompare {
+	bool operator()(const string &s1, const string &s2) const {
+		return StringUtil::CILessThan(s1, s2);
+	}
+};
+
+template <typename T>
+using case_insensitive_tree_t = map<string, T, CaseInsensitiveStringCompare>;
+
 } // namespace duckdb

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

@@ -33,6 +33,7 @@ using std::move;
 #define INVALID_CATALOG ""
 #define SYSTEM_CATALOG  "system"
 #define TEMP_CATALOG    "temp"
+#define IN_MEMORY_PATH  ":memory:"
 
 DUCKDB_API bool IsInvalidSchema(const string &str);
 DUCKDB_API bool IsInvalidCatalog(const string &str);

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

@@ -34,6 +34,8 @@ struct EnumUtil {
 
 enum class AccessMode : uint8_t;
 
+enum class AggregateCombineType : uint8_t;
+
 enum class AggregateHandling : uint8_t;
 
 enum class AggregateOrderDependent : uint8_t;
@@ -98,6 +100,10 @@ enum class DebugInitialize : uint8_t;
 
 enum class DefaultOrderByNullType : uint8_t;
 
+enum class DependencyEntryType : uint8_t;
+
+enum class DeprecatedIndexType : uint8_t;
+
 enum class DistinctType : uint8_t;
 
 enum class ErrorType : uint16_t;
@@ -114,6 +120,8 @@ enum class ExpressionType : uint8_t;
 
 enum class ExtensionLoadResult : uint8_t;
 
+enum class ExtraDropInfoType : uint8_t;
+
 enum class ExtraTypeInfoType : uint8_t;
 
 enum class FileBufferType : uint8_t;
@@ -130,14 +138,12 @@ enum class ForeignKeyType : uint8_t;
 
 enum class FunctionNullHandling : uint8_t;
 
-enum class FunctionSideEffects : uint8_t;
+enum class FunctionStability : uint8_t;
 
 enum class HLLStorageType : uint8_t;
 
 enum class IndexConstraintType : uint8_t;
 
-enum class IndexType : uint8_t;
-
 enum class InsertColumnOrder : uint8_t;
 
 enum class InterruptMode : uint8_t;
@@ -160,6 +166,8 @@ enum class MacroType : uint8_t;
 
 enum class MapInvalidReason : uint8_t;
 
+enum class MemoryTag : uint8_t;
+
 enum class NType : uint8_t;
 
 enum class NewLineIdentifier : uint8_t;
@@ -188,8 +196,6 @@ enum class ParseInfoType : uint8_t;
 
 enum class ParserExtensionResultType : uint8_t;
 
-enum class ParserMode : uint8_t;
-
 enum class PartitionSortStage : uint8_t;
 
 enum class PartitionedColumnDataType : uint8_t;
@@ -224,6 +230,10 @@ enum class ResultModifierType : uint8_t;
 
 enum class SampleMethod : uint8_t;
 
+enum class SecretDisplayType : uint8_t;
+
+enum class SecretPersistType : uint8_t;
+
 enum class SequenceInfo : uint8_t;
 
 enum class SetOperationType : uint8_t;
@@ -232,6 +242,8 @@ enum class SetScope : uint8_t;
 
 enum class SetType : uint8_t;
 
+enum class ShowType : uint8_t;
+
 enum class SimplifiedTokenType : uint8_t;
 
 enum class SinkCombineResultType : uint8_t;
@@ -294,10 +306,15 @@ enum class WindowAggregationMode : uint32_t;
 
 enum class WindowBoundary : uint8_t;
 
+enum class WindowExcludeMode : uint8_t;
+
 
 template<>
 const char* EnumUtil::ToChars<AccessMode>(AccessMode value);
 
+template<>
+const char* EnumUtil::ToChars<AggregateCombineType>(AggregateCombineType value);
+
 template<>
 const char* EnumUtil::ToChars<AggregateHandling>(AggregateHandling value);
 
@@ -394,6 +411,12 @@ const char* EnumUtil::ToChars<DebugInitialize>(DebugInitialize value);
 template<>
 const char* EnumUtil::ToChars<DefaultOrderByNullType>(DefaultOrderByNullType value);
 
+template<>
+const char* EnumUtil::ToChars<DependencyEntryType>(DependencyEntryType value);
+
+template<>
+const char* EnumUtil::ToChars<DeprecatedIndexType>(DeprecatedIndexType value);
+
 template<>
 const char* EnumUtil::ToChars<DistinctType>(DistinctType value);
 
@@ -418,6 +441,9 @@ const char* EnumUtil::ToChars<ExpressionType>(ExpressionType value);
 template<>
 const char* EnumUtil::ToChars<ExtensionLoadResult>(ExtensionLoadResult value);
 
+template<>
+const char* EnumUtil::ToChars<ExtraDropInfoType>(ExtraDropInfoType value);
+
 template<>
 const char* EnumUtil::ToChars<ExtraTypeInfoType>(ExtraTypeInfoType value);
 
@@ -443,7 +469,7 @@ template<>
 const char* EnumUtil::ToChars<FunctionNullHandling>(FunctionNullHandling value);
 
 template<>
-const char* EnumUtil::ToChars<FunctionSideEffects>(FunctionSideEffects value);
+const char* EnumUtil::ToChars<FunctionStability>(FunctionStability value);
 
 template<>
 const char* EnumUtil::ToChars<HLLStorageType>(HLLStorageType value);
@@ -451,9 +477,6 @@ const char* EnumUtil::ToChars<HLLStorageType>(HLLStorageType value);
 template<>
 const char* EnumUtil::ToChars<IndexConstraintType>(IndexConstraintType value);
 
-template<>
-const char* EnumUtil::ToChars<IndexType>(IndexType value);
-
 template<>
 const char* EnumUtil::ToChars<InsertColumnOrder>(InsertColumnOrder value);
 
@@ -487,6 +510,9 @@ const char* EnumUtil::ToChars<MacroType>(MacroType value);
 template<>
 const char* EnumUtil::ToChars<MapInvalidReason>(MapInvalidReason value);
 
+template<>
+const char* EnumUtil::ToChars<MemoryTag>(MemoryTag value);
+
 template<>
 const char* EnumUtil::ToChars<NType>(NType value);
 
@@ -529,9 +555,6 @@ const char* EnumUtil::ToChars<ParseInfoType>(ParseInfoType value);
 template<>
 const char* EnumUtil::ToChars<ParserExtensionResultType>(ParserExtensionResultType value);
 
-template<>
-const char* EnumUtil::ToChars<ParserMode>(ParserMode value);
-
 template<>
 const char* EnumUtil::ToChars<PartitionSortStage>(PartitionSortStage value);
 
@@ -583,6 +606,12 @@ const char* EnumUtil::ToChars<ResultModifierType>(ResultModifierType value);
 template<>
 const char* EnumUtil::ToChars<SampleMethod>(SampleMethod value);
 
+template<>
+const char* EnumUtil::ToChars<SecretDisplayType>(SecretDisplayType value);
+
+template<>
+const char* EnumUtil::ToChars<SecretPersistType>(SecretPersistType value);
+
 template<>
 const char* EnumUtil::ToChars<SequenceInfo>(SequenceInfo value);
 
@@ -595,6 +624,9 @@ const char* EnumUtil::ToChars<SetScope>(SetScope value);
 template<>
 const char* EnumUtil::ToChars<SetType>(SetType value);
 
+template<>
+const char* EnumUtil::ToChars<ShowType>(ShowType value);
+
 template<>
 const char* EnumUtil::ToChars<SimplifiedTokenType>(SimplifiedTokenType value);
 
@@ -688,10 +720,16 @@ const char* EnumUtil::ToChars<WindowAggregationMode>(WindowAggregationMode value
 template<>
 const char* EnumUtil::ToChars<WindowBoundary>(WindowBoundary value);
 
+template<>
+const char* EnumUtil::ToChars<WindowExcludeMode>(WindowExcludeMode value);
+
 
 template<>
 AccessMode EnumUtil::FromString<AccessMode>(const char *value);
 
+template<>
+AggregateCombineType EnumUtil::FromString<AggregateCombineType>(const char *value);
+
 template<>
 AggregateHandling EnumUtil::FromString<AggregateHandling>(const char *value);
 
@@ -788,6 +826,12 @@ DebugInitialize EnumUtil::FromString<DebugInitialize>(const char *value);
 template<>
 DefaultOrderByNullType EnumUtil::FromString<DefaultOrderByNullType>(const char *value);
 
+template<>
+DependencyEntryType EnumUtil::FromString<DependencyEntryType>(const char *value);
+
+template<>
+DeprecatedIndexType EnumUtil::FromString<DeprecatedIndexType>(const char *value);
+
 template<>
 DistinctType EnumUtil::FromString<DistinctType>(const char *value);
 
@@ -812,6 +856,9 @@ ExpressionType EnumUtil::FromString<ExpressionType>(const char *value);
 template<>
 ExtensionLoadResult EnumUtil::FromString<ExtensionLoadResult>(const char *value);
 
+template<>
+ExtraDropInfoType EnumUtil::FromString<ExtraDropInfoType>(const char *value);
+
 template<>
 ExtraTypeInfoType EnumUtil::FromString<ExtraTypeInfoType>(const char *value);
 
@@ -837,7 +884,7 @@ template<>
 FunctionNullHandling EnumUtil::FromString<FunctionNullHandling>(const char *value);
 
 template<>
-FunctionSideEffects EnumUtil::FromString<FunctionSideEffects>(const char *value);
+FunctionStability EnumUtil::FromString<FunctionStability>(const char *value);
 
 template<>
 HLLStorageType EnumUtil::FromString<HLLStorageType>(const char *value);
@@ -845,9 +892,6 @@ HLLStorageType EnumUtil::FromString<HLLStorageType>(const char *value);
 template<>
 IndexConstraintType EnumUtil::FromString<IndexConstraintType>(const char *value);
 
-template<>
-IndexType EnumUtil::FromString<IndexType>(const char *value);
-
 template<>
 InsertColumnOrder EnumUtil::FromString<InsertColumnOrder>(const char *value);
 
@@ -881,6 +925,9 @@ MacroType EnumUtil::FromString<MacroType>(const char *value);
 template<>
 MapInvalidReason EnumUtil::FromString<MapInvalidReason>(const char *value);
 
+template<>
+MemoryTag EnumUtil::FromString<MemoryTag>(const char *value);
+
 template<>
 NType EnumUtil::FromString<NType>(const char *value);
 
@@ -923,9 +970,6 @@ ParseInfoType EnumUtil::FromString<ParseInfoType>(const char *value);
 template<>
 ParserExtensionResultType EnumUtil::FromString<ParserExtensionResultType>(const char *value);
 
-template<>
-ParserMode EnumUtil::FromString<ParserMode>(const char *value);
-
 template<>
 PartitionSortStage EnumUtil::FromString<PartitionSortStage>(const char *value);
 
@@ -977,6 +1021,12 @@ ResultModifierType EnumUtil::FromString<ResultModifierType>(const char *value);
 template<>
 SampleMethod EnumUtil::FromString<SampleMethod>(const char *value);
 
+template<>
+SecretDisplayType EnumUtil::FromString<SecretDisplayType>(const char *value);
+
+template<>
+SecretPersistType EnumUtil::FromString<SecretPersistType>(const char *value);
+
 template<>
 SequenceInfo EnumUtil::FromString<SequenceInfo>(const char *value);
 
@@ -989,6 +1039,9 @@ SetScope EnumUtil::FromString<SetScope>(const char *value);
 template<>
 SetType EnumUtil::FromString<SetType>(const char *value);
 
+template<>
+ShowType EnumUtil::FromString<ShowType>(const char *value);
+
 template<>
 SimplifiedTokenType EnumUtil::FromString<SimplifiedTokenType>(const char *value);
 
@@ -1082,5 +1135,8 @@ WindowAggregationMode EnumUtil::FromString<WindowAggregationMode>(const char *va
 template<>
 WindowBoundary EnumUtil::FromString<WindowBoundary>(const char *value);
 
+template<>
+WindowExcludeMode EnumUtil::FromString<WindowExcludeMode>(const char *value);
+
 
 }

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

@@ -37,10 +37,20 @@ enum class CatalogType : uint8_t {
 	TABLE_MACRO_ENTRY = 31,
 
 	// version info
-	UPDATED_ENTRY = 50,
 	DELETED_ENTRY = 51,
+	RENAMED_ENTRY = 52,
+
+	// secrets
+	SECRET_ENTRY = 71,
+	SECRET_TYPE_ENTRY = 72,
+	SECRET_FUNCTION_ENTRY = 73,
+
+	// dependency info
+	DEPENDENCY_ENTRY = 100
+
 };
 
 DUCKDB_API string CatalogTypeToString(CatalogType type);
+CatalogType CatalogTypeFromString(const string &type);
 
 } // namespace duckdb

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

@@ -24,9 +24,12 @@ enum class CompressionType : uint8_t {
 	COMPRESSION_FSST = 7,
 	COMPRESSION_CHIMP = 8,
 	COMPRESSION_PATAS = 9,
+	COMPRESSION_ALP = 10,
+	COMPRESSION_ALPRD = 11,
 	COMPRESSION_COUNT // This has to stay the last entry of the type!
 };
 
+bool CompressionTypeIsDeprecated(CompressionType compression_type);
 vector<string> ListCompressionTypes(void);
 CompressionType CompressionTypeFromString(const string &str);
 string CompressionTypeToString(CompressionType type);

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

@@ -133,6 +133,7 @@ enum class ExpressionType : uint8_t {
 	COLUMN_REF = 203,
 	FUNCTION_REF = 204,
 	TABLE_REF = 205,
+	LAMBDA_REF = 206,
 
 	// -----------------------------
 	// Miscellaneous
@@ -173,6 +174,7 @@ enum class ExpressionClass : uint8_t {
 	LAMBDA = 17,
 	POSITIONAL_REFERENCE = 18,
 	BETWEEN = 19,
+	LAMBDA_REF = 20,
 	//===--------------------------------------------------------------------===//
 	// Bound Expressions
 	//===--------------------------------------------------------------------===//