d1f3843 Reorganize db functions. — HardenedBSD-pkg

HardenedBSD-pkg

rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9

HardenedBSD Package Manager

Reorganize db functions.

Vsevolod Stakhov committed 12 years ago

commit d1f3843cf80ec08f7bd4fbe51d0b0ff03fa2aee4
parent aac3b1f

4 files changed +194 -159

modified libpkg/pkg.h.in

@@ -1056,7 +1056,7 @@ struct pkgdb_it * pkgdb_query_which(struct pkgdb *db, const char *path, bool glo

 struct pkgdb_it * pkgdb_query_shlib_required(struct pkgdb *db, const char *shlib);
 struct pkgdb_it * pkgdb_query_shlib_provided(struct pkgdb *db, const char *shlib);
 struct pkgdb_it * pkgdb_query_provide(struct pkgdb *db,
 struct pkgdb_it * pkgdb_rquery_provide(struct pkgdb *db,
     const char *provide, const char *repo);
 /**

modified libpkg/pkgdb.c

@@ -81,7 +81,6 @@ static void pkgdb_regex_delete(void *);

 static int pkgdb_upgrade(struct pkgdb *);
 static void populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg);
 static void pkgdb_detach_remotes(sqlite3 *);
 static bool is_attached(sqlite3 *, const char *);
 static int sqlcmd_init(sqlite3 *db, __unused const char **err,
     __unused const void *noused);
 static int prstmt_initialize(struct pkgdb *db);

@@ -202,30 +201,6 @@ load_tag_val(sqlite3 *db, struct pkg *pkg, const char *sql, unsigned flags,

 	return (EPKG_OK);
 }
 static const char *
 pkgdb_get_reponame(struct pkgdb *db, const char *repo)
 {
 	const char	*reponame = NULL;
 	struct pkg_repo	*r;
 	assert(db->type == PKGDB_REMOTE);
 	if (repo != NULL) {
 		if ((r = pkg_repo_find_ident(repo)) == NULL) {
 			pkg_emit_error("repository '%s' does not exist", repo);
 			return (NULL);
 		}
 		reponame = pkg_repo_name(r);
 		if (!is_attached(db->sqlite, reponame)) {
 			pkg_emit_error("repository '%s' does not exist", repo);
 			return (NULL);
 		}
 	}
 	return (reponame);
 }
 static int
 compare_column_func(const void *pkey, const void *pcolumn)
 {

@@ -816,7 +791,7 @@ pkgdb_open_multirepos(const char *dbdir, struct pkgdb *db)

 			continue;
 		/* is it already attached? */
 		if (is_attached(db->sqlite, pkg_repo_name(r))) {
 		if (pkgdb_is_attached(db->sqlite, pkg_repo_name(r))) {
 			pkg_emit_error("repository '%s' is already "
 			    "listed, ignoring", pkg_repo_ident(r));
 			continue;

@@ -1470,7 +1445,7 @@ pkgdb_case_sensitive(void)

 	return (_case_sensitive_flag);
 }
 static const char *
 const char *
 pkgdb_get_pattern_query(const char *pattern, match_t match)
 {
 	char		*checkorigin = NULL;

@@ -3317,8 +3292,8 @@ sql_exec(sqlite3 *s, const char *sql, ...)

 	return (ret);
 }
 static bool
 is_attached(sqlite3 *s, const char *name)
 bool
 pkgdb_is_attached(sqlite3 *s, const char *name)
 {
 	sqlite3_stmt	*stmt;
 	const char	*dbname;

@@ -3345,8 +3320,8 @@ is_attached(sqlite3 *s, const char *name)

 	return (false);
 }
 static int
 sql_on_all_attached_db(sqlite3 *s, struct sbuf *sql, const char *multireposql,
 int
 pkgdb_sql_all_attached(sqlite3 *s, struct sbuf *sql, const char *multireposql,
     const char *compound)
 {
 	sqlite3_stmt	*stmt;

@@ -3523,128 +3498,6 @@ pkgdb_compact(struct pkgdb *db)

 	return (sql_exec(db->sqlite, "VACUUM;"));
 }
 struct pkgdb_it *
 pkgdb_rquery(struct pkgdb *db, const char *pattern, match_t match,
     const char *repo)
 {
 	sqlite3_stmt	*stmt = NULL;
 	struct sbuf	*sql = NULL;
 	const char	*reponame = NULL;
 	const char	*comp = NULL;
 	int		 ret;
 	char		 basesql[BUFSIZ] = ""
 		"SELECT id, origin, name, version, comment, "
 		"prefix, desc, arch, maintainer, www, "
 		"licenselogic, flatsize, pkgsize, "
 		"cksum, manifestdigest, path AS repopath, '%1$s' AS dbname "
 		"FROM '%1$s'.packages p";
 	assert(db != NULL);
 	assert(match == MATCH_ALL || (pattern != NULL && pattern[0] != '\0'));
 	/*
 	 * If we have no remote repos loaded, we just return nothing instead of failing
 	 * an assert deep inside pkgdb_get_reponame
 	 */
 	if (db->type != PKGDB_REMOTE)
 		return (NULL);
 	reponame = pkgdb_get_reponame(db, repo);
 	sql = sbuf_new_auto();
 	comp = pkgdb_get_pattern_query(pattern, match);
 	if (comp && comp[0])
 		strlcat(basesql, comp, sizeof(basesql));
 	/*
 	 * Working on multiple remote repositories
 	 */
 	if (reponame == NULL) {
 		/* duplicate the query via UNION for all the attached
 		 * databases */
 		ret = sql_on_all_attached_db(db->sqlite, sql,
 		    basesql, " UNION ALL ");
 		if (ret != EPKG_OK) {
 			sbuf_delete(sql);
 			return (NULL);
 		}
 	} else
 		sbuf_printf(sql, basesql, reponame, reponame);
 	sbuf_cat(sql, " ORDER BY name;");
 	sbuf_finish(sql);
 	pkg_debug(4, "Pkgdb: running '%s'", sbuf_get(sql));
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), sbuf_size(sql), &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		sbuf_delete(sql);
 		return (NULL);
 	}
 	sbuf_delete(sql);
 	if (match != MATCH_ALL && match != MATCH_CONDITION)
 		sqlite3_bind_text(stmt, 1, pattern, -1, SQLITE_TRANSIENT);
 	return (pkgdb_it_new(db, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE));
 }
 struct pkgdb_it *
 pkgdb_query_provide(struct pkgdb *db, const char *provide, const char *repo)
 {
 	sqlite3_stmt	*stmt;
 	struct sbuf	*sql = NULL;
 	const char	*reponame = NULL;
 	int		 ret;
 	const char	 basesql[] = ""
 			"SELECT p.id, p.origin, p.name, p.version, p.comment, p.desc, "
 			"p.message, p.arch, p.maintainer, p.www, "
 			"p.flatsize "
 			"FROM '%1$s'.packages AS p, '%1$s'.pkg_provides AS pp, "
 			"'%1$s'.provides AS pr "
 			"WHERE p.id = pp.package_id "
 			"AND pp.provide_id = pr.id "
 			"AND pr.name = ?1;";
 	assert(db != NULL);
 	reponame = pkgdb_get_reponame(db, repo);
 	sql = sbuf_new_auto();
 	/*
 	 * Working on multiple remote repositories
 	 */
 	if (reponame == NULL) {
 		/* duplicate the query via UNION for all the attached
 		 * databases */
 		ret = sql_on_all_attached_db(db->sqlite, sql,
 				basesql, " UNION ALL ");
 		if (ret != EPKG_OK) {
 			sbuf_delete(sql);
 			return (NULL);
 		}
 	} else
 		sbuf_printf(sql, basesql, reponame);
 	sbuf_finish(sql);
 	pkg_debug(4, "Pkgdb: running '%s'", sbuf_get(sql));
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		sbuf_delete(sql);
 		return (NULL);
 	}
 	sbuf_delete(sql);
 	sqlite3_bind_text(stmt, 1, provide, -1, SQLITE_TRANSIENT);
 	return (pkgdb_it_new(db, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE));
 }
 static int
 pkgdb_search_build_search_query(struct sbuf *sql, match_t match,
     pkgdb_field field, pkgdb_field sort)

@@ -3752,7 +3605,7 @@ pkgdb_search(struct pkgdb *db, const char *pattern, match_t match,

 			return (NULL);
 		}
 		/* test on all the attached databases */
 		if (sql_on_all_attached_db(db->sqlite, sql,
 		if (pkgdb_sql_all_attached(db->sqlite, sql,
 		    multireposql, " UNION ALL ") != EPKG_OK) {
 			sbuf_delete(sql);
 			return (NULL);

@@ -4474,7 +4327,7 @@ pkgdb_stats(struct pkgdb *db, pkg_stats_t type)

 		sbuf_printf(sql, "(");
 		/* execute on all databases */
 		sql_on_all_attached_db(db->sqlite, sql,
 		pkgdb_sql_all_attached(db->sqlite, sql,
 		    "SELECT origin AS c FROM '%1$s'.packages", " UNION ");
 		/* close parentheses for the compound statement */

@@ -4487,7 +4340,7 @@ pkgdb_stats(struct pkgdb *db, pkg_stats_t type)

 		sbuf_printf(sql, "(");
 		/* execute on all databases */
 		sql_on_all_attached_db(db->sqlite, sql,
 		pkgdb_sql_all_attached(db->sqlite, sql,
 		    "SELECT origin AS c FROM '%1$s'.packages", " UNION ALL ");
 		/* close parentheses for the compound statement */

@@ -4500,7 +4353,7 @@ pkgdb_stats(struct pkgdb *db, pkg_stats_t type)

 		sbuf_printf(sql, "(");
 		/* execute on all databases */
 		sql_on_all_attached_db(db->sqlite, sql,
 		pkgdb_sql_all_attached(db->sqlite, sql,
 		    "SELECT flatsize AS s FROM '%1$s'.packages", " UNION ALL ");
 		/* close parentheses for the compound statement */

@@ -4513,7 +4366,7 @@ pkgdb_stats(struct pkgdb *db, pkg_stats_t type)

 		sbuf_printf(sql, "(");
 		/* execute on all databases */
 		sql_on_all_attached_db(db->sqlite, sql,
 		pkgdb_sql_all_attached(db->sqlite, sql,
 		    "SELECT '%1$s' AS c", " UNION ALL ");
 		/* close parentheses for the compound statement */

modified libpkg/pkgdb_repo.c

@@ -1001,3 +1001,149 @@ pkgdb_repo_register_conflicts(const char *origin, char **conflicts,

 	return (EPKG_OK);
 }
 const char *
 pkgdb_get_reponame(struct pkgdb *db, const char *repo)
 {
 	const char	*reponame = NULL;
 	struct pkg_repo	*r;
 	assert(db->type == PKGDB_REMOTE);
 	if (repo != NULL) {
 		if ((r = pkg_repo_find_ident(repo)) == NULL) {
 			pkg_emit_error("repository '%s' does not exist", repo);
 			return (NULL);
 		}
 		reponame = pkg_repo_name(r);
 		if (!pkgdb_is_attached(db->sqlite, reponame)) {
 			pkg_emit_error("repository '%s' does not exist", repo);
 			return (NULL);
 		}
 	}
 	return (reponame);
 }
 struct pkgdb_it *
 pkgdb_rquery(struct pkgdb *db, const char *pattern, match_t match,
     const char *repo)
 {
 	sqlite3_stmt	*stmt = NULL;
 	struct sbuf	*sql = NULL;
 	const char	*reponame = NULL;
 	const char	*comp = NULL;
 	int		 ret;
 	char		 basesql[BUFSIZ] = ""
 		"SELECT id, origin, name, version, comment, "
 		"prefix, desc, arch, maintainer, www, "
 		"licenselogic, flatsize, pkgsize, "
 		"cksum, manifestdigest, path AS repopath, '%1$s' AS dbname "
 		"FROM '%1$s'.packages p";
 	assert(db != NULL);
 	assert(match == MATCH_ALL || (pattern != NULL && pattern[0] != '\0'));
 	/*
 	 * If we have no remote repos loaded, we just return nothing instead of failing
 	 * an assert deep inside pkgdb_get_reponame
 	 */
 	if (db->type != PKGDB_REMOTE)
 		return (NULL);
 	reponame = pkgdb_get_reponame(db, repo);
 	sql = sbuf_new_auto();
 	comp = pkgdb_get_pattern_query(pattern, match);
 	if (comp && comp[0])
 		strlcat(basesql, comp, sizeof(basesql));
 	/*
 	 * Working on multiple remote repositories
 	 */
 	if (reponame == NULL) {
 		/* duplicate the query via UNION for all the attached
 		 * databases */
 		ret = pkgdb_sql_all_attached(db->sqlite, sql,
 		    basesql, " UNION ALL ");
 		if (ret != EPKG_OK) {
 			sbuf_delete(sql);
 			return (NULL);
 		}
 	} else
 		sbuf_printf(sql, basesql, reponame, reponame);
 	sbuf_cat(sql, " ORDER BY name;");
 	sbuf_finish(sql);
 	pkg_debug(4, "Pkgdb: running '%s'", sbuf_get(sql));
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), sbuf_size(sql), &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		sbuf_delete(sql);
 		return (NULL);
 	}
 	sbuf_delete(sql);
 	if (match != MATCH_ALL && match != MATCH_CONDITION)
 		sqlite3_bind_text(stmt, 1, pattern, -1, SQLITE_TRANSIENT);
 	return (pkgdb_it_new(db, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE));
 }
 struct pkgdb_it *
 pkgdb_rquery_provide(struct pkgdb *db, const char *provide, const char *repo)
 {
 	sqlite3_stmt	*stmt;
 	struct sbuf	*sql = NULL;
 	const char	*reponame = NULL;
 	int		 ret;
 	const char	 basesql[] = ""
 			"SELECT p.id, p.origin, p.name, p.version, p.comment, p.desc, "
 			"p.message, p.arch, p.maintainer, p.www, "
 			"p.flatsize "
 			"FROM '%1$s'.packages AS p, '%1$s'.pkg_provides AS pp, "
 			"'%1$s'.provides AS pr "
 			"WHERE p.id = pp.package_id "
 			"AND pp.provide_id = pr.id "
 			"AND pr.name = ?1;";
 	assert(db != NULL);
 	reponame = pkgdb_get_reponame(db, repo);
 	sql = sbuf_new_auto();
 	/*
 	 * Working on multiple remote repositories
 	 */
 	if (reponame == NULL) {
 		/* duplicate the query via UNION for all the attached
 		 * databases */
 		ret = pkgdb_sql_all_attached(db->sqlite, sql,
 				basesql, " UNION ALL ");
 		if (ret != EPKG_OK) {
 			sbuf_delete(sql);
 			return (NULL);
 		}
 	} else
 		sbuf_printf(sql, basesql, reponame);
 	sbuf_finish(sql);
 	pkg_debug(4, "Pkgdb: running '%s'", sbuf_get(sql));
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		sbuf_delete(sql);
 		return (NULL);
 	}
 	sbuf_delete(sql);
 	sqlite3_bind_text(stmt, 1, provide, -1, SQLITE_TRANSIENT);
 	return (pkgdb_it_new(db, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE));
 }

modified libpkg/private/pkgdb.h

@@ -145,4 +145,40 @@ struct pkgdb_it *pkgdb_repo_origins(sqlite3 *sqlite);

 int pkgdb_repo_register_conflicts(const char *origin, char **conflicts,
 		int conflicts_num, sqlite3 *sqlite);
 /**
  * Execute SQL statement on all attached databases
  * @param s
  * @param sql
  * @param multireposql
  * @param compound
  * @return
  */
 int
 pkgdb_sql_all_attached(sqlite3 *s, struct sbuf *sql, const char *multireposql,
     const char *compound);
 /**
  * Get repository name
  * @param db
  * @param repo
  * @return
  */
 const char *pkgdb_get_reponame(struct pkgdb *db, const char *repo);
 /**
  * Get query for the specified match type
  * @param pattern
  * @param match
  * @return
  */
 const char * pkgdb_get_pattern_query(const char *pattern, match_t match);
 /**
  * Returns whether the specified database is attached
  * @param s
  * @param name
  * @return
  */
 bool pkgdb_is_attached(sqlite3 *s, const char *name);
 #endif