duckdb 0.7.2-dev2552.0 → 0.7.2-dev2699.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/main/query_result.hpp

@@ -20,7 +20,7 @@ enum class QueryResultType : uint8_t { MATERIALIZED_RESULT, STREAM_RESULT, PENDI
 
 //! A set of properties from the client context that can be used to interpret the query result
 struct ClientProperties {
-	string timezone;
+	string time_zone;
 };
 
 class BaseQueryResult {

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/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);
 

package/src/duckdb/src/include/duckdb/storage/buffer_manager.hpp

@@ -58,15 +58,10 @@ public:
 	//! Construct a managed buffer.
 	virtual unique_ptr<FileBuffer> ConstructManagedBuffer(idx_t size, unique_ptr<FileBuffer> &&source,
 	                                                      FileBufferType type = FileBufferType::MANAGED_BUFFER);
-	//! Increases the currently allocated memory, but the actual allocation does not go through the buffer manager
-	virtual void IncreaseUsedMemory(idx_t size, bool unsafe = false) = 0;
-	//! Decrease the currently allocated memory, but the actual deallocation does not go through the buffer manager
-	virtual void DecreaseUsedMemory(idx_t size) = 0;
 	//! Get the underlying buffer pool responsible for managing the buffers
 	virtual BufferPool &GetBufferPool();
 
 	// Static methods
-
 	DUCKDB_API static BufferManager &GetBufferManager(DatabaseInstance &db);
 	DUCKDB_API static BufferManager &GetBufferManager(ClientContext &context);
 	DUCKDB_API static BufferManager &GetBufferManager(AttachedDatabase &db);

package/src/duckdb/src/include/duckdb/storage/index.hpp

@@ -32,8 +32,7 @@ struct IndexScanState;
 class Index {
 public:
 	Index(AttachedDatabase &db, IndexType type, TableIOManager &table_io_manager, const vector<column_t> &column_ids,
-	      const vector<unique_ptr<Expression>> &unbound_expressions, IndexConstraintType constraint_type,
-	      bool track_memory);
+	      const vector<unique_ptr<Expression>> &unbound_expressions, IndexConstraintType constraint_type);
 	virtual ~Index() = default;
 
 	//! The type of the index
@@ -57,25 +56,21 @@ public:
 	AttachedDatabase &db;
 	//! Buffer manager of the database instance
 	BufferManager &buffer_manager;
-	//! The size of the index in memory
-	//! This does not track the size of the index meta information, but only allocated nodes and leaves
-	idx_t memory_size;
-	//! Flag determining if this index's size is tracked by the buffer manager
-	bool track_memory;
 
 public:
 	//! Initialize a single predicate scan on the index with the given expression and column IDs
 	virtual unique_ptr<IndexScanState> InitializeScanSinglePredicate(const Transaction &transaction, const Value &value,
-	                                                                 ExpressionType expressionType) = 0;
+	                                                                 const ExpressionType expression_type) = 0;
 	//! Initialize a two predicate scan on the index with the given expression and column IDs
-	virtual unique_ptr<IndexScanState> InitializeScanTwoPredicates(Transaction &transaction, const Value &low_value,
-	                                                               ExpressionType low_expression_type,
+	virtual unique_ptr<IndexScanState> InitializeScanTwoPredicates(const Transaction &transaction,
+	                                                               const Value &low_value,
+	                                                               const ExpressionType low_expression_type,
 	                                                               const Value &high_value,
-	                                                               ExpressionType high_expression_type) = 0;
+	                                                               const ExpressionType high_expression_type) = 0;
 	//! Performs a lookup on the index, fetching up to max_count result IDs. Returns true if all row IDs were fetched,
 	//! and false otherwise
-	virtual bool Scan(Transaction &transaction, DataTable &table, IndexScanState &state, idx_t max_count,
-	                  vector<row_t> &result_ids) = 0;
+	virtual bool Scan(const Transaction &transaction, const DataTable &table, IndexScanState &state,
+	                  const idx_t max_count, vector<row_t> &result_ids) = 0;
 
 	//! Obtain a lock on the index
 	virtual void InitializeLock(IndexLock &state);
