void
xmms_medialib_entry_cleanup (xmms_medialib_session_t *session,
xmms_medialib_entry_t entry)
{
s4_resultset_t *set;
s4_val_t *song_id;
gint i;
song_id = s4_val_new_int (entry);
set = xmms_medialib_filter (session, "song_id", song_id,
S4_COND_PARENT, NULL, NULL, S4_FETCH_DATA);
for (i = 0; i < s4_resultset_get_rowcount (set); i++) {
const s4_result_t *res;
res = s4_resultset_get_result (set, i, 0);
while (res != NULL) {
const gchar *src = s4_result_get_src (res);
const gchar *key = s4_result_get_key (res);
if (entry_attribute_is_derived (src, key)) {
const s4_val_t *value = s4_result_get_val (res);
xmms_medialib_session_property_unset (session, entry, key,
value, src);
}
res = s4_result_next (res);
}
}
s4_resultset_free (set);
s4_val_free (song_id);
}
gint
xmms_medialib_session_property_unset (xmms_medialib_session_t *session,
xmms_medialib_entry_t entry,
const gchar *key,
const s4_val_t *value,
const gchar *source)
{
GHashTable *events;
s4_val_t *song_id;
gint result;
song_id = s4_val_new_int (entry);
result = s4_del (session->trans, "song_id", song_id,
key, value, source);
s4_val_free (song_id);
if (strcmp (key, XMMS_MEDIALIB_ENTRY_PROPERTY_URL) == 0) {
events = xmms_medialib_session_get_table (&session->removed);
} else {
events = xmms_medialib_session_get_table (&session->updated);
}
g_hash_table_insert (events,
GINT_TO_POINTER (entry),
GINT_TO_POINTER (entry));
return result;
}
/**
* @internal
*/
static xmms_medialib_entry_t
xmms_medialib_get_id (xmms_medialib_session_t *session, const char *url, xmms_error_t *error)
{
s4_sourcepref_t *sourcepref;
s4_resultset_t *set;
s4_val_t *value;
const s4_result_t *res;
gint32 id = 0;
sourcepref = xmms_medialib_session_get_source_preferences (session);
value = s4_val_new_string (url);
set = xmms_medialib_filter (session, XMMS_MEDIALIB_ENTRY_PROPERTY_URL,
value, 0, sourcepref, "song_id", S4_FETCH_PARENT);
s4_val_free (value);
s4_sourcepref_unref (sourcepref);
res = s4_resultset_get_result (set, 0, 0);
if (res != NULL) {
s4_val_get_int (s4_result_get_val (res), &id);
}
s4_resultset_free (set);
return id;
}
/**
* Remove a medialib entry from the database
*
* @param id_num Entry to remove
*/
void
xmms_medialib_entry_remove (xmms_medialib_session_t *session,
xmms_medialib_entry_t entry)
{
s4_resultset_t *set;
s4_val_t *song_id;
gint i;
song_id = s4_val_new_int (entry);
set = xmms_medialib_filter (session, "song_id", song_id,
S4_COND_PARENT, NULL, NULL, S4_FETCH_DATA);
for (i = 0; i < s4_resultset_get_rowcount (set); i++) {
const s4_result_t *res;
res = s4_resultset_get_result (set, i, 0);
while (res != NULL) {
xmms_medialib_session_property_unset (session, entry,
s4_result_get_key (res),
s4_result_get_val (res),
s4_result_get_src (res));
res = s4_result_next (res);
}
}
s4_resultset_free (set);
s4_val_free (song_id);
}
static void
xmms_medialib_property_remove (xmms_medialib_session_t *session,
xmms_medialib_entry_t entry,
const gchar *source, const gchar *key,
xmms_error_t *error)
{
const char *sources[2] = { source, NULL };
s4_sourcepref_t *sp;
s4_resultset_t *set;
const s4_result_t *res;
s4_val_t *song_id;
sp = s4_sourcepref_create (sources);
song_id = s4_val_new_int (entry);
set = xmms_medialib_filter (session, "song_id", song_id,
S4_COND_PARENT, sp, key, S4_FETCH_DATA);
res = s4_resultset_get_result (set, 0, 0);
if (res != NULL) {
xmms_medialib_session_property_unset (session, entry, key,
s4_result_get_val (res),
source);
}
s4_resultset_free (set);
s4_sourcepref_unref (sp);
s4_val_free (song_id);
}
gint
xmms_medialib_session_property_set (xmms_medialib_session_t *session,
xmms_medialib_entry_t entry,
const gchar *key,
const s4_val_t *value,
const gchar *source)
{
const gchar *sources[2] = { source, NULL };
const s4_result_t *res;
s4_condition_t *cond;
s4_fetchspec_t *spec;
s4_resultset_t *set;
s4_sourcepref_t *sp;
s4_val_t *song_id;
gint result;
GHashTable *events;
song_id = s4_val_new_int (entry);
sp = s4_sourcepref_create (sources);
cond = s4_cond_new_filter (S4_FILTER_EQUAL, "song_id", song_id,
sp, S4_CMP_CASELESS, S4_COND_PARENT);
spec = s4_fetchspec_create ();
s4_fetchspec_add (spec, key, sp, S4_FETCH_DATA);
set = s4_query (session->trans, spec, cond);
s4_cond_free (cond);
s4_fetchspec_free (spec);
res = s4_resultset_get_result (set, 0, 0);
if (res != NULL) {
const s4_val_t *old_value = s4_result_get_val (res);
s4_del (session->trans, "song_id", song_id,
key, old_value, source);
}
s4_resultset_free (set);
s4_sourcepref_unref (sp);
result = s4_add (session->trans, "song_id", song_id,
key, value, source);
s4_val_free (song_id);
if (strcmp (key, XMMS_MEDIALIB_ENTRY_PROPERTY_URL) == 0) {
events = xmms_medialib_session_get_table (&session->added);
} else {
events = xmms_medialib_session_get_table (&session->updated);
}
g_hash_table_insert (events,
GINT_TO_POINTER (entry),
GINT_TO_POINTER (entry));
return result;
}
static s4_resultset_t *
not_resolved_set (xmms_medialib_session_t *session)
{
s4_condition_t *cond1, *cond2, *cond;
s4_sourcepref_t *sourcepref;
s4_fetchspec_t *spec;
s4_resultset_t *ret;
s4_val_t *v1, *v2;
sourcepref = xmms_medialib_session_get_source_preferences (session);
v1 = s4_val_new_int (XMMS_MEDIALIB_ENTRY_STATUS_NEW);
v2 = s4_val_new_int (XMMS_MEDIALIB_ENTRY_STATUS_REHASH);
cond1 = s4_cond_new_filter (S4_FILTER_EQUAL,
XMMS_MEDIALIB_ENTRY_PROPERTY_STATUS,
v1, sourcepref, S4_CMP_CASELESS, 0);
cond2 = s4_cond_new_filter (S4_FILTER_EQUAL,
XMMS_MEDIALIB_ENTRY_PROPERTY_STATUS,
v2, sourcepref, S4_CMP_CASELESS, 0);
cond = s4_cond_new_combiner (S4_COMBINE_OR);
s4_cond_add_operand (cond, cond1);
s4_cond_add_operand (cond, cond2);
spec = s4_fetchspec_create ();
s4_fetchspec_add (spec, "song_id", sourcepref, S4_FETCH_PARENT);
ret = xmms_medialib_session_query (session, spec, cond);
s4_sourcepref_unref (sourcepref);
s4_fetchspec_free (spec);
s4_cond_free (cond);
s4_cond_free (cond1);
s4_cond_free (cond2);
s4_val_free (v1);
s4_val_free (v2);
return ret;
}
static void create_db (struct db_struct *db)
{
s4_val_t *name_val, *arg_val;
int i, j;
for (i = 0; db[i].name != NULL; i++) {
name_val = s4_val_new_string (db[i].name);
for (j = 0; db[i].args[j] != NULL; j++) {
s4_transaction_t *trans;
arg_val = s4_val_new_string (db[i].args[j]);
trans = s4_begin (s4, 0);
CU_ASSERT (s4_add (trans, "entry", name_val, "property", arg_val, db[i].src));
s4_commit (trans);
s4_val_free (arg_val);
}
s4_val_free (name_val);
}
}
static xmmsv_t *
xmms_medialib_entry_to_tree (xmms_medialib_session_t *session,
xmms_medialib_entry_t entry)
{
s4_resultset_t *set;
s4_val_t *song_id;
xmmsv_t *ret, *id;
gint i;
song_id = s4_val_new_int (entry);
set = xmms_medialib_filter (session, "song_id", song_id, S4_COND_PARENT,
NULL, NULL, S4_FETCH_PARENT | S4_FETCH_DATA);
s4_val_free (song_id);
ret = xmmsv_new_dict ();
for (i = 0; i < s4_resultset_get_rowcount (set); i++) {
const s4_result_t *res;
res = s4_resultset_get_result (set, 0, 0);
while (res != NULL) {
xmmsv_t *v_entry = NULL;
const s4_val_t *val;
const char *s;
gint32 i;
val = s4_result_get_val (res);
if (s4_val_get_str (val, &s)) {
v_entry = xmmsv_new_string (s);
} else if (s4_val_get_int (val, &i)) {
v_entry = xmmsv_new_int (i);
}
xmms_medialib_tree_add_tuple (ret, s4_result_get_key (res),
s4_result_get_src (res), v_entry);
xmmsv_unref (v_entry);
res = s4_result_next (res);
}
}
s4_resultset_free (set);
id = xmmsv_new_int (entry);
xmms_medialib_tree_add_tuple (ret, "id", "server", id);
xmmsv_unref (id);
return ret;
}
gboolean
xmms_medialib_entry_property_set_int_source (xmms_medialib_session_t *session,
xmms_medialib_entry_t id_num,
const gchar *property, gint value,
const gchar *source)
{
gboolean ret;
s4_val_t *prop;
g_return_val_if_fail (property, FALSE);
prop = s4_val_new_int (value);
ret = xmms_medialib_session_property_set (session, id_num, property, prop, source);
s4_val_free (prop);
return ret;
}
gchar *
xmms_medialib_entry_property_get_str (xmms_medialib_session_t *session,
xmms_medialib_entry_t entry,
const gchar *property)
{
const gchar *string;
gchar *result = NULL;
s4_val_t *value;
value = xmms_medialib_entry_property_get (session, entry, property);
if (value != NULL && s4_val_get_str (value, &string)) {
result = g_strdup (string);
}
s4_val_free (value);
return result;
}
static void
xmms_medialib_client_rehash (xmms_medialib_t *medialib,
xmms_medialib_entry_t entry,
xmms_error_t *error)
{
xmms_medialib_session_t *session;
do {
session = xmms_medialib_session_begin (medialib);
if (xmms_medialib_check_id (session, entry)) {
xmms_medialib_entry_status_set (session, entry, XMMS_MEDIALIB_ENTRY_STATUS_REHASH);
} else if (entry == 0) {
s4_sourcepref_t *sourcepref;
s4_resultset_t *set;
s4_val_t *status;
gint i;
sourcepref = xmms_medialib_session_get_source_preferences (session);
status = s4_val_new_int (XMMS_MEDIALIB_ENTRY_STATUS_OK);
set = xmms_medialib_filter (session, XMMS_MEDIALIB_ENTRY_PROPERTY_STATUS,
status, 0, sourcepref, "song_id", S4_FETCH_PARENT);
s4_val_free (status);
s4_sourcepref_unref (sourcepref);
for (i = 0; i < s4_resultset_get_rowcount (set); i++) {
const s4_result_t *res;
res = s4_resultset_get_result (set, i, 0);
for (; res != NULL; res = s4_result_next (res)) {
xmms_medialib_entry_t item;
s4_val_get_int (s4_result_get_val (res), &item);
xmms_medialib_entry_status_set (session, item, XMMS_MEDIALIB_ENTRY_STATUS_REHASH);
}
}
s4_resultset_free (set);
} else {
xmms_error_set (error, XMMS_ERROR_NOENT, "No such entry");
}
} while (!xmms_medialib_session_commit (session));
}
/**
* Retrieve a property as a int from a entry.
*
* @param id_num Entry to query.
* @param property The property to extract. Strings passed should
* be defined in medialib.h
*
* @returns Property as integer, or -1 if it doesn't exist.
*/
gint
xmms_medialib_entry_property_get_int (xmms_medialib_session_t *session,
xmms_medialib_entry_t id_num,
const gchar *property)
{
gint32 ret;
s4_val_t *prop;
prop = xmms_medialib_entry_property_get (session, id_num, property);
if (prop == NULL) {
return -1;
}
if (!s4_val_get_int (prop, &ret)) {
ret = -1;
}
s4_val_free (prop);
return ret;
}
static void check_db (struct db_struct *db)
{
int i, j;
s4_fetchspec_t *fs = s4_fetchspec_create ();
s4_fetchspec_add (fs, NULL, NULL, S4_FETCH_DATA);
for (i = 0; db[i].name != NULL; i++) {
s4_val_t *name_val = s4_val_new_string (db[i].name);
s4_condition_t *cond = s4_cond_new_filter (S4_FILTER_EQUAL,
"entry", name_val, NULL, S4_CMP_CASELESS, S4_COND_PARENT);
s4_transaction_t *trans = s4_begin (s4, 0);
s4_resultset_t *set = s4_query (trans, fs, cond);
s4_commit (trans);
const s4_result_t *res = s4_resultset_get_result (set, 0, 0);
int found[ARG_SIZE] = {0};
for (; res != NULL; res = s4_result_next (res)) {
for (j = 0; db[i].args[j] != NULL; j++) {
const char *str;
if (s4_val_get_str (s4_result_get_val (res), &str) && !strcmp (str, db[i].args[j]) &&
!strcmp (s4_result_get_key (res), "property") &&
!strcmp (s4_result_get_src (res), db[i].src)) {
found[j] = 1;
break;
}
}
}
for (j = 0; db[i].args[j] != NULL; j++) {
CU_ASSERT_EQUAL (found[j], 1);
}
s4_resultset_free (set);
s4_cond_free (cond);
s4_val_free (name_val);
}
s4_fetchspec_free (fs);
}
gboolean
xmms_medialib_entry_property_set_str_source (xmms_medialib_session_t *session,
xmms_medialib_entry_t id_num,
const gchar *property, const gchar *value,
const gchar *source)
{
gboolean ret;
s4_val_t *prop;
g_return_val_if_fail (property, FALSE);
if (value && !g_utf8_validate (value, -1, NULL)) {
XMMS_DBG ("OOOOOPS! Trying to set property %s to a NON UTF-8 string (%s) I will deny that!", property, value);
return FALSE;
}
prop = s4_val_new_string (value);
ret = xmms_medialib_session_property_set (session, id_num, property, prop, source);
s4_val_free (prop);
return ret;
}
static s4_val_t *
xmms_medialib_entry_property_get (xmms_medialib_session_t *session,
xmms_medialib_entry_t entry,
const gchar *property)
{
s4_sourcepref_t *sourcepref;
const s4_result_t *res;
s4_resultset_t *set;
s4_val_t *ret = NULL;
s4_val_t *song_id;
g_return_val_if_fail (property, NULL);
song_id = s4_val_new_int (entry);
if (strcmp (property, XMMS_MEDIALIB_ENTRY_PROPERTY_ID) == 0) {
/* only resolving attributes other than 'id' */
return song_id;
}
sourcepref = xmms_medialib_session_get_source_preferences (session);
set = xmms_medialib_filter (session, "song_id", song_id, S4_COND_PARENT,
sourcepref, property, S4_FETCH_DATA);
s4_sourcepref_unref (sourcepref);
res = s4_resultset_get_result (set, 0, 0);
if (res != NULL) {
ret = s4_val_copy (s4_result_get_val (res));
}
s4_resultset_free (set);
s4_val_free (song_id);
return ret;
}
xmmsv_t *
xmms_medialib_entry_property_get_value (xmms_medialib_session_t *session,
xmms_medialib_entry_t id_num,
const gchar *property)
{
xmmsv_t *ret = NULL;
s4_val_t *prop;
const gchar *s;
gint32 i;
prop = xmms_medialib_entry_property_get (session, id_num, property);
if (prop == NULL)
return NULL;
if (s4_val_get_str (prop, &s)) {
ret = xmmsv_new_string (s);
} else if (s4_val_get_int (prop, &i)) {
ret = xmmsv_new_int (i);
}
s4_val_free (prop);
return ret;
}
int main (int argc, char *argv[])
{
s4_t *s4;
s4_transaction_t *t;
int i;
char *filename = tmpnam (NULL);
GTimeVal cur, prev;
g_thread_init (NULL);
log_init(G_LOG_LEVEL_MASK & ~G_LOG_LEVEL_DEBUG);
g_get_current_time (&prev);
s4 = s4_open (filename, NULL, S4_NEW);
if (s4 == NULL) {
fprintf (stderr, "Could not open %s\n", argv[1]);
exit (1);
}
take_time ("s4_open took", &prev, &cur);
for (i = 0; i < ENTRIES; i++) {
s4_val_t *val;
val = s4_val_new_int (i);
t = s4_begin (s4, 0);
s4_add (t, "a", val, "b", val, "src");
s4_commit (t);
s4_val_free (val);
}
take_time ("s4be_ip_add took", &prev, &cur);
for (i = 0; i < ENTRIES; i++) {
s4_val_t *val;
val = s4_val_new_int (i);
t = s4_begin (s4, 0);
s4_del (t, "a", val, "b", val, "src");
s4_commit (t);
s4_val_free (val);
}
take_time ("s4be_ip_del took", &prev, &cur);
t = s4_begin (s4, 0);
for (i = 0; i < ENTRIES; i++) {
s4_val_t *val;
val = s4_val_new_int (i);
s4_add (t, "a", val, "b", val, "src");
s4_val_free (val);
}
s4_commit (t);
take_time ("s4be_ip_add took", &prev, &cur);
t = s4_begin (s4, 0);
for (i = 0; i < ENTRIES; i++) {
s4_val_t *val;
val = s4_val_new_int (i);
s4_del (t, "a", val, "b", val, "src");
s4_val_free (val);
}
s4_commit (t);
take_time ("s4be_ip_del took", &prev, &cur);
for (i = ENTRIES; i > 0; i--) {
s4_val_t *val;
val = s4_val_new_int (i);
t = s4_begin (s4, 0);
s4_add (t, "a", val, "b", val, "src");
s4_commit (t);
s4_val_free (val);
}
take_time ("s4be_ip_add (backwards) took", &prev, &cur);
for (i = ENTRIES; i > 0; i--) {
s4_val_t *val;
val = s4_val_new_int (i);
t = s4_begin (s4, 0);
s4_del (t, "a", val, "b", val, "src");
s4_commit (t);
s4_val_free (val);
}
take_time ("s4be_ip_del (backwards) took", &prev, &cur);
s4_close (s4);
take_time ("s4_close took", &prev, &cur);
g_unlink (filename);
g_unlink (g_strconcat (filename, ".log", NULL));
take_time ("g_unlink took", &prev, &cur);
return 0;
}
CLEANUP () {
s4_val_free (val);
return 0;
}
