duckdb 0.8.2-dev1968.0 → 0.8.2-dev2068.0

package/configure.py

@@ -31,6 +31,7 @@ if os.environ.get('DUCKDB_NODE_BUILD_CACHE') == '1' and os.path.isfile(cache_fil
     windows_options = cache['windows_options']
     cflags = cache['cflags']
 elif 'DUCKDB_NODE_BINDIR' in os.environ:
+
     def find_library_path(libdir, libname):
         flist = os.listdir(libdir)
         for fname in flist:
@@ -38,6 +39,7 @@ elif 'DUCKDB_NODE_BINDIR' in os.environ:
             if os.path.isfile(fpath) and package_build.file_is_lib(fname, libname):
                 return fpath
         raise Exception(f"Failed to find library {libname} in {libdir}")
+
     # existing build
     existing_duckdb_dir = os.environ['DUCKDB_NODE_BINDIR']
     cflags = os.environ['DUCKDB_NODE_CFLAGS']
@@ -48,7 +50,7 @@ elif 'DUCKDB_NODE_BINDIR' in os.environ:
 
     result_libraries = package_build.get_libraries(existing_duckdb_dir, libraries, extensions)
     libraries = []
-    for (libdir, libname) in result_libraries:
+    for libdir, libname in result_libraries:
         if libdir is None:
             continue
         libraries.append(find_library_path(libdir, libname))
@@ -72,7 +74,7 @@ elif 'DUCKDB_NODE_BINDIR' in os.environ:
             'include_list': include_list,
             'libraries': libraries,
             'cflags': cflags,
-            'windows_options': windows_options
+            'windows_options': windows_options,
         }
         with open(cache_file, 'wb+') as f:
             pickle.dump(cache, f)
@@ -90,9 +92,11 @@ else:
     windows_options = ['/GR']
     cflags = ['-frtti']
 
+
 def sanitize_path(x):
     return x.replace('\\', '/')
 
+
 source_list = [sanitize_path(x) for x in source_list]
 include_list = [sanitize_path(x) for x in include_list]
 libraries = [sanitize_path(x) for x in libraries]
@@ -100,6 +104,7 @@ libraries = [sanitize_path(x) for x in libraries]
 with open(gyp_in, 'r') as f:
     input_json = json.load(f)
 
+
 def replace_entries(node, replacement_map):
     if type(node) == type([]):
         for key in replacement_map.keys():

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev1968.0",
+  "version": "0.8.2-dev2068.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/src/catalog/catalog.cpp