@@ -104,23 +99,13 @@ public:
 	//! Obtains a lock and calls MergeIndexes while holding that lock
 	bool MergeIndexes(Index &other_index);
 
+	//! Traverses an ART and vacuums the qualifying nodes. The lock obtained from InitializeLock must be held
+	virtual void Vacuum(IndexLock &state) = 0;
+	//! Obtains a lock and calls Vacuum while holding that lock
+	void Vacuum();
+
 	//! Returns the string representation of an index
 	virtual string ToString() = 0;
-	//! Verifies that the in-memory size value of the index matches its actual size
-	virtual void Verify() = 0;
-	//! Increases the memory size by the difference between the old size and the current size
-	//! and performs verifications
-	virtual void IncreaseAndVerifyMemorySize(idx_t old_memory_size) = 0;
-
-	//! Increases the in-memory size value
-	inline void IncreaseMemorySize(idx_t size) {
-		memory_size += size;
-	};
-	//! Decreases the in-memory size value
-	inline void DecreaseMemorySize(idx_t size) {
-		D_ASSERT(memory_size >= size);
-		memory_size -= size;
-	};
 
 	//! Returns true if the index is affected by updates on the specified column IDs, and false otherwise
 	bool IndexIsUpdated(const vector<PhysicalIndex> &column_ids) const;

package/src/duckdb/src/include/duckdb/storage/standard_buffer_manager.hpp

@@ -45,8 +45,6 @@ public:
 	shared_ptr<BlockHandle> RegisterSmallMemory(idx_t block_size) final override;
 
 	idx_t GetUsedMemory() const final override;
-	void IncreaseUsedMemory(idx_t amount, bool unsafe = false) final override;
-	void DecreaseUsedMemory(idx_t amount) final override;
 	idx_t GetMaxMemory() const final override;
 
 	//! Allocate an in-memory buffer with a single pin.

package/src/duckdb/src/include/duckdb/transaction/cleanup_state.hpp

