duckdb 0.10.2-dev0.0 → 0.10.2-dev3.0

package/src/duckdb/src/include/duckdb/catalog/dependency_list.hpp

@@ -9,23 +9,56 @@
 #pragma once
 
 #include "duckdb/catalog/catalog_entry_map.hpp"
+#include "duckdb/common/types/hash.hpp"
+#include "duckdb/common/enums/catalog_type.hpp"
+#include "duckdb/catalog/dependency.hpp"
 
 namespace duckdb {
 class Catalog;
 class CatalogEntry;
-class DependencySetCatalogEntry;
+struct CreateInfo;
+class SchemaCatalogEntry;
+struct CatalogTransaction;
+class LogicalDependencyList;
 
-//! The DependencyList
-class DependencyList {
-	friend class DependencyManager;
-	friend class DependencySetCatalogEntry;
+//! A minimal representation of a CreateInfo / CatalogEntry
+//! enough to look up the entry inside SchemaCatalogEntry::GetEntry
+struct LogicalDependency {
+public:
+	CatalogEntryInfo entry;
+	string catalog;
+
+public:
+	explicit LogicalDependency(CatalogEntry &entry);
+	LogicalDependency();
+	bool operator==(const LogicalDependency &other) const;
+};
+
+struct LogicalDependencyHashFunction {
+	uint64_t operator()(const LogicalDependency &a) const;
+};
+
+struct LogicalDependencyEquality {
+	bool operator()(const LogicalDependency &a, const LogicalDependency &b) const;
+};
+
+//! The DependencyList containing LogicalDependency objects, not looked up in the catalog yet
+class LogicalDependencyList {
+	using create_info_set_t =
+	    unordered_set<LogicalDependency, LogicalDependencyHashFunction, LogicalDependencyEquality>;
 
 public:
 	DUCKDB_API void AddDependency(CatalogEntry &entry);
+	DUCKDB_API void AddDependency(const LogicalDependency &entry);
+	DUCKDB_API bool Contains(CatalogEntry &entry);
 
+public:
 	DUCKDB_API void VerifyDependencies(Catalog &catalog, const string &name);
+	bool operator==(const LogicalDependencyList &other) const;
+	const create_info_set_t &Set() const;
 
 private:
-	catalog_entry_set_t set;
+	create_info_set_t set;
 };
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/dependency_manager.hpp

@@ -13,21 +13,16 @@
 #include "duckdb/catalog/dependency.hpp"
 #include "duckdb/catalog/catalog_entry_map.hpp"
 #include "duckdb/catalog/catalog_transaction.hpp"
+#include "duckdb/common/stack.hpp"
+#include "duckdb/common/string_util.hpp"
 
 #include <functional>
 
 namespace duckdb {
 class DuckCatalog;
 class ClientContext;
-class DependencyList;
 class DependencyEntry;
-class DependencySetCatalogEntry;
-
-struct CatalogEntryInfo {
-	CatalogType type;
-	string schema;
-	string name;
-};
+class LogicalDependencyList;
 
 // The subject of this dependency
 struct DependencySubject {
@@ -57,12 +52,20 @@ public:
 
 struct MangledEntryName {
 public:
-	MangledEntryName(const CatalogEntryInfo &info);
+	explicit MangledEntryName(const CatalogEntryInfo &info);
 	MangledEntryName() = delete;
 
 public:
 	//! Format: Type\0Schema\0Name
 	string name;
+
+public:
+	bool operator==(const MangledEntryName &other) const {
+		return StringUtil::CIEquals(other.name, name);
+	}
+	bool operator!=(const MangledEntryName &other) const {
+		return !(*this == other);
+	}
 };
 
 struct MangledDependencyName {
@@ -78,7 +81,6 @@ public:
 //! The DependencyManager is in charge of managing dependencies between catalog entries
 class DependencyManager {
 	friend class CatalogSet;
-	friend class DependencySetCatalogEntry;
 
 public:
 	explicit DependencyManager(DuckCatalog &catalog);
@@ -96,24 +98,27 @@ private:
 
 private:
 	bool IsSystemEntry(CatalogEntry &entry) const;
+	optional_ptr<CatalogEntry> LookupEntry(CatalogTransaction transaction, const LogicalDependency &dependency);
 	optional_ptr<CatalogEntry> LookupEntry(CatalogTransaction transaction, CatalogEntry &dependency);
 
 	void CleanupDependencies(CatalogTransaction transaction, CatalogEntry &entry);
 
 public:
-	static string GetSchema(CatalogEntry &entry);
+	static string GetSchema(const CatalogEntry &entry);
 	static MangledEntryName MangleName(const CatalogEntryInfo &info);
-	static MangledEntryName MangleName(CatalogEntry &entry);
-	static CatalogEntryInfo GetLookupProperties(CatalogEntry &entry);
+	static MangledEntryName MangleName(const CatalogEntry &entry);
+	static CatalogEntryInfo GetLookupProperties(const CatalogEntry &entry);
 
 private:
-	void AddObject(CatalogTransaction transaction, CatalogEntry &object, const DependencyList &dependencies);
+	void AddObject(CatalogTransaction transaction, CatalogEntry &object, const LogicalDependencyList &dependencies);
 	void DropObject(CatalogTransaction transaction, CatalogEntry &object, bool cascade);
 	void AlterObject(CatalogTransaction transaction, CatalogEntry &old_obj, CatalogEntry &new_obj);
 
 private:
 	void RemoveDependency(CatalogTransaction transaction, const DependencyInfo &info);
 	void CreateDependency(CatalogTransaction transaction, DependencyInfo &info);
+	void CreateDependencies(CatalogTransaction transaction, const CatalogEntry &object,
+	                        const LogicalDependencyList &dependencies);
 	using dependency_entry_func_t = const std::function<unique_ptr<DependencyEntry>(
 	    Catalog &catalog, const DependencyDependent &dependent, const DependencySubject &dependency)>;
 

package/src/duckdb/src/include/duckdb/catalog/duck_catalog.hpp

@@ -16,7 +16,7 @@ namespace duckdb {
 class DuckCatalog : public Catalog {
 public:
 	explicit DuckCatalog(AttachedDatabase &db);
-	~DuckCatalog();
+	~DuckCatalog() override;
 
 public:
 	bool IsDuckCatalog() override;

package/src/duckdb/src/include/duckdb/catalog/standard_entry.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/catalog/catalog_entry.hpp"
+#include "duckdb/catalog/dependency_list.hpp"
 
 namespace duckdb {
 class SchemaCatalogEntry;
@@ -29,6 +30,9 @@ public:
 	SchemaCatalogEntry &ParentSchema() override {
 		return schema;
 	}
+	const SchemaCatalogEntry &ParentSchema() const override {
+		return schema;
+	}
 };
 
 } // namespace duckdb

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

@@ -36,7 +36,7 @@ struct PrivateAllocatorData {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
@@ -58,10 +58,10 @@ public:
 	DUCKDB_API AllocatedData(AllocatedData &&other) noexcept;
 	DUCKDB_API AllocatedData &operator=(AllocatedData &&) noexcept;
 
-	data_ptr_t get() {
+	data_ptr_t get() { // NOLINT: matching std style
 		return pointer;
 	}
-	const_data_ptr_t get() const {
+	const_data_ptr_t get() const { // NOLINT: matching std style
 		return pointer;
 	}
 	idx_t GetSize() const {

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

@@ -35,7 +35,7 @@ public:
 		arrow_array.length = 0;
 		arrow_array.release = nullptr;
 	}
-	ArrowArrayWrapper(ArrowArrayWrapper &&other) : arrow_array(other.arrow_array) {
+	ArrowArrayWrapper(ArrowArrayWrapper &&other) noexcept : arrow_array(other.arrow_array) {
 		other.arrow_array.release = nullptr;
 	}
 	~ArrowArrayWrapper();

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

@@ -11,7 +11,7 @@
 #include "duckdb/common/hugeint.hpp"
 #include "duckdb/common/uhugeint.hpp"
 
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && !defined(__clang__)
 #define __restrict__
 #define __BYTE_ORDER__          __ORDER_LITTLE_ENDIAN__
 #define __ORDER_LITTLE_ENDIAN__ 2

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

@@ -37,22 +37,22 @@ struct BoxRendererConfig {
 	RenderMode render_mode = RenderMode::ROWS;
 
 #ifndef DUCKDB_ASCII_TREE_RENDERER
-	const char *LTCORNER = "\342\224\214"; // "┌";
-	const char *RTCORNER = "\342\224\220"; // "┐";
-	const char *LDCORNER = "\342\224\224"; // "└";
-	const char *RDCORNER = "\342\224\230"; // "┘";
-
-	const char *MIDDLE = "\342\224\274";  // "┼";
-	const char *TMIDDLE = "\342\224\254"; // "┬";
-	const char *LMIDDLE = "\342\224\234"; // "├";
-	const char *RMIDDLE = "\342\224\244"; // "┤";
-	const char *DMIDDLE = "\342\224\264"; // "┴";
-
-	const char *VERTICAL = "\342\224\202";   // "│";
-	const char *HORIZONTAL = "\342\224\200"; // "─";
-
-	const char *DOTDOTDOT = "\xE2\x80\xA6"; // "…";
-	const char *DOT = "\xC2\xB7";           // "·";
+	const char *LTCORNER = "\342\224\214"; // NOLINT: "┌";
+	const char *RTCORNER = "\342\224\220"; // NOLINT: "┐";
+	const char *LDCORNER = "\342\224\224"; // NOLINT: "└";
+	const char *RDCORNER = "\342\224\230"; // NOLINT: "┘";
+
+	const char *MIDDLE = "\342\224\274";  // NOLINT: "┼";
+	const char *TMIDDLE = "\342\224\254"; // NOLINT: "┬";
+	const char *LMIDDLE = "\342\224\234"; // NOLINT: "├";
+	const char *RMIDDLE = "\342\224\244"; // NOLINT: "┤";
+	const char *DMIDDLE = "\342\224\264"; // NOLINT: "┴";
+
+	const char *VERTICAL = "\342\224\202";   // NOLINT: "│";
+	const char *HORIZONTAL = "\342\224\200"; // NOLINT: "─";
+
+	const char *DOTDOTDOT = "\xE2\x80\xA6"; // NOLINT: "…";
+	const char *DOT = "\xC2\xB7";           // NOLINT: "·";
 	const idx_t DOTDOTDOT_LENGTH = 1;
 
 #else

package/src/duckdb/src/include/duckdb/common/crypto/md5.hpp

@@ -41,7 +41,6 @@ public:
 
 private:
 	void MD5Update(const_data_ptr_t data, idx_t len);
-	static void DigestToBase16(const_data_ptr_t digest, char *zBuf);
 
 	uint32_t buf[4];
 	uint32_t bits[2];

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

@@ -58,6 +58,8 @@ enum class AppenderType : uint8_t;
 
 enum class ArrowDateTimeType : uint8_t;
 
+enum class ArrowOffsetSize : uint8_t;
+
 enum class ArrowVariableSizeType : uint8_t;
 
 enum class BindingMode : uint8_t;
@@ -112,6 +114,8 @@ enum class ErrorType : uint16_t;
 
 enum class ExceptionFormatValueType : uint8_t;
 
+enum class ExceptionType : uint8_t;
+
 enum class ExplainOutputType : uint8_t;
 
 enum class ExplainType : uint8_t;
@@ -122,6 +126,8 @@ enum class ExpressionType : uint8_t;
 
 enum class ExtensionLoadResult : uint8_t;
 
+enum class ExternalDependenciesType : uint8_t;
+
 enum class ExtraDropInfoType : uint8_t;
 
 enum class ExtraTypeInfoType : uint8_t;
@@ -236,6 +242,8 @@ enum class ResultModifierType : uint8_t;
 
 enum class SampleMethod : uint8_t;
 
+enum class ScanType : uint8_t;
+
 enum class SecretDisplayType : uint8_t;
 
 enum class SecretPersistType : uint8_t;
@@ -356,6 +364,9 @@ const char* EnumUtil::ToChars<AppenderType>(AppenderType value);
 template<>
 const char* EnumUtil::ToChars<ArrowDateTimeType>(ArrowDateTimeType value);
 
+template<>
+const char* EnumUtil::ToChars<ArrowOffsetSize>(ArrowOffsetSize value);
+
 template<>
 const char* EnumUtil::ToChars<ArrowVariableSizeType>(ArrowVariableSizeType value);
 
@@ -437,6 +448,9 @@ const char* EnumUtil::ToChars<ErrorType>(ErrorType value);
 template<>
 const char* EnumUtil::ToChars<ExceptionFormatValueType>(ExceptionFormatValueType value);
 
+template<>
+const char* EnumUtil::ToChars<ExceptionType>(ExceptionType value);
+
 template<>
 const char* EnumUtil::ToChars<ExplainOutputType>(ExplainOutputType value);
 
@@ -452,6 +466,9 @@ const char* EnumUtil::ToChars<ExpressionType>(ExpressionType value);
 template<>
 const char* EnumUtil::ToChars<ExtensionLoadResult>(ExtensionLoadResult value);
 
+template<>
+const char* EnumUtil::ToChars<ExternalDependenciesType>(ExternalDependenciesType value);
+
 template<>
 const char* EnumUtil::ToChars<ExtraDropInfoType>(ExtraDropInfoType value);
 
@@ -623,6 +640,9 @@ const char* EnumUtil::ToChars<ResultModifierType>(ResultModifierType value);
 template<>
 const char* EnumUtil::ToChars<SampleMethod>(SampleMethod value);
 
+template<>
+const char* EnumUtil::ToChars<ScanType>(ScanType value);
+
 template<>
 const char* EnumUtil::ToChars<SecretDisplayType>(SecretDisplayType value);
 
@@ -783,6 +803,9 @@ AppenderType EnumUtil::FromString<AppenderType>(const char *value);
 template<>
 ArrowDateTimeType EnumUtil::FromString<ArrowDateTimeType>(const char *value);
 
+template<>
+ArrowOffsetSize EnumUtil::FromString<ArrowOffsetSize>(const char *value);
+
 template<>
 ArrowVariableSizeType EnumUtil::FromString<ArrowVariableSizeType>(const char *value);
 
@@ -864,6 +887,9 @@ ErrorType EnumUtil::FromString<ErrorType>(const char *value);
 template<>
 ExceptionFormatValueType EnumUtil::FromString<ExceptionFormatValueType>(const char *value);
 
+template<>
+ExceptionType EnumUtil::FromString<ExceptionType>(const char *value);
+
 template<>
 ExplainOutputType EnumUtil::FromString<ExplainOutputType>(const char *value);
 
@@ -879,6 +905,9 @@ ExpressionType EnumUtil::FromString<ExpressionType>(const char *value);
 template<>
 ExtensionLoadResult EnumUtil::FromString<ExtensionLoadResult>(const char *value);
 
+template<>
+ExternalDependenciesType EnumUtil::FromString<ExternalDependenciesType>(const char *value);
+
 template<>
 ExtraDropInfoType EnumUtil::FromString<ExtraDropInfoType>(const char *value);
 
@@ -1050,6 +1079,9 @@ ResultModifierType EnumUtil::FromString<ResultModifierType>(const char *value);
 template<>
 SampleMethod EnumUtil::FromString<SampleMethod>(const char *value);
 
+template<>
+ScanType EnumUtil::FromString<ScanType>(const char *value);
+
 template<>
 SecretDisplayType EnumUtil::FromString<SecretDisplayType>(const char *value);
 

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

@@ -145,7 +145,8 @@ enum class ExpressionType : uint8_t {
 	COLLATE = 230,
 	LAMBDA = 231,
 	POSITIONAL_REFERENCE = 232,
-	BOUND_LAMBDA_REF = 233
+	BOUND_LAMBDA_REF = 233,
+	BOUND_EXPANDED = 234
 };
 
 //===--------------------------------------------------------------------===//
@@ -199,7 +200,8 @@ enum class ExpressionClass : uint8_t {
 	//===--------------------------------------------------------------------===//
 	// Miscellaneous
 	//===--------------------------------------------------------------------===//
-	BOUND_EXPRESSION = 50
+	BOUND_EXPRESSION = 50,
+	BOUND_EXPANDED = 51
 };
 
 DUCKDB_API string ExpressionTypeToString(ExpressionType type);

package/src/duckdb/src/include/duckdb/common/exception/binder_exception.hpp

@@ -18,23 +18,27 @@ public:
 	DUCKDB_API explicit BinderException(const string &msg, const unordered_map<string, string> &extra_info);
 	DUCKDB_API explicit BinderException(const string &msg);
 
-	template <typename... Args>
-	explicit BinderException(const string &msg, Args... params) : BinderException(ConstructMessage(msg, params...)) {
+	template <typename... ARGS>
+	explicit BinderException(const string &msg, ARGS... params) : BinderException(ConstructMessage(msg, params...)) {
 	}
-	template <typename... Args>
-	explicit BinderException(const TableRef &ref, const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit BinderException(const TableRef &ref, const string &msg, ARGS... params)
 	    : BinderException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(ref)) {
 	}
-	template <typename... Args>
-	explicit BinderException(const ParsedExpression &expr, const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit BinderException(const ParsedExpression &expr, const string &msg, ARGS... params)
 	    : BinderException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(expr)) {
 	}
-	template <typename... Args>
-	explicit BinderException(QueryErrorContext error_context, const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit BinderException(const Expression &expr, const string &msg, ARGS... params)
+	    : BinderException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(expr)) {
+	}
+	template <typename... ARGS>
+	explicit BinderException(QueryErrorContext error_context, const string &msg, ARGS... params)
 	    : BinderException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(error_context)) {
 	}
-	template <typename... Args>
-	explicit BinderException(optional_idx error_location, const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit BinderException(optional_idx error_location, const string &msg, ARGS... params)
 	    : BinderException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(error_location)) {
 	}
 

package/src/duckdb/src/include/duckdb/common/exception/catalog_exception.hpp

@@ -20,11 +20,11 @@ public:
 	DUCKDB_API explicit CatalogException(const string &msg);
 	DUCKDB_API explicit CatalogException(const string &msg, const unordered_map<string, string> &extra_info);
 
-	template <typename... Args>
-	explicit CatalogException(const string &msg, Args... params) : CatalogException(ConstructMessage(msg, params...)) {
+	template <typename... ARGS>
+	explicit CatalogException(const string &msg, ARGS... params) : CatalogException(ConstructMessage(msg, params...)) {
 	}
-	template <typename... Args>
-	explicit CatalogException(QueryErrorContext error_context, const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit CatalogException(QueryErrorContext error_context, const string &msg, ARGS... params)
 	    : CatalogException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(error_context)) {
 	}
 

package/src/duckdb/src/include/duckdb/common/exception/conversion_exception.hpp

@@ -17,15 +17,15 @@ class ConversionException : public Exception {
 public:
 	DUCKDB_API explicit ConversionException(const string &msg);
 	DUCKDB_API explicit ConversionException(optional_idx error_location, const string &msg);
-	DUCKDB_API ConversionException(const PhysicalType origType, const PhysicalType newType);
-	DUCKDB_API ConversionException(const LogicalType &origType, const LogicalType &newType);
+	DUCKDB_API ConversionException(const PhysicalType orig_type, const PhysicalType new_type);
+	DUCKDB_API ConversionException(const LogicalType &orig_type, const LogicalType &new_type);
 
-	template <typename... Args>
-	explicit ConversionException(const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit ConversionException(const string &msg, ARGS... params)
 	    : ConversionException(ConstructMessage(msg, params...)) {
 	}
-	template <typename... Args>
-	explicit ConversionException(optional_idx error_location, const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit ConversionException(optional_idx error_location, const string &msg, ARGS... params)
 	    : ConversionException(error_location, ConstructMessage(msg, params...)) {
 	}
 };

package/src/duckdb/src/include/duckdb/common/exception/http_exception.hpp

@@ -17,10 +17,10 @@ class HTTPException : public Exception {
 public:
 	template <typename>
 	struct ResponseShape {
-		typedef int status;
+		typedef int status; // NOLINT
 	};
 
-	explicit HTTPException(string message) : Exception(ExceptionType::HTTP, std::move(message)) {
+	explicit HTTPException(const string &message) : Exception(ExceptionType::HTTP, message) {
 	}
 
 	template <class RESPONSE, typename ResponseShape<decltype(RESPONSE::status)>::status = 0, typename... ARGS>
@@ -30,7 +30,7 @@ public:
 
 	template <typename>
 	struct ResponseWrapperShape {
-		typedef int code;
+		typedef int code; // NOLINT
 	};
 
 	template <class RESPONSE, typename ResponseWrapperShape<decltype(RESPONSE::code)>::code = 0, typename... ARGS>

package/src/duckdb/src/include/duckdb/common/exception/parser_exception.hpp

@@ -19,11 +19,11 @@ public:
 	DUCKDB_API explicit ParserException(const string &msg);
 	DUCKDB_API explicit ParserException(const string &msg, const unordered_map<string, string> &extra_info);
 
-	template <typename... Args>
-	explicit ParserException(const string &msg, Args... params) : ParserException(ConstructMessage(msg, params...)) {
+	template <typename... ARGS>
+	explicit ParserException(const string &msg, ARGS... params) : ParserException(ConstructMessage(msg, params...)) {
 	}
-	template <typename... Args>
-	explicit ParserException(optional_idx error_location, const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit ParserException(optional_idx error_location, const string &msg, ARGS... params)
 	    : ParserException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(error_location)) {
 	}
 

package/src/duckdb/src/include/duckdb/common/exception/transaction_exception.hpp

@@ -16,8 +16,8 @@ class TransactionException : public Exception {
 public:
 	DUCKDB_API explicit TransactionException(const string &msg);
 
-	template <typename... Args>
-	explicit TransactionException(const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit TransactionException(const string &msg, ARGS... params)
 	    : TransactionException(ConstructMessage(msg, params...)) {
 	}
 };