@@ -278,7 +278,7 @@ optional_ptr<CatalogEntry> Catalog::CreateIndex(CatalogTransaction transaction,
 
 optional_ptr<CatalogEntry> Catalog::CreateIndex(ClientContext &context, CreateIndexInfo &info) {
 	auto &schema = GetSchema(context, info.schema);
-	auto &table = GetEntry<TableCatalogEntry>(context, schema.name, info.table->table_name);
+	auto &table = GetEntry<TableCatalogEntry>(context, schema.name, info.table);
 	return schema.CreateIndex(context, info, table);
 }
 

package/src/duckdb/src/catalog/catalog_entry/index_catalog_entry.cpp

@@ -19,47 +19,23 @@ string IndexCatalogEntry::ToSQL() const {
 	return sql;
 }
 
-void IndexCatalogEntry::Serialize(Serializer &serializer) const {
-	// here we serialize the index metadata in the following order:
-	// schema name, table name, index name, sql, index type, index constraint type, expression list, parsed expressions,
-	// column IDs
-
-	FieldWriter writer(serializer);
-	writer.WriteString(GetSchemaName());
-	writer.WriteString(GetTableName());
-	writer.WriteString(name);
-	writer.WriteString(sql);
-	writer.WriteField(index->type);
-	writer.WriteField(index->constraint_type);
-	writer.WriteSerializableList(expressions);
-	writer.WriteSerializableList(parsed_expressions);
-	writer.WriteList<idx_t>(index->column_ids);
-	writer.Finalize();
-}
-
-unique_ptr<CreateIndexInfo> IndexCatalogEntry::Deserialize(Deserializer &source, ClientContext &context) {
-	// here we deserialize the index metadata in the following order:
-	// schema name, table schema name, table name, index name, sql, index type, index constraint type, expression list,
-	// parsed expression list, column IDs
-
-	auto create_index_info = make_uniq<CreateIndexInfo>();
-
-	FieldReader reader(source);
-
-	create_index_info->schema = reader.ReadRequired<string>();
-	create_index_info->table = make_uniq<BaseTableRef>();
-	create_index_info->table->schema_name = create_index_info->schema;
-	create_index_info->table->table_name = reader.ReadRequired<string>();
-	create_index_info->index_name = reader.ReadRequired<string>();
-	create_index_info->sql = reader.ReadRequired<string>();
-	create_index_info->index_type = IndexType(reader.ReadRequired<uint8_t>());
-	create_index_info->constraint_type = IndexConstraintType(reader.ReadRequired<uint8_t>());
-	create_index_info->expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
-	create_index_info->parsed_expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
-
-	create_index_info->column_ids = reader.ReadRequiredList<idx_t>();
-	reader.Finalize();
-	return create_index_info;
+unique_ptr<CreateInfo> IndexCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateIndexInfo>();
+	result->schema = GetSchemaName();
+	result->table = GetTableName();
+	result->index_name = name;
+	result->sql = sql;
+	result->index_type = index->type;
+	result->constraint_type = index->constraint_type;
+	for (auto &expr : expressions) {
+		result->expressions.push_back(expr->Copy());
+	}
+	for (auto &expr : parsed_expressions) {
+		result->parsed_expressions.push_back(expr->Copy());
+	}
+	result->column_ids = index->column_ids;
+	result->temporary = temporary;
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/catalog/catalog_entry/macro_catalog_entry.cpp

@@ -22,21 +22,13 @@ TableMacroCatalogEntry::TableMacroCatalogEntry(Catalog &catalog, SchemaCatalogEn
     : MacroCatalogEntry(catalog, schema, info) {
 }
 
-unique_ptr<CreateMacroInfo> MacroCatalogEntry::GetInfoForSerialization() const {
+unique_ptr<CreateInfo> MacroCatalogEntry::GetInfo() const {
 	auto info = make_uniq<CreateMacroInfo>(type);
 	info->catalog = catalog.GetName();
 	info->schema = schema.name;
 	info->name = name;
 	info->function = function->Copy();
-	return info;
-}
-void MacroCatalogEntry::Serialize(Serializer &serializer) const {
-	auto info = GetInfoForSerialization();
-	info->Serialize(serializer);
-}
-
-unique_ptr<CreateMacroInfo> MacroCatalogEntry::Deserialize(Deserializer &main_source, ClientContext &context) {
-	return unique_ptr_cast<CreateInfo, CreateMacroInfo>(CreateInfo::Deserialize(main_source));
+	return std::move(info);
 }
 
 } // namespace duckdb

package/src/duckdb/src/catalog/catalog_entry/schema_catalog_entry.cpp

@@ -33,20 +33,10 @@ SimilarCatalogEntry SchemaCatalogEntry::GetSimilarEntry(CatalogTransaction trans
 	return result;
 }
 
-void SchemaCatalogEntry::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.Finalize();
-}
-
-unique_ptr<CreateSchemaInfo> SchemaCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_uniq<CreateSchemaInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	reader.Finalize();
-
-	return info;
+unique_ptr<CreateInfo> SchemaCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateSchemaInfo>();
+	result->schema = name;
+	return std::move(result);
 }
 
 string SchemaCatalogEntry::ToSQL() const {

package/src/duckdb/src/catalog/catalog_entry/sequence_catalog_entry.cpp

@@ -18,34 +18,17 @@ SequenceCatalogEntry::SequenceCatalogEntry(Catalog &catalog, SchemaCatalogEntry
 	this->temporary = info.temporary;
 }
 
-void SequenceCatalogEntry::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(schema.name);
-	writer.WriteString(name);
-	writer.WriteField<uint64_t>(usage_count);
-	writer.WriteField<int64_t>(increment);
-	writer.WriteField<int64_t>(min_value);
-	writer.WriteField<int64_t>(max_value);
-	writer.WriteField<int64_t>(counter);
-	writer.WriteField<bool>(cycle);
-	writer.Finalize();
-}
-
-unique_ptr<CreateSequenceInfo> SequenceCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_uniq<CreateSequenceInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	info->name = reader.ReadRequired<string>();
-	info->usage_count = reader.ReadRequired<uint64_t>();
-	info->increment = reader.ReadRequired<int64_t>();
-	info->min_value = reader.ReadRequired<int64_t>();
-	info->max_value = reader.ReadRequired<int64_t>();
-	info->start_value = reader.ReadRequired<int64_t>();
-	info->cycle = reader.ReadRequired<bool>();
-	reader.Finalize();
-
-	return info;
+unique_ptr<CreateInfo> SequenceCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateSequenceInfo>();
+	result->schema = schema.name;
+	result->name = name;
+	result->usage_count = usage_count;
+	result->increment = increment;
+	result->min_value = min_value;
+	result->max_value = max_value;
+	result->start_value = counter;
+	result->cycle = cycle;
+	return std::move(result);
 }
 
 string SequenceCatalogEntry::ToSQL() const {

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -56,42 +56,16 @@ vector<LogicalType> TableCatalogEntry::GetTypes() {
 	return types;
 }
 
-CreateTableInfo TableCatalogEntry::GetTableInfoForSerialization() const {
-	CreateTableInfo result;
-	result.catalog = catalog.GetName();
-	result.schema = schema.name;
-	result.table = name;
-	result.columns = columns.Copy();
-	result.constraints.reserve(constraints.size());
+unique_ptr<CreateInfo> TableCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateTableInfo>();
+	result->catalog = catalog.GetName();
+	result->schema = schema.name;
+	result->table = name;
+	result->columns = columns.Copy();
+	result->constraints.reserve(constraints.size());
 	std::for_each(constraints.begin(), constraints.end(),
-	              [&result](const unique_ptr<Constraint> &c) { result.constraints.emplace_back(c->Copy()); });
-	return result;
-}
-
-void TableCatalogEntry::Serialize(Serializer &serializer) const {
-	D_ASSERT(!internal);
-	const auto info = GetTableInfoForSerialization();
-	FieldWriter writer(serializer);
-	writer.WriteString(info.catalog);
-	writer.WriteString(info.schema);
-	writer.WriteString(info.table);
-	info.columns.Serialize(writer);
-	writer.WriteSerializableList(info.constraints);
-	writer.Finalize();
-}
-
-unique_ptr<CreateTableInfo> TableCatalogEntry::Deserialize(Deserializer &source, ClientContext &context) {
-	auto info = make_uniq<CreateTableInfo>();
-
-	FieldReader reader(source);
-	info->catalog = reader.ReadRequired<string>();
-	info->schema = reader.ReadRequired<string>();
-	info->table = reader.ReadRequired<string>();
-	info->columns = ColumnList::Deserialize(reader);
-	info->constraints = reader.ReadRequiredSerializableList<Constraint>();
-	reader.Finalize();
-
-	return info;
+	              [&result](const unique_ptr<Constraint> &c) { result->constraints.emplace_back(c->Copy()); });
+	return std::move(result);
 }
 
 string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<unique_ptr<Constraint>> &constraints) {
@@ -162,11 +136,10 @@ string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<u
 			// single column unique: insert constraint here
 			ss << " UNIQUE";
 		}
