duckdb 0.7.2-dev2552.0 → 0.7.2-dev2675.0

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

@@ -7,48 +7,65 @@
 //===----------------------------------------------------------------------===//
 
 #pragma once
+
+#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/swizzleable_pointer.hpp"
+#include "duckdb/execution/index/art/prefix.hpp"
 
 namespace duckdb {
 
-class Node256 : public Node {
+//! Node256 holds up to 256 ARTNode children which can be directly indexed by the key byte
+class Node256 {
 public:
-	//! Empty Node256
-	explicit Node256();
-	//! ART pointers to the child nodes
-	ARTPointer children[256];
+	//! Number of non-null children
+	uint16_t count;
+	//! Compressed path (prefix)
+	Prefix prefix;
+	//! ART node pointers to the child nodes
+	Node children[Node::NODE_256_CAPACITY];
 
 public:
-	static Node256 *New();
-	//! Returns the memory size of the Node256
-	idx_t MemorySize(ART &art, const bool &recurse) override;
-	//! Get position of a specific byte, returns DConstants::INVALID_INDEX if not exists
-	idx_t GetChildPos(uint8_t k) override;
-	//! Get the position of the first child that is greater or equal to the specific byte, or DConstants::INVALID_INDEX
-	//! if there are no children matching the criteria
-	idx_t GetChildGreaterEqual(uint8_t k, bool &equal) override;
-	//! Get the position of the minimum element in the node
-	idx_t GetMin() override;
-	//! Get the next position in the node, or DConstants::INVALID_INDEX if there is no next position
-	idx_t GetNextPos(idx_t pos) override;
-	//! Get the next position in the node, or DConstants::INVALID_INDEX if there is no next position
-	idx_t GetNextPosAndByte(idx_t pos, uint8_t &byte) override;
-	//! Get Node256 child
-	Node *GetChild(ART &art, idx_t pos) override;
-	//! Replace child pointer
-	void ReplaceChildPointer(idx_t pos, Node *node) override;
-	//! Returns whether the child at pos is in memory
-	bool ChildIsInMemory(idx_t pos) override;
-
-	//! Insert a new child node at key_byte into the Node256
-	static void InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_child);
-	//! Erase the child at pos and (if necessary) shrink to Node48
-	static void EraseChild(ART &art, Node *&node, idx_t pos);
-
-	//! Returns the size (maximum capacity) of the Node256
-	static constexpr idx_t GetSize() {
-		return 256;
+	//! Get a new Node256 node, might cause a new buffer allocation, and initialize it
+	static Node256 &New(ART &art, Node &node);
+	//! Free the node (and its subtree)
+	static void Free(ART &art, Node &node);
+	//! Get a reference to the node
+	static inline Node256 &Get(const ART &art, const Node ptr) {
+		return *Node::GetAllocator(art, NType::NODE_256).Get<Node256>(ptr);
+	}
+	//! Initializes all the fields of the node while growing a Node48 to a Node256
+	static Node256 &GrowNode48(ART &art, Node &node256, Node &node48);
+
+	//! Initializes a merge by incrementing the buffer IDs of the node
+	void InitializeMerge(ART &art, const ARTFlags &flags);
+
+	//! Insert a child node at byte
+	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
+	//! Delete the child node at the respective byte
+	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
+
+	//! Replace the child node at the respective byte
+	inline void ReplaceChild(const uint8_t byte, const Node child) {
+		children[byte] = child;
 	}
+
+	//! Get the child for the respective byte in the node
+	inline optional_ptr<Node> GetChild(const uint8_t byte) {
+		if (children[byte].IsSet()) {
+			return &children[byte];
+		}
+		return nullptr;
+	}
+	//! Get the first child that is greater or equal to the specific byte
+	optional_ptr<Node> GetNextChild(uint8_t &byte);
+
+	//! Serialize an ART node
+	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
+	//! Deserialize this node
+	void Deserialize(ART &art, MetaBlockReader &reader);
+
+	//! Vacuum the children of the node
+	void Vacuum(ART &art, const ARTFlags &flags);
 };
 } // namespace duckdb

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

@@ -7,50 +7,60 @@
 //===----------------------------------------------------------------------===//
 
 #pragma once
+
+#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/swizzleable_pointer.hpp"
+#include "duckdb/execution/index/art/prefix.hpp"
 
 namespace duckdb {
 
-class Node4 : public Node {
+//! Node4 holds up to four ARTNode children sorted by their key byte
+class Node4 {
 public:
-	//! Empty Node4
-	explicit Node4();
+	//! Number of non-null children
+	uint8_t count;
+	//! Compressed path (prefix)
+	Prefix prefix;
 	//! Array containing all partial key bytes
-	uint8_t key[4];
-	//! ART pointers to the child nodes
-	ARTPointer children[4];
+	uint8_t key[Node::NODE_4_CAPACITY];
+	//! ART node pointers to the child nodes
+	Node children[Node::NODE_4_CAPACITY];
 
 public:
-	static Node4 *New();
-	//! Returns the memory size of the Node4
-	idx_t MemorySize(ART &art, const bool &recurse) override;
-	//! Get position of a byte, returns DConstants::INVALID_INDEX if not exists
-	idx_t GetChildPos(uint8_t k) override;
-	//! Get the position of the first child that is greater or equal to the specific byte, or DConstants::INVALID_INDEX
-	//! if there are no children matching the criteria
-	idx_t GetChildGreaterEqual(uint8_t k, bool &equal) override;
-	//! Get the position of the minimum element in the node
-	idx_t GetMin() override;
-	//! Get the next position in the node, or DConstants::INVALID_INDEX if there is no next position
-	idx_t GetNextPos(idx_t pos) override;
-	//! Get the next position in the node, or DConstants::INVALID_INDEX if there is no next position
-	idx_t GetNextPosAndByte(idx_t pos, uint8_t &byte) override;
-	//! Get Node4 child
-	Node *GetChild(ART &art, idx_t pos) override;
-	//! Replace child pointer
-	void ReplaceChildPointer(idx_t pos, Node *node) override;
-	//! Returns whether the child at pos is in memory
-	bool ChildIsInMemory(idx_t pos) override;
-
-	//! Insert a new child node at key_byte into the Node4
-	static void InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_child);
-	//! Erase the child at pos and (if necessary) merge with last child
-	static void EraseChild(ART &art, Node *&node, idx_t pos);
-
-	//! Returns the size (maximum capacity) of the Node4
-	static constexpr idx_t GetSize() {
-		return 4;
+	//! Get a new Node4 node, might cause a new buffer allocation, and initialize it
+	static Node4 &New(ART &art, Node &node);
+	//! Free the node (and its subtree)
+	static void Free(ART &art, Node &node);
+	//! Get a reference to the node
+	static inline Node4 &Get(const ART &art, const Node ptr) {
+		return *Node::GetAllocator(art, NType::NODE_4).Get<Node4>(ptr);
 	}
+	//! Initializes all fields of the node while shrinking a Node16 to a Node4
+	static Node4 &ShrinkNode16(ART &art, Node &node4, Node &node16);
+
+	//! Initializes a merge by incrementing the buffer IDs of the node
+	void InitializeMerge(ART &art, const ARTFlags &flags);
+
+	//! Insert a child node at byte
+	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
+	//! Delete the child node at the respective byte
+	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
+
+	//! Replace the child node at the respective byte
+	void ReplaceChild(const uint8_t byte, const Node child);
+
+	//! Get the child for the respective byte in the node
+	optional_ptr<Node> GetChild(const uint8_t byte);
+	//! Get the first child that is greater or equal to the specific byte
+	optional_ptr<Node> GetNextChild(uint8_t &byte);
+
+	//! Serialize an ART node
+	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
+	//! Deserialize this node
+	void Deserialize(ART &art, MetaBlockReader &reader);
+
+	//! Vacuum the children of the node
+	void Vacuum(ART &art, const ARTFlags &flags);
 };
 } // namespace duckdb

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

@@ -7,49 +7,71 @@
 //===----------------------------------------------------------------------===//
 
 #pragma once
+
+#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/swizzleable_pointer.hpp"
+#include "duckdb/execution/index/art/prefix.hpp"
 
 namespace duckdb {
 
-class Node48 : public Node {
+//! Node48 holds up to 48 ARTNode children. It contains a child_index array which can be directly indexed by the key
+//! byte, and which contains the position of the child node in the children array
+class Node48 {
 public:
-	//! Empty Node48
-	explicit Node48();
+	//! Number of non-null children
+	uint8_t count;
+	//! Compressed path (prefix)
+	Prefix prefix;
 	//! Array containing all possible partial key bytes, those not set have an EMPTY_MARKER
-	uint8_t child_index[256];
-	//! ART pointers to the child nodes
-	ARTPointer children[48];
+	uint8_t child_index[Node::NODE_256_CAPACITY];
+	//! ART node pointers to the child nodes
+	Node children[Node::NODE_48_CAPACITY];
 
 public:
-	static Node48 *New();
-	//! Returns the memory size of the Node48
-	idx_t MemorySize(ART &art, const bool &recurse) override;
-	//! Get position of a specific byte, returns DConstants::INVALID_INDEX if not exists
-	idx_t GetChildPos(uint8_t k) override;
-	//! Get the position of the first child that is greater or equal to the specific byte, or DConstants::INVALID_INDEX
-	//! if there are no children matching the criteria
-	idx_t GetChildGreaterEqual(uint8_t k, bool &equal) override;
-	//! Get the position of the minimum element in the node
-	idx_t GetMin() override;
-	//! Get the next position in the node, or DConstants::INVALID_INDEX if there is no next position
-	idx_t GetNextPos(idx_t pos) override;
-	//! Get the next position in the node, or DConstants::INVALID_INDEX if there is no next position
-	idx_t GetNextPosAndByte(idx_t pos, uint8_t &byte) override;
-	//! Get Node48 child
-	Node *GetChild(ART &art, idx_t pos) override;
-	//! Replace child pointer
-	void ReplaceChildPointer(idx_t pos, Node *node) override;
-	//! Returns whether the child at pos is in memory
-	bool ChildIsInMemory(idx_t pos) override;
-
-	//! Insert a new child node at key_byte into the Node48
-	static void InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_child);
-	//! Erase the child at pos and (if necessary) shrink to Node16
-	static void EraseChild(ART &art, Node *&node, idx_t pos);
-	//! Returns the size (maximum capacity) of the Node48
-	static constexpr idx_t GetSize() {
-		return 48;
+	//! Get a new Node48 node, might cause a new buffer allocation, and initialize it
+	static Node48 &New(ART &art, Node &node);
+	//! Free the node (and its subtree)
+	static void Free(ART &art, Node &node);
+	//! Get a reference to the node
+	static inline Node48 &Get(const ART &art, const Node ptr) {
+		return *Node::GetAllocator(art, NType::NODE_48).Get<Node48>(ptr);
+	}
+	//! Initializes all the fields of the node while growing a Node16 to a Node48
+	static Node48 &GrowNode16(ART &art, Node &node48, Node &node16);
+	//! Initializes all fields of the node while shrinking a Node256 to a Node48
+	static Node48 &ShrinkNode256(ART &art, Node &node48, Node &node256);
+
+	//! Initializes a merge by incrementing the buffer IDs of the node
+	void InitializeMerge(ART &art, const ARTFlags &flags);
+
+	//! Insert a child node at byte
+	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
+	//! Delete the child node at the respective byte
+	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
+
+	//! Replace the child node at the respective byte
+	inline void ReplaceChild(const uint8_t byte, const Node child) {
+		D_ASSERT(child_index[byte] != Node::EMPTY_MARKER);
+		children[child_index[byte]] = child;
 	}
+
+	//! Get the child for the respective byte in the node
+	inline optional_ptr<Node> GetChild(const uint8_t byte) {
+		if (child_index[byte] != Node::EMPTY_MARKER) {
+			return &children[child_index[byte]];
+		}
+		return nullptr;
+	}
+	//! Get the first child that is greater or equal to the specific byte
+	optional_ptr<Node> GetNextChild(uint8_t &byte);
+
+	//! Serialize an ART node
+	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
+	//! Deserialize this node
+	void Deserialize(ART &art, MetaBlockReader &reader);
+
+	//! Vacuum the children of the node
+	void Vacuum(ART &art, const ARTFlags &flags);
 };
 } // namespace duckdb

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

@@ -7,71 +7,78 @@
 //===----------------------------------------------------------------------===//
 #pragma once
 
-#include "duckdb/execution/index/art/art_key.hpp"
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/execution/index/art/node.hpp"
 
 namespace duckdb {
-class ART;
 
-class Prefix {
-	static constexpr idx_t PREFIX_INLINE_BYTES = 8;
+// classes
+class ARTKey;
+class PrefixSegment;
 
+class Prefix {
 public:
-	//! Empty prefix
-	Prefix();
-	//! Construct prefix from key starting at depth
-	Prefix(Key &key, uint32_t depth, uint32_t size);
-	//! Construct prefix from other prefix up to size
-	Prefix(Prefix &other_prefix, uint32_t size);
-	~Prefix();
+	//! Number of bytes in this prefix
+	uint32_t count;
+	union {
+		//! Pointer to the head of the list of prefix segments
+		Node ptr;
+		//! Inlined prefix bytes
+		uint8_t inlined[Node::PREFIX_INLINE_BYTES];
+	} data;
 
-	//! Returns the prefix size
-	inline uint32_t Size() const {
-		return size;
+public:
+	//! Delete all prefix segments (if not inlined) and reset all fields
+	void Free(ART &art);
+	//! Initializes all the fields of an empty prefix
+	inline void Initialize() {
+		count = 0;
 	}
-	//! Returns the memory size of the prefix
-	idx_t MemorySize();
-	//! Returns a pointer to the prefix data
-	uint8_t *GetPrefixData();
-	//! Returns a const pointer to the prefix data
-	const uint8_t *GetPrefixData() const;
+	//! Initialize a prefix from an ART key
+	void Initialize(ART &art, const ARTKey &key, const uint32_t depth, const uint32_t count_p);
+	//! Initialize a prefix from another prefix up to count
+	void Initialize(ART &art, const Prefix &other, const uint32_t count_p);
 
-	//! Subscript operator
-	uint8_t &operator[](idx_t idx);
-	//! Assign operator
-	Prefix &operator=(const Prefix &src);
-	//! Move operator
-	Prefix &operator=(Prefix &&other) noexcept;
+	//! Initializes a merge by incrementing the buffer IDs of the prefix segments
+	void InitializeMerge(ART &art, const idx_t buffer_count);
 
+	//! Move a prefix into this prefix
+	inline void Move(Prefix &other) {
+		count = other.count;
+		data = other.data;
+		other.Initialize();
+	}
+	//! Append a prefix to this prefix
+	void Append(ART &art, const Prefix &other);
 	//! Concatenate prefix with a partial key byte and another prefix: other.prefix + byte + this->prefix
-	//! Used when deleting a node
-	void Concatenate(ART &art, uint8_t key, Prefix &other);
-	//! Reduces the prefix in n bytes, and returns the new first byte
-	uint8_t Reduce(ART &art, uint32_t n);
-
-	//! Serializes the prefix
-	void Serialize(duckdb::MetaBlockWriter &writer);
-	//! Deserializes the prefix
-	void Deserialize(duckdb::MetaBlockReader &reader);
+	void Concatenate(ART &art, const uint8_t byte, const Prefix &other);
+	//! Removes the first n bytes, and returns the new first byte
+	uint8_t Reduce(ART &art, const idx_t reduce_count);
 
+	//! Get the byte at position
+	uint8_t GetByte(const ART &art, const idx_t position) const;
 	//! Compare the key with the prefix of the node, return the position where they mismatch
-	uint32_t KeyMismatchPosition(Key &key, uint32_t depth);
-	//! Compare this prefix to another prefix, return the position where they mismatch, or size otherwise
-	uint32_t MismatchPosition(Prefix &other);
+	uint32_t KeyMismatchPosition(const ART &art, const ARTKey &key, const uint32_t depth) const;
+	//! Compare this prefix to another prefix, return the position where they mismatch, or count otherwise
+	uint32_t MismatchPosition(const ART &art, const Prefix &other) const;
 
-private:
-	uint32_t size;
-	union {
-		uint8_t *ptr;
-		uint8_t inlined[8];
-	} value;
+	//! Serialize this prefix
+	void Serialize(const ART &art, MetaBlockWriter &writer) const;
+	//! Deserialize this prefix
+	void Deserialize(ART &art, MetaBlockReader &reader);
+
+	//! Vacuum the prefix segments of a prefix, if not inlined
+	void Vacuum(ART &art);
 
 private:
-	bool IsInlined() const;
-	uint8_t *AllocatePrefix(uint32_t size);
-	void Overwrite(uint32_t new_size, uint8_t *data);
-	void Destroy();
+	//! Returns whether this prefix is inlined
+	inline bool IsInlined() const {
+		return count <= Node::PREFIX_INLINE_BYTES;
+	}
+	//! Moves all inlined bytes onto a prefix segment, does not change the size
+	//! so this will be an (temporarily) invalid prefix
+	PrefixSegment &MoveInlinedToSegment(ART &art);
+	//! Inlines up to eight bytes on the first prefix segment
+	void MoveSegmentToInlined(ART &art);
 };
 
 } // namespace duckdb

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

@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/index/art/prefix_segment.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+#pragma once
+
+#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/execution/index/art/node.hpp"
+
+namespace duckdb {
+
+class PrefixSegment {
+public:
+	//! Constructor of an empty prefix segment containing bytes.
+	//! NOTE: only use this constructor for temporary prefix segments
+	PrefixSegment() {};
+
+	//! The prefix bytes stored in this segment
+	uint8_t bytes[Node::PREFIX_SEGMENT_SIZE];
+	//! The position of the next segment, if the prefix exceeds this segment
+	Node next;
+
+public:
+	//! Get a new prefix segment node, might cause a new buffer allocation, and initialize it
+	static PrefixSegment &New(ART &art, Node &node);
+	//! Get a reference to the prefix segment
+	static inline PrefixSegment &Get(const ART &art, const Node ptr) {
+		return *Node::GetAllocator(art, NType::PREFIX_SEGMENT).Get<PrefixSegment>(ptr);
+	}
+
+	//! Append a byte to the current segment, or create a new segment containing that byte
+	PrefixSegment &Append(ART &art, uint32_t &count, const uint8_t byte);
+	//! Get the tail of a list of segments
+	PrefixSegment &GetTail(const ART &art);
+};
+
+} // namespace duckdb

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