Replace IOExceptions

Flogex · Flogex · commit 54204d5d62b7 · 2025-03-31T10:22:15.000+02:00
diff --git a/src/common/api_utils.cpp b/src/common/api_utils.cpp
@@ -1,7 +1,8 @@
 #include "api_utils.hpp"
-#include <sys/stat.h>
-#include "storage/irc_catalog.hpp"
 #include "credentials/credential_provider.hpp"
+#include "duckdb/common/exception/http_exception.hpp"
+#include "storage/irc_catalog.hpp"
+#include <sys/stat.h>
 
 namespace duckdb {
 
@@ -45,7 +46,7 @@ string APIUtils::GetRequest(ClientContext &context, const IRCEndpointBuilder &en
 		                 curl_easy_strerror(res));
 		if (res != CURLcode::CURLE_OK) {
 			string error = curl_easy_strerror(res);
-			throw IOException("Curl Request to '%s' failed with error: '%s'", url, error);
+			throw HTTPException("Curl Request to '%s' failed with error: '%s'", url, error);
 		}
 
 		return readBuffer;
@@ -116,8 +117,8 @@ string APIUtils::GetRequestAws(ClientContext &context, IRCEndpointBuilder endpoi
 	} else {
 		Aws::StringStream resBody;
 		resBody << res->GetResponseBody().rdbuf();
-		throw IOException("Failed to query %s, http error %d thrown. Message: %s", req->GetUri().GetURIString(true),
-		                  res->GetResponseCode(), resBody.str());
+		throw HTTPException("Failed to query %s, http error %d thrown. Message: %s", req->GetUri().GetURIString(true),
+		                    res->GetResponseCode(), resBody.str());
 	}
 }
 
@@ -177,7 +178,7 @@ string APIUtils::DeleteRequest(const string &url, const string &token, curl_slis
 
 		if (res != CURLcode::CURLE_OK) {
 			string error = curl_easy_strerror(res);
-			throw IOException("Curl DELETE Request to '%s' failed with error: '%s'", url, error);
+			throw HTTPException("Curl DELETE Request to '%s' failed with error: '%s'", url, error);
 		}
 
 		return readBuffer;
@@ -227,7 +228,7 @@ string APIUtils::PostRequest(ClientContext &context, const string &url, const st
 	                 curl_easy_strerror(res));
 	if (res != CURLcode::CURLE_OK) {
 		string error = curl_easy_strerror(res);
-		throw IOException("Curl Request to '%s' failed with error: '%s'", url, error);
+		throw HTTPException("Curl Request to '%s' failed with error: '%s'", url, error);
 	}
 	return readBuffer;
 }
