duckdb 0.8.1-dev125.0 → 0.8.1-dev180.0

package/package.json

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

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

@@ -674,19 +674,6 @@ vector<reference<SchemaCatalogEntry>> Catalog::GetSchemas(ClientContext &context
 	return schemas;
 }
 
-bool Catalog::TypeExists(ClientContext &context, const string &catalog_name, const string &schema, const string &name) {
-	optional_ptr<CatalogEntry> entry;
-	entry = GetEntry(context, CatalogType::TYPE_ENTRY, catalog_name, schema, name, OnEntryNotFound::RETURN_NULL);
-	if (!entry) {
-		// look in the system catalog
-		entry = GetEntry(context, CatalogType::TYPE_ENTRY, SYSTEM_CATALOG, schema, name, OnEntryNotFound::RETURN_NULL);
-		if (!entry) {
-			return false;
-		}
-	}
-	return true;
-}
-
 vector<reference<SchemaCatalogEntry>> Catalog::GetSchemas(ClientContext &context, const string &catalog_name) {
 	vector<reference<Catalog>> catalogs;
 	if (IsInvalidCatalog(catalog_name)) {

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

@@ -5,6 +5,7 @@
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/main/database_manager.hpp"
 
 namespace duckdb {
 
@@ -245,4 +246,20 @@ void CatalogSearchPath::SetPaths(vector<CatalogSearchEntry> new_paths) {
 	paths.emplace_back(SYSTEM_CATALOG, "pg_catalog");
 }
 
+bool CatalogSearchPath::SchemaInSearchPath(ClientContext &context, const string &catalog_name,
+                                           const string &schema_name) {
+	for (auto &path : paths) {
+		if (path.schema != schema_name) {
+			continue;
+		}
+		if (path.catalog == catalog_name) {
+			return true;
+		}
+		if (IsInvalidCatalog(path.catalog) && catalog_name == DatabaseManager::GetDefaultDatabase(context)) {
+			return true;
+		}
+	}
+	return false;
+}
+
 } // namespace duckdb

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

@@ -5,10 +5,13 @@
 #include "duckdb/common/string_util.hpp"
 
 #include "duckdb.h"
-#include "duckdb/main/connection.hpp"
 #include "duckdb/common/arrow/arrow_wrapper.hpp"
 #include "duckdb/common/arrow/arrow.hpp"
 
+#ifndef DUCKDB_AMALGAMATION
+#include "duckdb/main/connection.hpp"
+#endif
+
 #include <string.h>
 #include <stdlib.h>
 
@@ -37,6 +40,10 @@ duckdb_adbc::AdbcStatusCode duckdb_adbc_init(size_t count, struct duckdb_adbc::A
 	driver->StatementSetOption = duckdb_adbc::StatementSetOption;
 	driver->StatementSetSqlQuery = duckdb_adbc::StatementSetSqlQuery;
 	driver->ConnectionGetObjects = duckdb_adbc::ConnectionGetObjects;
+	driver->ConnectionCommit = duckdb_adbc::ConnectionCommit;
+	driver->ConnectionRollback = duckdb_adbc::ConnectionRollback;
+	driver->ConnectionReadPartition = duckdb_adbc::ConnectionReadPartition;
+	driver->StatementExecutePartitions = duckdb_adbc::StatementExecutePartitions;
 	return ADBC_STATUS_OK;
 }
 
@@ -162,10 +169,104 @@ AdbcStatusCode ConnectionNew(struct AdbcConnection *connection, struct AdbcError
 	return ADBC_STATUS_OK;
 }
 
+AdbcStatusCode ExecuteQuery(duckdb::Connection *conn, const char *query, struct AdbcError *error) {
+	auto res = conn->Query(query);
+	if (res->HasError()) {
+		auto error_message = "Failed to execute query \"" + std::string(query) + "\": " + res->GetError();
+		SetError(error, error_message);
+		return ADBC_STATUS_INTERNAL;
+	}
+	return ADBC_STATUS_OK;
+}
+
 AdbcStatusCode ConnectionSetOption(struct AdbcConnection *connection, const char *key, const char *value,
                                    struct AdbcError *error) {
-	// there are no connection-level options that need to be set before connecting
-	return ADBC_STATUS_OK;
+	if (!connection) {
+		SetError(error, "Connection is not set");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	auto conn = (duckdb::Connection *)connection->private_data;
+	if (strcmp(key, ADBC_CONNECTION_OPTION_AUTOCOMMIT) == 0) {
+		if (strcmp(value, ADBC_OPTION_VALUE_ENABLED) == 0) {
+			if (conn->HasActiveTransaction()) {
+				AdbcStatusCode status = ExecuteQuery(conn, "COMMIT", error);
+				if (status != ADBC_STATUS_OK) {
+					return status;
+				}
+			} else {
+				// no-op
+			}
+		} else if (strcmp(value, ADBC_OPTION_VALUE_DISABLED) == 0) {
+			if (conn->HasActiveTransaction()) {
+				// no-op
+			} else {
+				// begin
+				AdbcStatusCode status = ExecuteQuery(conn, "START TRANSACTION", error);
+				if (status != ADBC_STATUS_OK) {
+					return status;
+				}
+			}
+		} else {
+			auto error_message = "Invalid connection option value " + std::string(key) + "=" + std::string(value);
+			SetError(error, error_message);
+			return ADBC_STATUS_INVALID_ARGUMENT;
+		}
+		return ADBC_STATUS_OK;
+	}
+	auto error_message =
+	    "Unknown connection option " + std::string(key) + "=" + (value ? std::string(value) : "(NULL)");
+	SetError(error, error_message);
+	return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
+AdbcStatusCode ConnectionReadPartition(struct AdbcConnection *connection, const uint8_t *serialized_partition,
+                                       size_t serialized_length, struct ArrowArrayStream *out,
+                                       struct AdbcError *error) {
+	SetError(error, "Read Partitions are not supported in DuckDB");
+	return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
+AdbcStatusCode StatementExecutePartitions(struct AdbcStatement *statement, struct ArrowSchema *schema,
+                                          struct AdbcPartitions *partitions, int64_t *rows_affected,
+                                          struct AdbcError *error) {
+	SetError(error, "Execute Partitions are not supported in DuckDB");
+	return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
+AdbcStatusCode ConnectionCommit(struct AdbcConnection *connection, struct AdbcError *error) {
+	if (!connection) {
+		SetError(error, "Connection is not set");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	auto conn = (duckdb::Connection *)connection->private_data;
+	if (!conn->HasActiveTransaction()) {
+		SetError(error, "No active transaction, cannot commit");
+		return ADBC_STATUS_INVALID_STATE;
+	}
+
+	AdbcStatusCode status = ExecuteQuery(conn, "COMMIT", error);
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+	return ExecuteQuery(conn, "START TRANSACTION", error);
+}
+
+AdbcStatusCode ConnectionRollback(struct AdbcConnection *connection, struct AdbcError *error) {
+	if (!connection) {
+		SetError(error, "Connection is not set");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	auto conn = (duckdb::Connection *)connection->private_data;
+	if (!conn->HasActiveTransaction()) {
+		SetError(error, "No active transaction, cannot rollback");
+		return ADBC_STATUS_INVALID_STATE;
+	}
+
+	AdbcStatusCode status = ExecuteQuery(conn, "ROLLBACK", error);
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+	return ExecuteQuery(conn, "START TRANSACTION", error);
 }
 
 AdbcStatusCode ConnectionInit(struct AdbcConnection *connection, struct AdbcDatabase *database,
@@ -219,11 +320,11 @@ void release(struct ArrowArrayStream *stream) {
 	if (!stream || !stream->release) {
 		return;
 	}
-	stream->release = nullptr;
 	if (stream->private_data) {
 		duckdb_destroy_arrow((duckdb_arrow *)&stream->private_data);
 		stream->private_data = nullptr;
 	}
+	stream->release = nullptr;
 }
 
 const char *get_last_error(struct ArrowArrayStream *stream) {
@@ -270,16 +371,21 @@ AdbcStatusCode Ingest(duckdb_connection connection, const char *table_name, stru
 	if (status != ADBC_STATUS_OK) {
 		return status;
 	}
+	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 {
-		// TODO evil cast, do we need a way to do this from the C api?
-		auto cconn = (duckdb::Connection *)connection;
-		cconn
-		    ->TableFunction("arrow_scan",
-		                    {duckdb::Value::POINTER((uintptr_t)input),
-		                     duckdb::Value::POINTER((uintptr_t)stream_produce),
-		                     duckdb::Value::POINTER((uintptr_t)get_schema)}) // TODO make this a parameter somewhere
-		    ->Create(table_name); // TODO this should probably be a temp table
+		if (!has_table) {
+			// We create the table based on an Arrow Scanner
+			arrow_scan->Create(table_name);
+		} else {
+			arrow_scan->CreateView("temp_adbc_view", true, true);
+			auto query = "insert into " + std::string(table_name) + " select * from temp_adbc_view";
+			auto result = cconn->Query(query);
+		}
 		// After creating a table, the arrow array stream is released. Hence we must set it as released to avoid
 		// double-releasing it
 		input->release = nullptr;

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

@@ -133,10 +133,6 @@ static AdbcStatusCode ReleaseDriver(struct AdbcDriver *driver, struct AdbcError
 
 // Default stubs
 
-AdbcStatusCode ConnectionCommit(struct AdbcConnection *, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
 AdbcStatusCode ConnectionGetInfo(struct AdbcConnection *connection, uint32_t *info_codes, size_t info_codes_length,
                                  struct ArrowArrayStream *out, struct AdbcError *error) {
 	return ADBC_STATUS_NOT_IMPLEMENTED;
@@ -147,27 +143,11 @@ AdbcStatusCode ConnectionGetTableSchema(struct AdbcConnection *, const char *, c
 	return ADBC_STATUS_NOT_IMPLEMENTED;
 }
 
-AdbcStatusCode ConnectionReadPartition(struct AdbcConnection *connection, const uint8_t *serialized_partition,
-                                       size_t serialized_length, struct ArrowArrayStream *out,
-                                       struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-AdbcStatusCode ConnectionRollback(struct AdbcConnection *, struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
 AdbcStatusCode StatementBind(struct AdbcStatement *, struct ArrowArray *, struct ArrowSchema *,
                              struct AdbcError *error) {
 	return ADBC_STATUS_NOT_IMPLEMENTED;
 }
 
-AdbcStatusCode StatementExecutePartitions(struct AdbcStatement *statement, struct ArrowSchema *schema,
-                                          struct AdbcPartitions *partitions, int64_t *rows_affected,
-                                          struct AdbcError *error) {
-	return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
 AdbcStatusCode StatementGetParameterSchema(struct AdbcStatement *statement, struct ArrowSchema *schema,
                                            struct AdbcError *error) {
 	return ADBC_STATUS_NOT_IMPLEMENTED;

package/src/duckdb/src/common/types/value.cpp

@@ -1319,6 +1319,7 @@ string Value::ToSQLString() const {
 	case LogicalTypeId::BLOB:
 		return "'" + ToString() + "'::" + type_.ToString();
 	case LogicalTypeId::VARCHAR:
+	case LogicalTypeId::ENUM:
 		return "'" + StringUtil::Replace(ToString(), "'", "''") + "'";
 	case LogicalTypeId::STRUCT: {
 		string ret = "{";

package/src/duckdb/src/core_functions/aggregate/holistic/quantile.cpp

@@ -16,13 +16,13 @@
 namespace duckdb {
 
 // Hugeint arithmetic
-static hugeint_t operator*(const hugeint_t &h, const double &d) {
+static hugeint_t MultiplyByDouble(const hugeint_t &h, const double &d) {
 	D_ASSERT(d >= 0 && d <= 1);
 	return Hugeint::Convert(Hugeint::Cast<double>(h) * d);
 }
 
 // Interval arithmetic
-static interval_t operator*(const interval_t &i, const double &d) { // NOLINT
+static interval_t MultiplyByDouble(const interval_t &i, const double &d) { // NOLINT
 	D_ASSERT(d >= 0 && d <= 1);
 	return Interval::FromMicro(std::llround(Interval::GetMicro(i) * d));
 }
@@ -207,6 +207,18 @@ timestamp_t CastInterpolation::Interpolate(const timestamp_t &lo, const double d
 	return timestamp_t(std::llround(lo.value * (1.0 - d) + hi.value * d));
 }
 
+template <>
+hugeint_t CastInterpolation::Interpolate(const hugeint_t &lo, const double d, const hugeint_t &hi) {
+	const hugeint_t delta = hi - lo;
+	return lo + MultiplyByDouble(delta, d);
+}
+
+template <>
+interval_t CastInterpolation::Interpolate(const interval_t &lo, const double d, const interval_t &hi) {
+	const interval_t delta = hi - lo;
+	return lo + MultiplyByDouble(delta, d);
+}
+
 template <>
 string_t CastInterpolation::Cast(const std::string &src, Vector &result) {
 	return StringVector::AddString(result, src);

package/src/duckdb/src/core_functions/function_list.cpp

@@ -169,6 +169,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION_SET(HexFun),
 	DUCKDB_AGGREGATE_FUNCTION_SET(HistogramFun),
 	DUCKDB_SCALAR_FUNCTION_SET(HoursFun),
+	DUCKDB_SCALAR_FUNCTION(InSearchPathFun),
 	DUCKDB_SCALAR_FUNCTION(InstrFun),
 	DUCKDB_SCALAR_FUNCTION_SET(IsFiniteFun),
 	DUCKDB_SCALAR_FUNCTION_SET(IsInfiniteFun),

package/src/duckdb/src/core_functions/scalar/generic/system_functions.cpp

@@ -49,6 +49,16 @@ static void CurrentSchemasFunction(DataChunk &input, ExpressionState &state, Vec
 	result.Reference(val);
 }
 
+// in_search_path
+static void InSearchPathFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	auto &context = state.GetContext();
+	auto &search_path = ClientData::Get(context).catalog_search_path;
+	BinaryExecutor::Execute<string_t, string_t, bool>(
+	    input.data[0], input.data[1], result, input.size(), [&](string_t db_name, string_t schema_name) {
+		    return search_path->SchemaInSearchPath(context, db_name.GetString(), schema_name.GetString());
+	    });
+}
+
 // txid_current
 static void TransactionIdCurrent(DataChunk &input, ExpressionState &state, Vector &result) {
 	auto &context = state.GetContext();
@@ -83,6 +93,10 @@ ScalarFunction CurrentSchemasFun::GetFunction() {
 	return ScalarFunction({LogicalType::BOOLEAN}, varchar_list_type, CurrentSchemasFunction);
 }
 
+ScalarFunction InSearchPathFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN, InSearchPathFunction);
+}
+
 ScalarFunction CurrentTransactionIdFun::GetFunction() {
 	return ScalarFunction({}, LogicalType::BIGINT, TransactionIdCurrent);
 }

package/src/duckdb/src/execution/operator/helper/physical_reset.cpp

@@ -20,10 +20,14 @@ void PhysicalReset::ResetExtensionVariable(ExecutionContext &context, DBConfig &
 }
 
 SourceResultType PhysicalReset::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
+	auto &config = DBConfig::GetConfig(context.client);
+	if (config.options.lock_configuration) {
+		throw InvalidInputException("Cannot reset configuration option \"%s\" - the configuration has been locked",
+		                            name);
+	}
 	auto option = DBConfig::GetOptionByName(name);
 	if (!option) {
 		// check if this is an extra extension variable
-		auto &config = DBConfig::GetConfig(context.client);
 		auto entry = config.extension_parameters.find(name);
 		if (entry == config.extension_parameters.end()) {
 			throw Catalog::UnrecognizedConfigurationError(context.client, name);
@@ -49,7 +53,6 @@ SourceResultType PhysicalReset::GetData(ExecutionContext &context, DataChunk &ch
 			throw CatalogException("option \"%s\" cannot be reset globally", name);
 		}
 		auto &db = DatabaseInstance::GetDatabase(context.client);
-		auto &config = DBConfig::GetConfig(context.client);
 		config.ResetOption(&db, *option);
 		break;
 	}

package/src/duckdb/src/execution/operator/helper/physical_set.cpp

@@ -23,10 +23,14 @@ void PhysicalSet::SetExtensionVariable(ClientContext &context, ExtensionOption &
 }
 
 SourceResultType PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
+	auto &config = DBConfig::GetConfig(context.client);
+	if (config.options.lock_configuration) {
+		throw InvalidInputException("Cannot change configuration option \"%s\" - the configuration has been locked",
+		                            name);
+	}
 	auto option = DBConfig::GetOptionByName(name);
 	if (!option) {
 		// check if this is an extra extension variable
-		auto &config = DBConfig::GetConfig(context.client);
 		auto entry = config.extension_parameters.find(name);
 		if (entry == config.extension_parameters.end()) {
 			throw Catalog::UnrecognizedConfigurationError(context.client, name);

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -18,21 +18,18 @@ string PragmaTableInfo(ClientContext &context, const FunctionParameters &paramet
 }
 
 string PragmaShowTables(ClientContext &context, const FunctionParameters &parameters) {
-	auto catalog = DatabaseManager::GetDefaultDatabase(context);
-	auto schema = ClientData::Get(context).catalog_search_path->GetDefault().schema;
-	schema = (schema == INVALID_SCHEMA) ? DEFAULT_SCHEMA : schema; // NOLINT
-
-	auto where_clause = StringUtil::Format("where ((database_name = '%s') and (schema_name = '%s'))", catalog, schema);
 	// clang-format off
-	auto pragma_query = StringUtil::Format(R"EOF(
+	return R"EOF(
 	with "tables" as
 	(
 		SELECT table_name as "name"
-		FROM duckdb_tables %s
+		FROM duckdb_tables
+		where in_search_path(database_name, schema_name)
 	), "views" as
 	(
 		SELECT view_name as "name"
-		FROM duckdb_views %s
+		FROM duckdb_views
+		where in_search_path(database_name, schema_name)
 	), db_objects as
 	(
 		SELECT "name" FROM "tables"
@@ -41,26 +38,39 @@ string PragmaShowTables(ClientContext &context, const FunctionParameters &parame
 	)
 	SELECT "name"
 	FROM db_objects
-	ORDER BY "name";)EOF", where_clause, where_clause);
+	ORDER BY "name";)EOF";
 	// clang-format on
-
-	return pragma_query;
 }
 
 string PragmaShowTablesExpanded(ClientContext &context, const FunctionParameters &parameters) {
 	return R"(
-			SELECT
-				t.database_name AS database,
-				t.schema_name AS schema,
-				t.table_name,
-				LIST(c.column_name order by c.column_index) AS column_names,
-				LIST(c.data_type order by c.column_index) AS column_types,
-				FIRST(t.temporary) AS temporary,
-			FROM duckdb_tables t
-			JOIN duckdb_columns c
-			USING (table_oid)
-			GROUP BY t.database_name, t.schema_name, t.table_name
-			ORDER BY t.database_name, t.schema_name, t.table_name;
+	SELECT
+		t.database_name AS database,
+		t.schema_name AS schema,
+		t.table_name AS name,
+		LIST(c.column_name order by c.column_index) AS column_names,
+		LIST(c.data_type order by c.column_index) AS column_types,
+		FIRST(t.temporary) AS temporary,
+	FROM duckdb_tables t
+	JOIN duckdb_columns c
+	USING (table_oid)
+	GROUP BY database, schema, name
+
+	UNION ALL
+
+	SELECT
+		v.database_name AS database,
+		v.schema_name AS schema,
+		v.view_name AS name,
+		LIST(c.column_name order by c.column_index) AS column_names,
+		LIST(c.data_type order by c.column_index) AS column_types,
+		FIRST(v.temporary) AS temporary,
+	FROM duckdb_views v
+	JOIN duckdb_columns c
+	ON (v.view_oid=c.table_oid)
+	GROUP BY database, schema, name
+
+	ORDER BY database, schema, name
 	)";
 }
 

package/src/duckdb/src/function/table/arrow.cpp

@@ -206,8 +206,8 @@ unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &contex
 			throw InvalidInputException("arrow_scan: released schema passed");
 		}
 		if (schema.dictionary) {
-			res->arrow_convert_data[col_idx] =
-			    make_uniq<ArrowConvertData>(GetArrowLogicalType(schema, res->arrow_convert_data, col_idx));
+			auto logical_type = GetArrowLogicalType(schema, res->arrow_convert_data, col_idx);
+			res->arrow_convert_data[col_idx] = make_uniq<ArrowConvertData>(std::move(logical_type));
 			return_types.emplace_back(GetArrowLogicalType(*schema.dictionary, res->arrow_convert_data, col_idx));
 		} else {
 			return_types.emplace_back(GetArrowLogicalType(schema, res->arrow_convert_data, col_idx));

package/src/duckdb/src/function/table/read_csv.cpp

@@ -378,8 +378,8 @@ private:
 	//! Current File Number
 	idx_t file_number = 0;
 	idx_t max_tuple_end = 0;
-	//! the vector stores positions where threads ended the last line they read in the CSV File, and the set stores
-	//! positions where they started reading the first line.
+	//! The vector stores positions where threads ended the last line they read in the CSV File, and the set stores
+	//! Positions where they started reading the first line.
 	vector<vector<idx_t>> tuple_end;
 	vector<set<idx_t>> tuple_start;
 	//! Tuple end to batch
@@ -559,15 +559,13 @@ bool ParallelCSVGlobalState::Next(ClientContext &context, const ReadCSVData &bin
 }
 void ParallelCSVGlobalState::UpdateVerification(VerificationPositions positions, idx_t file_number_p, idx_t batch_idx) {
 	lock_guard<mutex> parallel_lock(main_mutex);
-	if (positions.beginning_of_first_line < positions.end_of_last_line) {
-		if (positions.end_of_last_line > max_tuple_end) {
-			max_tuple_end = positions.end_of_last_line;
-		}
-		tuple_end_to_batch[file_number_p][positions.end_of_last_line] = batch_idx;
-		batch_to_tuple_end[file_number_p][batch_idx] = tuple_end[file_number_p].size();
-		tuple_start[file_number_p].insert(positions.beginning_of_first_line);
-		tuple_end[file_number_p].push_back(positions.end_of_last_line);
+	if (positions.end_of_last_line > max_tuple_end) {
+		max_tuple_end = positions.end_of_last_line;
 	}
+	tuple_end_to_batch[file_number_p][positions.end_of_last_line] = batch_idx;
+	batch_to_tuple_end[file_number_p][batch_idx] = tuple_end[file_number_p].size();
+	tuple_start[file_number_p].insert(positions.beginning_of_first_line);
+	tuple_end[file_number_p].push_back(positions.end_of_last_line);
 }
 
 void ParallelCSVGlobalState::UpdateLinesRead(CSVBufferRead &buffer_read, idx_t file_idx) {
@@ -690,17 +688,14 @@ static void ParallelReadCSVFunction(ClientContext &context, TableFunctionInput &
 		}
 		if (csv_local_state.csv_reader->finished) {
 			auto verification_updates = csv_local_state.csv_reader->GetVerificationPositions();
-			if (verification_updates.beginning_of_first_line != verification_updates.end_of_last_line) {
-				csv_global_state.UpdateVerification(verification_updates,
-				                                    csv_local_state.csv_reader->buffer->buffer->GetFileNumber(),
-				                                    csv_local_state.csv_reader->buffer->local_batch_index);
-			}
+			csv_global_state.UpdateVerification(verification_updates,
+			                                    csv_local_state.csv_reader->buffer->buffer->GetFileNumber(),
+			                                    csv_local_state.csv_reader->buffer->local_batch_index);
 			csv_global_state.UpdateLinesRead(*csv_local_state.csv_reader->buffer, csv_local_state.csv_reader->file_idx);
 			auto has_next = csv_global_state.Next(context, bind_data, csv_local_state.csv_reader);
 			if (csv_local_state.csv_reader) {
 				csv_local_state.csv_reader->linenr = 0;
 			}
-
 			if (!has_next) {
 				csv_global_state.DecrementThread();
 				break;

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.1-dev125"
+#define DUCKDB_VERSION "0.8.1-dev180"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "09486d2b9d"
+#define DUCKDB_SOURCE_ID "e9f6ba553a"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/catalog/catalog.hpp

@@ -229,9 +229,6 @@ public:
 	DUCKDB_API static LogicalType GetType(ClientContext &context, const string &catalog_name, const string &schema,
 	                                      const string &name);
 
-	static bool TypeExists(ClientContext &context, const string &catalog_name, const string &schema,
-	                       const string &name);
-
 	template <class T>
 	optional_ptr<T> GetEntry(ClientContext &context, const string &schema_name, const string &name,
 	                         OnEntryNotFound if_not_found, QueryErrorContext error_context = QueryErrorContext()) {

package/src/duckdb/src/include/duckdb/catalog/catalog_search_path.hpp

@@ -58,6 +58,8 @@ public:
 	DUCKDB_API vector<string> GetSchemasForCatalog(const string &catalog);
 	DUCKDB_API vector<string> GetCatalogsForSchema(const string &schema);
 
+	DUCKDB_API bool SchemaInSearchPath(ClientContext &context, const string &catalog_name, const string &schema_name);
+
 private:
 	void SetPaths(vector<CatalogSearchEntry> new_paths);
 

package/src/duckdb/src/include/duckdb/core_functions/scalar/generic_functions.hpp

@@ -121,6 +121,15 @@ struct CurrentDatabaseFun {
 	static ScalarFunction GetFunction();
 };
 
+struct InSearchPathFun {
+	static constexpr const char *Name = "in_search_path";
+	static constexpr const char *Parameters = "database_name,schema_name";
+	static constexpr const char *Description = "Returns whether or not the database/schema are in the search path.";
+	static constexpr const char *Example = "in_search_path('memory', 'main')";
+
+	static ScalarFunction GetFunction();
+};
+
 struct CurrentTransactionIdFun {
 	static constexpr const char *Name = "txid_current";
 	static constexpr const char *Parameters = "";

package/src/duckdb/src/include/duckdb/core_functions/scalar/map_functions.hpp

@@ -43,10 +43,7 @@ struct MapEntriesFun {
 struct MapExtractFun {
 	static constexpr const char *Name = "map_extract";
 	static constexpr const char *Parameters = "map,key";
-	static constexpr const char *Description =
-	    "Return a list containing the value for a given key or an empty list if the key is not contained in the map. "
-	    "The type of the key provided in the second parameter must match the type of the map’s keys else an error is "
-	    "returned.";
+	static constexpr const char *Description = "Return a list containing the value for a given key or an empty list if the key is not contained in the map. The type of the key provided in the second parameter must match the type of the map’s keys else an error is returned.";
 	static constexpr const char *Example = "map_extract(map(['key'], ['val']), 'key')";
 
 	static ScalarFunction GetFunction();
@@ -70,8 +67,7 @@ struct MapFromEntriesFun {
 struct MapConcatFun {
 	static constexpr const char *Name = "map_concat";
 	static constexpr const char *Parameters = "any,...";
-	static constexpr const char *Description = "Returns a map created from merging the input maps, on key collision "
-	                                           "the value is taken from the last map with that key";
+	static constexpr const char *Description = "Returns a map created from merging the input maps, on key collision the value is taken from the last map with that key";
 	static constexpr const char *Example = "map_concat(map([1,2], ['a', 'b']), map([2,3], ['c', 'd']));";
 
 	static ScalarFunction GetFunction();

package/src/duckdb/src/include/duckdb/core_functions/scalar/string_functions.hpp

@@ -31,8 +31,7 @@ struct StartsWithFun {
 struct ASCIIFun {
 	static constexpr const char *Name = "ascii";
 	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description =
-	    "Returns an integer that represents the Unicode code point of the first character of the string.";
+	static constexpr const char *Description = "Returns an integer that represents the Unicode code point of the first character of the string.";
 	static constexpr const char *Example = "ascii('Ω')";
 
 	static ScalarFunction GetFunction();
@@ -41,8 +40,7 @@ struct ASCIIFun {
 struct BarFun {
 	static constexpr const char *Name = "bar";
 	static constexpr const char *Parameters = "x,min,max,width";
-	static constexpr const char *Description = "Draw a band whose width is proportional to (x - min) and equal to "
-	                                           "width characters when x = max. width defaults to 80.";
+	static constexpr const char *Description = "Draw a band whose width is proportional to (x - min) and equal to width characters when x = max. width defaults to 80.";
 	static constexpr const char *Example = "bar(5, 0, 20, 10)";
 
 	static ScalarFunctionSet GetFunctions();
@@ -66,8 +64,7 @@ struct ToBinaryFun {
 struct ChrFun {
 	static constexpr const char *Name = "chr";
 	static constexpr const char *Parameters = "code_point";
-	static constexpr const char *Description =
-	    "returns a character which is corresponding the ASCII code value or Unicode code point";
+	static constexpr const char *Description = "returns a character which is corresponding the ASCII code value or Unicode code point";
 	static constexpr const char *Example = "chr(65)";
 
 	static ScalarFunction GetFunction();
@@ -76,10 +73,7 @@ struct ChrFun {
 struct DamerauLevenshteinFun {
 	static constexpr const char *Name = "damerau_levenshtein";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description =
-	    "Extension of Levenshtein distance to also include transposition of adjacent characters as an allowed edit "
-	    "operation. In other words, the minimum number of edit operations (insertions, deletions, substitutions or "
-	    "transpositions) required to change one string to another. Different case is considered different.";
+	static constexpr const char *Description = "Extension of Levenshtein distance to also include transposition of adjacent characters as an allowed edit operation. In other words, the minimum number of edit operations (insertions, deletions, substitutions or transpositions) required to change one string to another. Different case is considered different.";
 	static constexpr const char *Example = "damerau_levenshtein('hello', 'world')";
 
 	static ScalarFunction GetFunction();
@@ -112,8 +106,7 @@ struct FormatreadabledecimalsizeFun {
 struct HammingFun {
 	static constexpr const char *Name = "hamming";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The number of positions with different characters for 2 strings of "
-	                                           "equal length. Different case is considered different.";
+	static constexpr const char *Description = "The number of positions with different characters for 2 strings of equal length. Different case is considered different.";
 	static constexpr const char *Example = "hamming('duck','luck')";
 
 	static ScalarFunction GetFunction();
@@ -143,8 +136,7 @@ struct ToHexFun {
 struct InstrFun {
 	static constexpr const char *Name = "instr";
 	static constexpr const char *Parameters = "haystack,needle";
-	static constexpr const char *Description =
-	    "Return location of first occurrence of needle in haystack, counting from 1. Returns 0 if no match found.";
+	static constexpr const char *Description = "Return location of first occurrence of needle in haystack, counting from 1. Returns 0 if no match found.";
 	static constexpr const char *Example = "instr('test test','es')";
 
 	static ScalarFunction GetFunction();
@@ -165,8 +157,7 @@ struct PositionFun {
 struct JaccardFun {
 	static constexpr const char *Name = "jaccard";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The Jaccard similarity between two strings. Different case is "
-	                                           "considered different. Returns a number between 0 and 1.";
+	static constexpr const char *Description = "The Jaccard similarity between two strings. Different case is considered different. Returns a number between 0 and 1.";
 	static constexpr const char *Example = "jaccard('duck','luck')";
 
 	static ScalarFunction GetFunction();
@@ -175,8 +166,7 @@ struct JaccardFun {
 struct JaroSimilarityFun {
 	static constexpr const char *Name = "jaro_similarity";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The Jaro similarity between two strings. Different case is considered "
-	                                           "different. Returns a number between 0 and 1.";
+	static constexpr const char *Description = "The Jaro similarity between two strings. Different case is considered different. Returns a number between 0 and 1.";
 	static constexpr const char *Example = "jaro_similarity('duck','duckdb')";
 
 	static ScalarFunction GetFunction();
@@ -185,8 +175,7 @@ struct JaroSimilarityFun {
 struct JaroWinklerSimilarityFun {
 	static constexpr const char *Name = "jaro_winkler_similarity";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The Jaro-Winkler similarity between two strings. Different case is "
-	                                           "considered different. Returns a number between 0 and 1.";
+	static constexpr const char *Description = "The Jaro-Winkler similarity between two strings. Different case is considered different. Returns a number between 0 and 1.";
 	static constexpr const char *Example = "jaro_winkler_similarity('duck','duckdb')";
 
 	static ScalarFunction GetFunction();
@@ -213,9 +202,7 @@ struct LeftGraphemeFun {
 struct LevenshteinFun {
 	static constexpr const char *Name = "levenshtein";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description =
-	    "The minimum number of single-character edits (insertions, deletions or substitutions) required to change one "
-	    "string to the other. Different case is considered different.";
+	static constexpr const char *Description = "The minimum number of single-character edits (insertions, deletions or substitutions) required to change one string to the other. Different case is considered different.";
 	static constexpr const char *Example = "levenshtein('duck','db')";
 
 	static ScalarFunction GetFunction();
@@ -230,8 +217,7 @@ struct Editdist3Fun {
 struct LpadFun {
 	static constexpr const char *Name = "lpad";
 	static constexpr const char *Parameters = "string,count,character";
-	static constexpr const char *Description =
-	    "Pads the string with the character from the left until it has count characters";
+	static constexpr const char *Description = "Pads the string with the character from the left until it has count characters";
 	static constexpr const char *Example = "lpad('hello', 10, '>')";
 
 	static ScalarFunction GetFunction();
@@ -240,8 +226,7 @@ struct LpadFun {
 struct LtrimFun {
 	static constexpr const char *Name = "ltrim";
 	static constexpr const char *Parameters = "string,characters";
-	static constexpr const char *Description =
-	    "Removes any occurrences of any of the characters from the left side of the string";
+	static constexpr const char *Description = "Removes any occurrences of any of the characters from the left side of the string";
 	static constexpr const char *Example = "ltrim('>>>>test<<', '><')";
 
 	static ScalarFunctionSet GetFunctions();
@@ -340,8 +325,7 @@ struct RightGraphemeFun {
 struct RpadFun {
 	static constexpr const char *Name = "rpad";
 	static constexpr const char *Parameters = "string,count,character";
-	static constexpr const char *Description =
-	    "Pads the string with the character from the right until it has count characters";
+	static constexpr const char *Description = "Pads the string with the character from the right until it has count characters";
 	static constexpr const char *Example = "rpad('hello', 10, '<')";
 
 	static ScalarFunction GetFunction();
@@ -350,8 +334,7 @@ struct RpadFun {
 struct RtrimFun {
 	static constexpr const char *Name = "rtrim";
 	static constexpr const char *Parameters = "string,characters";
-	static constexpr const char *Description =
-	    "Removes any occurrences of any of the characters from the right side of the string";
+	static constexpr const char *Description = "Removes any occurrences of any of the characters from the right side of the string";
 	static constexpr const char *Example = "rtrim('>>>>test<<', '><')";
 
 	static ScalarFunctionSet GetFunctions();
@@ -408,9 +391,7 @@ struct RegexpSplitToArrayFun {
 struct TranslateFun {
 	static constexpr const char *Name = "translate";
 	static constexpr const char *Parameters = "string,from,to";
-	static constexpr const char *Description =
-	    "Replaces each character in string that matches a character in the from set with the corresponding character "
-	    "in the to set. If from is longer than to, occurrences of the extra characters in from are deleted.";
+	static constexpr const char *Description = "Replaces each character in string that matches a character in the from set with the corresponding character in the to set. If from is longer than to, occurrences of the extra characters in from are deleted.";
 	static constexpr const char *Example = "translate('12345', '143', 'ax')";
 
 	static ScalarFunction GetFunction();
@@ -419,8 +400,7 @@ struct TranslateFun {
 struct TrimFun {
 	static constexpr const char *Name = "trim";
 	static constexpr const char *Parameters = "string,characters";
-	static constexpr const char *Description =
-	    "Removes any occurrences of any of the characters from either side of the string";
+	static constexpr const char *Description = "Removes any occurrences of any of the characters from either side of the string";
 	static constexpr const char *Example = "trim('>>>>test<<', '><')";
 
 	static ScalarFunctionSet GetFunctions();

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

@@ -25,8 +25,10 @@ public:
 		bool serialize = function.serialize;
 		writer.WriteField(serialize);
 		if (serialize) {
-			D_ASSERT(function.deserialize);
 			function.serialize(writer, bind_info, function);
+			// First check if serialize throws a NotImplementedException, in which case it doesn't require a deserialize
+			// function
+			D_ASSERT(function.deserialize);
 		}
 	}
 

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

@@ -151,6 +151,8 @@ struct DBConfigOptions {
 	DebugInitialize debug_initialize = DebugInitialize::NO_INITIALIZE;
 	//! The set of unrecognized (other) options
 	unordered_map<string, Value> unrecognized_options;
+	//! Whether or not the configuration settings can be altered
+	bool lock_configuration = false;
 	//! Whether to print bindings when printing the plan (debug mode only)
 	static bool debug_print_bindings;
 

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

@@ -309,6 +309,15 @@ struct LogQueryPathSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct LockConfigurationSetting {
+	static constexpr const char *Name = "lock_configuration";
+	static constexpr const char *Description = "Whether or not the configuration can be altered";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct ImmediateTransactionModeSetting {
 	static constexpr const char *Name = "immediate_transaction_mode";
 	static constexpr const char *Description =

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

@@ -62,6 +62,8 @@ public:
 	//! Parses a column list (i.e. as found in a CREATE TABLE statement)
 	static ColumnList ParseColumnList(const string &column_list, ParserOptions options = ParserOptions());
 
+	static bool StripUnicodeSpaces(const string &query_str, string &new_query);
+
 private:
 	ParserOptions options;
 };

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

@@ -11,7 +11,7 @@
 #include "duckdb/parser/tableref.hpp"
 
 namespace duckdb {
-//! Represents a cross product
+
 class EmptyTableRef : public TableRef {
 public:
 	static constexpr const TableReferenceType TYPE = TableReferenceType::EMPTY;

package/src/duckdb/src/main/config.cpp

@@ -82,6 +82,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_GLOBAL(ForceBitpackingModeSetting),
                                                  DUCKDB_LOCAL(HomeDirectorySetting),
                                                  DUCKDB_LOCAL(LogQueryPathSetting),
+                                                 DUCKDB_GLOBAL(LockConfigurationSetting),
                                                  DUCKDB_GLOBAL(ImmediateTransactionModeSetting),
                                                  DUCKDB_LOCAL(IntegerDivisionSetting),
                                                  DUCKDB_LOCAL(MaximumExpressionDepthSetting),

package/src/duckdb/src/main/settings/settings.cpp

@@ -151,7 +151,7 @@ void OrderedAggregateThreshold::ResetLocal(ClientContext &context) {
 
 void OrderedAggregateThreshold::SetLocal(ClientContext &context, const Value &input) {
 	const auto param = input.GetValue<uint64_t>();
-	if (!param) {
+	if (param <= 0) {
 		throw ParserException("Invalid option for PRAGMA ordered_aggregate_threshold, value must be positive");
 	}
 	ClientConfig::GetConfig(context).ordered_aggregate_threshold = param;
@@ -189,7 +189,7 @@ Value DebugWindowMode::GetSetting(ClientContext &context) {
 // Debug AsOf Join
 //===--------------------------------------------------------------------===//
 void DebugAsOfIEJoin::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).force_no_cross_product = ClientConfig().force_asof_iejoin;
+	ClientConfig::GetConfig(context).force_asof_iejoin = ClientConfig().force_asof_iejoin;
 }
 
 void DebugAsOfIEJoin::SetLocal(ClientContext &context, const Value &input) {
@@ -433,7 +433,6 @@ Value EnableHTTPMetadataCacheSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Enable Profiling
 //===--------------------------------------------------------------------===//
-
 void EnableProfilingSetting::ResetLocal(ClientContext &context) {
 	auto &config = ClientConfig::GetConfig(context);
 	config.profiler_print_format = ClientConfig().profiler_print_format;
@@ -718,10 +717,10 @@ Value IntegerDivisionSetting::GetSetting(ClientContext &context) {
 	auto &config = ClientConfig::GetConfig(context);
 	return Value(config.integer_division);
 }
+
 //===--------------------------------------------------------------------===//
 // Log Query Path
 //===--------------------------------------------------------------------===//
-
 void LogQueryPathSetting::ResetLocal(ClientContext &context) {
 	auto &client_data = ClientData::Get(context);
 	// TODO: verify that this does the right thing
@@ -745,6 +744,23 @@ Value LogQueryPathSetting::GetSetting(ClientContext &context) {
 	return client_data.log_query_writer ? Value(client_data.log_query_writer->path) : Value();
 }
 
+//===--------------------------------------------------------------------===//
+// Lock Configuration
+//===--------------------------------------------------------------------===//
+void LockConfigurationSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
+	auto new_value = input.GetValue<bool>();
+	config.options.lock_configuration = new_value;
+}
+
+void LockConfigurationSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.lock_configuration = DBConfig().options.lock_configuration;
+}
+
+Value LockConfigurationSetting::GetSetting(ClientContext &context) {
+	auto &config = DBConfig::GetConfig(context);
+	return Value::BOOLEAN(config.options.lock_configuration);
+}
+
 //===--------------------------------------------------------------------===//
 // Immediate Transaction Mode
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/parser/column_definition.cpp

@@ -50,6 +50,7 @@ void ColumnDefinition::Serialize(Serializer &serializer) const {
 		writer.WriteOptional(default_value);
 	}
 	writer.WriteField<TableColumnType>(category);
+	writer.WriteField<duckdb::CompressionType>(compression_type);
 	writer.Finalize();
 }
 
@@ -59,16 +60,12 @@ ColumnDefinition ColumnDefinition::Deserialize(Deserializer &source) {
 	auto column_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 	auto expression = reader.ReadOptional<ParsedExpression>(nullptr);
 	auto category = reader.ReadField<TableColumnType>(TableColumnType::STANDARD);
+	auto compression_type = reader.ReadField<duckdb::CompressionType>(duckdb::CompressionType::COMPRESSION_AUTO);
 	reader.Finalize();
 
-	switch (category) {
-	case TableColumnType::STANDARD:
-		return ColumnDefinition(column_name, column_type, std::move(expression), TableColumnType::STANDARD);
-	case TableColumnType::GENERATED:
-		return ColumnDefinition(column_name, column_type, std::move(expression), TableColumnType::GENERATED);
-	default:
-		throw NotImplementedException("Type not implemented for TableColumnType");
-	}
+	ColumnDefinition result(column_name, column_type, std::move(expression), category);
+	result.compression_type = compression_type;
+	return result;
 }
 
 const unique_ptr<ParsedExpression> &ColumnDefinition::DefaultValue() const {

package/src/duckdb/src/parser/parser.cpp

@@ -45,7 +45,7 @@ static bool ReplaceUnicodeSpaces(const string &query, string &new_query, vector<
 // This function strips unicode space characters from the query and replaces them with regular spaces
 // It returns true if any unicode space characters were found and stripped
 // See here for a list of unicode space characters - https://jkorpela.fi/chars/spaces.html
-static bool StripUnicodeSpaces(const string &query_str, string &new_query) {
+bool Parser::StripUnicodeSpaces(const string &query_str, string &new_query) {
 	const idx_t NBSP_LEN = 2;
 	const idx_t USP_LEN = 3;
 	idx_t pos = 0;

package/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp

@@ -161,6 +161,9 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 				table_function.extra_info = "(Multi-Threaded)";
 			}
 		}
+	} else {
+		throw InvalidInputException("Cannot call function \"%s\" directly - it has no bind function",
+		                            table_function.name);
 	}
 	if (return_types.size() != return_names.size()) {
 		throw InternalException("Failed to bind \"%s\": return_types/names must have same size", table_function.name);

package/src/duckdb/src/storage/data_table.cpp

@@ -1201,13 +1201,14 @@ void DataTable::WALAddIndex(ClientContext &context, unique_ptr<Index> index,
 	// intermediate holds scanned chunks of the underlying data to create the index
 	DataChunk intermediate;
 	vector<LogicalType> intermediate_types;
-	auto column_ids = index->column_ids;
-	column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
-	for (auto &id : index->column_ids) {
-		auto &col = column_definitions[id];
-		intermediate_types.push_back(col.Type());
+	vector<column_t> column_ids;
+	for (auto &it : column_definitions) {
+		intermediate_types.push_back(it.Type());
+		column_ids.push_back(it.Oid());
 	}
+	column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
 	intermediate_types.emplace_back(LogicalType::ROW_TYPE);
+
 	intermediate.Initialize(allocator, intermediate_types);
 
 	// holds the result of executing the index expression on the intermediate chunks

package/src/duckdb/src/storage/wal_replay.cpp

@@ -195,15 +195,16 @@ void ReplayState::ReplayEntry(WALType entry_type) {
 // Replay Table
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateTable() {
-
 	auto info = TableCatalogEntry::Deserialize(source, context);
 	if (deserialize_only) {
 		return;
 	}
 
 	// bind the constraints to the table again
+
 	auto binder = Binder::CreateBinder(context);
-	auto bound_info = binder->BindCreateTableInfo(std::move(info));
+	auto &schema = catalog.GetSchema(context, info->schema);
+	auto bound_info = binder->BindCreateTableInfo(std::move(info), schema);
 
 	catalog.CreateTable(context, *bound_info);
 }
@@ -282,9 +283,7 @@ void ReplayState::ReplayDropSchema() {
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateType() {
 	auto info = TypeCatalogEntry::Deserialize(source);
-	if (Catalog::TypeExists(context, info->catalog, info->schema, info->name)) {
-		return;
-	}
+	info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
 	catalog.CreateType(context, *info);
 }