@@ -10,8 +10,10 @@
 
 #include "duckdb/transaction/undo_buffer.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/common/unordered_map.hpp"
 
 namespace duckdb {
+
 class DataTable;
 
 struct DeleteInfo;
@@ -22,6 +24,9 @@ public:
 	CleanupState();
 	~CleanupState();
 
+	// all tables with indexes that possibly need a vacuum (after e.g. a delete)
+	unordered_map<string, optional_ptr<DataTable>> indexed_tables;
+
 public:
 	void CleanupEntry(UndoFlags type, data_ptr_t data);
 

package/src/duckdb/src/include/duckdb.h

@@ -190,6 +190,23 @@ typedef struct {
 	idx_t size;
 } duckdb_string;
 
+/*
+    The internal data representation of a VARCHAR/BLOB column
+*/
+typedef struct {
+	union {
+		struct {
+			uint32_t length;
+			char prefix[4];
+			char *ptr;
+		} pointer;
+		struct {
+			uint32_t length;
+			char inlined[12];
+		} inlined;
+	} value;
+} duckdb_string_t;
+
 typedef struct {
 	void *data;
 	idx_t size;
@@ -298,6 +315,7 @@ typedef enum {
 /*!
 Creates a new database or opens an existing database file stored at the the given path.
 If no path is given a new in-memory database is created instead.
+The instantiated database should be closed with 'duckdb_close'
 
 * path: Path to the database file on disk, or `nullptr` or `:memory:` to open an in-memory database.
 * out_database: The result database object.
@@ -331,6 +349,7 @@ DUCKDB_API void duckdb_close(duckdb_database *database);
 /*!
 Opens a connection to a database. Connections are required to query the database, and store transactional state
 associated with the connection.
+The instantiated connection should be closed using 'duckdb_disconnect'
 
 * database: The database file to connect to.
 * out_connection: The result connection object.
@@ -751,6 +770,13 @@ This is the amount of tuples that will fit into a data chunk created by `duckdb_
 */
 DUCKDB_API idx_t duckdb_vector_size();
 
+/*!
+Whether or not the duckdb_string_t value is inlined.
+This means that the data of the string does not have a separate allocation.
+
+*/
+DUCKDB_API bool duckdb_string_is_inlined(duckdb_string_t string);
+
 //===--------------------------------------------------------------------===//
 // Date/Time/Timestamp Helpers
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/main/capi/helper-c.cpp

@@ -186,3 +186,10 @@ void duckdb_free(void *ptr) {
 idx_t duckdb_vector_size() {
 	return STANDARD_VECTOR_SIZE;
 }
+
+bool duckdb_string_is_inlined(duckdb_string_t string_p) {
+	static_assert(sizeof(duckdb_string_t) == sizeof(duckdb::string_t),
+	              "duckdb_string_t should have the same memory layout as duckdb::string_t");
+	auto &string = *(duckdb::string_t *)(&string_p);
+	return string.IsInlined();
+}

package/src/duckdb/src/main/client_context.cpp

@@ -1156,7 +1156,7 @@ ParserOptions ClientContext::GetParserOptions() const {
 
 ClientProperties ClientContext::GetClientProperties() const {
 	ClientProperties properties;
-	properties.timezone = ClientConfig::GetConfig(*this).ExtractTimezone();
+	properties.time_zone = ClientConfig::GetConfig(*this).ExtractTimezone();
 	return properties;
 }
 

package/src/duckdb/src/main/query_result.cpp

@@ -165,7 +165,7 @@ string QueryResult::HeaderToString() {
 }
 
 string QueryResult::GetConfigTimezone(QueryResult &query_result) {
-	return query_result.client_properties.timezone;
+	return query_result.client_properties.time_zone;
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/statement/insert_statement.cpp

@@ -27,9 +27,10 @@ InsertStatement::InsertStatement()
 }
 
 InsertStatement::InsertStatement(const InsertStatement &other)
-    : SQLStatement(other),
-      select_statement(unique_ptr_cast<SQLStatement, SelectStatement>(other.select_statement->Copy())),
-      columns(other.columns), table(other.table), schema(other.schema), catalog(other.catalog) {
+    : SQLStatement(other), select_statement(unique_ptr_cast<SQLStatement, SelectStatement>(
+                               other.select_statement ? other.select_statement->Copy() : nullptr)),
+      columns(other.columns), table(other.table), schema(other.schema), catalog(other.catalog),
+      default_values(other.default_values) {
 	cte_map = other.cte_map.Copy();
 	for (auto &expr : other.returning_list) {
 		returning_list.emplace_back(expr->Copy());
@@ -93,10 +94,15 @@ string InsertStatement::ToString() const {
 	result += " ";
 	auto values_list = GetValuesList();
 	if (values_list) {
+		D_ASSERT(!default_values);
 		values_list->alias = string();
 		result += values_list->ToString();
-	} else {
+	} else if (select_statement) {
+		D_ASSERT(!default_values);
 		result += select_statement->ToString();
+	} else {
+		D_ASSERT(default_values);
+		result += "DEFAULT VALUES";
 	}
 	if (!or_replace_shorthand_set && on_conflict_info) {
 		auto &conflict_info = *on_conflict_info;
@@ -155,7 +161,10 @@ unique_ptr<SQLStatement> InsertStatement::Copy() const {
 	return unique_ptr<InsertStatement>(new InsertStatement(*this));
 }
 
-ExpressionListRef *InsertStatement::GetValuesList() const {
+optional_ptr<ExpressionListRef> InsertStatement::GetValuesList() const {
+	if (!select_statement) {
+		return nullptr;
+	}
 	if (select_statement->node->type != QueryNodeType::SELECT_NODE) {
 		return nullptr;
 	}
@@ -178,7 +187,7 @@ ExpressionListRef *InsertStatement::GetValuesList() const {
 	if (!node.from_table || node.from_table->type != TableReferenceType::EXPRESSION_LIST) {
 		return nullptr;
 	}
-	return (ExpressionListRef *)node.from_table.get();
+	return &node.from_table->Cast<ExpressionListRef>();
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/transform/constraint/transform_constraint.cpp

@@ -108,7 +108,7 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 				pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
 			}
 		}
-		if (pk_columns.size() != fk_columns.size()) {
+		if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) {
 			throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
 		}
 		return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));

package/src/duckdb/src/parser/transform/expression/transform_function.cpp

@@ -13,15 +13,24 @@
 
 namespace duckdb {
 
-void Transformer::TransformWindowDef(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr) {
+void Transformer::TransformWindowDef(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr,
+                                     const char *window_name) {
 	D_ASSERT(window_spec);
 	D_ASSERT(expr);
 
 	// next: partitioning/ordering expressions
 	if (window_spec->partitionClause) {
+		if (window_name && !expr->partitions.empty()) {
+			throw ParserException("Cannot override PARTITION BY clause of window \"%s\"", window_name);
+		}
 		TransformExpressionList(*window_spec->partitionClause, expr->partitions);
 	}
-	TransformOrderBy(window_spec->orderClause, expr->orders);
+	if (window_spec->orderClause) {
+		if (window_name && !expr->orders.empty()) {
+			throw ParserException("Cannot override ORDER BY clause of window \"%s\"", window_name);
+		}
+		TransformOrderBy(window_spec->orderClause, expr->orders);
+	}
 }
 
 void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr) {
@@ -198,6 +207,7 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			D_ASSERT(window_spec);
 		}
 		auto window_ref = window_spec;
+		auto window_name = window_ref->refname;
 		if (window_ref->refname) {
 			auto it = window_clauses.find(StringUtil::Lower(string(window_spec->refname)));
 			if (it == window_clauses.end()) {
@@ -208,6 +218,9 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 		}
 		in_window_definition = true;
 		TransformWindowDef(window_ref, expr.get());
+		if (window_ref != window_spec) {
+			TransformWindowDef(window_spec, expr.get(), window_name);
+		}
 		TransformWindowFrame(window_spec, expr.get());
 		in_window_definition = false;
 		expr->query_location = root->location;
@@ -299,9 +312,9 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			                                               std::move(filter_expr), std::move(order_bys),
 			                                               root->agg_distinct, false, root->export_state);
 			lowercase_name = "list_sort";
-			order_bys.reset();
-			filter_expr.reset();
-			children.clear();
+			order_bys.reset();   // NOLINT
+			filter_expr.reset(); // NOLINT
+			children.clear();    // NOLINT
 			children.emplace_back(std::move(unordered));
 			children.emplace_back(std::move(sense));
 			children.emplace_back(std::move(nulls));

package/src/duckdb/src/parser/transform/statement/transform_insert.cpp

@@ -26,12 +26,6 @@ unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGNo
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGInsertStmt *>(node);
 	D_ASSERT(stmt);
 
-	if (!stmt->selectStmt) {
-		// TODO: This should be easy to add, we already support DEFAULT in the values list,
-		// this could probably just be transformed into VALUES (DEFAULT, DEFAULT, DEFAULT, ..) in the Binder
-		throw ParserException("DEFAULT VALUES clause is not supported!");
-	}
-
 	auto result = make_uniq<InsertStatement>();
 	if (stmt->withClause) {
 		TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), result->cte_map);
@@ -49,7 +43,11 @@ unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGNo
 	if (stmt->returningList) {
 		Transformer::TransformExpressionList(*(stmt->returningList), result->returning_list);
 	}
-	result->select_statement = TransformSelect(stmt->selectStmt, false);
+	if (stmt->selectStmt) {
+		result->select_statement = TransformSelect(stmt->selectStmt, false);
+	} else {
+		result->default_values = true;
+	}
 
 	auto qname = TransformQualifiedName(stmt->relation);
 	result->table = qname.name;

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -292,17 +292,30 @@ static void FindMatchingPrimaryKeyColumns(const ColumnList &columns, const vecto
 		} else {
 			pk_names = unique.columns;
 		}
-		if (pk_names.size() != fk.fk_columns.size()) {
-			// the number of referencing and referenced columns for foreign keys must be the same
-			continue;
-		}
 		if (find_primary_key) {
 			// found matching primary key
+			if (pk_names.size() != fk.fk_columns.size()) {
+				auto pk_name_str = StringUtil::Join(pk_names, ",");
+				auto fk_name_str = StringUtil::Join(fk.fk_columns, ",");
+				throw BinderException(
+				    "Failed to create foreign key: number of referencing (%s) and referenced columns (%s) differ",
+				    fk_name_str, pk_name_str);
+			}
 			fk.pk_columns = pk_names;
 			return;
 		}
-		if (fk.pk_columns != pk_names) {
-			// Name mismatch
+		if (pk_names.size() != fk.fk_columns.size()) {
+			// the number of referencing and referenced columns for foreign keys must be the same
+			continue;
+		}
+		bool equals = true;
+		for (idx_t i = 0; i < fk.pk_columns.size(); i++) {
+			if (!StringUtil::CIEquals(fk.pk_columns[i], pk_names[i])) {
+				equals = false;
+				break;
+			}
+		}
+		if (!equals) {
 			continue;
 		}
 		// found match
@@ -540,7 +553,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			D_ASSERT(fk.info.pk_keys.empty());
 			D_ASSERT(fk.info.fk_keys.empty());
 			FindForeignKeyIndexes(create_info.columns, fk.fk_columns, fk.info.fk_keys);
-			if (create_info.table == fk.info.table) {
+			if (StringUtil::CIEquals(create_info.table, fk.info.table)) {
 				// self-referential foreign key constraint
 				fk.info.type = ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE;
 				FindMatchingPrimaryKeyColumns(create_info.columns, create_info.constraints, fk);

package/src/duckdb/src/planner/binder/statement/bind_insert.cpp

@@ -9,6 +9,7 @@
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/function/table/table_scan.hpp"
+#include "duckdb/planner/operator/logical_dummy_scan.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/expression_binder/returning_binder.hpp"
@@ -409,7 +410,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	AddCTEMap(stmt.cte_map);
 
 	vector<LogicalIndex> named_column_map;
-	if (!stmt.columns.empty()) {
+	if (!stmt.columns.empty() || stmt.default_values) {
 		// insertion statement specifies column list
 
 		// create a mapping of (list index) -> (column index)
@@ -448,11 +449,10 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 
 	// bind the default values
 	BindDefaultValues(table.GetColumns(), insert->bound_defaults);
-	if (!stmt.select_statement) {
+	if (!stmt.select_statement && !stmt.default_values) {
 		result.plan = std::move(insert);
 		return result;
 	}
-
 	// Exclude the generated columns from this amount
 	idx_t expected_columns = stmt.columns.empty() ? table.GetColumns().PhysicalColumnCount() : stmt.columns.size();
 
@@ -488,14 +488,19 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	}
 
 	// parse select statement and add to logical plan
-	auto select_binder = Binder::CreateBinder(context, this);
-	auto root_select = select_binder->Bind(*stmt.select_statement);
-	MoveCorrelatedExpressions(*select_binder);
+	unique_ptr<LogicalOperator> root;
+	if (stmt.select_statement) {
+		auto select_binder = Binder::CreateBinder(context, this);
+		auto root_select = select_binder->Bind(*stmt.select_statement);
+		MoveCorrelatedExpressions(*select_binder);
 
-	CheckInsertColumnCountMismatch(expected_columns, root_select.types.size(), !stmt.columns.empty(),
-	                               table.name.c_str());
+		CheckInsertColumnCountMismatch(expected_columns, root_select.types.size(), !stmt.columns.empty(),
+		                               table.name.c_str());
 
-	auto root = CastLogicalOperatorToTypes(root_select.types, insert->expected_types, std::move(root_select.plan));
+		root = CastLogicalOperatorToTypes(root_select.types, insert->expected_types, std::move(root_select.plan));
+	} else {
+		root = make_uniq<LogicalDummyScan>(GenerateTableIndex());
+	}
 	insert->AddChild(std::move(root));
 
 	BindOnConflictClause(*insert, table, stmt);