diff --git a/src/common/iceberg.cpp b/src/common/iceberg.cpp
@@ -64,7 +64,7 @@ unique_ptr<SnapshotParseInfo> IcebergSnapshot::GetParseInfo(yyjson_doc &metadata
 	} else {
 		auto schema = yyjson_obj_get(root, "schema");
 		if (!schema) {
-			throw IOException("Neither a valid schema or schemas field was found");
+			throw InvalidInputException("Neither a valid schema or schemas field was found");
 		}
 		auto found_schema_id = IcebergUtils::TryGetNumFromObject(schema, "schema-id");
 		info.schemas.push_back(schema);
@@ -103,7 +103,7 @@ IcebergSnapshot IcebergSnapshot::GetSnapshotById(const string &path, FileSystem
 	auto snapshot = FindSnapshotByIdInternal(info->snapshots, snapshot_id);
 
 	if (!snapshot) {
-		throw IOException("Could not find snapshot with id " + to_string(snapshot_id));
+		throw InvalidInputException("Could not find snapshot with id " + to_string(snapshot_id));
 	}
 
 	return ParseSnapShot(snapshot, info->iceberg_version, info->schema_id, info->schemas, options);
@@ -115,7 +115,7 @@ IcebergSnapshot IcebergSnapshot::GetSnapshotByTimestamp(const string &path, File
 	auto snapshot = FindSnapshotByIdTimestampInternal(info->snapshots, timestamp);
 
 	if (!snapshot) {
-		throw IOException("Could not find latest snapshots for timestamp " + Timestamp::ToString(timestamp));
+		throw InvalidInputException("Could not find latest snapshots for timestamp " + Timestamp::ToString(timestamp));
 	}
 
 	return ParseSnapShot(snapshot, info->iceberg_version, info->schema_id, info->schemas, options);
@@ -138,7 +138,7 @@ static string GenerateMetaDataUrl(FileSystem &fs, const string &meta_path, strin
 		}
 	}
 
-	throw IOException(
+	throw InvalidInputException(
 	    "Iceberg metadata file not found for table version '%s' using '%s' compression and format(s): '%s'",
 	    table_version, options.metadata_compression_codec, options.version_name_format);
 }
@@ -171,7 +171,7 @@ string IcebergSnapshot::GetMetaDataPath(ClientContext &context, const string &pa
 	}
 	if (!UnsafeVersionGuessingEnabled(context)) {
 		// Make sure we're allowed to guess versions
-		throw IOException(
+		throw InvalidInputException(
 		    "Failed to read iceberg table. No version was provided and no version-hint could be found, globbing the "
 		    "filesystem to locate the latest version is disabled by default as this is considered unsafe and could "
 		    "result in reading uncommitted data. To enable this use 'SET %s = true;'",
@@ -195,7 +195,7 @@ IcebergSnapshot IcebergSnapshot::ParseSnapShot(yyjson_val *snapshot, idx_t icebe
 	if (snapshot) {
 		auto snapshot_tag = yyjson_get_type(snapshot);
 		if (snapshot_tag != YYJSON_TYPE_OBJ) {
-			throw IOException("Invalid snapshot field found parsing iceberg metadata.json");
+			throw InvalidInputException("Invalid snapshot field found parsing iceberg metadata.json");
 		}
 		ret.metadata_compression_codec = options.metadata_compression_codec;
 		if (iceberg_format_version == 1) {
@@ -226,9 +226,9 @@ string IcebergSnapshot::GetTableVersionFromHint(const string &meta_path, FileSys
 	try {
 		return version_file_content;
 	} catch (std::invalid_argument &e) {
-		throw IOException("Iceberg version hint file contains invalid value");
+		throw InvalidInputException("Iceberg version hint file contains invalid value");
 	} catch (std::out_of_range &e) {
-		throw IOException("Iceberg version hint file contains invalid value");
+		throw InvalidInputException("Iceberg version hint file contains invalid value");
 	}
 }
 
@@ -262,8 +262,8 @@ string IcebergSnapshot::GuessTableVersion(const string &meta_path, FileSystem &f
 		}
 	}
 
-	throw IOException("Could not guess Iceberg table version using '%s' compression and format(s): '%s'",
-	                  metadata_compression_codec, version_format);
+	throw InvalidInputException("Could not guess Iceberg table version using '%s' compression and format(s): '%s'",
+	                            metadata_compression_codec, version_format);
 }
 
 string IcebergSnapshot::PickTableVersion(vector<string> &found_metadata, string &version_pattern, string &glob) {
diff --git a/src/common/schema.cpp b/src/common/schema.cpp
@@ -63,13 +63,13 @@ static LogicalType ParseComplexType(yyjson_val *type) {
 	if (type_str == "map") {
 		return ParseMap(type);
 	}
-	throw IOException("Invalid field found while parsing field: type");
+	throw InvalidInputException("Invalid field found while parsing field: type");
 }
 
 static LogicalType ParseType(yyjson_val *type) {
 	auto val = yyjson_obj_get(type, "type");
 	if (!val) {
-		throw IOException("Invalid field found while parsing field: type");
+		throw InvalidInputException("Invalid field found while parsing field: type");
 	}
 	return ParseTypeValue(val);
 }
@@ -79,7 +79,7 @@ static LogicalType ParseTypeValue(yyjson_val *val) {
 		return ParseComplexType(val);
 	}
 	if (yyjson_get_type(val) != YYJSON_TYPE_STR) {
-		throw IOException("Invalid field found while parsing field: type");
+		throw InvalidInputException("Invalid field found while parsing field: type");
 	}
 	string type_str = yyjson_get_str(val);
 
@@ -136,7 +136,7 @@ static LogicalType ParseTypeValue(yyjson_val *val) {
 		auto scale = std::stoi(digits[1]);
 		return LogicalType::DECIMAL(width, scale);
 	}
-	throw IOException("Encountered an unrecognized type in JSON schema: \"%s\"", type_str);
+	throw InvalidInputException("Encountered an unrecognized type in JSON schema: \"%s\"", type_str);
 }
 
 IcebergColumnDefinition IcebergColumnDefinition::ParseFromJson(yyjson_val *val) {
@@ -155,7 +155,7 @@ static vector<IcebergColumnDefinition> ParseSchemaFromJson(yyjson_val *schema_js
 	// Assert that the top level 'type' is a struct
 	auto type_str = IcebergUtils::TryGetStrFromObject(schema_json, "type");
 	if (type_str != "struct") {
-		throw IOException("Schema in JSON Metadata is invalid");
+		throw InvalidInputException("Schema in JSON Metadata is invalid");
 	}
 	D_ASSERT(yyjson_get_type(schema_json) == YYJSON_TYPE_OBJ);
 	D_ASSERT(IcebergUtils::TryGetStrFromObject(schema_json, "type") == "struct");
@@ -180,7 +180,7 @@ vector<IcebergColumnDefinition> IcebergSnapshot::ParseSchema(vector<yyjson_val *
 		}
 	}
 
-	throw IOException("Iceberg schema with schema id " + to_string(schema_id) + " was not found!");
+	throw InvalidInputException("Iceberg schema with schema id " + to_string(schema_id) + " was not found!");
 }
 
 } // namespace duckdb
diff --git a/src/common/utils.cpp b/src/common/utils.cpp
@@ -32,29 +32,29 @@ string IcebergUtils::GetFullPath(const string &iceberg_path, const string &relat
 		return fs.JoinPath(iceberg_path, relative_file_path.substr(found + 1));
 	}
 
-	throw IOException("Did not recognize iceberg path");
+	throw InvalidInputException("Did not recognize iceberg path");
 }
 
 uint64_t IcebergUtils::TryGetNumFromObject(yyjson_val *obj, const string &field) {
 	auto val = yyjson_obj_getn(obj, field.c_str(), field.size());
 	if (!val || yyjson_get_type(val) != YYJSON_TYPE_NUM) {
-		throw IOException("Invalid field found while parsing field: " + field);
+		throw InvalidInputException("Invalid field found while parsing field: " + field);
 	}
 	return yyjson_get_uint(val);
 }
 
 bool IcebergUtils::TryGetBoolFromObject(yyjson_val *obj, const string &field) {
 	auto val = yyjson_obj_getn(obj, field.c_str(), field.size());
 	if (!val || yyjson_get_type(val) != YYJSON_TYPE_BOOL) {
-		throw IOException("Invalid field found while parsing field: " + field);
+		throw InvalidInputException("Invalid field found while parsing field: " + field);
 	}
 	return yyjson_get_bool(val);
 }
 
 string IcebergUtils::TryGetStrFromObject(yyjson_val *obj, const string &field) {
 	auto val = yyjson_obj_getn(obj, field.c_str(), field.size());
 	if (!val || yyjson_get_type(val) != YYJSON_TYPE_STR) {
-		throw IOException("Invalid field found while parsing field: " + field);
+		throw InvalidInputException("Invalid field found while parsing field: " + field);
 	}
 	return yyjson_get_str(val);
 }
@@ -67,7 +67,7 @@ static TYPE TemplatedTryGetYYJson(yyjson_val *obj, const string &field, TYPE def
 	} else if (!fail_on_missing) {
 		return default_val;
 	}
-	throw IOException("Invalid field found while parsing field: " + field);
+	throw InvalidInputException("Invalid field found while parsing field: " + field);
 }
 
 uint64_t IcebergUtils::TryGetNumFromObject(yyjson_val *obj, const string &field, bool fail_on_missing,
diff --git a/src/iceberg_extension.cpp b/src/iceberg_extension.cpp
@@ -64,13 +64,14 @@ static bool SanityCheckGlueWarehouse(string warehouse) {
 	auto bucket_sep = warehouse.find_first_of('/');
 	bool bucket_sep_correct = bucket_sep == 28;
 	if (!account_id_correct) {
-		throw IOException("Invalid Glue Catalog Format: '" + warehouse + "'. Expect 12 digits for account_id.");
+		throw InvalidInputException("Invalid Glue Catalog Format: '" + warehouse +
+		                            "'. Expect 12 digits for account_id.");
 	}
 	if (bucket_sep_correct) {
 		return true;
 	}
-	throw IOException("Invalid Glue Catalog Format: '" + warehouse +
-	                  "'. Expected '<account_id>:s3tablescatalog/<bucket>");
+	throw InvalidInputException("Invalid Glue Catalog Format: '" + warehouse +
+	                            "'. Expected '<account_id>:s3tablescatalog/<bucket>");
 }
 
 static unique_ptr<Catalog> IcebergCatalogAttach(StorageExtensionInfo *storage_info, ClientContext &context,
@@ -120,8 +121,8 @@ static unique_ptr<Catalog> IcebergCatalogAttach(StorageExtensionInfo *storage_in
 		auto region = kv_secret.TryGetValue("region");
 
 		if (region.IsNull()) {
-			throw IOException("Assumed catalog secret " + secret_entry->secret->GetName() + " for catalog " + name +
-			                  " does not have a region");
+			throw InvalidInputException("Assumed catalog secret " + secret_entry->secret->GetName() + " for catalog " +
+			                            name + " does not have a region");
 		}
 		switch (catalog_type) {
 		case ICEBERG_CATALOG_TYPE::AWS_S3TABLES: {
@@ -137,7 +138,7 @@ static unique_ptr<Catalog> IcebergCatalogAttach(StorageExtensionInfo *storage_in
 			SanityCheckGlueWarehouse(warehouse);
 			break;
 		default:
-			throw IOException("Unsupported AWS catalog type");
+			throw NotImplementedException("Unsupported AWS catalog type");
 		}
 
 		auto catalog_host = service + "." + region.ToString() + ".amazonaws.com";
@@ -149,10 +150,11 @@ static unique_ptr<Catalog> IcebergCatalogAttach(StorageExtensionInfo *storage_in
 
 	// Check no endpoint type has been passed.
 	if (!endpoint_type.empty()) {
-		throw IOException("Unrecognized endpoint point: %s. Expected either S3_TABLES or GLUE", endpoint_type);
+		throw InvalidInputException("Unrecognized endpoint point: %s. Expected either S3_TABLES or GLUE",
+		                            endpoint_type);
 	}
 	if (endpoint_type.empty() && endpoint.empty()) {
-		throw IOException("No endpoint type or endpoint provided");
+		throw InvalidInputException("No endpoint type or endpoint provided");
 	}
 
 	catalog_type = ICEBERG_CATALOG_TYPE::OTHER;
@@ -162,7 +164,7 @@ static unique_ptr<Catalog> IcebergCatalogAttach(StorageExtensionInfo *storage_in
 	// if no secret is referenced, this throw
 	auto secret_entry = IRCatalog::GetSecret(context, secret_name);
 	if (!secret_entry) {
-		throw IOException("No secret found to use with catalog " + name);
+		throw InvalidConfigurationException("No secret found to use with catalog " + name);
 	}
 	// secret found - read data
 	const auto &kv_secret = dynamic_cast<const KeyValueSecret &>(*secret_entry->secret);
diff --git a/src/iceberg_functions/iceberg_multi_file_reader.cpp b/src/iceberg_functions/iceberg_multi_file_reader.cpp
@@ -313,7 +313,7 @@ void IcebergMultiFileReader::CreateColumnMapping(const string &file_name,
 		// Lookup the required column in the local map
 		auto entry = name_map.find("file_row_number");
 		if (entry == name_map.end()) {
-			throw IOException("Failed to find the file_row_number column");
+			throw InvalidInputException("Failed to find the file_row_number column");
 		}
 
 		// Register the column to be scanned from this file
diff --git a/src/include/iceberg_types.hpp b/src/include/iceberg_types.hpp
@@ -27,7 +27,7 @@ static string IcebergManifestContentTypeToString(IcebergManifestContentType type
 	case IcebergManifestContentType::DELETE:
 		return "DELETE";
 	default:
-		throw IOException("Invalid Manifest Content Type");
+		throw InvalidInputException("Invalid Manifest Content Type");
 	}
 }
 
@@ -42,7 +42,7 @@ static string IcebergManifestEntryStatusTypeToString(IcebergManifestEntryStatusT
 	case IcebergManifestEntryStatusType::DELETED:
 		return "DELETED";
 	default:
-		throw IOException("Invalid matifest entry type");
+		throw InvalidInputException("Invalid matifest entry type");
 	}
 }
 
@@ -57,7 +57,7 @@ static string IcebergManifestEntryContentTypeToString(IcebergManifestEntryConten
 	case IcebergManifestEntryContentType::EQUALITY_DELETES:
 		return "EQUALITY_DELETES";
 	default:
-		throw IOException("Invalid Manifest Entry Content Type");
+		throw InvalidInputException("Invalid Manifest Entry Content Type");
 	}
 }
 
diff --git a/src/storage/irc_catalog.cpp b/src/storage/irc_catalog.cpp
@@ -168,14 +168,14 @@ unique_ptr<SecretEntry> IRCatalog::GetSecret(ClientContext &context, const strin
 	if (!secret_entry) {
 		auto secret_match = context.db->GetSecretManager().LookupSecret(transaction, "s3://", "s3");
 		if (!secret_match.HasMatch()) {
-			throw IOException("Failed to find a secret and no explicit secret was passed!");
+			throw InvalidConfigurationException("Failed to find a secret and no explicit secret was passed!");
 		}
 		secret_entry = std::move(secret_match.secret_entry);
 	}
 	if (secret_entry) {
 		return secret_entry;
 	}
-	throw IOException("Could not find valid Iceberg secret");
+	throw InvalidConfigurationException("Could not find valid Iceberg secret");
 }
 
 unique_ptr<PhysicalOperator> IRCatalog::PlanInsert(ClientContext &context, LogicalInsert &op,

Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ unique_ptr<SnapshotParseInfo> IcebergSnapshot::GetParseInfo(yyjson_doc &metadata`
`64`	`64`	`} else {`
`65`	`65`	`auto schema = yyjson_obj_get(root, "schema");`
`66`	`66`	`if (!schema) {`
`67`		`- throw IOException("Neither a valid schema or schemas field was found");`
	`67`	`+ throw InvalidInputException("Neither a valid schema or schemas field was found");`
`68`	`68`	`}`
`69`	`69`	`auto found_schema_id = IcebergUtils::TryGetNumFromObject(schema, "schema-id");`
`70`	`70`	`info.schemas.push_back(schema);`
`@@ -103,7 +103,7 @@ IcebergSnapshot IcebergSnapshot::GetSnapshotById(const string &path, FileSystem`
`103`	`103`	`auto snapshot = FindSnapshotByIdInternal(info->snapshots, snapshot_id);`
`104`	`104`
`105`	`105`	`if (!snapshot) {`
`106`		`- throw IOException("Could not find snapshot with id " + to_string(snapshot_id));`
	`106`	`+ throw InvalidInputException("Could not find snapshot with id " + to_string(snapshot_id));`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`return ParseSnapShot(snapshot, info->iceberg_version, info->schema_id, info->schemas, options);`
`@@ -115,7 +115,7 @@ IcebergSnapshot IcebergSnapshot::GetSnapshotByTimestamp(const string &path, File`
`115`	`115`	`auto snapshot = FindSnapshotByIdTimestampInternal(info->snapshots, timestamp);`
`116`	`116`
`117`	`117`	`if (!snapshot) {`
`118`		`- throw IOException("Could not find latest snapshots for timestamp " + Timestamp::ToString(timestamp));`
	`118`	`+ throw InvalidInputException("Could not find latest snapshots for timestamp " + Timestamp::ToString(timestamp));`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`return ParseSnapShot(snapshot, info->iceberg_version, info->schema_id, info->schemas, options);`
`@@ -138,7 +138,7 @@ static string GenerateMetaDataUrl(FileSystem &fs, const string &meta_path, strin`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`
`141`		`- throw IOException(`
	`141`	`+ throw InvalidInputException(`
`142`	`142`	`"Iceberg metadata file not found for table version '%s' using '%s' compression and format(s): '%s'",`
`143`	`143`	`table_version, options.metadata_compression_codec, options.version_name_format);`
`144`	`144`	`}`
`@@ -171,7 +171,7 @@ string IcebergSnapshot::GetMetaDataPath(ClientContext &context, const string &pa`
`171`	`171`	`}`
`172`	`172`	`if (!UnsafeVersionGuessingEnabled(context)) {`
`173`	`173`	`// Make sure we're allowed to guess versions`
`174`		`- throw IOException(`
	`174`	`+ throw InvalidInputException(`
`175`	`175`	`"Failed to read iceberg table. No version was provided and no version-hint could be found, globbing the "`
`176`	`176`	`"filesystem to locate the latest version is disabled by default as this is considered unsafe and could "`
`177`	`177`	`"result in reading uncommitted data. To enable this use 'SET %s = true;'",`
`@@ -195,7 +195,7 @@ IcebergSnapshot IcebergSnapshot::ParseSnapShot(yyjson_val *snapshot, idx_t icebe`
`195`	`195`	`if (snapshot) {`
`196`	`196`	`auto snapshot_tag = yyjson_get_type(snapshot);`
`197`	`197`	`if (snapshot_tag != YYJSON_TYPE_OBJ) {`
`198`		`- throw IOException("Invalid snapshot field found parsing iceberg metadata.json");`
	`198`	`+ throw InvalidInputException("Invalid snapshot field found parsing iceberg metadata.json");`
`199`	`199`	`}`
`200`	`200`	`ret.metadata_compression_codec = options.metadata_compression_codec;`
`201`	`201`	`if (iceberg_format_version == 1) {`
`@@ -226,9 +226,9 @@ string IcebergSnapshot::GetTableVersionFromHint(const string &meta_path, FileSys`
`226`	`226`	`try {`
`227`	`227`	`return version_file_content;`
`228`	`228`	`} catch (std::invalid_argument &e) {`
`229`		`- throw IOException("Iceberg version hint file contains invalid value");`
	`229`	`+ throw InvalidInputException("Iceberg version hint file contains invalid value");`
`230`	`230`	`} catch (std::out_of_range &e) {`
`231`		`- throw IOException("Iceberg version hint file contains invalid value");`
	`231`	`+ throw InvalidInputException("Iceberg version hint file contains invalid value");`
`232`	`232`	`}`
`233`	`233`	`}`
`234`	`234`
`@@ -262,8 +262,8 @@ string IcebergSnapshot::GuessTableVersion(const string &meta_path, FileSystem &f`
`262`	`262`	`}`
`263`	`263`	`}`
`264`	`264`
`265`		`- throw IOException("Could not guess Iceberg table version using '%s' compression and format(s): '%s'",`
`266`		`- metadata_compression_codec, version_format);`
	`265`	`+ throw InvalidInputException("Could not guess Iceberg table version using '%s' compression and format(s): '%s'",`
	`266`	`+ metadata_compression_codec, version_format);`
`267`	`267`	`}`
`268`	`268`
`269`	`269`	`string IcebergSnapshot::PickTableVersion(vector<string> &found_metadata, string &version_pattern, string &glob) {`
Original file line number	Diff line number	Diff line change
`@@ -63,13 +63,13 @@ static LogicalType ParseComplexType(yyjson_val *type) {`
`63`	`63`	`if (type_str == "map") {`
`64`	`64`	`return ParseMap(type);`
`65`	`65`	`}`
`66`		`- throw IOException("Invalid field found while parsing field: type");`
	`66`	`+ throw InvalidInputException("Invalid field found while parsing field: type");`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`static LogicalType ParseType(yyjson_val *type) {`
`70`	`70`	`auto val = yyjson_obj_get(type, "type");`
`71`	`71`	`if (!val) {`
`72`		`- throw IOException("Invalid field found while parsing field: type");`
	`72`	`+ throw InvalidInputException("Invalid field found while parsing field: type");`
`73`	`73`	`}`
`74`	`74`	`return ParseTypeValue(val);`
`75`	`75`	`}`
`@@ -79,7 +79,7 @@ static LogicalType ParseTypeValue(yyjson_val *val) {`
`79`	`79`	`return ParseComplexType(val);`
`80`	`80`	`}`
`81`	`81`	`if (yyjson_get_type(val) != YYJSON_TYPE_STR) {`
`82`		`- throw IOException("Invalid field found while parsing field: type");`
	`82`	`+ throw InvalidInputException("Invalid field found while parsing field: type");`
`83`	`83`	`}`
`84`	`84`	`string type_str = yyjson_get_str(val);`
`85`	`85`
`@@ -136,7 +136,7 @@ static LogicalType ParseTypeValue(yyjson_val *val) {`
`136`	`136`	`auto scale = std::stoi(digits[1]);`
`137`	`137`	`return LogicalType::DECIMAL(width, scale);`
`138`	`138`	`}`
`139`		`- throw IOException("Encountered an unrecognized type in JSON schema: \"%s\"", type_str);`
	`139`	`+ throw InvalidInputException("Encountered an unrecognized type in JSON schema: \"%s\"", type_str);`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`IcebergColumnDefinition IcebergColumnDefinition::ParseFromJson(yyjson_val *val) {`
`@@ -155,7 +155,7 @@ static vector<IcebergColumnDefinition> ParseSchemaFromJson(yyjson_val *schema_js`
`155`	`155`	`// Assert that the top level 'type' is a struct`
`156`	`156`	`auto type_str = IcebergUtils::TryGetStrFromObject(schema_json, "type");`
`157`	`157`	`if (type_str != "struct") {`
`158`		`- throw IOException("Schema in JSON Metadata is invalid");`
	`158`	`+ throw InvalidInputException("Schema in JSON Metadata is invalid");`
`159`	`159`	`}`
`160`	`160`	`D_ASSERT(yyjson_get_type(schema_json) == YYJSON_TYPE_OBJ);`
`161`	`161`	`D_ASSERT(IcebergUtils::TryGetStrFromObject(schema_json, "type") == "struct");`
`@@ -180,7 +180,7 @@ vector<IcebergColumnDefinition> IcebergSnapshot::ParseSchema(vector<yyjson_val *`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`
`183`		`- throw IOException("Iceberg schema with schema id " + to_string(schema_id) + " was not found!");`
	`183`	`+ throw InvalidInputException("Iceberg schema with schema id " + to_string(schema_id) + " was not found!");`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`} // namespace duckdb`
Original file line number	Diff line number	Diff line change
`@@ -32,29 +32,29 @@ string IcebergUtils::GetFullPath(const string &iceberg_path, const string &relat`
`32`	`32`	`return fs.JoinPath(iceberg_path, relative_file_path.substr(found + 1));`
`33`	`33`	`}`
`34`	`34`
`35`		`- throw IOException("Did not recognize iceberg path");`
	`35`	`+ throw InvalidInputException("Did not recognize iceberg path");`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`uint64_t IcebergUtils::TryGetNumFromObject(yyjson_val *obj, const string &field) {`
`39`	`39`	`auto val = yyjson_obj_getn(obj, field.c_str(), field.size());`
`40`	`40`	`if (!val \|\| yyjson_get_type(val) != YYJSON_TYPE_NUM) {`
`41`		`- throw IOException("Invalid field found while parsing field: " + field);`
	`41`	`+ throw InvalidInputException("Invalid field found while parsing field: " + field);`
`42`	`42`	`}`
`43`	`43`	`return yyjson_get_uint(val);`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`bool IcebergUtils::TryGetBoolFromObject(yyjson_val *obj, const string &field) {`
`47`	`47`	`auto val = yyjson_obj_getn(obj, field.c_str(), field.size());`
`48`	`48`	`if (!val \|\| yyjson_get_type(val) != YYJSON_TYPE_BOOL) {`
`49`		`- throw IOException("Invalid field found while parsing field: " + field);`
	`49`	`+ throw InvalidInputException("Invalid field found while parsing field: " + field);`
`50`	`50`	`}`
`51`	`51`	`return yyjson_get_bool(val);`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`string IcebergUtils::TryGetStrFromObject(yyjson_val *obj, const string &field) {`
`55`	`55`	`auto val = yyjson_obj_getn(obj, field.c_str(), field.size());`
`56`	`56`	`if (!val \|\| yyjson_get_type(val) != YYJSON_TYPE_STR) {`
`57`		`- throw IOException("Invalid field found while parsing field: " + field);`
	`57`	`+ throw InvalidInputException("Invalid field found while parsing field: " + field);`
`58`	`58`	`}`
`59`	`59`	`return yyjson_get_str(val);`
`60`	`60`	`}`
`@@ -67,7 +67,7 @@ static TYPE TemplatedTryGetYYJson(yyjson_val *obj, const string &field, TYPE def`
`67`	`67`	`} else if (!fail_on_missing) {`
`68`	`68`	`return default_val;`
`69`	`69`	`}`
`70`		`- throw IOException("Invalid field found while parsing field: " + field);`
	`70`	`+ throw InvalidInputException("Invalid field found while parsing field: " + field);`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`uint64_t IcebergUtils::TryGetNumFromObject(yyjson_val *obj, const string &field, bool fail_on_missing,`
Original file line number	Diff line number	Diff line change
`@@ -313,7 +313,7 @@ void IcebergMultiFileReader::CreateColumnMapping(const string &file_name,`
`313`	`313`	`// Lookup the required column in the local map`
`314`	`314`	`auto entry = name_map.find("file_row_number");`
`315`	`315`	`if (entry == name_map.end()) {`
`316`		`- throw IOException("Failed to find the file_row_number column");`
	`316`	`+ throw InvalidInputException("Failed to find the file_row_number column");`
`317`	`317`	`}`
`318`	`318`
`319`	`319`	`// Register the column to be scanned from this file`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ static string IcebergManifestContentTypeToString(IcebergManifestContentType type`
`27`	`27`	`case IcebergManifestContentType::DELETE:`
`28`	`28`	`return "DELETE";`
`29`	`29`	`default:`
`30`		`- throw IOException("Invalid Manifest Content Type");`
	`30`	`+ throw InvalidInputException("Invalid Manifest Content Type");`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`
`@@ -42,7 +42,7 @@ static string IcebergManifestEntryStatusTypeToString(IcebergManifestEntryStatusT`
`42`	`42`	`case IcebergManifestEntryStatusType::DELETED:`
`43`	`43`	`return "DELETED";`
`44`	`44`	`default:`
`45`		`- throw IOException("Invalid matifest entry type");`
	`45`	`+ throw InvalidInputException("Invalid matifest entry type");`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`@@ -57,7 +57,7 @@ static string IcebergManifestEntryContentTypeToString(IcebergManifestEntryConten`
`57`	`57`	`case IcebergManifestEntryContentType::EQUALITY_DELETES:`
`58`	`58`	`return "EQUALITY_DELETES";`
`59`	`59`	`default:`
`60`		`- throw IOException("Invalid Manifest Entry Content Type");`
	`60`	`+ throw InvalidInputException("Invalid Manifest Entry Content Type");`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
Original file line number	Diff line number	Diff line change
`@@ -168,14 +168,14 @@ unique_ptr<SecretEntry> IRCatalog::GetSecret(ClientContext &context, const strin`
`168`	`168`	`if (!secret_entry) {`
`169`	`169`	`auto secret_match = context.db->GetSecretManager().LookupSecret(transaction, "s3://", "s3");`
`170`	`170`	`if (!secret_match.HasMatch()) {`
`171`		`- throw IOException("Failed to find a secret and no explicit secret was passed!");`
	`171`	`+ throw InvalidConfigurationException("Failed to find a secret and no explicit secret was passed!");`
`172`	`172`	`}`
`173`	`173`	`secret_entry = std::move(secret_match.secret_entry);`
`174`	`174`	`}`
`175`	`175`	`if (secret_entry) {`
`176`	`176`	`return secret_entry;`
`177`	`177`	`}`
`178`		`- throw IOException("Could not find valid Iceberg secret");`
	`178`	`+ throw InvalidConfigurationException("Could not find valid Iceberg secret");`
`179`	`179`	`}`
`180`	`180`
`181`	`181`	`unique_ptr<PhysicalOperator> IRCatalog::PlanInsert(ClientContext &context, LogicalInsert &op,`