Database: more flexible get_variants()

This change moves prune-trace's --variants-exclude / --benchmarks-exclude
capabilities to Database::get_variants() to make it available to all users.

Change-Id: Icbc6bb1a3ae7c846d2de40b881f47a9cc1ed7bbf

src/core/util/Database.cc

@@ -141,34 +141,81 @@ my_ulonglong Database::insert_id()
 	return mysql_insert_id(handle);
 }
 
-std::vector<Database::Variant> Database::get_variants(const std::string &variant, const std::string &benchmark) {
+bool Database::create_variants_table()
-	std::vector<Variant> result;
+{
-
 	if (!query("CREATE TABLE IF NOT EXISTS variant ("
-		  "	 id int(11) NOT NULL AUTO_INCREMENT,"
+		"      id int(11) NOT NULL AUTO_INCREMENT,"
-		  "	 variant varchar(255) NOT NULL,"
+		"      variant varchar(255) NOT NULL,"
-		  "	 benchmark varchar(255) NOT NULL,"
+		"      benchmark varchar(255) NOT NULL,"
-		  "	 PRIMARY KEY (id),"
+		"      PRIMARY KEY (id),"
-		  "UNIQUE KEY variant (variant,benchmark)) ENGINE=MyISAM")) {
+		"UNIQUE KEY variant (variant,benchmark)) ENGINE=MyISAM")) {
+		return false;
+	}
+	return true;
+}
+
+std::vector<Database::Variant> Database::get_variants(const std::string &variant, const std::string &benchmark)
+{
+	std::vector<std::string> variants;
+	variants.push_back(variant);
+	std::vector<std::string> benchmarks;
+	benchmarks.push_back(benchmark);
+	std::vector<std::string> dummy;
+
+	return get_variants(variants, dummy, benchmarks, dummy);
+}
+
+std::vector<Database::Variant> Database::get_variants(
+	const std::vector<std::string>& variants,
+	const std::vector<std::string>& variants_exclude,
+	const std::vector<std::string>& benchmarks,
+	const std::vector<std::string>& benchmarks_exclude)
+{
+	std::vector<Variant> result;
+	std::stringstream ss;
+
+	// make sure variant table exists
+	if (!create_variants_table()) {
 		return result;
 	}
 
-	std::stringstream ss;
+	// FIXME string escaping
-	// FIXME SQL injection possible
+	ss << "SELECT id, variant, benchmark FROM variant WHERE ";
-	ss << "SELECT id, variant, benchmark FROM variant WHERE variant LIKE '" << variant << "' AND benchmark LIKE '" << benchmark << "'";
+	ss << "(";
-	MYSQL_RES *variant_id_res = query(ss.str().c_str(), true);
+	for (std::vector<std::string>::const_iterator it = variants.begin();
+	     it != variants.end(); ++it) {
+		ss << "variant LIKE '" << *it << "' OR ";
+	}
+	ss << "0) AND (";
+	for (std::vector<std::string>::const_iterator it = benchmarks.begin();
+	     it != benchmarks.end(); ++it) {
+		ss << "benchmark LIKE '" << *it << "' OR ";
+	}
+	// dummy terminator to avoid special cases in query construction above
+	ss << "0) AND NOT (";
+	for (std::vector<std::string>::const_iterator it = variants_exclude.begin();
+	     it != variants_exclude.end(); ++it) {
+		ss << "variant LIKE '" << *it << "' OR ";
+	}
+	for (std::vector<std::string>::const_iterator it = benchmarks_exclude.begin();
+	     it != benchmarks_exclude.end(); ++it) {
+		ss << "benchmark LIKE '" << *it << "' OR ";
+	}
+	// dummy terminator to avoid special cases in query construction above
+	ss << "0)";
 
+	MYSQL_RES *variant_id_res = query(ss.str().c_str(), true);
 	if (!variant_id_res) {
 		return result;
-	} else if (mysql_num_rows(variant_id_res)) {
+	}
-		for (unsigned int i = 0; i < mysql_num_rows(variant_id_res); ++i) {
+
-			MYSQL_ROW row = mysql_fetch_row(variant_id_res);
+	MYSQL_ROW row;
-			Variant var;
+	while ((row = mysql_fetch_row(variant_id_res))) {
-			var.id = atoi(row[0]);
+		Variant var;
-			var.variant = std::string(row[1]);
+		var.id = atoi(row[0]);
-			var.benchmark = std::string(row[2]);
+		var.variant = row[1];
-			result.push_back(var);
+		var.benchmark = row[2];
-		}
+		result.push_back(var);
 	}
 
 	return result;

src/core/util/Database.hpp

@@ -54,6 +54,16 @@ namespace fail {
 		 */
 		std::vector<Variant> get_variants(const std::string &variant, const std::string &benchmark);
 
+		/**
+		 * Get all variants that fit one of the variant, one of the benchmark,
+		 * and none of the variant/benchmark exclude patterns (will be queried
+		 * with SQL LIKE).
+		 */
+		std::vector<Variant> get_variants(
+			const std::vector<std::string>& variants,
+			const std::vector<std::string>& variants_exclude,
+			const std::vector<std::string>& benchmarks,
+			const std::vector<std::string>& benchmarks_exclude);
 
 		/**
 		 * Get the fault space pruning method id for a specific
@@ -113,6 +123,9 @@ namespace fail {
 		 */
 		static void cmdline_setup();
 		static Database * cmdline_connect();
+
+	private:
+		bool create_variants_table();
 	};
 
 }

