duckdb 0.7.2-dev2507.0 → 0.7.2-dev2675.0

package/src/duckdb/src/include/duckdb/execution/index/art/swizzleable_pointer.hpp

@@ -7,45 +7,52 @@
 //===----------------------------------------------------------------------===//
 #pragma once
 
-#include "duckdb/execution/index/art/node.hpp"
+#include "duckdb/common/constants.hpp"
 
 namespace duckdb {
 
-class ART;
-class Node;
+// classes
+class MetaBlockReader;
 
-// SwizzleablePointer assumes that the 64-bit blockId always has 0s in the top
-// 33 bits. It thus uses 8 bytes of memory rather than 12.
+// structs
+struct BlockPointer;
+
+//! SwizzleablePointer provides functions on a (possibly) swizzled pointer. If the swizzle flag is set, then the
+//! pointer points to a storage address (and has no type), otherwise the pointer has a type and stores
+//! other information (e.g., a buffer location)
 class SwizzleablePointer {
 public:
-	~SwizzleablePointer();
-	explicit SwizzleablePointer(duckdb::MetaBlockReader &reader);
-	SwizzleablePointer() : pointer(0) {};
-
-	BlockPointer Serialize(ART &art, duckdb::MetaBlockWriter &writer);
-
-	//! Transforms from Node* to uint64_t
-	SwizzleablePointer &operator=(const Node *ptr);
+	//! Constructs an empty SwizzleablePointer
+	SwizzleablePointer() : swizzle_flag(0), type(0), offset(0), buffer_id(0) {};
+	//! Constructs a swizzled pointer from a buffer ID and an offset
+	explicit SwizzleablePointer(MetaBlockReader &reader);
+	//! Constructs a non-swizzled pointer from a buffer ID and an offset
+	SwizzleablePointer(uint32_t offset, uint32_t buffer_id)
+	    : swizzle_flag(0), type(0), offset(offset), buffer_id(buffer_id) {};
+
+	//! The swizzle flag, set if swizzled, not set otherwise
+	uint8_t swizzle_flag : 1;
+	//! The type of the pointer, zero if not set
+	uint8_t type : 7;
+	//! The offset of a memory location
+	uint32_t offset : 24;
+	//! The buffer ID of a memory location
+	uint32_t buffer_id : 32;
 
-	//! Checks if pointer is swizzled
-	bool IsSwizzled();
-	//! Unswizzle the pointer (if possible)
-	Node *Unswizzle(ART &art);
-
-	operator bool() const {
-		return pointer;
+public:
+	//! Checks if the pointer is swizzled
+	inline bool IsSwizzled() const {
+		return swizzle_flag;
+	}
+	//! Returns true, if neither the swizzle flag nor the type is set, and false otherwise
+	inline bool IsSet() const {
+		return swizzle_flag || type;
+	}
+	//! Reset the pointer
+	inline void Reset() {
+		swizzle_flag = 0;
+		type = 0;
 	}
-
-	//! Deletes the underlying object (if necessary) and set the pointer to nullptr
-	void Reset();
-
-private:
-	uint64_t pointer;
-
-	friend bool operator!=(const SwizzleablePointer &s_ptr, const uint64_t &ptr);
-
-	//! Extracts the block info from swizzled pointer
-	BlockPointer GetSwizzledBlockInfo();
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/persistent/csv_file_handle.hpp

@@ -16,7 +16,8 @@ namespace duckdb {
 
 struct CSVFileHandle {
 public:
-	explicit CSVFileHandle(unique_ptr<FileHandle> file_handle_p) : file_handle(std::move(file_handle_p)) {
+	explicit CSVFileHandle(unique_ptr<FileHandle> file_handle_p, bool enable_reset = true)
+	    : file_handle(std::move(file_handle_p)), reset_enabled(enable_reset) {
 		can_seek = file_handle->CanSeek();
 		plain_file_source = file_handle->OnDiskFile() && can_seek;
 		file_size = file_handle->GetFileSize();

package/src/duckdb/src/include/duckdb/execution/operator/persistent/csv_reader_options.hpp

@@ -62,6 +62,8 @@ struct BufferedCSVReaderOptions {
 	//! Whether file is compressed or not, and if so which compression type
 	//! AUTO_DETECT (default; infer from file extension)
 	FileCompressionType compression = FileCompressionType::AUTO_DETECT;
+	//! Option to convert quoted values to NULL values
+	bool allow_quoted_nulls = true;
 
 	//===--------------------------------------------------------------------===//
 	// CSVAutoOptions

package/src/duckdb/src/include/duckdb/function/function_serialization.hpp

@@ -47,13 +47,13 @@ public:
 		// note: original_arguments are optional (can be list of size 0)
 		auto original_arguments = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 
-		auto func_catalog = Catalog::GetEntry(context, type, SYSTEM_CATALOG, DEFAULT_SCHEMA, name);
-		if (!func_catalog || func_catalog->type != type) {
+		auto &func_catalog = Catalog::GetEntry(context, type, SYSTEM_CATALOG, DEFAULT_SCHEMA, name);
+		if (func_catalog.type != type) {
 			throw InternalException("Cant find catalog entry for function %s", name);
 		}
 
-		auto functions = (CATALOG_ENTRY *)func_catalog;
-		auto function = functions->functions.GetFunctionByArguments(
+		auto &functions = func_catalog.Cast<CATALOG_ENTRY>();
+		auto function = functions.functions.GetFunctionByArguments(
 		    state.context, original_arguments.empty() ? arguments : original_arguments);
 		function.arguments = std::move(arguments);
 		function.original_arguments = std::move(original_arguments);

package/src/duckdb/src/include/duckdb/function/scalar_function.hpp

@@ -15,6 +15,7 @@
 #include "duckdb/execution/expression_executor_state.hpp"
 #include "duckdb/function/function.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 
@@ -39,13 +40,13 @@ class DependencyList;
 class ScalarFunctionCatalogEntry;
 
 struct FunctionStatisticsInput {
-	FunctionStatisticsInput(BoundFunctionExpression &expr_p, FunctionData *bind_data_p,
+	FunctionStatisticsInput(BoundFunctionExpression &expr_p, optional_ptr<FunctionData> bind_data_p,
 	                        vector<BaseStatistics> &child_stats_p, unique_ptr<Expression> *expr_ptr_p)
 	    : expr(expr_p), bind_data(bind_data_p), child_stats(child_stats_p), expr_ptr(expr_ptr_p) {
 	}
 
 	BoundFunctionExpression &expr;
-	FunctionData *bind_data;
+	optional_ptr<FunctionData> bind_data;
 	vector<BaseStatistics> &child_stats;
 	unique_ptr<Expression> *expr_ptr;
 };

package/src/duckdb/src/include/duckdb/function/table/table_scan.hpp

@@ -17,11 +17,11 @@ class DuckTableEntry;
 class TableCatalogEntry;
 
 struct TableScanBindData : public TableFunctionData {
-	explicit TableScanBindData(DuckTableEntry *table) : table(table), is_index_scan(false), is_create_index(false) {
+	explicit TableScanBindData(DuckTableEntry &table) : table(table), is_index_scan(false), is_create_index(false) {
 	}
 
 	//! The table to scan
-	DuckTableEntry *table;
+	DuckTableEntry &table;
 
 	//! Whether or not the table scan is an index scan
 	bool is_index_scan;
@@ -33,7 +33,7 @@ struct TableScanBindData : public TableFunctionData {
 public:
 	bool Equals(const FunctionData &other_p) const override {
 		auto &other = (const TableScanBindData &)other_p;
-		return other.table == table && result_ids == other.result_ids;
+		return &other.table == &table && result_ids == other.result_ids;
 	}
 };
 
@@ -42,7 +42,8 @@ struct TableScanFunction {
 	static void RegisterFunction(BuiltinFunctions &set);
 	static TableFunction GetFunction();
 	static TableFunction GetIndexScanFunction();
-	static TableCatalogEntry *GetTableEntry(const TableFunction &function, const FunctionData *bind_data);
+	static optional_ptr<TableCatalogEntry> GetTableEntry(const TableFunction &function,
+	                                                     const optional_ptr<FunctionData> bind_data);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/table_function.hpp

@@ -14,6 +14,7 @@
 #include "duckdb/planner/bind_context.hpp"
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/storage/statistics/node_statistics.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 #include <functional>
 
@@ -26,6 +27,17 @@ class TableFilterSet;
 
 struct TableFunctionInfo {
 	DUCKDB_API virtual ~TableFunctionInfo();
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return (TARGET &)*this;
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return (const TARGET &)*this;
+	}
 };
 
 struct GlobalTableFunctionState {
@@ -70,7 +82,7 @@ struct LocalTableFunctionState {
 struct TableFunctionBindInput {
 	TableFunctionBindInput(vector<Value> &inputs, named_parameter_map_t &named_parameters,
 	                       vector<LogicalType> &input_table_types, vector<string> &input_table_names,
-	                       TableFunctionInfo *info)
+	                       optional_ptr<TableFunctionInfo> info)
 	    : inputs(inputs), named_parameters(named_parameters), input_table_types(input_table_types),
 	      input_table_names(input_table_names), info(info) {
 	}
@@ -79,19 +91,19 @@ struct TableFunctionBindInput {
 	named_parameter_map_t &named_parameters;
 	vector<LogicalType> &input_table_types;
 	vector<string> &input_table_names;
-	TableFunctionInfo *info;
+	optional_ptr<TableFunctionInfo> info;
 };
 
 struct TableFunctionInitInput {
-	TableFunctionInitInput(const FunctionData *bind_data_p, const vector<column_t> &column_ids_p,
-	                       const vector<idx_t> &projection_ids_p, TableFilterSet *filters_p)
+	TableFunctionInitInput(optional_ptr<const FunctionData> bind_data_p, const vector<column_t> &column_ids_p,
+	                       const vector<idx_t> &projection_ids_p, optional_ptr<TableFilterSet> filters_p)
 	    : bind_data(bind_data_p), column_ids(column_ids_p), projection_ids(projection_ids_p), filters(filters_p) {
 	}
 
-	const FunctionData *bind_data;
+	optional_ptr<const FunctionData> bind_data;
 	const vector<column_t> &column_ids;
 	const vector<idx_t> projection_ids;
-	TableFilterSet *filters;
+	optional_ptr<TableFilterSet> filters;
 
 	bool CanRemoveFilterColumns() const {
 		if (projection_ids.empty()) {
@@ -109,15 +121,16 @@ struct TableFunctionInitInput {
 
 struct TableFunctionInput {
 public:
-	TableFunctionInput(const FunctionData *bind_data_p, LocalTableFunctionState *local_state_p,
-	                   GlobalTableFunctionState *global_state_p)
+	TableFunctionInput(optional_ptr<const FunctionData> bind_data_p,
+	                   optional_ptr<LocalTableFunctionState> local_state_p,
+	                   optional_ptr<GlobalTableFunctionState> global_state_p)
 	    : bind_data(bind_data_p), local_state(local_state_p), global_state(global_state_p) {
 	}
 
 public:
-	const FunctionData *bind_data;
-	LocalTableFunctionState *local_state;
-	GlobalTableFunctionState *global_state;
+	optional_ptr<const FunctionData> bind_data;
+	optional_ptr<LocalTableFunctionState> local_state;
+	optional_ptr<GlobalTableFunctionState> global_state;
 };
 
 enum ScanType { TABLE, PARQUET };
@@ -127,21 +140,21 @@ public:
 	explicit BindInfo(ScanType type_p) : type(type_p) {};
 	unordered_map<string, Value> options;
 	ScanType type;
-	void InsertOption(string name, Value value) {
+	void InsertOption(const string &name, Value value) {
 		if (options.find(name) != options.end()) {
 			throw InternalException("This option already exists");
 		}
-		options[name] = value;
+		options[name] = std::move(value);
 	}
 	template <class T>
-	T GetOption(string name) {
+	T GetOption(const string &name) {
 		if (options.find(name) == options.end()) {
 			throw InternalException("This option does not exist");
 		}
 		return options[name].GetValue<T>();
 	}
 	template <class T>
-	vector<T> GetOptionList(string name) {
+	vector<T> GetOptionList(const string &name) {
 		if (options.find(name) == options.end()) {
 			throw InternalException("This option does not exist");
 		}

package/src/duckdb/src/include/duckdb/main/attached_database.hpp

@@ -44,6 +44,7 @@ public:
 
 	void Initialize();
 
+	Catalog &ParentCatalog() override;
 	StorageManager &GetStorageManager();
 	Catalog &GetCatalog();
 	TransactionManager &GetTransactionManager();
@@ -65,6 +66,7 @@ private:
 	unique_ptr<Catalog> catalog;
 	unique_ptr<TransactionManager> transaction_manager;
 	AttachedDatabaseType type;
+	optional_ptr<Catalog> parent_catalog;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/client_context.hpp

@@ -149,7 +149,7 @@ public:
 	DUCKDB_API double GetProgress();
 
 	//! Register function in the temporary schema
-	DUCKDB_API void RegisterFunction(CreateFunctionInfo *info);
+	DUCKDB_API void RegisterFunction(CreateFunctionInfo &info);
 
 	//! Parse statements from a query
 	DUCKDB_API vector<unique_ptr<SQLStatement>> ParseStatements(const string &query);

package/src/duckdb/src/include/duckdb/main/database_manager.hpp

@@ -13,6 +13,7 @@
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/atomic.hpp"
 #include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/common/enums/on_entry_not_found.hpp"
 
 namespace duckdb {
 class AttachedDatabase;
@@ -39,13 +40,13 @@ public:
 	optional_ptr<AttachedDatabase> GetDatabase(ClientContext &context, const string &name);
 	//! Add a new attached database to the database manager
 	void AddDatabase(ClientContext &context, unique_ptr<AttachedDatabase> db);
-	void DetachDatabase(ClientContext &context, const string &name, bool if_exists);
+	void DetachDatabase(ClientContext &context, const string &name, OnEntryNotFound if_not_found);
 	//! Returns a reference to the system catalog
 	Catalog &GetSystemCatalog();
 	static const string &GetDefaultDatabase(ClientContext &context);
 
 	optional_ptr<AttachedDatabase> GetDatabaseFromPath(ClientContext &context, const string &path);
-	vector<optional_ptr<AttachedDatabase>> GetDatabases(ClientContext &context);
+	vector<reference<AttachedDatabase>> GetDatabases(ClientContext &context);
 
 	transaction_t GetNewQueryNumber() {
 		return current_query_number++;

package/src/duckdb/src/include/duckdb/parser/expression/bound_expression.hpp

@@ -28,6 +28,8 @@ public:
 	unique_ptr<Expression> expr;
 
 public:
+	static unique_ptr<Expression> &GetExpression(ParsedExpression &expr);
+
 	string ToString() const override;
 
 	bool Equals(const BaseExpression *other) const override;

package/src/duckdb/src/include/duckdb/parser/keyword_helper.hpp

@@ -18,10 +18,10 @@ public:
 	static bool IsKeyword(const string &text);
 
 	//! Returns true if the given string needs to be quoted when written as an identifier
-	static bool RequiresQuotes(const string &text, bool allow_caps = false);
+	static bool RequiresQuotes(const string &text, bool allow_caps = true);
 
 	//! Writes a string that is optionally quoted + escaped so it can be used as an identifier
-	static string WriteOptionallyQuoted(const string &text, char quote = '"', bool allow_caps = false);
+	static string WriteOptionallyQuoted(const string &text, char quote = '"', bool allow_caps = true);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_info.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/common/enums/catalog_type.hpp"
 #include "duckdb/parser/column_definition.hpp"
 #include "duckdb/parser/parsed_data/parse_info.hpp"
+#include "duckdb/common/enums/on_entry_not_found.hpp"
 
 namespace duckdb {
 
@@ -27,23 +28,24 @@ enum class AlterType : uint8_t {
 struct AlterEntryData {
 	AlterEntryData() {
 	}
-	AlterEntryData(string catalog_p, string schema_p, string name_p, bool if_exists)
-	    : catalog(std::move(catalog_p)), schema(std::move(schema_p)), name(std::move(name_p)), if_exists(if_exists) {
+	AlterEntryData(string catalog_p, string schema_p, string name_p, OnEntryNotFound if_not_found)
+	    : catalog(std::move(catalog_p)), schema(std::move(schema_p)), name(std::move(name_p)),
+	      if_not_found(if_not_found) {
 	}
 
 	string catalog;
 	string schema;
 	string name;
-	bool if_exists;
+	OnEntryNotFound if_not_found;
 };
 
 struct AlterInfo : public ParseInfo {
-	AlterInfo(AlterType type, string catalog, string schema, string name, bool if_exists);
+	AlterInfo(AlterType type, string catalog, string schema, string name, OnEntryNotFound if_not_found);
 	virtual ~AlterInfo() override;
 
 	AlterType type;
 	//! if exists
-	bool if_exists;
+	OnEntryNotFound if_not_found;
 	//! Catalog name to alter
 	string catalog;
 	//! Schema name to alter

package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_info.hpp

@@ -22,7 +22,7 @@ enum AlterForeignKeyType : uint8_t { AFT_ADD = 0, AFT_DELETE = 1 };
 //===--------------------------------------------------------------------===//
 struct ChangeOwnershipInfo : public AlterInfo {
 	ChangeOwnershipInfo(CatalogType entry_catalog_type, string entry_catalog, string entry_schema, string entry_name,
-	                    string owner_schema, string owner_name, bool if_exists);
+	                    string owner_schema, string owner_name, OnEntryNotFound if_not_found);
 
 	// Catalog type refers to the entry type, since this struct is usually built from an
 	// ALTER <TYPE> <schema>.<name> OWNED BY <owner_schema>.<owner_name> statement

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_info.hpp

@@ -22,7 +22,7 @@ class SchemaCatalogEntry;
 struct CreateTableInfo : public CreateInfo {
 	DUCKDB_API CreateTableInfo();
 	DUCKDB_API CreateTableInfo(string catalog, string schema, string name);
-	DUCKDB_API CreateTableInfo(SchemaCatalogEntry *schema, string name);
+	DUCKDB_API CreateTableInfo(SchemaCatalogEntry &schema, string name);
 
 	//! Table name to insert to
 	string table;

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_view_info.hpp

@@ -16,7 +16,7 @@ class SchemaCatalogEntry;
 
 struct CreateViewInfo : public CreateInfo {
 	CreateViewInfo();
-	CreateViewInfo(SchemaCatalogEntry *schema, string view_name);
+	CreateViewInfo(SchemaCatalogEntry &schema, string view_name);
 	CreateViewInfo(string catalog_p, string schema_p, string view_name);
 
 	//! Table name to insert to

package/src/duckdb/src/include/duckdb/parser/parsed_data/detach_info.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/parser/parsed_data/parse_info.hpp"
+#include "duckdb/common/enums/on_entry_not_found.hpp"
 
 namespace duckdb {
 
@@ -19,13 +20,13 @@ struct DetachInfo : public ParseInfo {
 	//! The alias of the attached database
 	string name;
 	//! Whether to throw an exception if alias is not found
-	bool if_exists;
+	OnEntryNotFound if_not_found;
 
 public:
 	unique_ptr<DetachInfo> Copy() const {
 		auto result = make_uniq<DetachInfo>();
 		result->name = name;
-		result->if_exists = if_exists;
+		result->if_not_found = if_not_found;
 		return result;
 	}
 };

package/src/duckdb/src/include/duckdb/parser/parsed_data/drop_info.hpp

@@ -15,7 +15,7 @@
 namespace duckdb {
 
 struct DropInfo : public ParseInfo {
-	DropInfo() : catalog(INVALID_CATALOG), schema(INVALID_SCHEMA), if_exists(false), cascade(false) {
+	DropInfo() : catalog(INVALID_CATALOG), schema(INVALID_SCHEMA), cascade(false) {
 	}
 
 	//! The catalog type to drop
@@ -27,7 +27,7 @@ struct DropInfo : public ParseInfo {
 	//! Element name to drop
 	string name;
 	//! Ignore if the entry does not exist instead of failing
-	bool if_exists = false;
+	OnEntryNotFound if_not_found = OnEntryNotFound::THROW_EXCEPTION;
 	//! Cascade drop (drop all dependents instead of throwing an error if there
 	//! are any)
 	bool cascade = false;
@@ -41,7 +41,7 @@ public:
 		result->catalog = catalog;
 		result->schema = schema;
 		result->name = name;
-		result->if_exists = if_exists;
+		result->if_not_found = if_not_found;
 		result->cascade = cascade;
 		result->allow_drop_internal = allow_drop_internal;
 		return result;
@@ -53,7 +53,7 @@ public:
 		writer.WriteString(catalog);
 		writer.WriteString(schema);
 		writer.WriteString(name);
-		writer.WriteField(if_exists);
+		writer.WriteField(if_not_found);
 		writer.WriteField(cascade);
 		writer.WriteField(allow_drop_internal);
 		writer.Finalize();
@@ -66,7 +66,7 @@ public:
 		drop_info->catalog = reader.ReadRequired<string>();
 		drop_info->schema = reader.ReadRequired<string>();
 		drop_info->name = reader.ReadRequired<string>();
-		drop_info->if_exists = reader.ReadRequired<bool>();
+		drop_info->if_not_found = reader.ReadRequired<OnEntryNotFound>();
 		drop_info->cascade = reader.ReadRequired<bool>();
 		drop_info->allow_drop_internal = reader.ReadRequired<bool>();
 		reader.Finalize();

package/src/duckdb/src/include/duckdb/parser/parsed_data/parse_info.hpp

@@ -15,6 +15,19 @@ namespace duckdb {
 struct ParseInfo {
 	virtual ~ParseInfo() {
 	}
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return (TARGET &)*this;
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return (const TARGET &)*this;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/statement/insert_statement.hpp

@@ -72,6 +72,9 @@ public:
 	//! CTEs
 	CommonTableExpressionMap cte_map;
 
+	//! Whether or not this a DEFAULT VALUES
+	bool default_values = false;
+
 protected:
 	InsertStatement(const InsertStatement &other);
 
@@ -82,7 +85,7 @@ public:
 
 	//! If the INSERT statement is inserted DIRECTLY from a values list (i.e. INSERT INTO tbl VALUES (...)) this returns
 	//! the expression list Otherwise, this returns NULL
-	ExpressionListRef *GetValuesList() const;
+	optional_ptr<ExpressionListRef> GetValuesList() const;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref.hpp

@@ -18,6 +18,9 @@ class Serializer;
 
 //! Represents a generic expression that returns a table.
 class TableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::INVALID;
+
 public:
 	explicit TableRef(TableReferenceType type) : type(type) {
 	}
@@ -57,7 +60,7 @@ public:
 public:
 	template <class TARGET>
 	TARGET &Cast() {
-		if (type != TARGET::TYPE) {
+		if (type != TARGET::TYPE && TARGET::TYPE != TableReferenceType::INVALID) {
 			throw InternalException("Failed to cast constraint to type - constraint type mismatch");
 		}
 		return (TARGET &)*this;
@@ -65,7 +68,7 @@ public:
 
 	template <class TARGET>
 	const TARGET &Cast() const {
-		if (type != TARGET::TYPE) {
+		if (type != TARGET::TYPE && TARGET::TYPE != TableReferenceType::INVALID) {
 			throw InternalException("Failed to cast constraint to type - constraint type mismatch");
 		}
 		return (const TARGET &)*this;

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -312,7 +312,8 @@ private:
 	void TransformExpressionList(duckdb_libpgquery::PGList &list, vector<unique_ptr<ParsedExpression>> &result);
 
 	//! Transform a Postgres PARTITION BY/ORDER BY specification into lists of expressions
-	void TransformWindowDef(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr);
+	void TransformWindowDef(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr,
+	                        const char *window_name = nullptr);
 	//! Transform a Postgres window frame specification into frame expressions
 	void TransformWindowFrame(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr);
 
@@ -320,6 +321,8 @@ private:
 	//! Returns true if an expression is only a star (i.e. "*", without any other decorators)
 	bool ExpressionIsEmptyStar(ParsedExpression &expr);
 
+	OnEntryNotFound TransformOnEntryNotFound(bool missing_ok);
+
 private:
 	//! Current stack depth
 	idx_t stack_depth;

package/src/duckdb/src/include/duckdb/planner/binder.hpp

@@ -172,7 +172,7 @@ public:
 	void BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &table, InsertStatement &stmt);
 
 	static void BindSchemaOrCatalog(ClientContext &context, string &catalog, string &schema);
-	static void BindLogicalType(ClientContext &context, LogicalType &type, Catalog *catalog = nullptr,
+	static void BindLogicalType(ClientContext &context, LogicalType &type, optional_ptr<Catalog> catalog = nullptr,
 	                            const string &schema = INVALID_SCHEMA);
 
 	bool HasMatchingBinding(const string &table_name, const string &column_name, string &error_message);
@@ -259,7 +259,7 @@ private:
 	                             const string &alias, idx_t update_table_index,
 	                             unique_ptr<LogicalOperator> child_operator, BoundStatement result);
 
-	unique_ptr<QueryNode> BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry *macro_func, idx_t depth);
+	unique_ptr<QueryNode> BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry &macro_func, idx_t depth);
 
 	unique_ptr<BoundQueryNode> BindNode(SelectNode &node);
 	unique_ptr<BoundQueryNode> BindNode(SetOperationNode &node);

package/src/duckdb/src/include/duckdb/planner/expression_binder/base_select_binder.hpp

@@ -43,8 +43,7 @@ protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
-	BindResult BindAggregate(FunctionExpression &expr, optional_ptr<AggregateFunctionCatalogEntry> function,
-	                         idx_t depth) override;
+	BindResult BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry &function, idx_t depth) override;
 
 	bool inside_window;
 	bool bound_aggregate = false;

package/src/duckdb/src/include/duckdb/planner/expression_binder.hpp

@@ -134,14 +134,11 @@ protected:
 
 protected:
 	virtual BindResult BindGroupingFunction(OperatorExpression &op, idx_t depth);
-	virtual BindResult BindFunction(FunctionExpression &expr, optional_ptr<ScalarFunctionCatalogEntry> function,
-	                                idx_t depth);
-	virtual BindResult BindLambdaFunction(FunctionExpression &expr, optional_ptr<ScalarFunctionCatalogEntry> function,
-	                                      idx_t depth);
-	virtual BindResult BindAggregate(FunctionExpression &expr, optional_ptr<AggregateFunctionCatalogEntry> function,
-	                                 idx_t depth);
+	virtual BindResult BindFunction(FunctionExpression &expr, ScalarFunctionCatalogEntry &function, idx_t depth);
+	virtual BindResult BindLambdaFunction(FunctionExpression &expr, ScalarFunctionCatalogEntry &function, idx_t depth);
+	virtual BindResult BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry &function, idx_t depth);
 	virtual BindResult BindUnnest(FunctionExpression &expr, idx_t depth, bool root_expression);
-	virtual BindResult BindMacro(FunctionExpression &expr, optional_ptr<ScalarMacroCatalogEntry> macro, idx_t depth,
+	virtual BindResult BindMacro(FunctionExpression &expr, ScalarMacroCatalogEntry &macro, idx_t depth,
 	                             unique_ptr<ParsedExpression> &expr_ptr);
 
 	virtual string UnsupportedAggregateMessage();

package/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp

@@ -53,7 +53,7 @@ public:
 	string GetName() const override;
 	string ParamsToString() const override;
 	//! Returns the underlying table that is being scanned, or nullptr if there is none
-	TableCatalogEntry *GetTable() const;
+	optional_ptr<TableCatalogEntry> GetTable() const;
 
 public:
 	vector<ColumnBinding> GetColumnBindings() override;