static int
pkg_repo_register(struct pkg_repo *repo, sqlite3 *sqlite)
{
sqlite3_stmt *stmt;
const char sql[] = ""
"INSERT OR REPLACE INTO repodata (key, value) "
"VALUES (\"packagesite\", ?1);";
/* register the packagesite */
if (sql_exec(sqlite, "CREATE TABLE IF NOT EXISTS repodata ("
" key TEXT UNIQUE NOT NULL,"
" value TEXT NOT NULL"
");") != EPKG_OK) {
pkg_emit_error("Unable to register the packagesite in the "
"database");
return (EPKG_FATAL);
}
if (sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
ERROR_SQLITE(sqlite);
return (EPKG_FATAL);
}
sqlite3_bind_text(stmt, 1, pkg_repo_url(repo), -1, SQLITE_STATIC);
if (sqlite3_step(stmt) != SQLITE_DONE) {
ERROR_SQLITE(sqlite);
sqlite3_finalize(stmt);
return (EPKG_FATAL);
}
sqlite3_finalize(stmt);
return (EPKG_OK);
}
int
pkgdb_unregister_pkg(struct pkgdb *db, const char *origin)
{
sqlite3_stmt *stmt_del;
int ret;
const char sql[] = "DELETE FROM packages WHERE origin = ?1;";
if (db == NULL)
return (ERROR_BAD_ARG("db"));
if (origin == NULL)
return (ERROR_BAD_ARG("origin"));
if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt_del, NULL) != SQLITE_OK)
return (ERROR_SQLITE(db->sqlite));
sqlite3_bind_text(stmt_del, 1, origin, -1, SQLITE_STATIC);
ret = sqlite3_step(stmt_del);
sqlite3_finalize(stmt_del);
if (ret != SQLITE_DONE)
return (ERROR_SQLITE(db->sqlite));
return (EPKG_OK);
}
int
pkgdb_loadfiles(struct pkgdb *db, struct pkg *pkg)
{
sqlite3_stmt *stmt;
struct pkg_file *f;
int ret;
const char sql[] = ""
"SELECT path, sha256 "
"FROM files "
"WHERE package_id = ?1 "
"ORDER BY PATH ASC";
const char sqldir[] = ""
"SELECT path "
"FROM pkg_dirs "
"WHERE origin = ?1 "
"ORDER by path DESC";
if (pkg->type != PKG_INSTALLED)
return (ERROR_BAD_ARG("pkg"));
if (pkg->flags & PKG_LOAD_FILES)
return (EPKG_OK);
array_init(&pkg->files, 10);
if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK)
return (ERROR_SQLITE(db->sqlite));
sqlite3_bind_int64(stmt, 1, pkg->rowid);
while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
pkg_file_new(&f);
strlcpy(f->path, sqlite3_column_text(stmt, 0), sizeof(f->path));
strlcpy(f->sha256, sqlite3_column_text(stmt, 1), sizeof(f->sha256));
array_append(&pkg->files, f);
}
sqlite3_finalize(stmt);
if (ret != SQLITE_DONE) {
array_reset(&pkg->files, &free);
return (ERROR_SQLITE(db->sqlite));
}
if (sqlite3_prepare_v2(db->sqlite, sqldir, -1, &stmt, NULL) != SQLITE_OK)
return (ERROR_SQLITE(db->sqlite));
sqlite3_bind_text(stmt, 1, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);
while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
pkg_file_new(&f);
strlcpy(f->path, sqlite3_column_text(stmt, 0), sizeof(f->path));
array_append(&pkg->files, f);
}
sqlite3_finalize(stmt);
pkg->flags |= PKG_LOAD_FILES;
return (EPKG_OK);
}
int
pkgdb_load(struct pkgdb *db, const char *src)
{
sqlite3 *restore;
int ret;
if (eaccess(src, R_OK)) {
pkg_emit_error("eaccess(%s) -- %s", src, strerror(errno));
return (EPKG_FATAL);
}
ret = sqlite3_open(src, &restore);
if (ret != SQLITE_OK) {
ERROR_SQLITE(restore);
sqlite3_close(restore);
return (EPKG_FATAL);
}
ret = copy_database(restore, db->sqlite, src);
sqlite3_close(restore);
return (ret == SQLITE_OK? EPKG_OK : EPKG_FATAL);
}
int
pkgdb_dump(struct pkgdb *db, const char *dest)
{
sqlite3 *backup;
int ret;
if (eaccess(dest, W_OK)) {
if (errno != ENOENT) {
pkg_fatal_errno("Unable to access '%s'", dest);
}
/* Could we create the Sqlite DB file? */
if (eaccess(bsd_dirname(dest), W_OK)) {
pkg_fatal_errno("Unable to access '%s'",
bsd_dirname(dest));
}
}
ret = sqlite3_open(dest, &backup);
if (ret != SQLITE_OK) {
ERROR_SQLITE(backup, "sqlite3_open");
sqlite3_close(backup);
return (EPKG_FATAL);
}
pkg_emit_backup();
ret = copy_database(db->sqlite, backup);
sqlite3_close(backup);
return (ret == SQLITE_OK? EPKG_OK : EPKG_FATAL);
}
static int
get_repo_user_version(sqlite3 *sqlite, const char *database, int *reposcver)
{
sqlite3_stmt *stmt;
int retcode;
char sql[BUFSIZ];
const char *fmt = "PRAGMA %Q.user_version";
assert(database != NULL);
sqlite3_snprintf(sizeof(sql), sql, fmt, database);
if (sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
ERROR_SQLITE(sqlite);
return (EPKG_FATAL);
}
if (sqlite3_step(stmt) == SQLITE_ROW) {
*reposcver = sqlite3_column_int(stmt, 0);
retcode = EPKG_OK;
} else {
*reposcver = -1;
retcode = EPKG_FATAL;
}
sqlite3_finalize(stmt);
return (retcode);
}
int
pkgdb_dump(struct pkgdb *db, const char *dest)
{
sqlite3 *backup;
int ret;
if (eaccess(dest, W_OK)) {
if (errno != ENOENT) {
pkg_emit_error("eaccess(%s) -- %s", dest,
strerror(errno));
return (EPKG_FATAL);
}
/* Could we create the Sqlite DB file? */
if (eaccess(dirname(dest), W_OK)) {
pkg_emit_error("eaccess(%s) -- %s", dirname(dest),
strerror(errno));
return (EPKG_FATAL);
}
}
ret = sqlite3_open(dest, &backup);
if (ret != SQLITE_OK) {
ERROR_SQLITE(backup);
sqlite3_close(backup);
return (EPKG_FATAL);
}
ret = copy_database(db->sqlite, backup, dest);
sqlite3_close(backup);
return (ret == SQLITE_OK? EPKG_OK : EPKG_FATAL);
}
int
pkgdb_load(struct pkgdb *db, const char *src)
{
sqlite3 *restore;
int ret;
if (eaccess(src, R_OK)) {
pkg_fatal_errno("Unable to access '%s'", src);
}
ret = sqlite3_open(src, &restore);
if (ret != SQLITE_OK) {
ERROR_SQLITE(restore, "sqlite3_open");
sqlite3_close(restore);
return (EPKG_FATAL);
}
pkg_emit_restore();
ret = copy_database(restore, db->sqlite);
sqlite3_close(restore);
return (ret == SQLITE_OK? EPKG_OK : EPKG_FATAL);
}
struct pkgdb_it *
pkgdb_repo_origins(sqlite3 *sqlite)
{
sqlite3_stmt *stmt = NULL;
int ret;
static struct pkgdb repodb;
const char query_sql[] = ""
"SELECT id, origin, name, version, comment, "
"prefix, desc, arch, maintainer, www, "
"licenselogic, flatsize, pkgsize, "
"cksum, path AS repopath, manifestdigest "
"FROM packages "
"ORDER BY origin;";
ret = sqlite3_prepare_v2(sqlite, query_sql, -1,
&stmt, NULL);
if (ret != SQLITE_OK) {
ERROR_SQLITE(sqlite);
return (NULL);
}
repodb.sqlite = sqlite;
repodb.type = PKGDB_REMOTE;
return pkgdb_it_new(&repodb, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE);
}
struct pkg_repo_it *
pkg_repo_binary_require(struct pkg_repo *repo, const char *provide)
{
sqlite3_stmt *stmt;
sqlite3 *sqlite = PRIV_GET(repo);
UT_string *sql = NULL;
int ret;
const char basesql[] = ""
"SELECT p.id, p.origin, p.name, p.version, p.comment, "
"p.name as uniqueid, "
"p.prefix, p.desc, p.arch, p.maintainer, p.www, "
"p.licenselogic, p.flatsize, p.pkgsize, "
"p.cksum, p.manifestdigest, p.path AS repopath, '%s' AS dbname "
"FROM packages AS p INNER JOIN pkg_requires AS ps ON "
"p.id = ps.package_id "
"WHERE ps.require_id = (SELECT id FROM requires WHERE require=?1);";
utstring_new(sql);
utstring_printf(sql, basesql, repo->name);
pkg_debug(4, "Pkgdb: running '%s'", utstring_body(sql));
ret = sqlite3_prepare_v2(sqlite, utstring_body(sql), -1, &stmt, NULL);
if (ret != SQLITE_OK) {
ERROR_SQLITE(sqlite, utstring_body(sql));
utstring_free(sql);
return (NULL);
}
utstring_free(sql);
sqlite3_bind_text(stmt, 1, provide, -1, SQLITE_TRANSIENT);
return (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE));
}
static int get_pragma(sqlite3 *s, const char *sql, int64_t *res) {
sqlite3_stmt *stmt;
int ret;
if (sqlite3_prepare_v2(s, sql, -1, &stmt, NULL) != SQLITE_OK)
return (ERROR_SQLITE(s));
ret = sqlite3_step(stmt);
if (ret == SQLITE_ROW)
*res = sqlite3_column_int64(stmt, 0);
sqlite3_finalize(stmt);
if (ret != SQLITE_ROW)
return (ERROR_SQLITE(s));
return (EPKG_OK);
}
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.name || '~' || p.origin as uniqueid, "
"p.prefix, p.desc, p.arch, p.maintainer, p.www, "
"p.licenselogic, p.flatsize, p.pkgsize, "
"p.cksum, p.manifestdigest, p.path AS repopath, '%1$s' AS dbname "
"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_get(sql));
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
pkg_repo_binary_set_version(sqlite3 *sqlite, int reposcver)
{
const char *sql = "PRAGMA user_version = %d;";
if (sql_exec(sqlite, sql, reposcver) != EPKG_OK) {
ERROR_SQLITE(sqlite, sql);
return (EPKG_FATAL);
}
return (EPKG_OK);
}
int
pkgdb_repo_cksum_exists(sqlite3 *sqlite, const char *cksum)
{
if (run_prepared_statement(EXISTS, cksum) != SQLITE_ROW) {
ERROR_SQLITE(sqlite);
return (EPKG_FATAL);
}
if (sqlite3_column_int(STMT(EXISTS), 0) > 0) {
return (EPKG_OK);
}
return (EPKG_END);
}
int
pkgdb_loadconflicts(struct pkgdb *db, struct pkg *pkg)
{
sqlite3_stmt *stmt;
struct pkg_conflict *c;
int ret;
const char sql[] = ""
"SELECT name "
"FROM conflicts "
"WHERE package_id = ?1;";
if (pkg->type != PKG_INSTALLED)
return (ERROR_BAD_ARG("pkg"));
if (pkg->flags & PKG_LOAD_CONFLICTS)
return (EPKG_OK);
array_init(&pkg->conflicts, 5);
if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK)
return (ERROR_SQLITE(db->sqlite));
sqlite3_bind_int64(stmt, 1, pkg->rowid);
while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
pkg_conflict_new(&c);
sbuf_set(&c->glob, sqlite3_column_text(stmt, 0));
array_append(&pkg->conflicts, c);
}
sqlite3_finalize(stmt);
if (ret != SQLITE_DONE) {
array_reset(&pkg->conflicts, &pkg_conflict_free_void);
return (ERROR_SQLITE(db->sqlite));
}
pkg->flags |= PKG_LOAD_CONFLICTS;
return (EPKG_OK);
}
int
pkgdb_loadoptions(struct pkgdb *db, struct pkg *pkg)
{
sqlite3_stmt *stmt;
struct pkg_option *o;
int ret;
const char sql[] = ""
"SELECT option, value "
"FROM options "
"WHERE package_id = ?1";
if (pkg->type != PKG_INSTALLED)
return (ERROR_BAD_ARG("pkg"));
if (pkg->flags & PKG_LOAD_OPTIONS)
return (EPKG_OK);
array_init(&pkg->options, 5);
if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK)
return (ERROR_SQLITE(db->sqlite));
sqlite3_bind_int64(stmt, 1, pkg->rowid);
while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
pkg_option_new(&o);
sbuf_set(&o->opt, sqlite3_column_text(stmt, 0));
sbuf_set(&o->value, sqlite3_column_text(stmt, 1));
array_append(&pkg->options, o);
}
sqlite3_finalize(stmt);
if (ret != SQLITE_DONE) {
array_reset(&pkg->options, &pkg_option_free_void);
return (ERROR_SQLITE(db->sqlite));
}
pkg->flags |= PKG_LOAD_OPTIONS;
return (EPKG_OK);
}
int
pkgdb_loadscripts(struct pkgdb *db, struct pkg *pkg)
{
sqlite3_stmt *stmt;
struct pkg_script *s;
int ret;
const char sql[] = ""
"SELECT script, type "
"FROM scripts "
"WHERE package_id = ?1";
if (pkg->type != PKG_INSTALLED)
return (ERROR_BAD_ARG("pkg"));
if (pkg->flags & PKG_LOAD_SCRIPTS)
return (EPKG_OK);
array_init(&pkg->scripts, 6);
if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK)
return (ERROR_SQLITE(db->sqlite));
sqlite3_bind_int64(stmt, 1, pkg->rowid);
while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
pkg_script_new(&s);
sbuf_set(&s->data, sqlite3_column_text(stmt, 0));
s->type = sqlite3_column_int(stmt, 1);
array_append(&pkg->scripts, s);
}
sqlite3_finalize(stmt);
if (ret != SQLITE_DONE) {
array_reset(&pkg->scripts, &pkg_script_free_void);
return (ERROR_SQLITE(db->sqlite));
}
pkg->flags |= PKG_LOAD_SCRIPTS;
return (EPKG_OK);
}
int64_t
pkg_repo_binary_stat(struct pkg_repo *repo, pkg_stats_t type)
{
sqlite3 *sqlite = PRIV_GET(repo);
sqlite3_stmt *stmt = NULL;
int64_t stats = 0;
struct sbuf *sql = NULL;
int ret;
sql = sbuf_new_auto();
switch(type) {
case PKG_STATS_LOCAL_COUNT:
goto out;
break;
case PKG_STATS_LOCAL_SIZE:
goto out;
break;
case PKG_STATS_REMOTE_UNIQUE:
sbuf_printf(sql, "SELECT COUNT(id) FROM main.packages;");
break;
case PKG_STATS_REMOTE_COUNT:
sbuf_printf(sql, "SELECT COUNT(id) FROM main.packages;");
break;
case PKG_STATS_REMOTE_SIZE:
sbuf_printf(sql, "SELECT SUM(pkgsize) FROM main.packages;");
break;
case PKG_STATS_REMOTE_REPOS:
goto out;
break;
}
sbuf_finish(sql);
pkg_debug(4, "binary_repo: running '%s'", sbuf_data(sql));
ret = sqlite3_prepare_v2(sqlite, sbuf_data(sql), -1, &stmt, NULL);
if (ret != SQLITE_OK) {
ERROR_SQLITE(sqlite, sbuf_data(sql));
goto out;
}
while (sqlite3_step(stmt) != SQLITE_DONE) {
stats = sqlite3_column_int64(stmt, 0);
}
out:
sbuf_free(sql);
if (stmt != NULL)
sqlite3_finalize(stmt);
return (stats);
}
int
pkgdb_loadmtree(struct pkgdb *db, struct pkg *pkg)
{
sqlite3_stmt *stmt;
int ret;
const char sql[] = ""
"SELECT m.content "
"FROM mtree AS m, packages AS p "
"WHERE m.id = p.mtree_id "
" AND p.id = ?1;";
if (pkg->type != PKG_INSTALLED)
return (ERROR_BAD_ARG("pkg"));
if (pkg->flags & PKG_LOAD_MTREE)
return (EPKG_OK);
if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK)
return (ERROR_SQLITE(db->sqlite));
sqlite3_bind_int64(stmt, 1, pkg->rowid);
ret = sqlite3_step(stmt);
if (ret == SQLITE_ROW) {
sbuf_set(&pkg->fields[PKG_MTREE].value,
sqlite3_column_text(stmt, 0));
ret = SQLITE_DONE;
}
sqlite3_finalize(stmt);
if (ret != SQLITE_DONE)
return (ERROR_SQLITE(db->sqlite));
pkg->flags |= PKG_LOAD_MTREE;
return (EPKG_OK);
}
static int
initialize_prepared_statements(sqlite3 *sqlite)
{
sql_prstmt_index i;
int ret;
for (i = 0; i < PRSTMT_LAST; i++)
{
ret = sqlite3_prepare_v2(sqlite, SQL(i), -1, &STMT(i), NULL);
if (ret != SQLITE_OK) {
ERROR_SQLITE(sqlite);
return (EPKG_FATAL);
}
}
return (EPKG_OK);
}
int
pkgdb_loaddeps(struct pkgdb *db, struct pkg *pkg)
{
sqlite3_stmt *stmt;
struct pkgdb_it it;
struct pkg *p;
int ret;
const char sql[] = ""
"SELECT p.rowid, p.origin, p.name, p.version, p.comment, p.desc, "
"p.message, p.arch, p.osversion, p.maintainer, p.www, "
"p.prefix, p.flatsize "
"FROM packages AS p, deps AS d "
"WHERE p.origin = d.origin "
"AND d.package_id = ?1;";
if (pkg->type != PKG_INSTALLED)
return (ERROR_BAD_ARG("pkg"));
if (pkg->flags & PKG_LOAD_DEPS)
return (EPKG_OK);
array_init(&pkg->deps, 10);
if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK)
return (ERROR_SQLITE(db->sqlite));
sqlite3_bind_int64(stmt, 1, pkg->rowid);
it.stmt = stmt;
it.db = db;
p = NULL;
while ((ret = pkgdb_it_next(&it, &p, PKG_LOAD_BASIC)) == EPKG_OK) {
array_append(&pkg->deps, p);
p = NULL;
}
sqlite3_finalize(stmt);
if (ret != EPKG_END) {
array_reset(&pkg->deps, &pkg_free_void);
return (ret);
}
pkg->flags |= PKG_LOAD_DEPS;
return (EPKG_OK);
}
struct pkg_repo_it *
pkg_repo_binary_query(struct pkg_repo *repo, const char *pattern, match_t match)
{
sqlite3 *sqlite = PRIV_GET(repo);
sqlite3_stmt *stmt = NULL;
struct sbuf *sql = NULL;
const char *comp = NULL;
int ret;
char basesql[BUFSIZ] = ""
"SELECT id, origin, name, name as uniqueid, version, comment, "
"prefix, desc, arch, maintainer, www, "
"licenselogic, flatsize, pkgsize, "
"cksum, manifestdigest, path AS repopath, '%s' AS dbname "
"FROM packages AS p";
if (match != MATCH_ALL && (pattern == NULL || pattern[0] == '\0'))
return (NULL);
sql = sbuf_new_auto();
comp = pkgdb_get_pattern_query(pattern, match);
if (comp && comp[0])
strlcat(basesql, comp, sizeof(basesql));
sbuf_printf(sql, basesql, repo->name);
sbuf_cat(sql, " ORDER BY name;");
sbuf_finish(sql);
pkg_debug(4, "Pkgdb: running '%s' query for %s", sbuf_data(sql),
pattern == NULL ? "all": pattern);
ret = sqlite3_prepare_v2(sqlite, sbuf_data(sql), sbuf_len(sql), &stmt,
NULL);
if (ret != SQLITE_OK) {
ERROR_SQLITE(sqlite, sbuf_data(sql));
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 (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE));
}
int
pkg_repo_binary_init_prstatements(sqlite3 *sqlite)
{
sql_prstmt_index i, last;
int ret;
last = PRSTMT_LAST;
for (i = 0; i < last; i++) {
ret = sqlite3_prepare_v2(sqlite, SQL(i), -1, &STMT(i), NULL);
if (ret != SQLITE_OK) {
ERROR_SQLITE(sqlite, SQL(i));
return (EPKG_FATAL);
}
}
return (EPKG_OK);
}
struct pkg_repo_it *
pkg_repo_binary_search(struct pkg_repo *repo, const char *pattern, match_t match,
pkgdb_field field, pkgdb_field sort)
{
sqlite3 *sqlite = PRIV_GET(repo);
sqlite3_stmt *stmt = NULL;
struct sbuf *sql = NULL;
int ret;
const char *multireposql = ""
"SELECT id, origin, name, version, comment, "
"prefix, desc, arch, maintainer, www, "
"licenselogic, flatsize, pkgsize, "
"cksum, path AS repopath, '%1$s' AS dbname, '%2$s' AS repourl "
"FROM packages ";
if (pattern == NULL || pattern[0] == '\0')
return (NULL);
sql = sbuf_new_auto();
sbuf_printf(sql, multireposql, repo->name, repo->url);
/* close the UNIONs and build the search query */
sbuf_cat(sql, "WHERE ");
pkg_repo_binary_build_search_query(sql, match, field, sort);
sbuf_cat(sql, ";");
sbuf_finish(sql);
pkg_debug(4, "Pkgdb: running '%s'", sbuf_data(sql));
ret = sqlite3_prepare_v2(sqlite, sbuf_data(sql), -1, &stmt, NULL);
if (ret != SQLITE_OK) {
ERROR_SQLITE(sqlite, sbuf_data(sql));
sbuf_delete(sql);
return (NULL);
}
sbuf_delete(sql);
sqlite3_bind_text(stmt, 1, pattern, -1, SQLITE_TRANSIENT);
return (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE));
}
struct pkgdb_it *
pkgdb_query_which(struct pkgdb *db, const char *path)
{
sqlite3_stmt *stmt;
const char sql[] = ""
"SELECT p.rowid, p.origin, p.name, p.version, p.comment, p.desc, "
"p.message, p.arch, p.osversion, p.maintainer, p.www, "
"p.prefix, p.flatsize "
"FROM packages AS p, files AS f "
"WHERE p.rowid = f.package_id "
"AND f.path = ?1;";
if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
ERROR_SQLITE(db->sqlite);
return (NULL);
}
sqlite3_bind_text(stmt, 1, path, -1, SQLITE_TRANSIENT);
return (pkgdb_it_new(db, stmt, IT_LOCAL));
}
static int
pkg_repo_binary_get_user_version(sqlite3 *sqlite, int *reposcver)
{
sqlite3_stmt *stmt;
int retcode;
const char *sql = "PRAGMA user_version;";
if (sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
ERROR_SQLITE(sqlite, sql);
return (EPKG_FATAL);
}
if (sqlite3_step(stmt) == SQLITE_ROW) {
*reposcver = sqlite3_column_int(stmt, 0);
retcode = EPKG_OK;
} else {
*reposcver = -1;
retcode = EPKG_FATAL;
}
sqlite3_finalize(stmt);
return (retcode);
}
sqlite3_stmt *
pkg_repo_binary_get_origins(sqlite3 *sqlite)
{
sqlite3_stmt *stmt = NULL;
int ret;
const char query_sql[] = ""
"SELECT id, origin, name, name || '~' || origin as uniqueid, version, comment, "
"prefix, desc, arch, maintainer, www, "
"licenselogic, flatsize, pkgsize, "
"cksum, path AS repopath, manifestdigest "
"FROM packages "
"ORDER BY origin;";
pkg_debug(4, "binary_repo: running '%s'", query_sql);
ret = sqlite3_prepare_v2(sqlite, query_sql, -1,
&stmt, NULL);
if (ret != SQLITE_OK) {
ERROR_SQLITE(sqlite, query_sql);
return (NULL);
}
return (stmt);
}
struct pkg_repo_it *
pkg_repo_binary_shlib_provide(struct pkg_repo *repo, const char *require)
{
sqlite3_stmt *stmt;
sqlite3 *sqlite = PRIV_GET(repo);
struct sbuf *sql = NULL;
int ret;
const char basesql[] = ""
"SELECT p.id, p.origin, p.name, p.version, p.comment, "
"p.name as uniqueid, "
"p.prefix, p.desc, p.arch, p.maintainer, p.www, "
"p.licenselogic, p.flatsize, p.pkgsize, "
"p.cksum, p.manifestdigest, p.path AS repopath, '%s' AS dbname "
"FROM packages AS p INNER JOIN pkg_shlibs_provided AS ps ON "
"p.id = ps.package_id "
"WHERE ps.shlib_id IN (SELECT id FROM shlibs WHERE "
"name BETWEEN ?1 AND ?1 || '.9');";
sql = sbuf_new_auto();
sbuf_printf(sql, basesql, repo->name);
sbuf_finish(sql);
pkg_debug(4, "Pkgdb: running '%s'", sbuf_data(sql));
ret = sqlite3_prepare_v2(sqlite, sbuf_data(sql), -1, &stmt, NULL);
if (ret != SQLITE_OK) {
ERROR_SQLITE(sqlite, sbuf_data(sql));
sbuf_delete(sql);
return (NULL);
}
sbuf_delete(sql);
sqlite3_bind_text(stmt, 1, require, -1, SQLITE_TRANSIENT);
return (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE));
}
static int
pkg_repo_binary_register_conflicts(const char *origin, char **conflicts,
int conflicts_num, sqlite3 *sqlite)
{
const char clean_conflicts_sql[] = ""
"DELETE FROM pkg_conflicts "
"WHERE package_id = ?1;";
const char select_id_sql[] = ""
"SELECT id FROM packages "
"WHERE origin = ?1;";
const char insert_conflict_sql[] = ""
"INSERT INTO pkg_conflicts "
"(package_id, conflict_id) "
"VALUES (?1, ?2);";
sqlite3_stmt *stmt = NULL;
int ret, i;
int64_t origin_id, conflict_id;
pkg_debug(4, "pkgdb_repo_register_conflicts: running '%s'", select_id_sql);
if (sqlite3_prepare_v2(sqlite, select_id_sql, -1, &stmt, NULL) != SQLITE_OK) {
ERROR_SQLITE(sqlite, select_id_sql);
return (EPKG_FATAL);
}
sqlite3_bind_text(stmt, 1, origin, -1, SQLITE_TRANSIENT);
ret = sqlite3_step(stmt);
if (ret == SQLITE_ROW) {
origin_id = sqlite3_column_int64(stmt, 0);
}
else {
ERROR_SQLITE(sqlite, select_id_sql);
return (EPKG_FATAL);
}
sqlite3_finalize(stmt);
pkg_debug(4, "pkgdb_repo_register_conflicts: running '%s'", clean_conflicts_sql);
if (sqlite3_prepare_v2(sqlite, clean_conflicts_sql, -1, &stmt, NULL) != SQLITE_OK) {
ERROR_SQLITE(sqlite, clean_conflicts_sql);
return (EPKG_FATAL);
}
sqlite3_bind_int64(stmt, 1, origin_id);
/* Ignore cleanup result */
(void)sqlite3_step(stmt);
sqlite3_finalize(stmt);
for (i = 0; i < conflicts_num; i ++) {
/* Select a conflict */
pkg_debug(4, "pkgdb_repo_register_conflicts: running '%s'", select_id_sql);
if (sqlite3_prepare_v2(sqlite, select_id_sql, -1, &stmt, NULL) != SQLITE_OK) {
ERROR_SQLITE(sqlite, select_id_sql);
return (EPKG_FATAL);
}
sqlite3_bind_text(stmt, 1, conflicts[i], -1, SQLITE_TRANSIENT);
ret = sqlite3_step(stmt);
if (ret == SQLITE_ROW) {
conflict_id = sqlite3_column_int64(stmt, 0);
}
else {
ERROR_SQLITE(sqlite, select_id_sql);
return (EPKG_FATAL);
}
sqlite3_finalize(stmt);
/* Insert a pair */
pkg_debug(4, "pkgdb_repo_register_conflicts: running '%s'", insert_conflict_sql);
if (sqlite3_prepare_v2(sqlite, insert_conflict_sql, -1, &stmt, NULL) != SQLITE_OK) {
ERROR_SQLITE(sqlite, insert_conflict_sql);
return (EPKG_FATAL);
}
sqlite3_bind_int64(stmt, 1, origin_id);
sqlite3_bind_int64(stmt, 2, conflict_id);
ret = sqlite3_step(stmt);
if (ret != SQLITE_DONE) {
ERROR_SQLITE(sqlite, insert_conflict_sql);
return (EPKG_FATAL);
}
sqlite3_finalize(stmt);
}
return (EPKG_OK);
}
static int
pkg_repo_binary_add_pkg(struct pkg *pkg, const char *pkg_path,
sqlite3 *sqlite, bool forced)
{
const char *name, *version, *origin, *comment, *desc;
const char *arch, *maintainer, *www, *prefix, *sum, *rpath;
const char *olddigest, *manifestdigest;
int64_t flatsize, pkgsize;
int64_t licenselogic;
int ret;
struct pkg_dep *dep = NULL;
struct pkg_option *option = NULL;
struct pkg_shlib *shlib = NULL;
const pkg_object *obj, *licenses, *categories, *annotations;
pkg_iter it;
int64_t package_id;
pkg_get(pkg, PKG_ORIGIN, &origin, PKG_NAME, &name,
PKG_VERSION, &version, PKG_COMMENT, &comment,
PKG_DESC, &desc, PKG_ARCH, &arch,
PKG_MAINTAINER, &maintainer, PKG_WWW, &www,
PKG_PREFIX, &prefix, PKG_FLATSIZE, &flatsize,
PKG_LICENSE_LOGIC, &licenselogic, PKG_CKSUM, &sum,
PKG_PKGSIZE, &pkgsize, PKG_REPOPATH, &rpath,
PKG_LICENSES, &licenses, PKG_CATEGORIES, &categories,
PKG_ANNOTATIONS, &annotations, PKG_OLD_DIGEST, &olddigest,
PKG_DIGEST, &manifestdigest);
try_again:
if ((ret = pkg_repo_binary_run_prstatement(PKG, origin, name, version,
comment, desc, arch, maintainer, www, prefix,
pkgsize, flatsize, (int64_t)licenselogic, sum,
rpath, manifestdigest, olddigest)) != SQLITE_DONE) {
if (ret == SQLITE_CONSTRAINT) {
switch(pkg_repo_binary_delete_conflicting(origin,
version, pkg_path, forced)) {
case EPKG_FATAL: /* sqlite error */
ERROR_SQLITE(sqlite, pkg_repo_binary_sql_prstatement(PKG));
return (EPKG_FATAL);
break;
case EPKG_END: /* repo already has newer */
return (EPKG_END);
break;
default: /* conflict cleared, try again */
goto try_again;
break;
}
} else {
ERROR_SQLITE(sqlite, pkg_repo_binary_sql_prstatement(PKG));
return (EPKG_FATAL);
}
}
package_id = sqlite3_last_insert_rowid(sqlite);
if (pkg_repo_binary_run_prstatement (FTS_APPEND, package_id,
name, version, origin) != SQLITE_DONE) {
ERROR_SQLITE(sqlite, pkg_repo_binary_sql_prstatement(FTS_APPEND));
return (EPKG_FATAL);
}
dep = NULL;
while (pkg_deps(pkg, &dep) == EPKG_OK) {
if (pkg_repo_binary_run_prstatement(DEPS,
pkg_dep_origin(dep),
pkg_dep_name(dep),
pkg_dep_version(dep),
package_id) != SQLITE_DONE) {
ERROR_SQLITE(sqlite, pkg_repo_binary_sql_prstatement(DEPS));
return (EPKG_FATAL);
}
}
it = NULL;
while ((obj = pkg_object_iterate(categories, &it))) {
ret = pkg_repo_binary_run_prstatement(CAT1, pkg_object_string(obj));
if (ret == SQLITE_DONE)
ret = pkg_repo_binary_run_prstatement(CAT2, package_id,
pkg_object_string(obj));
if (ret != SQLITE_DONE)
{
ERROR_SQLITE(sqlite, pkg_repo_binary_sql_prstatement(CAT2));
return (EPKG_FATAL);
}
}
it = NULL;
while ((obj = pkg_object_iterate(licenses, &it))) {
ret = pkg_repo_binary_run_prstatement(LIC1, pkg_object_string(obj));
if (ret == SQLITE_DONE)
ret = pkg_repo_binary_run_prstatement(LIC2, package_id,
pkg_object_string(obj));
if (ret != SQLITE_DONE) {
ERROR_SQLITE(sqlite, pkg_repo_binary_sql_prstatement(LIC2));
return (EPKG_FATAL);
}
}
option = NULL;
while (pkg_options(pkg, &option) == EPKG_OK) {
ret = pkg_repo_binary_run_prstatement(OPT1, pkg_option_opt(option));
if (ret == SQLITE_DONE)
ret = pkg_repo_binary_run_prstatement(OPT2, pkg_option_opt(option),
pkg_option_value(option), package_id);
if(ret != SQLITE_DONE) {
ERROR_SQLITE(sqlite, pkg_repo_binary_sql_prstatement(OPT2));
return (EPKG_FATAL);
}
}
shlib = NULL;
while (pkg_shlibs_required(pkg, &shlib) == EPKG_OK) {
const char *shlib_name = pkg_shlib_name(shlib);
ret = pkg_repo_binary_run_prstatement(SHLIB1, shlib_name);
if (ret == SQLITE_DONE)
ret = pkg_repo_binary_run_prstatement(SHLIB_REQD, package_id,
shlib_name);
if (ret != SQLITE_DONE) {
ERROR_SQLITE(sqlite, pkg_repo_binary_sql_prstatement(SHLIB_REQD));
return (EPKG_FATAL);
}
}
shlib = NULL;
while (pkg_shlibs_provided(pkg, &shlib) == EPKG_OK) {
const char *shlib_name = pkg_shlib_name(shlib);
ret = pkg_repo_binary_run_prstatement(SHLIB1, shlib_name);
if (ret == SQLITE_DONE)
ret = pkg_repo_binary_run_prstatement(SHLIB_PROV, package_id,
shlib_name);
if (ret != SQLITE_DONE) {
ERROR_SQLITE(sqlite, pkg_repo_binary_sql_prstatement(SHLIB_PROV));
return (EPKG_FATAL);
}
}
it = NULL;
while ((obj = pkg_object_iterate(annotations, &it))) {
const char *note_tag = pkg_object_key(obj);
const char *note_val = pkg_object_string(obj);
ret = pkg_repo_binary_run_prstatement(ANNOTATE1, note_tag);
if (ret == SQLITE_DONE)
ret = pkg_repo_binary_run_prstatement(ANNOTATE1, note_val);
if (ret == SQLITE_DONE)
ret = pkg_repo_binary_run_prstatement(ANNOTATE2, package_id,
note_tag, note_val);
if (ret != SQLITE_DONE) {
ERROR_SQLITE(sqlite, pkg_repo_binary_sql_prstatement(ANNOTATE2));
return (EPKG_FATAL);
}
}
return (EPKG_OK);
}