-		if (column.DefaultValue()) {
-			ss << " DEFAULT(" << column.DefaultValue()->ToString() << ")";
-		}
 		if (column.Generated()) {
 			ss << " GENERATED ALWAYS AS(" << column.GeneratedExpression().ToString() << ")";
+		} else if (column.DefaultValue()) {
+			ss << " DEFAULT(" << column.DefaultValue()->ToString() << ")";
 		}
 	}
 	// print any extra constraints that still need to be printed

package/src/duckdb/src/catalog/catalog_entry/view_catalog_entry.cpp

@@ -25,6 +25,17 @@ ViewCatalogEntry::ViewCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
 	Initialize(info);
 }
 
+unique_ptr<CreateInfo> ViewCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateViewInfo>();
+	result->schema = schema.name;
+	result->view_name = name;
+	result->sql = sql;
+	result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
+	result->aliases = aliases;
+	result->types = types;
+	return std::move(result);
+}
+
 unique_ptr<CatalogEntry> ViewCatalogEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
 	D_ASSERT(!internal);
 	if (info.type != AlterType::ALTER_VIEW) {
@@ -43,33 +54,6 @@ unique_ptr<CatalogEntry> ViewCatalogEntry::AlterEntry(ClientContext &context, Al
 	}
 }
 