tools/prune-trace/BasicPruner.cc

@@ -19,22 +19,21 @@ bool BasicPruner::prune_all() {
 		  "SELECT 0, variant_id, instr2, " << injection_instr << ", " << injection_instr_absolute << ", "
 		  "  data_address, width, " << m_method_id << " "
 		  "FROM trace "
-		  "WHERE variant_id IN (" << m_variant_id_query << ") AND accesstype = 'R'";
+		  "WHERE variant_id IN (" << m_variants_sql << ") AND accesstype = 'R'";
 	if (!db->query(ss.str().c_str())) return false;
 	ss.str("");
 
 	int rows = db->affected_rows();
 
 	// for each variant:
-	MYSQL_RES *res = db->query(m_variant_id_query.c_str(), true);
+	for (std::vector<fail::Database::Variant>::const_iterator it = m_variants.begin();
-	MYSQL_ROW row;
+		it != m_variants.end(); ++it) {
-	while ((row = mysql_fetch_row(res))) {
 		// single entry for known outcome (write access)
 		ss << "INSERT INTO fsppilot (known_outcome, variant_id, instr2, injection_instr, injection_instr_absolute, data_address, data_width, fspmethod_id) "
 			  "SELECT 1, variant_id, instr2, " << injection_instr << ", " << injection_instr_absolute << ", "
 			  "  data_address, width, " << m_method_id << " "
 			  "FROM trace "
-			  "WHERE variant_id = " << row[0] << " AND accesstype = 'W' "
+			  "WHERE variant_id = " << it->id << " AND accesstype = 'W' "
 			  "ORDER BY instr2 ASC "
 			  "LIMIT 1";
 		if (!db->query(ss.str().c_str())) return false;
@@ -50,7 +49,7 @@ bool BasicPruner::prune_all() {
 	   << "JOIN trace t ON t.variant_id = p.variant_id AND t.instr2 = p.instr2"
 	   << "            AND t.data_address = p.data_address "
 	   << "WHERE known_outcome = 0 AND p.fspmethod_id = " << m_method_id << " "
-	   << "AND p.variant_id IN (" << m_variant_id_query << ")";
+	   << "AND p.variant_id IN (" << m_variants_sql << ")";
 
 	if (!db->query(ss.str().c_str())) return false;
 	ss.str("");
@@ -61,7 +60,7 @@ bool BasicPruner::prune_all() {
 		"FROM fsppilot p "
 		"JOIN trace t "
 		"ON t.variant_id = p.variant_id AND p.fspmethod_id = " << m_method_id << " AND p.known_outcome = 1 "
-		"WHERE t.variant_id IN (" << m_variant_id_query << ") AND t.accesstype = 'W'";
+		"WHERE t.variant_id IN (" << m_variants_sql << ") AND t.accesstype = 'W'";
 	if (!db->query(ss.str().c_str())) return false;
 	ss.str("");
 	rows += db->affected_rows();

tools/prune-trace/Pruner.cc

@@ -15,29 +15,24 @@ bool Pruner::init(fail::Database *db,
 		const std::vector<std::string>& benchmarks_exclude)
 {
 	this->db = db;
-	std::stringstream ss;
 
-	// FIXME string escaping
+	m_variants = db->get_variants(
-	ss << "SELECT id FROM variant WHERE ";
+		variants, variants_exclude,
-	for (std::vector<std::string>::const_iterator it = variants.begin();
+		benchmarks, benchmarks_exclude);
-	     it != variants.end(); ++it) {
+	if (m_variants.size() == 0) {
-		ss << "variant LIKE '" << *it << "' AND ";
+		LOG << "no variants found, nothing to do" << std::endl;
+		return false;
 	}
-	for (std::vector<std::string>::const_iterator it = variants_exclude.begin();
+
-	     it != variants_exclude.end(); ++it) {
+	std::stringstream ss;
-		ss << "variant NOT LIKE '" << *it << "' AND ";
+	for (std::vector<fail::Database::Variant>::const_iterator it = m_variants.begin();
+		it != m_variants.end(); ++it) {
+		if (it != m_variants.begin()) {
+			ss << ",";
+		}
+		ss << it->id;
 	}
-	for (std::vector<std::string>::const_iterator it = benchmarks.begin();
+	m_variants_sql = ss.str();
-	     it != benchmarks.end(); ++it) {
-		ss << "benchmark LIKE '" << *it << "' AND ";
-	}
-	for (std::vector<std::string>::const_iterator it = benchmarks_exclude.begin();
-	     it != benchmarks_exclude.end(); ++it) {
-		ss << "benchmark NOT LIKE '" << *it << "' AND ";
-	}
-	// dummy terminator to avoid special cases in query construction above
-	ss << "1";
-	m_variant_id_query = ss.str();
 
 	if (!(m_method_id = db->get_fspmethod_id(method_name()))) {
 		return false;
@@ -79,13 +74,13 @@ bool Pruner::create_database() {
 
 bool Pruner::clear_database() {
 	std::stringstream ss;
-	ss << "DELETE FROM fsppilot WHERE variant_id IN (" << m_variant_id_query
+	ss << "DELETE FROM fsppilot WHERE variant_id IN (" << m_variants_sql
 		<< ") AND fspmethod_id = " << m_method_id;
 	bool ret = (bool) db->query(ss.str().c_str());
 	LOG << "deleted " << db->affected_rows() << " rows from fsppilot table" << std::endl;
 	ss.str("");
 
-	ss << "DELETE FROM fspgroup WHERE variant_id IN (" << m_variant_id_query
+	ss << "DELETE FROM fspgroup WHERE variant_id IN (" << m_variants_sql
 		<< ") AND fspmethod_id = " << m_method_id;
 	ret = ret && (bool) db->query(ss.str().c_str());
 	LOG << "deleted " << db->affected_rows() << " rows from fspgroup table" << std::endl;

tools/prune-trace/Pruner.hpp

@@ -8,8 +8,9 @@
 class Pruner {
 protected:
 	int m_method_id;
-	std::string m_variant_id_query;
 	fail::Database *db;
+	std::vector<fail::Database::Variant> m_variants;
+	std::string m_variants_sql;
 
 public:
 	bool init(fail::Database *db,