Update vendored DuckDB sources to 9612b5bea5

Author: duckdblabs-bot

src/duckdb/extension/core_functions/lambda_functions.cpp

@@ -22,10 +22,11 @@ struct LambdaExecuteInfo {
 
 		// get the input types for the input chunk
 		vector<LogicalType> input_types;
+
+		input_types.push_back(child_vector.GetType());
 		if (has_index) {
 			input_types.push_back(LogicalType::BIGINT);
 		}
-		input_types.push_back(child_vector.GetType());
 		for (idx_t i = 1; i < args.ColumnCount(); i++) {
 			input_types.push_back(args.data[i].GetType());
 		}
@@ -152,8 +153,9 @@ struct ListFilterFunctor {
 
 		// slice the input chunk's corresponding vector to get the new lists
 		// and append them to the result
-		idx_t source_list_idx = execute_info.has_index ? 1 : 0;
-		Vector result_lists(execute_info.input_chunk.data[source_list_idx], sel, count);
+
+		// The first vector in the input chunk is always the list vector
+		Vector result_lists(execute_info.input_chunk.data[0], sel, count);
 		ListVector::Append(result, result_lists, count, 0);
 	}
 };
@@ -190,8 +192,8 @@ static void ExecuteExpression(const idx_t elem_cnt, const LambdaFunctions::Colum
 
 	// reference the child vector (and the index vector)
 	if (info.has_index) {
-		info.input_chunk.data[0].Reference(index_vector);
-		info.input_chunk.data[1].Reference(slice);
+		info.input_chunk.data[0].Reference(slice);
+		info.input_chunk.data[1].Reference(index_vector);
 	} else {
 		info.input_chunk.data[0].Reference(slice);
 	}
@@ -247,7 +249,8 @@ LogicalType LambdaFunctions::DetermineListChildType(const LogicalType &child_typ
 		} else if (child_type.id() == LogicalTypeId::LIST) {
 			return ListType::GetChildType(child_type);
 		}
-		throw InternalException("The first argument must be a list or array type");
+
+		throw BinderException("Invalid LIST argument during lambda function binding!");
 	}
 
 	return child_type;

src/duckdb/extension/core_functions/scalar/list/list_reduce.cpp

@@ -41,11 +41,13 @@ struct ReduceExecuteInfo {
 		}
 		left_slice->Slice(left_vector, reduced_row_idx);
 
+		input_types.push_back(left_slice->GetType());
+		input_types.push_back(left_slice->GetType());
+
 		if (info.has_index) {
 			input_types.push_back(LogicalType::BIGINT);
 		}
