f Avoid allocating msg strings

Author: tnull

src/io/sqlite_store.rs

@@ -68,7 +68,6 @@ impl KVStore for SqliteStore {
 		let sql =
 			format!("SELECT value FROM {} WHERE namespace=:namespace AND key=:key;", KV_TABLE_NAME);
 
-		let msg = format!("Failed to read from key: {}/{}", namespace, key);
 		let res = self
 			.connection
 			.lock()
@@ -81,23 +80,25 @@ impl KVStore for SqliteStore {
 				},
 				|row| row.get(0),
 			)
-			.map_err(|_| std::io::Error::new(std::io::ErrorKind::NotFound, msg))?;
+			.map_err(|_| {
+				let msg = format!("Failed to read from key: {}/{}", namespace, key);
+				std::io::Error::new(std::io::ErrorKind::NotFound, msg)
+			})?;
 		Ok(Cursor::new(res))
 	}
 
 	fn write(&self, namespace: &str, key: &str, buf: &[u8]) -> std::io::Result<()> {
 		let mut locked_conn = self.connection.lock().unwrap();
 
-		let msg = format!("Failed to start transaction");
-		let sql_tx = locked_conn
-			.transaction()
-			.map_err(|_| std::io::Error::new(std::io::ErrorKind::Other, msg))?;
+		let sql_tx = locked_conn.transaction().map_err(|_| {
+			let msg = format!("Failed to start transaction");
+			std::io::Error::new(std::io::ErrorKind::Other, msg)
+		})?;
 
 		let sql = format!(
 			"INSERT OR REPLACE INTO {} (namespace, key, value) VALUES (:namespace, :key, :data);",
 			KV_TABLE_NAME
 		);
-		let msg = format!("Failed to write to key: {}/{}", namespace, key);
 		sql_tx
 			.execute(
 				&sql,
@@ -107,17 +108,21 @@ impl KVStore for SqliteStore {
 					":data": buf,
 				},
 			)
-			.map_err(|_| std::io::Error::new(std::io::ErrorKind::Other, msg))?;
-
-		let msg = format!("Failed to commit transaction");
-		sql_tx.commit().map_err(|_| std::io::Error::new(std::io::ErrorKind::Other, msg))?;
+			.map_err(|_| {
+				let msg = format!("Failed to write to key: {}/{}", namespace, key);
+				std::io::Error::new(std::io::ErrorKind::Other, msg)
+			})?;
+
+		sql_tx.commit().map_err(|_| {
+			let msg = format!("Failed to commit transaction");
+			std::io::Error::new(std::io::ErrorKind::Other, msg)
+		})?;
 
 		Ok(())
 	}
 
 	fn remove(&self, namespace: &str, key: &str) -> std::io::Result<bool> {
 		let sql = format!("DELETE FROM {} WHERE namespace=:namespace AND key=:key;", KV_TABLE_NAME);
-		let msg = format!("Failed to delete key: {}/{}", namespace, key);
 		let changes = self
 			.connection
 			.lock()
@@ -129,7 +134,10 @@ impl KVStore for SqliteStore {
 					":key": key,
 				},
 			)
-			.map_err(|_| std::io::Error::new(std::io::ErrorKind::Other, msg))?;
+			.map_err(|_| {
+				let msg = format!("Failed to delete key: {}/{}", namespace, key);
+				std::io::Error::new(std::io::ErrorKind::Other, msg)
+			})?;
 
 		let was_present = changes != 0;
 
@@ -140,21 +148,25 @@ impl KVStore for SqliteStore {
 		let locked_conn = self.connection.lock().unwrap();
 
 		let sql = format!("SELECT key FROM {} WHERE namespace=:namespace", KV_TABLE_NAME);
-		let msg = format!("Failed to prepare statement");
-		let mut stmt = locked_conn
-			.prepare(&sql)
-			.map_err(|_| std::io::Error::new(std::io::ErrorKind::Other, msg))?;
+		let mut stmt = locked_conn.prepare(&sql).map_err(|_| {
+			let msg = format!("Failed to prepare statement");
+			std::io::Error::new(std::io::ErrorKind::Other, msg)
+		})?;
 
 		let mut keys = Vec::new();
 
-		let msg = format!("Failed to retrieve queried rows");
 		let rows_iter = stmt
 			.query_map(named_params! {":namespace": namespace, }, |row| row.get(0))
-			.map_err(|_| std::io::Error::new(std::io::ErrorKind::Other, msg))?;
+			.map_err(|_| {
+				let msg = format!("Failed to retrieve queried rows");
+				std::io::Error::new(std::io::ErrorKind::Other, msg)
+			})?;
 
 		for k in rows_iter {
-			let msg = format!("Failed to retrieve queried rows");
-			keys.push(k.map_err(|_| std::io::Error::new(std::io::ErrorKind::Other, msg))?);
+			keys.push(k.map_err(|_| {
+				let msg = format!("Failed to retrieve queried rows");
+				std::io::Error::new(std::io::ErrorKind::Other, msg)
+			})?);
 		}
 
 		Ok(keys)
@@ -163,20 +175,21 @@ impl KVStore for SqliteStore {
 
 impl KVStorePersister for SqliteStore {
 	fn persist<W: Writeable>(&self, prefixed_key: &str, object: &W) -> lightning::io::Result<()> {
-		let msg = format!("Could not persist file for key {}.", prefixed_key);
 		let dest_file_path = PathBuf::from_str(prefixed_key).map_err(|_| {
-			lightning::io::Error::new(lightning::io::ErrorKind::InvalidInput, msg.clone())
+			let msg = format!("Could not persist file for key {}.", prefixed_key);
+			lightning::io::Error::new(lightning::io::ErrorKind::InvalidInput, msg)
 		})?;
 
-		let parent_directory = dest_file_path.parent().ok_or(lightning::io::Error::new(
-			lightning::io::ErrorKind::InvalidInput,
-			msg.clone(),
-		))?;
+		let parent_directory = dest_file_path.parent().ok_or_else(|| {
+			let msg = format!("Could not persist file for key {}.", prefixed_key);
+			lightning::io::Error::new(lightning::io::ErrorKind::InvalidInput, msg)
+		})?;
 		let namespace = parent_directory.display().to_string();
 
-		let dest_without_namespace = dest_file_path
-			.strip_prefix(&namespace)
-			.map_err(|_| lightning::io::Error::new(lightning::io::ErrorKind::InvalidInput, msg))?;
+		let dest_without_namespace = dest_file_path.strip_prefix(&namespace).map_err(|_| {
+			let msg = format!("Could not persist file for key {}.", prefixed_key);
+			lightning::io::Error::new(lightning::io::ErrorKind::InvalidInput, msg)
+		})?;
 		let key = dest_without_namespace.display().to_string();
 
 		self.write(&namespace, &key, &object.encode())?;