1ed9bed Tidy up iterator SQL — HardenedBSD-pkg

HardenedBSD-pkg

rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9

HardenedBSD Package Manager

Tidy up iterator SQL

Matthew Seaman committed 11 years ago

commit 1ed9beddd217350c543f22577ed098071956e3dc
parent 50512f1

1 file changed +103 -143

modified libpkg/pkgdb_iterator.c

@@ -4,7 +4,7 @@

  * Copyright (c) 2011 Will Andrews <will@FreeBSD.org>
  * Copyright (c) 2011 Philippe Pepiot <phil@philpep.org>
  * Copyright (c) 2011-2012 Marin Atanasov Nikolov <dnaeon@gmail.com>
  * Copyright (c) 2012-2013 Matthew Seaman <matthew@FreeBSD.org>
  * Copyright (c) 2012-2014 Matthew Seaman <matthew@FreeBSD.org>
  * Copyright (c) 2012 Bryan Drewery <bryan@shatow.net>
  * Copyright (c) 2013 Gerald Pfeifer <gerald@pfeifer.com>
  * Copyright (c) 2013-2014 Vsevolod Stakhov <vsevolod@FreeBSD.org>

@@ -202,13 +202,13 @@ pkgdb_load_deps(sqlite3 *sqlite, struct pkg *pkg)

 {
 	sqlite3_stmt	*stmt = NULL;
 	int		 ret = EPKG_OK;
 	char		 sql[BUFSIZ];
 	const char	*mainsql = ""
 		"SELECT d.name, d.origin, d.version, 0 "
 		"FROM main.deps AS d "
 		"LEFT JOIN main.packages AS p ON p.origin = d.origin "
 		"AND p.name = d.name "
 		"WHERE d.package_id = ?1 ORDER BY d.origin DESC;";
 	const char	 sql[] = ""
 		"SELECT d.name, d.origin, d.version, 0"
 		"  FROM deps AS d"
 		"    LEFT JOIN packages AS p ON"
 		"    (p.origin = d.origin AND p.name = d.name)"
 		"  WHERE d.package_id = ?1"
 		"  ORDER BY d.origin DESC";
 	assert(pkg != NULL);

@@ -216,8 +216,8 @@ pkgdb_load_deps(sqlite3 *sqlite, struct pkg *pkg)

 		return (EPKG_OK);
 	pkg_debug(4, "Pkgdb: running '%s'", mainsql);
 	ret = sqlite3_prepare_v2(sqlite, mainsql, -1, &stmt, NULL);
 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	ret = sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(sqlite, sql);

@@ -250,11 +250,11 @@ pkgdb_load_rdeps(sqlite3 *sqlite, struct pkg *pkg)

 {
 	sqlite3_stmt	*stmt = NULL;
 	int		 ret;
 	const char	*mainsql = ""
 		"SELECT p.name, p.origin, p.version, 0 "
 		"FROM main.packages AS p "
 		"INNER JOIN main.deps AS d ON p.id = d.package_id "
 		"WHERE d.name = ?1;";
 	const char	 sql[] = ""
 		"SELECT p.name, p.origin, p.version, 0"
 		"  FROM packages AS p"
 		"    INNER JOIN deps AS d ON (p.id = d.package_id)"
 		"  WHERE d.name = ?1";
 	assert(pkg != NULL);

@@ -262,11 +262,11 @@ pkgdb_load_rdeps(sqlite3 *sqlite, struct pkg *pkg)

 		return (EPKG_OK);
 	pkg_debug(4, "Pkgdb: running '%s'", mainsql);
 	ret = sqlite3_prepare_v2(sqlite, mainsql, -1, &stmt, NULL);
 	pkg_debug(4, "Pkgdb: running '%s'", sql);
 	ret = sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(sqlite, mainsql);
 		ERROR_SQLITE(sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -283,7 +283,7 @@ pkgdb_load_rdeps(sqlite3 *sqlite, struct pkg *pkg)

 	if (ret != SQLITE_DONE) {
 		pkg_list_free(pkg, PKG_RDEPS);
 		ERROR_SQLITE(sqlite, mainsql);
 		ERROR_SQLITE(sqlite, sql);
 		return (EPKG_FATAL);
 	}

@@ -297,15 +297,15 @@ pkgdb_load_files(sqlite3 *sqlite, struct pkg *pkg)

 	sqlite3_stmt	*stmt = NULL;
 	int		 ret;
 	const char	 sql[] = ""
 		"SELECT path, sha256 "
 		"FROM files "
 		"WHERE package_id = ?1 "
 		"ORDER BY PATH ASC";
 		"SELECT path, sha256"
 		"  FROM files"
 		"  WHERE package_id = ?1"
 		"  ORDER BY PATH ASC";
 	const char	 sql2[] = ""
 		"SELECT path, content "
 		"FROM config_files "
 		"WHERE package_id = ?1 "
 		"ORDER BY PATH ASC";
 		"SELECT path, content"
 		"  FROM config_files"
 		"  WHERE package_id = ?1"
 		"  ORDER BY PATH ASC";
 	assert( pkg != NULL);
 	assert(pkg->type == PKG_INSTALLED);

@@ -355,11 +355,11 @@ static int

 pkgdb_load_dirs(sqlite3 *sqlite, struct pkg *pkg)
 {
 	const char	 sql[] = ""
 		"SELECT path, try "
 		"FROM pkg_directories, directories "
 		"WHERE package_id = ?1 "
 		"AND directory_id = directories.id "
 		"ORDER by path DESC";
 		"SELECT path, try"
 		"  FROM pkg_directories, directories"
 		"  WHERE package_id = ?1"
 		"    AND directory_id = directories.id"
 		"  ORDER by path DESC";
 	sqlite3_stmt	*stmt;
 	int		 ret;

@@ -397,18 +397,15 @@ pkgdb_load_dirs(sqlite3 *sqlite, struct pkg *pkg)

 static int
 pkgdb_load_license(sqlite3 *sqlite, struct pkg *pkg)
 {
 	char		 sql[BUFSIZ];
 	const char	*basesql = ""
 		"SELECT name "
 		"FROM %Q.pkg_licenses, %Q.licenses AS l "
 		"WHERE package_id = ?1 "
 			"AND license_id = l.id "
 		"ORDER by name DESC";
 	const char	 sql[] = ""
 		"SELECT name"
 		"  FROM pkg_licenses, licenses AS l"
 		"  WHERE package_id = ?1"
 		"    AND license_id = l.id"
 		"  ORDER by name DESC";
 	assert(pkg != NULL);
 	sqlite3_snprintf(sizeof(sql), sql, basesql, "main", "main");
 	return (load_val(sqlite, pkg, sql, PKG_LOAD_LICENSES,
 	    pkg_addlicense, PKG_LICENSES));
 }

@@ -416,18 +413,15 @@ pkgdb_load_license(sqlite3 *sqlite, struct pkg *pkg)

 static int
 pkgdb_load_category(sqlite3 *sqlite, struct pkg *pkg)
 {
 	char		 sql[BUFSIZ];
 	const char	*basesql = ""
 		"SELECT name "
 		"FROM %Q.pkg_categories, %Q.categories AS c "
 		"WHERE package_id = ?1 "
 			"AND category_id = c.id "
 		"ORDER by name DESC";
 	const char	 sql[] = ""
 		"SELECT name"
 		"  FROM pkg_categories, categories AS c"
 		"  WHERE package_id = ?1"
 		"    AND category_id = c.id"
 		"  ORDER by name DESC";
 	assert(pkg != NULL);
 	sqlite3_snprintf(sizeof(sql), sql, basesql, "main", "main");
 	return (load_val(sqlite, pkg, sql, PKG_LOAD_CATEGORIES,
 	    pkg_addcategory, PKG_CATEGORIES));
 }

@@ -439,11 +433,11 @@ pkgdb_load_user(sqlite3 *sqlite, struct pkg *pkg)

 	struct passwd *pwd = NULL;*/
 	int		ret;
 	const char	sql[] = ""
 		"SELECT users.name "
 		"FROM pkg_users, users "
 		"WHERE package_id = ?1 "
 			"AND user_id = users.id "
 		"ORDER by name DESC";
 		"SELECT users.name"
 		"  FROM pkg_users, users"
 		"  WHERE package_id = ?1"
 		"    AND user_id = users.id"
 		"  ORDER by name DESC";
 	assert(pkg != NULL);
 	assert(pkg->type == PKG_INSTALLED);

@@ -469,11 +463,11 @@ pkgdb_load_group(sqlite3 *sqlite, struct pkg *pkg)

 	struct group		*grp = NULL;
 	int			 ret;
 	const char		 sql[] = ""
 		"SELECT groups.name "
 		"FROM pkg_groups, groups "
 		"WHERE package_id = ?1 "
 			"AND group_id = groups.id "
 		"ORDER by name DESC";
 		"SELECT groups.name"
 		"  FROM pkg_groups, groups"
 		"  WHERE package_id = ?1"
 		"    AND group_id = groups.id"
 		"  ORDER by name DESC";
 	assert(pkg != NULL);
 	assert(pkg->type == PKG_INSTALLED);

@@ -494,18 +488,15 @@ pkgdb_load_group(sqlite3 *sqlite, struct pkg *pkg)

 static int
 pkgdb_load_shlib_required(sqlite3 *sqlite, struct pkg *pkg)
 {
 	char		 sql[BUFSIZ];
 	const char	*basesql = ""
 		"SELECT name "
 		"FROM %Q.pkg_shlibs_required, %Q.shlibs AS s "
 		"WHERE package_id = ?1 "
 			"AND shlib_id = s.id "
 		"ORDER by name DESC";
 	const char	sql[] = ""
 		"SELECT name"
 		"  FROM pkg_shlibs_required, shlibs AS s"
 		"  WHERE package_id = ?1"
 		"    AND shlib_id = s.id"
 		"  ORDER by name DESC";
 	assert(pkg != NULL);
 	sqlite3_snprintf(sizeof(sql), sql, basesql, "main", "main");
 	return (load_val(sqlite, pkg, sql, PKG_LOAD_SHLIBS_REQUIRED,
 	    pkg_addshlib_required, PKG_SHLIBS_REQUIRED));
 }

@@ -514,18 +505,15 @@ pkgdb_load_shlib_required(sqlite3 *sqlite, struct pkg *pkg)

 static int
 pkgdb_load_shlib_provided(sqlite3 *sqlite, struct pkg *pkg)
 {
 	char		 sql[BUFSIZ];
 	const char	*basesql = ""
 		"SELECT name "
 		"FROM %Q.pkg_shlibs_provided, %Q.shlibs AS s "
 		"WHERE package_id = ?1 "
 			"AND shlib_id = s.id "
 		"ORDER by name DESC";
 	const char	sql[] = ""
 		"SELECT name"
 		"  FROM pkg_shlibs_provided, shlibs AS s"
 		"  WHERE package_id = ?1"
 		"    AND shlib_id = s.id"
 		"  ORDER by name DESC";
 	assert(pkg != NULL);
 	sqlite3_snprintf(sizeof(sql), sql, basesql, "main", "main");
 	return (load_val(sqlite, pkg, sql, PKG_LOAD_SHLIBS_PROVIDED,
 	    pkg_addshlib_provided, PKG_SHLIBS_PROVIDED));
 }

@@ -533,18 +521,14 @@ pkgdb_load_shlib_provided(sqlite3 *sqlite, struct pkg *pkg)

 static int
 pkgdb_load_annotations(sqlite3 *sqlite, struct pkg *pkg)
 {
 	char		 sql[BUFSIZ];
 	const char	*basesql = ""
 	const char	sql[] = ""
 		"SELECT k.annotation AS tag, v.annotation AS value"
 		"  FROM %Q.pkg_annotation p"
 		"    JOIN %Q.annotation k ON (p.tag_id = k.annotation_id)"
 		"    JOIN %Q.annotation v ON (p.value_id = v.annotation_id)"
 		"  FROM pkg_annotation p"
 		"    JOIN annotation k ON (p.tag_id = k.annotation_id)"
 		"    JOIN annotation v ON (p.value_id = v.annotation_id)"
 		"  WHERE p.package_id = ?1"
 		"  ORDER BY tag, value";
 	sqlite3_snprintf(sizeof(sql), sql, basesql, "main",
                     "main", "main");
 	return (load_tag_val(sqlite, pkg, sql, PKG_LOAD_ANNOTATIONS,
 		   pkg_addannotation, PKG_ANNOTATIONS));
 }

@@ -555,9 +539,10 @@ pkgdb_load_scripts(sqlite3 *sqlite, struct pkg *pkg)

 	sqlite3_stmt	*stmt = NULL;
 	int		 ret;
 	const char	 sql[] = ""
 		"SELECT script, type "
 		"FROM pkg_script JOIN script USING(script_id) "
 		"WHERE package_id = ?1";
 		"SELECT script, type"
 		"  FROM pkg_script"
 		"    JOIN script USING(script_id)"
 		"  WHERE package_id = ?1";
 	assert(pkg != NULL);
 	assert(pkg->type == PKG_INSTALLED);

@@ -592,8 +577,6 @@ pkgdb_load_scripts(sqlite3 *sqlite, struct pkg *pkg)

 static int
 pkgdb_load_options(sqlite3 *sqlite, struct pkg *pkg)
 {
 	const char	*reponame;
 	char		 sql[BUFSIZ];
 	unsigned int	 i;
 	struct optionsql {

@@ -601,68 +584,51 @@ pkgdb_load_options(sqlite3 *sqlite, struct pkg *pkg)

 		int		(*pkg_addtagval)(struct pkg *pkg,
 						  const char *tag,
 						  const char *val);
 		int		  nargs;
 	}			  optionsql[] = {
 		{
 			"SELECT option, value "
 			"FROM %Q.option JOIN %Q.pkg_option USING(option_id) "
 			"WHERE package_id = ?1 ORDER BY option",
 			"SELECT option, value"
 			"  FROM option"
 			"    JOIN pkg_option USING(option_id)"
 			"  WHERE package_id = ?1"
 			"  ORDER BY option",
 			pkg_addoption,
 ,
 		},
 		{
 			"SELECT option, default_value "
 			"FROM %Q.option JOIN %Q.pkg_option_default USING(option_id) "
 			"WHERE package_id = ?1 ORDER BY option",
 			"SELECT option, default_value"
 			"  FROM option"
 			"    JOIN pkg_option_default USING(option_id)"
 			"  WHERE package_id = ?1"
 			"  ORDER BY option",
 			pkg_addoption_default,
 ,
 		},
 		{
 			"SELECT option, description "
 			"FROM %Q.option JOIN %Q.pkg_option_desc USING(option_id) "
 			"JOIN %Q.option_desc USING(option_desc_id) ORDER BY option",
 			"SELECT option, description"
 			"  FROM option"
 			"    JOIN pkg_option_desc USING(option_id)"
 			"    JOIN option_desc USING(option_desc_id)"
 			"  WHERE package_id = ?1"
 			"  ORDER BY option",
 			pkg_addoption_description,
 ,
 		}
 	};
 	const char		 *opt_sql;
 	int			(*pkg_addtagval)(struct pkg *pkg,
 						 const char *tag,
 						 const char *val);
 	int			  nargs, ret;
 	int			  ret;
 	assert(pkg != NULL);
 	if (pkg->flags & PKG_LOAD_OPTIONS)
 		return (EPKG_OK);
 	reponame = "main";
 	for (i = 0; i < NELEM(optionsql); i++) {
 		opt_sql       = optionsql[i].sql;
 		pkg_addtagval = optionsql[i].pkg_addtagval;
 		nargs         = optionsql[i].nargs;
 		switch(nargs) {
 		case 1:
 			sqlite3_snprintf(sizeof(sql), sql, opt_sql, reponame);
 			break;
 		case 2:
 			sqlite3_snprintf(sizeof(sql), sql, opt_sql, reponame,
 					 reponame);
 			break;
 		case 3:
 			sqlite3_snprintf(sizeof(sql), sql, opt_sql, reponame,
 					 reponame, reponame);
 			break;
 		default:
 			/* Nothing needs 4 or more, yet... */
 			return (EPKG_FATAL);
 			break;
 		}
 		pkg_debug(4, "Pkgdb> adding option");
 		ret = load_tag_val(sqlite, pkg, sql, PKG_LOAD_OPTIONS,
 		ret = load_tag_val(sqlite, pkg, opt_sql, PKG_LOAD_OPTIONS,
 				   pkg_addtagval, PKG_OPTIONS);
 		if (ret != EPKG_OK)
 			break;

@@ -673,18 +639,15 @@ pkgdb_load_options(sqlite3 *sqlite, struct pkg *pkg)

 static int
 pkgdb_load_conflicts(sqlite3 *sqlite, struct pkg *pkg)
 {
 	char		 sql[BUFSIZ];
 	const char	*basesql = ""
 			"SELECT packages.name "
 			"FROM %Q.pkg_conflicts "
 			"LEFT JOIN %Q.packages ON "
 			"packages.id = pkg_conflicts.conflict_id "
 			"WHERE package_id = ?1";
 	const char	sql[] = ""
 		"SELECT packages.name"
 		"  FROM pkg_conflicts"
 		"    LEFT JOIN packages ON"
 		"    (packages.id = pkg_conflicts.conflict_id)"
 		"  WHERE package_id = ?1";
 	assert(pkg != NULL);
 	sqlite3_snprintf(sizeof(sql), sql, basesql, "main", "main");
 	return (load_val(sqlite, pkg, sql, PKG_LOAD_CONFLICTS,
 			pkg_addconflict, PKG_CONFLICTS));
 }

@@ -692,16 +655,13 @@ pkgdb_load_conflicts(sqlite3 *sqlite, struct pkg *pkg)

 static int
 pkgdb_load_provides(sqlite3 *sqlite, struct pkg *pkg)
 {
 	char		 sql[BUFSIZ];
 	const char	*basesql = ""
 		"SELECT provide "
 		"FROM %Q.provides "
 		"WHERE package_id = ?1";
 	const char	sql[] = ""
 		"SELECT provide"
 		"  FROM provides"
 		"  WHERE package_id = ?1";
 	assert(pkg != NULL);
 	sqlite3_snprintf(sizeof(sql), sql, basesql, "main", "main");
 	return (load_val(sqlite, pkg, sql, PKG_LOAD_PROVIDES,
 			pkg_addconflict, PKG_PROVIDES));
 }

@@ -710,7 +670,7 @@ static void

 populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg) {
 	int		 icol = 0;
 	const char	*colname;
 	char legacyarch[BUFSIZ];
 	char		 legacyarch[BUFSIZ];
 	assert(stmt != NULL);