-		input_types.push_back(left_slice->GetType());
-		input_types.push_back(left_slice->GetType());
+
 		// skip the first entry if there is an initial value
 		for (idx_t i = info.has_initial ? 1 : 0; i < info.column_infos.size(); i++) {
 			input_types.push_back(info.column_infos[i].vector.get().GetType());
@@ -133,18 +135,19 @@ bool ExecuteReduce(const idx_t loops, ReduceExecuteInfo &execute_info, LambdaFun
 	input_chunk.InitializeEmpty(execute_info.input_types);
 	input_chunk.SetCardinality(reduced_row_idx);
 
-	const idx_t slice_offset = info.has_index ? 1 : 0;
-	if (info.has_index) {
-		input_chunk.data[0].Reference(index_vector);
-	}
+	idx_t vec_offset = 0;
 
 	if (loops == 0 && info.has_initial) {
-		info.column_infos[0].vector.get().Slice(execute_info.active_rows_sel, reduced_row_idx);
-		input_chunk.data[slice_offset + 1].Reference(info.column_infos[0].vector);
+		info.column_infos[vec_offset].vector.get().Slice(execute_info.active_rows_sel, reduced_row_idx);
+		input_chunk.data[vec_offset++].Reference(info.column_infos[0].vector);
 	} else {
-		input_chunk.data[slice_offset + 1].Reference(*execute_info.left_slice);
+		input_chunk.data[vec_offset++].Reference(*execute_info.left_slice);
+	}
+	input_chunk.data[vec_offset++].Reference(right_slice);
+
+	if (info.has_index) {
+		input_chunk.data[vec_offset++].Reference(index_vector);
 	}
-	input_chunk.data[slice_offset].Reference(right_slice);
 
 	// add the other columns
 	// skip the initial value if there is one
@@ -153,12 +156,12 @@ bool ExecuteReduce(const idx_t loops, ReduceExecuteInfo &execute_info, LambdaFun
 	for (idx_t i = 0; i < info.column_infos.size() - initial_offset; i++) {
 		if (info.column_infos[i].vector.get().GetVectorType() == VectorType::CONSTANT_VECTOR) {
 			// only reference constant vectors
-			input_chunk.data[slice_offset + 2 + i].Reference(info.column_infos[initial_offset + i].vector);
+			input_chunk.data[vec_offset++].Reference(info.column_infos[initial_offset + i].vector);
 		} else {
 			// slice the other vectors
 			slices.emplace_back(info.column_infos[initial_offset + i].vector, execute_info.active_rows_sel,
 			                    reduced_row_idx);
-			input_chunk.data[slice_offset + 2 + i].Reference(slices.back());
+			input_chunk.data[vec_offset++].Reference(slices.back());
 		}
 	}
 

src/duckdb/extension/icu/icu-timezone.cpp

@@ -164,7 +164,7 @@ struct ICUFromNaiveTimestamp : public ICUDateFunc {
 		if (!input.context) {
 			throw InternalException("Missing context for TIMESTAMP to TIMESTAMPTZ cast.");
 		}
-		if (DBConfig::GetSetting<DisableTimestamptzCastsSetting>(*input.context)) {
+		if (Settings::Get<DisableTimestamptzCastsSetting>(*input.context)) {
 			throw BinderException("Casting from TIMESTAMP to TIMESTAMP WITH TIME ZONE without an explicit time zone "
 			                      "has been disabled  - use \"AT TIME ZONE ...\"");
 		}
@@ -251,7 +251,7 @@ struct ICUToNaiveTimestamp : public ICUDateFunc {
 		if (!input.context) {
 			throw InternalException("Missing context for TIMESTAMPTZ to TIMESTAMP cast.");
 		}
-		if (DBConfig::GetSetting<DisableTimestamptzCastsSetting>(*input.context)) {
+		if (Settings::Get<DisableTimestamptzCastsSetting>(*input.context)) {
 			throw BinderException("Casting from TIMESTAMP WITH TIME ZONE to TIMESTAMP without an explicit time zone "
 			                      "has been disabled  - use \"AT TIME ZONE ...\"");
 		}

src/duckdb/extension/parquet/parquet_extension.cpp

@@ -340,7 +340,7 @@ static unique_ptr<FunctionData> ParquetWriteBind(ClientContext &context, CopyFun
 		}
 	}
 	if (row_group_size_bytes_set) {
-		if (DBConfig::GetSetting<PreserveInsertionOrderSetting>(context)) {
+		if (Settings::Get<PreserveInsertionOrderSetting>(context)) {
 			throw BinderException("ROW_GROUP_SIZE_BYTES does not work while preserving insertion order. Use \"SET "
 			                      "preserve_insertion_order=false;\" to disable preserving insertion order.");
 		}

src/duckdb/src/catalog/catalog.cpp

@@ -139,6 +139,10 @@ optional_ptr<CatalogEntry> Catalog::CreateTable(ClientContext &context, unique_p
 
 optional_ptr<CatalogEntry> Catalog::CreateTable(CatalogTransaction transaction, SchemaCatalogEntry &schema,
                                                 BoundCreateTableInfo &info) {
+	auto supports_create_table = SupportsCreateTable(info);
+	if (supports_create_table.HasError()) {
+		supports_create_table.Throw();
+	}
 	return schema.CreateTable(transaction, info);
 }
 
@@ -520,8 +524,7 @@ bool Catalog::TryAutoLoad(ClientContext &context, const string &original_name) n
 		return true;
 	}
 #ifndef DUCKDB_DISABLE_EXTENSION_LOAD
-	auto &dbconfig = DBConfig::GetConfig(context);
-	if (!dbconfig.options.autoload_known_extensions) {
+	if (!Settings::Get<AutoloadKnownExtensionsSetting>(context)) {
 		return false;
 	}
 	try {
@@ -537,8 +540,7 @@ bool Catalog::TryAutoLoad(ClientContext &context, const string &original_name) n
 
 String Catalog::AutoloadExtensionByConfigName(ClientContext &context, const String &configuration_name) {
 #ifndef DUCKDB_DISABLE_EXTENSION_LOAD
-	auto &dbconfig = DBConfig::GetConfig(context);
-	if (dbconfig.options.autoload_known_extensions) {
+	if (Settings::Get<AutoloadKnownExtensionsSetting>(context)) {
 		auto extension_name =
 		    ExtensionHelper::FindExtensionInEntries(configuration_name.ToStdString(), EXTENSION_SETTINGS);
 		if (ExtensionHelper::CanAutoloadExtension(extension_name)) {
@@ -594,8 +596,7 @@ static bool CompareCatalogTypes(CatalogType type_a, CatalogType type_b) {
 
 bool Catalog::AutoLoadExtensionByCatalogEntry(DatabaseInstance &db, CatalogType type, const string &entry_name) {
 #ifndef DUCKDB_DISABLE_EXTENSION_LOAD
-	auto &dbconfig = DBConfig::GetConfig(db);
-	if (dbconfig.options.autoload_known_extensions) {
+	if (Settings::Get<AutoloadKnownExtensionsSetting>(db)) {
 		string extension_name;
 		if (IsAutoloadableFunction(type)) {
 			auto lookup_result = ExtensionHelper::FindExtensionInFunctionEntries(entry_name, EXTENSION_FUNCTIONS);
@@ -640,7 +641,7 @@ CatalogException Catalog::UnrecognizedConfigurationError(ClientContext &context,
 	// the setting is not in an extension
 	// get a list of all options
 	vector<string> potential_names = DBConfig::GetOptionNames();
-	for (auto &entry : DBConfig::GetConfig(context).extension_parameters) {
+	for (auto &entry : DBConfig::GetConfig(context).GetExtensionSettings()) {
 		potential_names.push_back(entry.first);
 	}
 	throw CatalogException::MissingEntry("configuration parameter", name, potential_names);
@@ -651,7 +652,7 @@ CatalogException Catalog::CreateMissingEntryException(CatalogEntryRetriever &ret
                                                       const reference_set_t<SchemaCatalogEntry> &schemas) {
 	auto &context = retriever.GetContext();
 	auto entries = SimilarEntriesInSchemas(context, lookup_info, schemas);
-	auto max_schema_count = DBConfig::GetSetting<CatalogErrorMaxSchemasSetting>(context);
+	auto max_schema_count = Settings::Get<CatalogErrorMaxSchemasSetting>(context);
 
 	reference_set_t<SchemaCatalogEntry> unseen_schemas;
 	auto &db_manager = DatabaseManager::Get(context);
@@ -1211,6 +1212,25 @@ optional_ptr<DependencyManager> Catalog::GetDependencyManager() {
 	return nullptr;
 }
 
+ErrorData Catalog::SupportsCreateTable(BoundCreateTableInfo &info) {
+	auto &base = info.Base().Cast<CreateTableInfo>();
+	if (!base.partition_keys.empty()) {
+		return ErrorData(
+		    ExceptionType::CATALOG,
+		    StringUtil::Format("PARTITIONED BY is not supported for tables in a %s catalog", GetCatalogType()));
+	}
+	if (!base.sort_keys.empty()) {
+		return ErrorData(ExceptionType::CATALOG,
+		                 StringUtil::Format("SORTED BY is not supported for tables in a %s catalog", GetCatalogType()));
+	}
+	if (!base.options.empty()) {
+		return ErrorData(
+		    ExceptionType::CATALOG,
+		    StringUtil::Format("WITH clause is not supported for tables in a %s catalog", GetCatalogType()));
+	}
+	return ErrorData();
+}
+
 string Catalog::GetDefaultSchema() const {
 	return DEFAULT_SCHEMA;
 }

src/duckdb/src/common/encryption_state.cpp

@@ -29,6 +29,8 @@ void EncryptionState::GenerateRandomData(data_ptr_t, idx_t) {
 	throw NotImplementedException("EncryptionState Abstract Class is called");
 }
 
+static constexpr EncryptionTypes::EncryptionVersion MAX_VERSION = EncryptionTypes::V0_1;
+
 string EncryptionTypes::CipherToString(CipherType cipher_p) {
 	switch (cipher_p) {
 	case GCM:
@@ -56,6 +58,17 @@ EncryptionTypes::CipherType EncryptionTypes::StringToCipher(const string &encryp
 	return INVALID;
 }
 
+EncryptionTypes::EncryptionVersion EncryptionTypes::StringToVersion(const string &encryption_version_p) {
+	if (encryption_version_p == "v0") {
+		return V0_0;
+	} else if (encryption_version_p == "v1") {
+		return V0_1;
+	} else {
+		throw NotImplementedException("No encryption version higher then v%d is supported yet in this DuckDB version",
+		                              MAX_VERSION);
+	}
+}
+
 string EncryptionTypes::KDFToString(KeyDerivationFunction kdf_p) {
 	switch (kdf_p) {
 	case SHA256: