duckdb 1.1.4-dev11.0 → 1.1.4-dev14.0

package/src/duckdb/src/storage/table_index_list.cpp

@@ -128,30 +128,57 @@ void TableIndexList::Move(TableIndexList &other) {
 	indexes = std::move(other.indexes);
 }
 
-Index *TableIndexList::FindForeignKeyIndex(const vector<PhysicalIndex> &fk_keys, const ForeignKeyType fk_type) {
-	for (auto &index : indexes) {
-		if (DataTable::IsForeignKeyIndex(fk_keys, *index, fk_type)) {
-			return &(*index);
+bool IsForeignKeyIndex(const vector<PhysicalIndex> &fk_keys, Index &index, ForeignKeyType fk_type) {
+	if (fk_type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE ? !index.IsUnique() : !index.IsForeign()) {
+		return false;
+	}
+	if (fk_keys.size() != index.GetColumnIds().size()) {
+		return false;
+	}
+
+	auto &column_ids = index.GetColumnIds();
+	for (auto &fk_key : fk_keys) {
+		bool found = false;
+		for (auto &index_key : column_ids) {
+			if (fk_key.index == index_key) {
+				found = true;
+				break;
+			}
+		}
+		if (!found) {
+			return false;
+		}
+	}
+	return true;
+}
+
+optional_ptr<Index> TableIndexList::FindForeignKeyIndex(const vector<PhysicalIndex> &fk_keys,
+                                                        const ForeignKeyType fk_type) {
+	for (auto &index_elem : indexes) {
+		if (IsForeignKeyIndex(fk_keys, *index_elem, fk_type)) {
+			return index_elem;
 		}
 	}
 	return nullptr;
 }
 
-void TableIndexList::VerifyForeignKey(const vector<PhysicalIndex> &fk_keys, DataChunk &chunk,
-                                      ConflictManager &conflict_manager) {
+void TableIndexList::VerifyForeignKey(optional_ptr<LocalTableStorage> storage, const vector<PhysicalIndex> &fk_keys,
+                                      DataChunk &chunk, ConflictManager &conflict_manager) {
 	auto fk_type = conflict_manager.LookupType() == VerifyExistenceType::APPEND_FK
 	                   ? ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE
 	                   : ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
 
-	// Check whether the chunk can be inserted or deleted into the referenced table storage.
+	// Check whether the chunk can be inserted in or deleted from the referenced table storage.
 	auto index = FindForeignKeyIndex(fk_keys, fk_type);
-	if (!index) {
-		throw InternalException("Internal Foreign Key error: could not find index to verify...");
-	}
-	if (!index->IsBound()) {
-		throw InternalException("Internal Foreign Key error: trying to verify an unbound index...");
+	D_ASSERT(index && index->IsBound());
+	if (storage) {
+		auto delete_index = storage->delete_indexes.Find(index->GetIndexName());
+		IndexAppendInfo index_append_info(IndexAppendMode::DEFAULT, delete_index);
+		index->Cast<BoundIndex>().VerifyConstraint(chunk, index_append_info, conflict_manager);
+	} else {
+		IndexAppendInfo index_append_info;
+		index->Cast<BoundIndex>().VerifyConstraint(chunk, index_append_info, conflict_manager);
 	}
-	index->Cast<BoundIndex>().VerifyConstraint(chunk, nullptr, conflict_manager);
 }
 
 unordered_set<column_t> TableIndexList::GetRequiredColumns() {
@@ -176,10 +203,9 @@ vector<IndexStorageInfo> TableIndexList::GetStorageInfos(const case_insensitive_
 		}
 
 		auto info = index->Cast<UnboundIndex>().GetStorageInfo();
-		D_ASSERT(info.IsValid() && !info.name.empty());
+		D_ASSERT(!info.name.empty());
 		infos.push_back(info);
 	}
-
 	return infos;
 }
 

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

@@ -50,11 +50,13 @@ public:
 	WriteAheadLogDeserializer(ReplayState &state_p, BufferedFileReader &stream_p, bool deserialize_only = false)
 	    : state(state_p), db(state.db), context(state.context), catalog(state.catalog), data(nullptr),
 	      stream(nullptr, 0), deserializer(stream_p), deserialize_only(deserialize_only) {
+		deserializer.Set<Catalog &>(catalog);
 	}
 	WriteAheadLogDeserializer(ReplayState &state_p, unique_ptr<data_t[]> data_p, idx_t size,
 	                          bool deserialize_only = false)
 	    : state(state_p), db(state.db), context(state.context), catalog(state.catalog), data(std::move(data_p)),
 	      stream(data.get(), size), deserializer(stream), deserialize_only(deserialize_only) {
+		deserializer.Set<Catalog &>(catalog);
 	}
 
 	static WriteAheadLogDeserializer Open(ReplayState &state_p, BufferedFileReader &stream,
@@ -738,7 +740,7 @@ void WriteAheadLogDeserializer::ReplayInsert() {
 	// Append to the current table without constraint verification.
 	vector<unique_ptr<BoundConstraint>> bound_constraints;
 	auto &storage = state.current_table->GetStorage();
-	storage.LocalAppend(*state.current_table, context, chunk, bound_constraints);
+	storage.LocalWALAppend(*state.current_table, context, chunk, bound_constraints);
 }
 
 static void MarkBlocksAsUsed(BlockManager &manager, const PersistentColumnData &col_data) {

package/src/duckdb/src/storage/write_ahead_log.cpp

@@ -19,6 +19,7 @@
 #include "duckdb/storage/table/column_data.hpp"
 #include "duckdb/storage/table/data_table_info.hpp"
 #include "duckdb/storage/table_io_manager.hpp"
+#include "duckdb/storage/storage_manager.hpp"
 
 namespace duckdb {
 
@@ -32,6 +33,10 @@ WriteAheadLog::WriteAheadLog(AttachedDatabase &database, const string &wal_path,
 WriteAheadLog::~WriteAheadLog() {
 }
 
+AttachedDatabase &WriteAheadLog::GetDatabase() {
+	return database;
+}
+
 BufferedFileWriter &WriteAheadLog::Initialize() {
 	if (Initialized()) {
 		return *writer;
@@ -98,7 +103,7 @@ void WriteAheadLog::Delete() {
 //===--------------------------------------------------------------------===//
 class ChecksumWriter : public WriteStream {
 public:
-	explicit ChecksumWriter(WriteAheadLog &wal) : wal(wal) {
+	explicit ChecksumWriter(WriteAheadLog &wal) : wal(wal), memory_stream(Allocator::Get(wal.GetDatabase())) {
 	}
 
 	void WriteData(const_data_ptr_t buffer, idx_t write_size) override {
@@ -131,7 +136,8 @@ private:
 
 class WriteAheadLogSerializer {
 public:
-	WriteAheadLogSerializer(WriteAheadLog &wal, WALType wal_type) : checksum_writer(wal), serializer(checksum_writer) {
+	WriteAheadLogSerializer(WriteAheadLog &wal, WALType wal_type)
+	    : checksum_writer(wal), serializer(checksum_writer, SerializationOptions(wal.GetDatabase())) {
 		if (!wal.Initialized()) {
 			wal.Initialize();
 		}
@@ -158,6 +164,7 @@ public:
 
 private:
 	ChecksumWriter checksum_writer;
+	SerializationOptions options;
 	BinarySerializer serializer;
 };
 
@@ -274,8 +281,8 @@ void WriteAheadLog::WriteDropTableMacro(const TableMacroCatalogEntry &entry) {
 
 void SerializeIndex(AttachedDatabase &db, WriteAheadLogSerializer &serializer, TableIndexList &list,
                     const string &name) {
-	const auto &db_options = db.GetDatabase().config.options;
-	auto v1_0_0_storage = db_options.serialization_compatibility.serialization_version < 3;
+	auto storage_version = db.GetStorageManager().GetStorageVersion();
+	auto v1_0_0_storage = storage_version < 3;
 	case_insensitive_map_t<Value> options;
 	if (!v1_0_0_storage) {
 		options.emplace("v1_0_0_storage", v1_0_0_storage);

package/src/duckdb/src/transaction/meta_transaction.cpp

@@ -55,7 +55,7 @@ Transaction &MetaTransaction::GetTransaction(AttachedDatabase &db) {
 	auto entry = transactions.find(db);
 	if (entry == transactions.end()) {
 		auto &new_transaction = db.GetTransactionManager().StartTransaction(context);
-		new_transaction.active_query = active_query;
+		new_transaction.active_query = active_query.load();
 #ifdef DEBUG
 		VerifyAllTransactionsUnique(db, all_transactions);
 #endif

package/src/duckdb/src/verification/deserialized_statement_verifier.cpp

@@ -15,7 +15,8 @@ DeserializedStatementVerifier::Create(const SQLStatement &statement,
                                       optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters) {
 
 	auto &select_stmt = statement.Cast<SelectStatement>();
-	MemoryStream stream;
+	Allocator allocator;
+	MemoryStream stream(allocator);
 	BinarySerializer::Serialize(select_stmt, stream);
 	stream.Rewind();
 	auto result = BinaryDeserializer::Deserialize<SelectStatement>(stream);

package/src/duckdb/third_party/httplib/httplib.hpp

@@ -2466,7 +2466,6 @@ inline std::string encode_url(const std::string &s) {
   for (size_t i = 0; s[i]; i++) {
     switch (s[i]) {
     case ' ': result += "%20"; break;
-    case '+': result += "%2B"; break;
     case '\r': result += "%0D"; break;
     case '\n': result += "%0A"; break;
     case '\'': result += "%27"; break;

package/src/duckdb/third_party/re2/util/logging.h

@@ -34,26 +34,26 @@
 #define CHECK_EQ(x, y)	CHECK((x) == (y))
 #define CHECK_NE(x, y)	CHECK((x) != (y))
 
-#define LOG_INFO LogMessage(__FILE__, __LINE__)
-#define LOG_WARNING LogMessage(__FILE__, __LINE__)
-#define LOG_ERROR LogMessage(__FILE__, __LINE__)
-#define LOG_FATAL LogMessageFatal(__FILE__, __LINE__)
-#define LOG_QFATAL LOG_FATAL
+#define RE2_LOG_INFO LogMessage(__FILE__, __LINE__)
+#define RE2_LOG_WARNING LogMessage(__FILE__, __LINE__)
+#define RE2_LOG_ERROR LogMessage(__FILE__, __LINE__)
+#define RE2_LOG_FATAL LogMessageFatal(__FILE__, __LINE__)
+#define RE2_LOG_QFATAL RE2_LOG_FATAL
 
 // It seems that one of the Windows header files defines ERROR as 0.
 #ifdef _WIN32
-#define LOG_0 LOG_INFO
+#define LOG_0 RE2_LOG_INFO
 #endif
 
 #ifdef NDEBUG
-#define LOG_DFATAL LOG_ERROR
+#define RE2_LOG_DFATAL RE2_LOG_ERROR
 #else
-#define LOG_DFATAL LOG_FATAL
+#define RE2_LOG_DFATAL RE2_LOG_FATAL
 #endif
 
-#define LOG(severity) LOG_ ## severity.stream()
+#define LOG(severity) RE2_LOG_ ## severity.stream()
 
-#define VLOG(x) if((x)>0){}else LOG_INFO.stream()
+#define VLOG(x) if((x)>0){}else RE2_LOG_INFO.stream()
 
 class LogMessage {
  public:

package/src/duckdb/ub_src_function_table_system.cpp

@@ -28,6 +28,8 @@
 
 #include "src/function/table/system/duckdb_which_secret.cpp"
 
+#include "src/function/table/system/duckdb_secret_types.cpp"
+
 #include "src/function/table/system/duckdb_sequences.cpp"
 
 #include "src/function/table/system/duckdb_settings.cpp"