/*
* Copyright (C) 2018 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#define G_LOG_DOMAIN "XbSilo"
#include "config.h"
#include <string.h>
#include <gio/gio.h>
#include "xb-node-private.h"
#include "xb-opcode.h"
#include "xb-silo-private.h"
#include "xb-silo-query-private.h"
#include "xb-stack-private.h"
#include "xb-query-private.h"
static gboolean
xb_silo_query_node_matches (XbSilo *self,
XbMachine *machine,
XbSiloNode *sn,
XbQuerySection *section,
XbSiloQueryData *query_data,
gboolean *result,
GError **error)
{
/* we have an index into the string table */
if (section->element_idx != sn->element_name &&
section->kind != XB_SILO_QUERY_KIND_WILDCARD) {
*result = FALSE;
return TRUE;
}
/* for section */
query_data->position += 1;
/* check predicates */
if (section->predicates != NULL) {
for (guint i = 0; i < section->predicates->len; i++) {
XbStack *opcodes = g_ptr_array_index (section->predicates, i);
if (!xb_machine_run (machine, opcodes, result, query_data, error))
return FALSE;
}
}
/* success */
return TRUE;
}
typedef struct {
GPtrArray *sections; /* of XbQuerySection */
GPtrArray *results; /* of XbNode */
GHashTable *results_hash; /* of sn:1 */
guint limit;
XbSiloQueryData *query_data;
} XbSiloQueryHelper;
static gboolean
xb_silo_query_section_add_result (XbSilo *self, XbSiloQueryHelper *helper, XbSiloNode *sn)
{
if (g_hash_table_lookup (helper->results_hash, sn) != NULL)
return FALSE;
g_ptr_array_add (helper->results, xb_silo_node_create (self, sn));
g_hash_table_add (helper->results_hash, sn);
return helper->results->len == helper->limit;
}
/*
* @parent: (allow-none)
*/
static gboolean
xb_silo_query_section_root (XbSilo *self,
XbSiloNode *sn,
guint i,
XbSiloQueryHelper *helper,
GError **error)
{
XbMachine *machine = xb_silo_get_machine (self);
XbSiloQueryData *query_data = helper->query_data;
XbQuerySection *section = g_ptr_array_index (helper->sections, i);
/* handle parent */
if (section->kind == XB_SILO_QUERY_KIND_PARENT) {
XbSiloNode *parent;
if (sn == NULL) {
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
"cannot obtain parent for root");
return FALSE;
}
parent = xb_silo_node_get_parent (self, sn);
if (parent == NULL) {
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
"no parent set for %s",
xb_silo_node_get_element (self, sn));
return FALSE;
}
if (i == helper->sections->len - 1) {
xb_silo_query_section_add_result (self, helper, parent);
return TRUE;
}
// g_debug ("PARENT @%u",
// xb_silo_get_offset_for_node (self, parent));
return xb_silo_query_section_root (self, parent, i + 1, helper, error);
}
/* no node means root */
if (sn == NULL) {
sn = xb_silo_get_sroot (self);
if (sn == NULL) {
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_NOT_FOUND,
"silo root not found");
return FALSE;
}
} else {
sn = xb_silo_node_get_child (self, sn);
if (sn == NULL)
return TRUE;
}
/* set up level pointer */
query_data->position = 0;
/* continue matching children ".." */
do {
gboolean result = TRUE;
query_data->sn = sn;
if (!xb_silo_query_node_matches (self, machine, sn, section,
query_data, &result, error))
return FALSE;
if (result) {
if (i == helper->sections->len - 1) {
// g_debug ("add result %u",
// xb_silo_get_offset_for_node (self, sn));
if (xb_silo_query_section_add_result (self, helper, sn))
break;
} else {
// g_debug ("MATCH %s at @%u, deeper",
// xb_silo_node_get_element (self, sn),
// xb_silo_get_offset_for_node (self, sn));
if (!xb_silo_query_section_root (self, sn, i + 1, helper, error))
return FALSE;
if (helper->results->len > 0 &&
helper->results->len == helper->limit)
break;
}
}
if (sn->next == 0x0)
break;
sn = xb_silo_get_node (self, sn->next);
} while (TRUE);
return TRUE;
}
static gboolean
xb_silo_query_part (XbSilo *self,
XbSiloNode *sroot,
GPtrArray *results,
GHashTable *results_hash,
XbQuery *query,
XbSiloQueryData *query_data,
GError **error)
{
XbSiloQueryHelper helper = {
.results = results,
.limit = xb_query_get_limit (query),
.results_hash = results_hash,
.query_data = query_data,
};
/* find each section */
helper.sections = xb_query_get_sections (query);
return xb_silo_query_section_root (self, sroot, 0, &helper, error);
}
/**
* xb_silo_query_with_root: (skip)
* @self: a #XbSilo
* @n: (allow-none): a #XbNode
* @xpath: an XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
* @limit: maximum number of results to return, or 0 for "all"
* @error: the #GError, or %NULL
*
* Searches the silo using an XPath query, returning up to @limit results.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
*
* Returns: (transfer container) (element-type XbNode): results, or %NULL if unfound
*
* Since: 0.1.0
**/
GPtrArray *
xb_silo_query_with_root (XbSilo *self, XbNode *n, const gchar *xpath, guint limit, GError **error)
{
XbSiloNode *sn = NULL;
g_auto(GStrv) split = NULL;
g_autoptr(GHashTable) results_hash = g_hash_table_new (g_direct_hash, g_direct_equal);
g_autoptr(GPtrArray) results = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
g_autoptr(GTimer) timer = g_timer_new ();
XbSiloQueryData query_data = {
.sn = NULL,
.position = 0,
};
g_return_val_if_fail (XB_IS_SILO (self), NULL);
g_return_val_if_fail (xpath != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
/* empty silo */
if (xb_silo_is_empty (self)) {
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_NOT_FOUND,
"silo has no data");
return NULL;
}
/* subtree query */
if (n != NULL) {
sn = xb_node_get_sn (n);
if (xpath[0] == '/') {
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_NOT_SUPPORTED,
"XPath node query not supported");
return NULL;
}
} else {
/* assume it's just a root query */
if (xpath[0] == '/')
xpath++;
}
/* do 'or' searches */
split = g_strsplit (xpath, "|", -1);
for (guint i = 0; split[i] != NULL; i++) {
g_autoptr(GError) error_local = NULL;
g_autoptr(XbQuery) query = xb_query_new (self, split[i], &error_local);
if (query == NULL) {
if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT) &&
(split[i + 1] != NULL || results->len > 0)) {
g_debug ("ignoring for OR statement: %s",
error_local->message);
continue;
}
g_propagate_prefixed_error (error,
g_steal_pointer (&error_local),
"failed to process %s: ",
xpath);
return NULL;
}
xb_query_set_limit (query, limit);
if (!xb_silo_query_part (self, sn,
results, results_hash,
query, &query_data,
error)) {
return NULL;
}
}
/* profile */
if (xb_silo_get_profile_flags (self) & XB_SILO_PROFILE_FLAG_XPATH) {
xb_silo_add_profile (self, timer,
"query on %s with `%s` limit=%u -> %u results",
n != NULL ? xb_node_get_element (n) : "/",
xpath, limit, results->len);
}
/* nothing found */
if (results->len == 0) {
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_NOT_FOUND,
"no results for XPath query '%s'",
xpath);
return NULL;
}
return g_steal_pointer (&results);
}
static void
_g_ptr_array_reverse (GPtrArray *array)
{
guint last_idx = array->len - 1;
for (guint i = 0; i < array->len / 2; i++) {
gpointer tmp = array->pdata[i];
array->pdata[i] = array->pdata[last_idx - i];
array->pdata[last_idx - i] = tmp;
}
}
/**
* xb_silo_query_with_root_full: (skip)
* @self: a #XbSilo
* @n: (allow-none): a #XbNode
* @query: an #XbQuery
* @error: the #GError, or %NULL
*
* Searches the silo using an XPath query, returning up to @limit results.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
*
* Returns: (transfer container) (element-type XbNode): results, or %NULL if unfound
*
* Since: 0.1.4
**/
GPtrArray *
xb_silo_query_with_root_full (XbSilo *self, XbNode *n, XbQuery *query, GError **error)
{
XbSiloNode *sn = NULL;
g_autoptr(GHashTable) results_hash = g_hash_table_new (g_direct_hash, g_direct_equal);
g_autoptr(GPtrArray) results = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
g_autoptr(GTimer) timer = g_timer_new ();
XbSiloQueryData query_data = {
.sn = NULL,
.position = 0,
};
/* empty silo */
if (xb_silo_is_empty (self)) {
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_NOT_FOUND,
"silo has no data");
return NULL;
}
/* subtree query */
if (n != NULL)
sn = xb_node_get_sn (n);
/* only one query allowed */
if (!xb_silo_query_part (self, sn, results, results_hash,
query, &query_data, error))
return NULL;
/* profile */
if (xb_silo_get_profile_flags (self) & XB_SILO_PROFILE_FLAG_XPATH) {
g_autofree gchar *tmp = xb_query_to_string (query);
xb_silo_add_profile (self, timer,
"query on %s with `%s` limit=%u -> %u results",
n != NULL ? xb_node_get_element (n) : "/",
tmp,
xb_query_get_limit (query),
results->len);
}
/* nothing found */
if (results->len == 0) {
g_autofree gchar *tmp = xb_query_to_string (query);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_NOT_FOUND,
"no results for XPath query '%s'",
tmp);
return NULL;
}
/* reverse order */
if (xb_query_get_flags (query) & XB_QUERY_FLAG_REVERSE)
_g_ptr_array_reverse (results);
return g_steal_pointer (&results);
}
/**
* xb_silo_query_full:
* @self: a #XbSilo
* @query: an #XbQuery
* @error: the #GError, or %NULL
*
* Searches the silo using an XPath query.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
*
* Returns: (transfer container) (element-type XbNode): results, or %NULL if unfound
*
* Since: 0.1.13
**/
GPtrArray *
xb_silo_query_full (XbSilo *self, XbQuery *query, GError **error)
{
g_return_val_if_fail (XB_IS_SILO (self), NULL);
g_return_val_if_fail (XB_IS_QUERY (query), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
return xb_silo_query_with_root_full (self, NULL, query, error);
}
/**
* xb_silo_query_first_full:
* @self: a #XbSilo
* @query: an #XbQuery
* @error: the #GError, or %NULL
*
* Searches the silo using an XPath query, returning up to one result.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a tiny subset of XPath 1.0 is supported.
*
* Returns: (transfer none): a #XbNode, or %NULL if unfound
*
* Since: 0.1.13
**/
XbNode *
xb_silo_query_first_full (XbSilo *self, XbQuery *query, GError **error)
{
g_autoptr(GPtrArray) results = NULL;
results = xb_silo_query_full (self, query, error);
if (results == NULL)
return NULL;
return g_object_ref (g_ptr_array_index (results, 0));
}
/**
* xb_silo_query:
* @self: a #XbSilo
* @xpath: an XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
* @limit: maximum number of results to return, or 0 for "all"
* @error: the #GError, or %NULL
*
* Searches the silo using an XPath query, returning up to @limit results.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
*
* Returns: (transfer container) (element-type XbNode): results, or %NULL if unfound
*
* Since: 0.1.0
**/
GPtrArray *
xb_silo_query (XbSilo *self, const gchar *xpath, guint limit, GError **error)
{
g_return_val_if_fail (XB_IS_SILO (self), NULL);
g_return_val_if_fail (xpath != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
return xb_silo_query_with_root (self, NULL, xpath, limit, error);
}
/**
* xb_silo_query_first:
* @self: a #XbSilo
* @xpath: An XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
* @error: the #GError, or %NULL
*
* Searches the silo using an XPath query, returning up to one result.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a tiny subset of XPath 1.0 is supported.
*
* Returns: (transfer none): a #XbNode, or %NULL if unfound
*
* Since: 0.1.0
**/
XbNode *
xb_silo_query_first (XbSilo *self, const gchar *xpath, GError **error)
{
g_autoptr(GPtrArray) results = NULL;
results = xb_silo_query_with_root (self, NULL, xpath, 1, error);
if (results == NULL)
return NULL;
return g_object_ref (g_ptr_array_index (results, 0));
}
/**
* xb_silo_query_build_index:
* @self: a #XbSilo
* @xpath: An XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
* @attr: (nullable): Attribute name, e.g. `type`, or NULL
* @error: the #GError, or %NULL
*
* Adds the `attr()` or `text()` results of a query to the index.
*
* Returns: %TRUE for success
*
* Since: 0.1.4
**/
gboolean
xb_silo_query_build_index (XbSilo *self,
const gchar *xpath,
const gchar *attr,
GError **error)
{
g_autoptr(GError) error_local = NULL;
g_autoptr(GPtrArray) array = NULL;
g_return_val_if_fail (XB_IS_SILO (self), FALSE);
g_return_val_if_fail (xpath != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* do the query */
array = xb_silo_query_with_root (self, NULL, xpath, 0, &error_local);
if (array == NULL) {
if (g_error_matches (error_local,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT) ||
g_error_matches (error_local,
G_IO_ERROR,
G_IO_ERROR_NOT_FOUND)) {
g_debug ("ignoring index: %s", error_local->message);
return TRUE;
}
g_propagate_error (error, g_steal_pointer (&error_local));
return FALSE;
}
/* add each attribute name AND value */
for (guint i = 0; i < array->len; i++) {
XbNode *n = g_ptr_array_index (array, i);
XbSiloNode *sn = xb_node_get_sn (n);
if (attr != NULL) {
guint32 off = xb_silo_get_offset_for_node (self, sn);
for (guint8 j = 0; j < sn->nr_attrs; j++) {
XbSiloAttr *a = xb_silo_get_attr (self, off, j);
xb_silo_strtab_index_insert (self, a->attr_name);
xb_silo_strtab_index_insert (self, a->attr_value);
}
} else {
xb_silo_strtab_index_insert (self, sn->text);
}
}
/* success */
return TRUE;
}