duckdb 0.8.2-dev33.0 → 0.8.2-dev3334.0

package/test/test_all_types.test.ts

@@ -0,0 +1,234 @@
+import { expect } from "chai";
+import duckdb, { DuckDbError, TableData } from "..";
+
+function get_all_types(): Promise<string[]> {
+  return new Promise((resolve, reject) => {
+    const conn = new duckdb.Database(":memory:");
+    conn.all(
+      "describe select * from test_all_types()",
+      (error: DuckDbError | null, data: TableData) => {
+        if (error) reject(error);
+        resolve(data.map((row) => row.column_name));
+      }
+    );
+  });
+}
+
+function timedelta(obj: { days: number; micros: number; months: number }) {
+  return obj;
+}
+
+// We replace these values since the extreme ranges are not supported in native-node.
+const replacement_values: Record<string, string> = {
+  timestamp:
+    "'1990-01-01 00:00:00'::TIMESTAMP, '9999-12-31 23:59:59'::TIMESTAMP, NULL::TIMESTAMP",
+  // TODO: fix these, they are currently being returned as strings
+  //   timestamp_s: "'1990-01-01 00:00:00'::TIMESTAMP_S",
+  //   timestamp_ns: "'1990-01-01 00:00:00'::TIMESTAMP_NS",
+  //   timestamp_ms: "'1990-01-01 00:00:00'::TIMESTAMP_MS",
+  timestamp_tz:
+    "'1990-01-01 00:00:00Z'::TIMESTAMPTZ, '9999-12-31 23:59:59.999999Z'::TIMESTAMPTZ, NULL::TIMESTAMPTZ",
+  date: "'1990-01-01'::DATE, '9999-12-31'::DATE, NULL::DATE",
+  date_array:
+    "[], ['1970-01-01'::DATE, NULL, '0001-01-01'::DATE, '9999-12-31'::DATE,], [NULL::DATE,]",
+  timestamp_array:
+    "[], ['1970-01-01'::TIMESTAMP, NULL, '0001-01-01'::TIMESTAMP, '9999-12-31 23:59:59.999999'::TIMESTAMP,], [NULL::TIMESTAMP,]",
+  timestamptz_array:
+    "[], ['1970-01-01 00:00:00Z'::TIMESTAMPTZ, NULL, '0001-01-01 00:00:00Z'::TIMESTAMPTZ, '9999-12-31 23:59:59.999999Z'::TIMESTAMPTZ,], [NULL::TIMESTAMPTZ,]",
+};
+
+const correct_answer_map: Record<string, any[]> = {
+  bool: [false, true, null],
+
+  tinyint: [-128, 127, null],
+  smallint: [-32768, 32767, null],
+
+  int: [-2147483648, 2147483647, null],
+  bigint: [BigInt("-9223372036854775808"), BigInt("9223372036854775807"), null],
+
+  hugeint: [
+    BigInt("-170141183460469231731687303715884105727"),
+    BigInt("170141183460469231731687303715884105727"),
+    null,
+  ],
+
+  utinyint: [0, 255, null],
+  usmallint: [0, 65535, null],
+
+  uint: [0, 4294967295, null],
+  ubigint: [BigInt(0), BigInt("18446744073709551615"), null],
+
+  time: ["00:00:00", "23:59:59.999999", null],
+
+  float: [-3.4028234663852886e38, 3.4028234663852886e38, null],
+  double: [-1.7976931348623157e308, 1.7976931348623157e308, null],
+
+  dec_4_1: [-999.9, 999.9, null],
+  dec_9_4: [-99999.9999, 99999.9999, null],
+  dec_18_6: ["-999999999999.999999", "999999999999.999999", null],
+  dec38_10: [
+    "-9999999999999999999999999999.9999999999",
+    "9999999999999999999999999999.9999999999",
+    null,
+  ],
+  uuid: [
+    "00000000-0000-0000-0000-000000000001",
+    "ffffffff-ffff-ffff-ffff-ffffffffffff",
+    null,
+  ],
+  varchar: ["🦆🦆🦆🦆🦆🦆", "goo\0se", null],
+  json: ["🦆🦆🦆🦆🦆🦆", "goose", null],
+  blob: [
+    Buffer.from("thisisalongblob\x00withnullbytes"),
+    Buffer.from("\x00\x00\x00a"),
+    null,
+  ],
+  bit: ["0010001001011100010101011010111", "10101", null],
+  small_enum: ["DUCK_DUCK_ENUM", "GOOSE", null],
+  medium_enum: ["enum_0", "enum_299", null],
+  large_enum: ["enum_0", "enum_69999", null],
+  date_array: [
+    [],
+    [
+      new Date(1970, 0, 1),
+      null,
+      new Date("0001-01-01T00:00:00.000Z"),
+      new Date("9999-12-31T00:00:00.000Z"),
+    ],
+    [null],
+  ],
+  timestamp_array: [
+    [],
+    [
+      new Date(1970, 0, 1),
+      null,
+      new Date("0001-01-01T00:00:00.000Z"),
+      new Date("9999-12-31T23:59:59.999Z"),
+    ],
+    [null],
+  ],
+
+  timestamptz_array: [
+    [],
+    [
+      new Date(1970, 0, 1),
+      null,
+      new Date("0001-01-01T00:00:00.000Z"),
+      new Date("9999-12-31T23:59:59.999Z"),
+    ],
+    [null],
+  ],
+
+  int_array: [[], [42, 999, null, null, -42], null],
+  varchar_array: [[], ["🦆🦆🦆🦆🦆🦆", "goose", null, ""], null],
+
+  double_array: [
+    [],
+    [
+      42.0,
+      Number.NaN,
+      Number.POSITIVE_INFINITY,
+      Number.NEGATIVE_INFINITY,
+      null,
+      -42.0,
+    ],
+    null,
+  ],
+
+  nested_int_array: [
+    [],
+    [[], [42, 999, null, null, -42], null, [], [42, 999, null, null, -42]],
+    null,
+  ],
+  struct: [{ a: null, b: null }, { a: 42, b: "🦆🦆🦆🦆🦆🦆" }, null],
+
+  struct_of_arrays: [
+    { a: null, b: null },
+    {
+      a: [42, 999, null, null, -42],
+      b: ["🦆🦆🦆🦆🦆🦆", "goose", null, ""],
+    },
+    null,
+  ],
+
+  array_of_structs: [
+    [],
+    [{ a: null, b: null }, { a: 42, b: "🦆🦆🦆🦆🦆🦆" }, null],
+    null,
+  ],
+  map: ["{}", "{key1=🦆🦆🦆🦆🦆🦆, key2=goose}", null],
+  union: ['Frank', '5', null],
+
+  time_tz: ["00:00:00-1559", "23:59:59.999999+1559", null],
+  interval: [
+    timedelta({
+      days: 0,
+      months: 0,
+      micros: 0,
+    }),
+    timedelta({ days: 999, months: 999, micros: 999999999 }),
+    null,
+  ],
+
+  timestamp: [
+    new Date("1990-01-01T00:00"),
+    new Date("9999-12-31T23:59:59.000Z"),
+    null,
+  ],
+  date: [new Date("1990-01-01"), new Date("9999-12-31"), null],
+  timestamp_s: ["290309-12-22 (BC) 00:00:00", "294247-01-10 04:00:54", null],
+
+  timestamp_ns: [
+    "1677-09-21 00:12:43.145225",
+    "2262-04-11 23:47:16.854775",
+    null,
+  ],
+  timestamp_ms: [
+    "290309-12-22 (BC) 00:00:00",
+    "294247-01-10 04:00:54.775",
+    null,
+  ],
+  timestamp_tz: [
+    new Date("1990-01-01T00:00:00.000Z"),
+    new Date("9999-12-31T23:59:59.999Z"),
+    null,
+  ],
+};
+
+const suite = describe("test_all_types", () => {
+  before(async function () {
+    const all_types = await get_all_types();
+
+    for (const cur_type of all_types) {
+      // FIXME: these currently have too high a precision to be tested
+      if (["dec_18_6", "dec38_10"].includes(cur_type)) continue;
+
+      suite.addTest(
+        it(cur_type, async () => {
+          const conn = new duckdb.Database(":memory:");
+
+          let query: string;
+          if (cur_type in replacement_values) {
+            query = `select UNNEST([${replacement_values[cur_type]}]) AS ${cur_type}`;
+          } else {
+            query = `select "${cur_type}" from test_all_types()`;
+          }
+
+          let result = await new Promise<any[]>((resolve, reject) =>
+            conn.all(query, (err: DuckDbError | null, data: TableData) =>
+              err ? reject(err) : resolve(data)
+            )
+          );
+
+          result = result.map((row) => row[cur_type]); // pluck values
+
+          const correct_result = correct_answer_map[cur_type];
+
+          expect(result).deep.eq(correct_result);
+        })
+      );
+    }
+  });
+
+  it("dummy", () => {});
+});