-void ViewCatalogEntry::Serialize(Serializer &serializer) const {
-	D_ASSERT(!internal);
-	FieldWriter writer(serializer);
-	writer.WriteString(schema.name);
-	writer.WriteString(name);
-	writer.WriteString(sql);
-	writer.WriteSerializable(*query);
-	writer.WriteList<string>(aliases);
-	writer.WriteRegularSerializableList<LogicalType>(types);
-	writer.Finalize();
-}
-
-unique_ptr<CreateViewInfo> ViewCatalogEntry::Deserialize(Deserializer &source, ClientContext &context) {
-	auto info = make_uniq<CreateViewInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	info->view_name = reader.ReadRequired<string>();
-	info->sql = reader.ReadRequired<string>();
-	info->query = reader.ReadRequiredSerializable<SelectStatement>();
-	info->aliases = reader.ReadRequiredList<string>();
-	info->types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	reader.Finalize();
-
-	return info;
-}
-
 string ViewCatalogEntry::ToSQL() const {
 	if (sql.empty()) {
 		//! Return empty sql with view name so pragma view_tables don't complain

package/src/duckdb/src/catalog/catalog_entry.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/catalog/catalog_entry.hpp"
-
+#include "duckdb/parser/parsed_data/create_info.hpp"
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
+#include "duckdb/common/serializer/binary_deserializer.hpp"
 
 namespace duckdb {
 
@@ -31,6 +33,10 @@ unique_ptr<CatalogEntry> CatalogEntry::Copy(ClientContext &context) const {
 	throw InternalException("Unsupported copy type for catalog entry!");
 }
 
+unique_ptr<CreateInfo> CatalogEntry::GetInfo() const {
+	throw InternalException("Unsupported type for CatalogEntry::GetInfo!");
+}
+
 string CatalogEntry::ToSQL() const {
 	throw InternalException("Unsupported catalog type for ToSQL()");
 }
@@ -44,6 +50,24 @@ SchemaCatalogEntry &CatalogEntry::ParentSchema() {
 }
 // LCOV_EXCL_STOP
 
+void CatalogEntry::Serialize(Serializer &serializer) const {
+	const auto info = GetInfo();
+	info->Serialize(serializer);
+}
+
+unique_ptr<CreateInfo> CatalogEntry::Deserialize(Deserializer &source) {
+	return CreateInfo::Deserialize(source);
+}
+
+void CatalogEntry::FormatSerialize(FormatSerializer &serializer) const {
+	const auto info = GetInfo();
+	info->FormatSerialize(serializer);
+}
+
+unique_ptr<CreateInfo> CatalogEntry::FormatDeserialize(FormatDeserializer &deserializer) {
+	return CreateInfo::FormatDeserialize(deserializer);
+}
+
 void CatalogEntry::Verify(Catalog &catalog_p) {
 }
 

package/src/duckdb/src/common/adbc/adbc.cpp

@@ -52,12 +52,14 @@ duckdb_adbc::AdbcStatusCode duckdb_adbc_init(size_t count, struct duckdb_adbc::A
 
 namespace duckdb_adbc {
 
+enum class IngestionMode { CREATE = 0, APPEND = 1 };
 struct DuckDBAdbcStatementWrapper {
 	::duckdb_connection connection;
 	::duckdb_arrow result;
 	::duckdb_prepared_statement statement;
 	char *ingestion_table_name;
 	ArrowArrayStream *ingestion_stream;
+	IngestionMode ingestion_mode = IngestionMode::CREATE;
 };
 static AdbcStatusCode QueryInternal(struct AdbcConnection *connection, struct ArrowArrayStream *out, const char *query,
                                     struct AdbcError *error);
@@ -428,7 +430,7 @@ void stream_schema(uintptr_t factory_ptr, duckdb::ArrowSchemaWrapper &schema) {
 }
 
 AdbcStatusCode Ingest(duckdb_connection connection, const char *table_name, struct ArrowArrayStream *input,
-                      struct AdbcError *error) {
+                      struct AdbcError *error, IngestionMode ingestion_mode) {
 
 	auto status = SetErrorMaybe(connection, error, "Invalid connection");
 	if (status != ADBC_STATUS_OK) {
@@ -446,12 +448,11 @@ AdbcStatusCode Ingest(duckdb_connection connection, const char *table_name, stru
 	}
 	auto cconn = (duckdb::Connection *)connection;
 
-	auto has_table = cconn->TableInfo(table_name);
 	auto arrow_scan = cconn->TableFunction("arrow_scan", {duckdb::Value::POINTER((uintptr_t)input),
 	                                                      duckdb::Value::POINTER((uintptr_t)stream_produce),
 	                                                      duckdb::Value::POINTER((uintptr_t)get_schema)});
 	try {
-		if (!has_table) {
+		if (ingestion_mode == IngestionMode::CREATE) {
 			// We create the table based on an Arrow Scanner
 			arrow_scan->Create(table_name);
 		} else {
@@ -505,6 +506,7 @@ AdbcStatusCode StatementNew(struct AdbcConnection *connection, struct AdbcStatem
 	statement_wrapper->result = nullptr;
 	statement_wrapper->ingestion_stream = nullptr;
 	statement_wrapper->ingestion_table_name = nullptr;
+	statement_wrapper->ingestion_mode = IngestionMode::CREATE;
 	return ADBC_STATUS_OK;
 }
 
@@ -557,7 +559,7 @@ AdbcStatusCode StatementExecuteQuery(struct AdbcStatement *statement, struct Arr
 	if (wrapper->ingestion_stream && wrapper->ingestion_table_name) {
 		auto stream = wrapper->ingestion_stream;
 		wrapper->ingestion_stream = nullptr;
-		return Ingest(wrapper->connection, wrapper->ingestion_table_name, stream, error);
+		return Ingest(wrapper->connection, wrapper->ingestion_table_name, stream, error, wrapper->ingestion_mode);
 	}
 
 	auto res = duckdb_execute_prepared_arrow(wrapper->statement, &wrapper->result);
@@ -643,6 +645,18 @@ AdbcStatusCode StatementSetOption(struct AdbcStatement *statement, const char *k
 		wrapper->ingestion_table_name = strdup(value);
 		return ADBC_STATUS_OK;
 	}
+	if (strcmp(key, ADBC_INGEST_OPTION_MODE) == 0) {
+		if (strcmp(value, ADBC_INGEST_OPTION_MODE_CREATE) == 0) {
+			wrapper->ingestion_mode = IngestionMode::CREATE;
+			return ADBC_STATUS_OK;
+		} else if (strcmp(value, ADBC_INGEST_OPTION_MODE_APPEND) == 0) {
+			wrapper->ingestion_mode = IngestionMode::APPEND;
+			return ADBC_STATUS_OK;
+		} else {
+			SetError(error, "Invalid ingestion mode");
+			return ADBC_STATUS_INVALID_ARGUMENT;
+		}
+	}
 	return ADBC_STATUS_INVALID_ARGUMENT;
 }
 

package/src/duckdb/src/common/enum_util.cpp

@@ -88,6 +88,8 @@
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
 #include "duckdb/parser/parsed_data/create_info.hpp"
 #include "duckdb/parser/parsed_data/create_sequence_info.hpp"
+#include "duckdb/parser/parsed_data/load_info.hpp"
+#include "duckdb/parser/parsed_data/parse_info.hpp"
 #include "duckdb/parser/parsed_data/pragma_info.hpp"
 #include "duckdb/parser/parsed_data/sample_options.hpp"
 #include "duckdb/parser/parsed_data/transaction_info.hpp"
@@ -217,6 +219,29 @@ AggregateType EnumUtil::FromString<AggregateType>(const char *value) {
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<AlterForeignKeyType>(AlterForeignKeyType value) {
+	switch(value) {
+	case AlterForeignKeyType::AFT_ADD:
+		return "AFT_ADD";
+	case AlterForeignKeyType::AFT_DELETE:
+		return "AFT_DELETE";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+AlterForeignKeyType EnumUtil::FromString<AlterForeignKeyType>(const char *value) {
+	if (StringUtil::Equals(value, "AFT_ADD")) {
+		return AlterForeignKeyType::AFT_ADD;
+	}
+	if (StringUtil::Equals(value, "AFT_DELETE")) {
+		return AlterForeignKeyType::AFT_DELETE;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<AlterScalarFunctionType>(AlterScalarFunctionType value) {
 	switch(value) {
@@ -2274,6 +2299,39 @@ FunctionSideEffects EnumUtil::FromString<FunctionSideEffects>(const char *value)
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<IndexConstraintType>(IndexConstraintType value) {
+	switch(value) {
+	case IndexConstraintType::NONE:
+		return "NONE";
+	case IndexConstraintType::UNIQUE:
+		return "UNIQUE";
+	case IndexConstraintType::PRIMARY:
+		return "PRIMARY";
+	case IndexConstraintType::FOREIGN:
+		return "FOREIGN";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+IndexConstraintType EnumUtil::FromString<IndexConstraintType>(const char *value) {
+	if (StringUtil::Equals(value, "NONE")) {
+		return IndexConstraintType::NONE;
+	}
+	if (StringUtil::Equals(value, "UNIQUE")) {
+		return IndexConstraintType::UNIQUE;
+	}
+	if (StringUtil::Equals(value, "PRIMARY")) {
+		return IndexConstraintType::PRIMARY;
+	}
+	if (StringUtil::Equals(value, "FOREIGN")) {
+		return IndexConstraintType::FOREIGN;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<IndexType>(IndexType value) {
 	switch(value) {
@@ -2482,6 +2540,34 @@ KeywordCategory EnumUtil::FromString<KeywordCategory>(const char *value) {
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<LoadType>(LoadType value) {
+	switch(value) {
+	case LoadType::LOAD:
+		return "LOAD";
+	case LoadType::INSTALL:
+		return "INSTALL";
+	case LoadType::FORCE_INSTALL:
+		return "FORCE_INSTALL";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+LoadType EnumUtil::FromString<LoadType>(const char *value) {
+	if (StringUtil::Equals(value, "LOAD")) {
+		return LoadType::LOAD;
+	}
+	if (StringUtil::Equals(value, "INSTALL")) {
+		return LoadType::INSTALL;
+	}
+	if (StringUtil::Equals(value, "FORCE_INSTALL")) {
+		return LoadType::FORCE_INSTALL;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<LogicalOperatorType>(LogicalOperatorType value) {
 	switch(value) {
@@ -3558,6 +3644,79 @@ OutputStream EnumUtil::FromString<OutputStream>(const char *value) {
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<ParseInfoType>(ParseInfoType value) {
+	switch(value) {
+	case ParseInfoType::ALTER_INFO:
+		return "ALTER_INFO";
+	case ParseInfoType::ATTACH_INFO:
+		return "ATTACH_INFO";
+	case ParseInfoType::COPY_INFO:
+		return "COPY_INFO";
+	case ParseInfoType::CREATE_INFO:
+		return "CREATE_INFO";
+	case ParseInfoType::DETACH_INFO:
+		return "DETACH_INFO";
+	case ParseInfoType::DROP_INFO:
+		return "DROP_INFO";
+	case ParseInfoType::BOUND_EXPORT_DATA:
+		return "BOUND_EXPORT_DATA";
+	case ParseInfoType::LOAD_INFO:
+		return "LOAD_INFO";
+	case ParseInfoType::PRAGMA_INFO:
+		return "PRAGMA_INFO";
+	case ParseInfoType::SHOW_SELECT_INFO:
+		return "SHOW_SELECT_INFO";
+	case ParseInfoType::TRANSACTION_INFO:
+		return "TRANSACTION_INFO";
+	case ParseInfoType::VACUUM_INFO:
+		return "VACUUM_INFO";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+ParseInfoType EnumUtil::FromString<ParseInfoType>(const char *value) {
+	if (StringUtil::Equals(value, "ALTER_INFO")) {
+		return ParseInfoType::ALTER_INFO;
+	}
+	if (StringUtil::Equals(value, "ATTACH_INFO")) {
+		return ParseInfoType::ATTACH_INFO;
+	}
+	if (StringUtil::Equals(value, "COPY_INFO")) {
+		return ParseInfoType::COPY_INFO;
+	}
+	if (StringUtil::Equals(value, "CREATE_INFO")) {
+		return ParseInfoType::CREATE_INFO;
+	}
+	if (StringUtil::Equals(value, "DETACH_INFO")) {
+		return ParseInfoType::DETACH_INFO;
+	}
+	if (StringUtil::Equals(value, "DROP_INFO")) {
+		return ParseInfoType::DROP_INFO;
+	}
+	if (StringUtil::Equals(value, "BOUND_EXPORT_DATA")) {
+		return ParseInfoType::BOUND_EXPORT_DATA;
+	}
+	if (StringUtil::Equals(value, "LOAD_INFO")) {
+		return ParseInfoType::LOAD_INFO;
+	}
+	if (StringUtil::Equals(value, "PRAGMA_INFO")) {
+		return ParseInfoType::PRAGMA_INFO;
+	}
+	if (StringUtil::Equals(value, "SHOW_SELECT_INFO")) {
+		return ParseInfoType::SHOW_SELECT_INFO;
+	}
+	if (StringUtil::Equals(value, "TRANSACTION_INFO")) {
+		return ParseInfoType::TRANSACTION_INFO;
+	}
+	if (StringUtil::Equals(value, "VACUUM_INFO")) {
+		return ParseInfoType::VACUUM_INFO;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<ParserExtensionResultType>(ParserExtensionResultType value) {
 	switch(value) {