package/tsconfig.json

@@ -2,6 +2,7 @@
   "compilerOptions": {
     "allowJs": false,
     "esModuleInterop": true,
+    "lib": ["ES2015"],
     "noImplicitAny": true,
     "strict": true,
     "outDir": "./dist",

package/src/duckdb/src/execution/index/art/leaf_segment.cpp

@@ -1,52 +0,0 @@
-#include "duckdb/execution/index/art/leaf_segment.hpp"
-
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-
-namespace duckdb {
-
-LeafSegment &LeafSegment::New(ART &art, Node &node) {
-
-	node.SetPtr(Node::GetAllocator(art, NType::LEAF_SEGMENT).New());
-	node.type = (uint8_t)NType::LEAF_SEGMENT;
-
-	auto &segment = LeafSegment::Get(art, node);
-	segment.next.Reset();
-	return segment;
-}
-
-void LeafSegment::Free(ART &art, Node &node) {
-
-	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
-
-	// free next segment
-	auto next_segment = LeafSegment::Get(art, node).next;
-	Node::Free(art, next_segment);
-}
-
-LeafSegment &LeafSegment::Append(ART &art, uint32_t &count, const row_t row_id) {
-
-	reference<LeafSegment> segment(*this);
-	auto position = count % Node::LEAF_SEGMENT_SIZE;
-
-	// we need a new segment
-	if (position == 0 && count != 0) {
-		segment = LeafSegment::New(art, next);
-	}
-
-	segment.get().row_ids[position] = row_id;
-	count++;
-	return segment.get();
-}
-
-LeafSegment &LeafSegment::GetTail(const ART &art) {
-
-	reference<LeafSegment> segment(*this);
-	while (segment.get().next.IsSet()) {
-		segment = LeafSegment::Get(art, segment.get().next);
-	}
-	return segment.get();
-}
-
-} // namespace duckdb

package/src/duckdb/src/execution/index/art/prefix_segment.cpp

@@ -1,42 +0,0 @@
-#include "duckdb/execution/index/art/prefix_segment.hpp"
-
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-
-namespace duckdb {
-
-PrefixSegment &PrefixSegment::New(ART &art, Node &node) {
-
-	node.SetPtr(Node::GetAllocator(art, NType::PREFIX_SEGMENT).New());
-	node.type = (uint8_t)NType::PREFIX_SEGMENT;
-
-	auto &segment = PrefixSegment::Get(art, node);
-	segment.next.Reset();
-	return segment;
-}
-
-PrefixSegment &PrefixSegment::Append(ART &art, uint32_t &count, const uint8_t byte) {
-
-	reference<PrefixSegment> segment(*this);
-	auto position = count % Node::PREFIX_SEGMENT_SIZE;
-
-	// we need a new segment
-	if (position == 0 && count != 0) {
-		segment = PrefixSegment::New(art, next);
-	}
-
-	segment.get().bytes[position] = byte;
-	count++;
-	return segment.get();
-}
-
-PrefixSegment &PrefixSegment::GetTail(const ART &art) {
-
-	reference<PrefixSegment> segment(*this);
-	while (segment.get().next.IsSet()) {
-		segment = PrefixSegment::Get(art, segment.get().next);
-	}
-	return segment.get();
-}
-
-} // namespace duckdb

package/src/duckdb/src/execution/index/art/swizzleable_pointer.cpp

@@ -1,22 +0,0 @@
-#include "duckdb/execution/index/art/swizzleable_pointer.hpp"
-
-#include "duckdb/storage/meta_block_reader.hpp"
-
-namespace duckdb {
-
-SwizzleablePointer::SwizzleablePointer(MetaBlockReader &reader) {
-
-	idx_t block_id = reader.Read<block_id_t>();
-	offset = reader.Read<uint32_t>();
-	type = 0;
-
-	if (block_id == DConstants::INVALID_INDEX) {
-		swizzle_flag = 0;
-		return;
-	}
-
-	buffer_id = (uint32_t)block_id;
-	swizzle_flag = 1;
-}
-
-} // namespace duckdb

package/src/duckdb/src/execution/operator/schema/physical_create_index.cpp

@@ -1,193 +0,0 @@
-#include "duckdb/execution/operator/schema/physical_create_index.hpp"
-
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/execution/index/art/art_key.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/leaf.hpp"
-
-namespace duckdb {
-
-PhysicalCreateIndex::PhysicalCreateIndex(LogicalOperator &op, TableCatalogEntry &table_p,
-                                         const vector<column_t> &column_ids, unique_ptr<CreateIndexInfo> info,
-                                         vector<unique_ptr<Expression>> unbound_expressions,
-                                         idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::CREATE_INDEX, op.types, estimated_cardinality),
-      table(table_p.Cast<DuckTableEntry>()), info(std::move(info)),
-      unbound_expressions(std::move(unbound_expressions)) {
-	// convert virtual column ids to storage column ids
-	for (auto &column_id : column_ids) {
-		storage_ids.push_back(table.GetColumns().LogicalToPhysical(LogicalIndex(column_id)).index);
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Sink
-//===--------------------------------------------------------------------===//
-
-class CreateIndexGlobalSinkState : public GlobalSinkState {
-public:
-	//! Global index to be added to the table
-	unique_ptr<Index> global_index;
-};
-
-class CreateIndexLocalSinkState : public LocalSinkState {
-public:
-	explicit CreateIndexLocalSinkState(ClientContext &context) : arena_allocator(Allocator::Get(context)) {};
-
-	unique_ptr<Index> local_index;
-	ArenaAllocator arena_allocator;
-	vector<ARTKey> keys;
-	DataChunk key_chunk;
-	vector<column_t> key_column_ids;
-};
-
-unique_ptr<GlobalSinkState> PhysicalCreateIndex::GetGlobalSinkState(ClientContext &context) const {
-	auto state = make_uniq<CreateIndexGlobalSinkState>();
-
-	// create the global index
-	switch (info->index_type) {
-	case IndexType::ART: {
-		auto &storage = table.GetStorage();
-		state->global_index = make_uniq<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
-		                                     info->constraint_type, storage.db);
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented index type");
-	}
-	return (std::move(state));
-}
-
-unique_ptr<LocalSinkState> PhysicalCreateIndex::GetLocalSinkState(ExecutionContext &context) const {
-	auto state = make_uniq<CreateIndexLocalSinkState>(context.client);
-
-	// create the local index
-	switch (info->index_type) {
-	case IndexType::ART: {
-		auto &storage = table.GetStorage();
-		state->local_index = make_uniq<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
-		                                    info->constraint_type, storage.db);
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented index type");
-	}
-	state->keys = vector<ARTKey>(STANDARD_VECTOR_SIZE);
-	state->key_chunk.Initialize(Allocator::Get(context.client), state->local_index->logical_types);
-
-	for (idx_t i = 0; i < state->key_chunk.ColumnCount(); i++) {
-		state->key_column_ids.push_back(i);
-	}
-	return std::move(state);
-}
-
-SinkResultType PhysicalCreateIndex::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-
-	D_ASSERT(chunk.ColumnCount() >= 2);
-	auto &lstate = input.local_state.Cast<CreateIndexLocalSinkState>();
-	auto &row_identifiers = chunk.data[chunk.ColumnCount() - 1];
-
-	// generate the keys for the given input
-	lstate.key_chunk.ReferenceColumns(chunk, lstate.key_column_ids);
-	lstate.arena_allocator.Reset();
-	ART::GenerateKeys(lstate.arena_allocator, lstate.key_chunk, lstate.keys);
-
-	auto &storage = table.GetStorage();
-	auto art = make_uniq<ART>(lstate.local_index->column_ids, lstate.local_index->table_io_manager,
-	                          lstate.local_index->unbound_expressions, lstate.local_index->constraint_type, storage.db);
-	if (!art->ConstructFromSorted(lstate.key_chunk.size(), lstate.keys, row_identifiers)) {
-		throw ConstraintException("Data contains duplicates on indexed column(s)");
-	}
-
-	// merge into the local ART
-	if (!lstate.local_index->MergeIndexes(*art)) {
-		throw ConstraintException("Data contains duplicates on indexed column(s)");
-	}
-
-#ifdef DEBUG
-	// ensure that all row IDs of this chunk exist in the ART
-	auto row_ids = FlatVector::GetData<row_t>(row_identifiers);
-	for (idx_t i = 0; i < lstate.key_chunk.size(); i++) {
-		auto leaf_node =
-		    lstate.local_index->Cast<ART>().Lookup(*lstate.local_index->Cast<ART>().tree, lstate.keys[i], 0);
-		D_ASSERT(leaf_node.IsSet());
-		auto &leaf = Leaf::Get(lstate.local_index->Cast<ART>(), leaf_node);
-
-		if (leaf.IsInlined()) {
-			D_ASSERT(row_ids[i] == leaf.row_ids.inlined);
-			continue;
-		}
-
-		D_ASSERT(leaf.row_ids.ptr.IsSet());
-		Node leaf_segment = leaf.row_ids.ptr;
-		auto position = leaf.FindRowId(lstate.local_index->Cast<ART>(), leaf_segment, row_ids[i]);
-		D_ASSERT(position != (uint32_t)DConstants::INVALID_INDEX);
-	}
-#endif
-
-	return SinkResultType::NEED_MORE_INPUT;
-}
-
-void PhysicalCreateIndex::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
-                                  LocalSinkState &lstate_p) const {
-
-	auto &gstate = gstate_p.Cast<CreateIndexGlobalSinkState>();
-	auto &lstate = lstate_p.Cast<CreateIndexLocalSinkState>();
-
-	// merge the local index into the global index
-	if (!gstate.global_index->MergeIndexes(*lstate.local_index)) {
-		throw ConstraintException("Data contains duplicates on indexed column(s)");
-	}
-
-	// vacuum excess memory
-	gstate.global_index->Vacuum();
-}
-
-SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                               GlobalSinkState &gstate_p) const {
-
-	// here, we just set the resulting global index as the newly created index of the table
-
-	auto &state = gstate_p.Cast<CreateIndexGlobalSinkState>();
-	D_ASSERT(!state.global_index->VerifyAndToString(true).empty());
-
-	auto &storage = table.GetStorage();
-	if (!storage.IsRoot()) {
-		throw TransactionException("Transaction conflict: cannot add an index to a table that has been altered!");
-	}
-
-	auto &schema = table.schema;
-	auto index_entry = schema.CreateIndex(context, *info, table).get();
-	if (!index_entry) {
-		D_ASSERT(info->on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT);
-		// index already exists, but error ignored because of IF NOT EXISTS
-		return SinkFinalizeType::READY;
-	}
-	auto &index = index_entry->Cast<DuckIndexEntry>();
-
-	index.index = state.global_index.get();
-	index.info = storage.info;
-	for (auto &parsed_expr : info->parsed_expressions) {
-		index.parsed_expressions.push_back(parsed_expr->Copy());
-	}
-
-	// add index to storage
-	storage.info->indexes.AddIndex(std::move(state.global_index));
-	return SinkFinalizeType::READY;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-
-SourceResultType PhysicalCreateIndex::GetData(ExecutionContext &context, DataChunk &chunk,
-                                              OperatorSourceInput &input) const {
-	return SourceResultType::FINISHED;
-}
-
-} // namespace duckdb

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

@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/arrow/arrow_options.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-namespace duckdb {
-
-enum ArrowOffsetSize { REGULAR, LARGE };
-
-struct ArrowOptions {
-	explicit ArrowOptions(ArrowOffsetSize offset_size_p) : offset_size(offset_size_p) {
-	}
-	ArrowOptions(ArrowOffsetSize offset_size_p, string timezone_p) : offset_size(offset_size_p), time_zone(timezone_p) {
-	}
-	ArrowOptions() {
-	}
-	ArrowOffsetSize offset_size = ArrowOffsetSize::REGULAR;
-	string time_zone = "UTC";
-};
-} // namespace duckdb

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

@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/leaf_segment.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-#pragma once
-
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-
-namespace duckdb {
-
-class LeafSegment {
-public:
-	//! The row IDs stored in this segment
-	row_t row_ids[Node::LEAF_SEGMENT_SIZE];
-	//! The pointer of the next segment, if the row IDs exceeds this segment
-	Node next;
-
-public:
-	//! Get a new leaf segment node, might cause a new buffer allocation, and initialize it
-	static LeafSegment &New(ART &art, Node &node);
-	//! Get a reference to the leaf segment
-	static inline LeafSegment &Get(const ART &art, const Node ptr) {
-		return *Node::GetAllocator(art, NType::LEAF_SEGMENT).Get<LeafSegment>(ptr);
-	}
-	//! Free the leaf segment and any subsequent ones
-	static void Free(ART &art, Node &node);
-
-	//! Append a row ID to the current segment, or create a new segment containing that row ID
-	LeafSegment &Append(ART &art, uint32_t &count, const row_t row_id);
-	//! Get the tail of a list of segments
-	LeafSegment &GetTail(const ART &art);
-};
-
-} // namespace duckdb

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

@@ -1,40 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         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