@@ -10,6 +10,7 @@ INCLUDES = \ -I$(top_builddir)/calendar/libical/src/libical \ $(EVOLUTION_CALENDAR_CFLAGS) +noinst_PROGRAMS = test-intervaltree test-intervaltree-coverage test-interval-searches extension_LTLIBRARIES = libecalbackendfile.la libecalbackendfile_la_SOURCES = \ @@ -17,6 +18,8 @@ libecalbackendfile_la_SOURCES = \ e-cal-backend-file-factory.h\ e-cal-backend-file-events.c\ e-cal-backend-file-events.h\ + e-cal-backend-file-intervaltree.c\ + e-cal-backend-file-intervaltree.h\ e-cal-backend-file-journal.c\ e-cal-backend-file-journal.h\ e-cal-backend-file-todos.c\ @@ -30,5 +33,50 @@ libecalbackendfile_la_LIBADD = \ $(top_builddir)/libedataserver/libedataserver-1.2.la \ $(EVOLUTION_CALENDAR_LIBS) +libecalbackendfile_la_CFLAGS = $(AM_CFLAGS) + libecalbackendfile_la_LDFLAGS = \ -module -avoid-version $(NO_UNDEFINED) + +test_intervaltree_SOURCES = test-intervaltree.c e-cal-backend-file-intervaltree.c + +test_intervaltree_LDADD = \ + $(top_builddir)/calendar/libecal/libecal-1.2.la \ + $(top_builddir)/calendar/libedata-cal/libedata-cal-1.2.la \ + $(top_builddir)/libedataserver/libedataserver-1.2.la \ + $(EVOLUTION_CALENDAR_LIBS) + +test_intervaltree_CFLAGS = $(AM_CFLAGS) + +test_interval_searches_SOURCES = e-cal-backend-file.c + +test_interval_searches_LDADD = \ + $(top_builddir)/calendar/libecal/libecal-1.2.la \ + $(top_builddir)/calendar/libedata-cal/libedata-cal-1.2.la \ + $(top_builddir)/libedataserver/libedataserver-1.2.la \ + $(top_builddir)/calendar/backends/file/libecalbackendfile.la \ + $(EVOLUTION_CALENDAR_LIBS) + +test_interval_searches_CFLAGS = $(AM_CFLAGS) -DTEST_QUERY_RESULT + +test_intervaltree_coverage_SOURCES = test-intervaltree.c e-cal-backend-file-intervaltree.c + +test_intervaltree_coverage_LDADD = \ + $(top_builddir)/calendar/libecal/libecal-1.2.la \ + $(top_builddir)/calendar/libedata-cal/libedata-cal-1.2.la \ + $(top_builddir)/libedataserver/libedataserver-1.2.la \ + $(EVOLUTION_CALENDAR_LIBS) \ + -lgcov + +test_intervaltree_coverage_CFLAGS = $(AM_CFLAGS) -fprofile-arcs -ftest-coverage + +.PHONY: coverage +coverage: + mkdir -p ./coverage + lcov --directory . --zerocounters + ./test-intervaltree-coverage + lcov --directory . --capture --output-file ./coverage/*.info + genhtml -o ./coverage --legend --num-spaces 2 ./coverage/*.info + +clean-local: + rm -f *.gcda *.gcno calendar/backends/file/Makefile.am @@ -35,6 +35,7 @@ #include <gio/gio.h> #include "libedataserver/e-data-server-util.h" #include "libedataserver/e-xml-hash-utils.h" +#include "libedataserver/e-debug-log.h" #include <libecal/e-cal-recur.h> #include <libecal/e-cal-time-util.h> #include <libecal/e-cal-util.h> @@ -42,6 +43,7 @@ #include <libedata-cal/e-cal-backend-util.h> #include <libedata-cal/e-cal-backend-sexp.h> #include "e-cal-backend-file-events.h" +#include "e-cal-backend-file-intervaltree.h" #ifndef O_BINARY #define O_BINARY 0 @@ -82,6 +84,8 @@ struct _ECalBackendFilePrivate { */ GHashTable *comp_uid_hash; + EIntervalTree *interval_tree; + GList *comp; /* The calendar's default timezone, used for resolving DATE and @@ -104,6 +108,12 @@ static ECalBackendSyncClass *parent_class; static ECalBackendSyncStatus e_cal_backend_file_add_timezone (ECalBackendSync *backend, EDataCal *cal, const char *tzobj); +static icaltimezone * +e_cal_backend_file_internal_get_timezone (ECalBackend *backend, const char *tzid); + +static icaltimezone * +e_cal_backend_file_internal_get_default_timezone (ECalBackend *backend); + /* g_hash_table_foreach() callback to destroy a ECalBackendFileObject */ static void free_object_data (gpointer data) @@ -262,6 +272,9 @@ free_calendar_data (ECalBackendFile *cbfile) priv = cbfile->priv; + e_intervaltree_destroy (priv->interval_tree); + priv->interval_tree = NULL; + free_calendar_components (priv->comp_uid_hash, priv->icalcomp); priv->comp_uid_hash = NULL; priv->icalcomp = NULL; @@ -416,7 +429,12 @@ resolve_tzid (const char *tzid, gpointer user_data) else if (!strcmp (tzid, "UTC")) return icaltimezone_get_utc_timezone (); - return icalcomponent_get_timezone (vcalendar_comp, tzid); + icaltimezone* zone = icalcomponent_get_timezone (vcalendar_comp, tzid); + + if (!zone) + zone = icaltimezone_get_builtin_timezone_from_tzid (tzid); + + return zone; } /* Checks if the specified component has a duplicated UID and if so changes it */ @@ -469,6 +487,58 @@ get_rid_icaltime (ECalComponent *comp) return tt; } + +/* Adds component to the interval tree + */ +static gboolean +add_component_to_intervaltree (ECalBackendFile *cbfile, ECalComponent *comp) +{ + time_t time_start = -1, time_end = -1; + ECalBackendFilePrivate *priv; + + g_return_val_if_fail (cbfile != NULL, FALSE); + g_return_val_if_fail (comp != NULL, FALSE); + + priv = cbfile->priv; + + get_component_occur_times (comp, &time_start, &time_end, + resolve_tzid, priv->icalcomp, priv->default_zone); + + if (time_end != -1 && time_start > time_end) + g_print ("Bogus component %s\n", e_cal_component_get_as_string (comp)); + else + e_intervaltree_insert (priv->interval_tree, time_start, time_end, comp); + + return FALSE; +} + +static gboolean +remove_component_from_intervaltree (ECalBackendFile *cbfile, ECalComponent *comp) +{ + time_t time_start = -1, time_end = -1; + const char *uid = NULL; + ECalBackendFilePrivate *priv; + + g_return_val_if_fail (cbfile != NULL, FALSE); + g_return_val_if_fail (comp != NULL, FALSE); + + priv = cbfile->priv; + + get_component_occur_times (comp, &time_start, &time_end, + resolve_tzid, priv->icalcomp, priv->default_zone); + + if (time_end != -1 && time_start > time_end) { + g_error ("Bogus component %s\n", e_cal_component_get_as_string (comp)); + return FALSE; + } else { + char *rid = e_cal_component_get_recurid_as_string (comp); + e_cal_component_get_uid (comp, &uid); + gboolean res = e_intervaltree_remove (priv->interval_tree, uid, rid, time_start, time_end); + g_free (rid); + return res; + } +} + /* Tries to add an icalcomponent to the file backend. We only store the objects * of the types we support; all others just remain in the toplevel component so * that we don't lose them. @@ -507,6 +577,7 @@ add_component (ECalBackendFile *cbfile, ECalComponent *comp, gboolean add_to_top g_hash_table_insert (priv->comp_uid_hash, g_strdup (uid), obj_data); } + add_component_to_intervaltree (cbfile, comp); g_hash_table_insert (obj_data->recurrences, rid, comp); obj_data->recurrences_list = g_list_append (obj_data->recurrences_list, comp); } else { @@ -528,6 +599,7 @@ add_component (ECalBackendFile *cbfile, ECalComponent *comp, gboolean add_to_top obj_data->recurrences = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref); g_hash_table_insert (priv->comp_uid_hash, g_strdup (uid), obj_data); + add_component_to_intervaltree (cbfile, comp); } } @@ -561,6 +633,9 @@ remove_recurrence_cb (gpointer key, gpointer value, gpointer data) icalcomp = e_cal_component_get_icalcomponent (comp); g_assert (icalcomp != NULL); + if (!remove_component_from_intervaltree (cbfile, comp)) { + g_message (G_STRLOC " Could not remove component from interval tree!"); + } icalcomponent_remove_component (priv->icalcomp, icalcomp); /* remove it from our mapping */ @@ -594,6 +669,10 @@ remove_component (ECalBackendFile *cbfile, const char *uid, ECalBackendFileObjec l = g_list_find (priv->comp, obj_data->full_object); g_assert (l != NULL); priv->comp = g_list_delete_link (priv->comp, l); + + if (!remove_component_from_intervaltree (cbfile, obj_data->full_object)) { + g_message (G_STRLOC " Could not remove component from interval tree!"); + } } /* remove the recurrences also */ @@ -708,6 +787,7 @@ open_cal (ECalBackendFile *cbfile, const char *uristr) priv->path = uri_to_path (E_CAL_BACKEND (cbfile)); priv->comp_uid_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, free_object_data); + priv->interval_tree = e_intervaltree_new (); scan_vcalendar (cbfile); return GNOME_Evolution_Calendar_Success; @@ -853,6 +933,7 @@ reload_cal (ECalBackendFile *cbfile, const char *uristr) priv->icalcomp = icalcomp; priv->comp_uid_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, free_object_data); + priv->interval_tree = e_intervaltree_new (); scan_vcalendar (cbfile); priv->path = uri_to_path (E_CAL_BACKEND (cbfile)); @@ -889,6 +970,7 @@ create_cal (ECalBackendFile *cbfile, const char *uristr) /* Create our internal data */ priv->comp_uid_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, free_object_data); + priv->interval_tree = e_intervaltree_new (); priv->path = uri_to_path (E_CAL_BACKEND (cbfile)); @@ -1299,6 +1381,33 @@ typedef struct { } MatchObjectData; static void +match_object_sexp_to_component (gpointer value, gpointer data) +{ + ECalComponent* comp = value; + MatchObjectData *match_data = data; + const char *uid; + e_cal_component_get_uid (comp, &uid); + ECalBackendFile *cbfile; + ECalBackendFilePrivate *priv; + + g_return_if_fail (comp != NULL); + + cbfile = E_CAL_BACKEND_FILE (match_data->backend); + + g_return_if_fail (match_data->backend != NULL); + + priv = cbfile->priv; + + g_return_if_fail (priv != NULL); + + if ((!match_data->search_needed) || + (e_cal_backend_sexp_match_comp (match_data->obj_sexp, comp, match_data->backend))) { + match_data->obj_list = g_list_append (match_data->obj_list, + e_cal_component_get_as_string (comp)); + } +} + +static void match_recurrence_sexp (gpointer key, gpointer value, gpointer data) { ECalComponent *comp = value; @@ -1331,6 +1440,7 @@ match_object_sexp (gpointer key, gpointer value, gpointer data) match_data); } + /* Get_objects_in_range handler for the file backend */ static ECalBackendSyncStatus e_cal_backend_file_get_object_list (ECalBackendSync *backend, EDataCal *cal, const char *sexp, GList **objects) @@ -1358,11 +1468,35 @@ e_cal_backend_file_get_object_list (ECalBackendSync *backend, EDataCal *cal, con return GNOME_Evolution_Calendar_InvalidQuery; g_static_rec_mutex_lock (&priv->idle_save_rmutex); - g_hash_table_foreach (priv->comp_uid_hash, (GHFunc) match_object_sexp, &match_data); + + time_t occur_start = -1, occur_end = -1; + + gboolean prunning_by_time = e_cal_backend_sexp_evaluate_occur_times(match_data.obj_sexp, + &occur_start, + &occur_end); + + GList* objs_occuring_in_tw = NULL; + + if (!prunning_by_time) { + g_hash_table_foreach (priv->comp_uid_hash, (GHFunc) match_object_sexp, + &match_data); + } else { + objs_occuring_in_tw = e_intervaltree_search(priv->interval_tree, + occur_start, occur_end); + + g_list_foreach(objs_occuring_in_tw, (GFunc) match_object_sexp_to_component, + &match_data); + } + g_static_rec_mutex_unlock (&priv->idle_save_rmutex); *objects = match_data.obj_list; + if (objs_occuring_in_tw) { + g_list_foreach(objs_occuring_in_tw, (GFunc)g_object_unref, NULL); + g_list_free (objs_occuring_in_tw); + } + g_object_unref (match_data.obj_sexp); return GNOME_Evolution_Calendar_Success; @@ -1396,28 +1530,64 @@ e_cal_backend_file_start_query (ECalBackend *backend, EDataCalView *query) match_data.obj_list = NULL; match_data.backend = backend; match_data.default_zone = priv->default_zone; + match_data.obj_sexp = e_data_cal_view_get_object_sexp (query); if (!strcmp (match_data.query, "#t")) match_data.search_needed = FALSE; - match_data.obj_sexp = e_data_cal_view_get_object_sexp (query); if (!match_data.obj_sexp) { e_data_cal_view_notify_done (query, GNOME_Evolution_Calendar_InvalidQuery); return; } + time_t occur_start = -1, occur_end = -1; + gboolean prunning_by_time = e_cal_backend_sexp_evaluate_occur_times(match_data.obj_sexp, + &occur_start, + &occur_end); + + GList* objs_occuring_in_tw = NULL; + g_static_rec_mutex_lock (&priv->idle_save_rmutex); - g_hash_table_foreach (priv->comp_uid_hash, (GHFunc) match_object_sexp, &match_data); + + if (!prunning_by_time) { + /* full scan */ + g_hash_table_foreach (priv->comp_uid_hash, (GHFunc) match_object_sexp, + &match_data); + + e_debug_log(FALSE, E_DEBUG_LOG_DOMAIN_CAL_QUERIES, "---;%p;QUERY-ITEMS;%s;%s;%d", query, + e_data_cal_view_get_text (query), G_OBJECT_TYPE_NAME (backend), + g_hash_table_size(priv->comp_uid_hash)); + } else { + /* matches objects in new "interval tree" way */ + /* events occuring in time window */ + objs_occuring_in_tw = e_intervaltree_search(priv->interval_tree, occur_start, occur_end); + + g_list_foreach(objs_occuring_in_tw, (GFunc) match_object_sexp_to_component, + &match_data); + + e_debug_log(FALSE, E_DEBUG_LOG_DOMAIN_CAL_QUERIES, "---;%p;QUERY-ITEMS;%s;%s;%d", query, + e_data_cal_view_get_text (query), G_OBJECT_TYPE_NAME (backend), + g_list_length (objs_occuring_in_tw)); + } + g_static_rec_mutex_unlock (&priv->idle_save_rmutex); /* notify listeners of all objects */ if (match_data.obj_list) { - e_data_cal_view_notify_objects_added (query, (const GList *) match_data.obj_list); + e_data_cal_view_notify_objects_added + (query, (const GList *) match_data.obj_list); /* free memory */ g_list_foreach (match_data.obj_list, (GFunc) g_free, NULL); g_list_free (match_data.obj_list); } + + + if (objs_occuring_in_tw) { + g_list_foreach(objs_occuring_in_tw, (GFunc)g_object_unref, NULL); + g_list_free (objs_occuring_in_tw); + } + g_object_unref (match_data.obj_sexp); e_data_cal_view_notify_done (query, GNOME_Evolution_Calendar_Success); @@ -2726,6 +2896,7 @@ e_cal_backend_file_init (ECalBackendFile *cbfile) priv->icalcomp = NULL; priv->comp_uid_hash = NULL; priv->comp = NULL; + priv->interval_tree = NULL; /* The timezone defaults to UTC. */ priv->default_zone = icaltimezone_get_utc_timezone (); @@ -2882,3 +3053,250 @@ e_cal_backend_file_reload (ECalBackendFile *cbfile) g_static_rec_mutex_unlock (&priv->idle_save_rmutex); return status; } + +#ifdef TEST_QUERY_RESULT +#include <glib.h> + +static void +test_query_by_scanning_all_objects (ECalBackendFile* cbfile, const char *sexp, GList **objects) +{ + MatchObjectData match_data; + ECalBackendFilePrivate *priv; + + priv = cbfile->priv; + + match_data.search_needed = TRUE; + match_data.query = sexp; + match_data.obj_list = NULL; + match_data.default_zone = priv->default_zone; + match_data.backend = E_CAL_BACKEND (cbfile); + + if (!strcmp (sexp, "#t")) + match_data.search_needed = FALSE; + + match_data.obj_sexp = e_cal_backend_sexp_new (sexp); + if (!match_data.obj_sexp) + return; + + g_static_rec_mutex_lock (&priv->idle_save_rmutex); + + if (!match_data.obj_sexp) + { + g_message (G_STRLOC ": Getting object list (%s)", sexp); + exit (-1); + } + + g_hash_table_foreach (priv->comp_uid_hash, (GHFunc) match_object_sexp, + &match_data); + + g_static_rec_mutex_unlock (&priv->idle_save_rmutex); + + *objects = match_data.obj_list; + + g_object_unref (match_data.obj_sexp); +} + +static void +write_list (GList* list) +{ + GList *l; + + for (l = list; l; l = l->next) + { + const char *str = l->data; + ECalComponent *comp = e_cal_component_new_from_string (str); + const char *uid; + e_cal_component_get_uid (comp, &uid); + g_print ("%s\n", uid); + } +} + +static void +get_difference_of_lists (ECalBackendFile* cbfile, GList* smaller, GList* bigger) +{ + GList *l, *lsmaller; + + for (l = bigger ; l; l = l->next) { + char *str = l->data; + + ECalComponent *comp = e_cal_component_new_from_string (str); + const char *uid; + e_cal_component_get_uid (comp, &uid); + gboolean found = FALSE; + + for (lsmaller = smaller; lsmaller && !found; lsmaller = lsmaller->next) + { + char *strsmaller = lsmaller->data; + ECalComponent *compsmaller = e_cal_component_new_from_string (strsmaller); + const char *uidsmaller; + e_cal_component_get_uid (compsmaller, &uidsmaller); + + found = strcmp (uid, uidsmaller) == 0; + + g_object_unref (compsmaller); + } + + if (!found) + { + printf ("%s IS MISSING\n", uid); + time_t time_start, time_end; + + get_component_occur_times (comp, &time_start, &time_end, + resolve_tzid, cbfile->priv->icalcomp, + cbfile->priv->default_zone); + + d (printf ("start %s\n", asctime(gmtime(&time_start)))); + d (printf ("end %s\n", asctime(gmtime(&time_end)))); + } + + g_object_unref (comp); + } +} + +static void +test_query (ECalBackendFile* cbfile, const char* query) +{ + GList *objects = NULL, *all_objects = NULL; + + g_return_if_fail (query != NULL); + + d (g_print ("Query %s\n", query)); + + test_query_by_scanning_all_objects (cbfile, query, &all_objects); + + if (e_cal_backend_file_get_object_list (E_CAL_BACKEND_SYNC (cbfile), NULL, query, &objects) + != GNOME_Evolution_Calendar_Success) + { + g_message (G_STRLOC " failed to get objects\n"); + exit(0); + } + + if (g_list_length (objects) < g_list_length (all_objects) ) + { + g_print ("ERROR\n"); + get_difference_of_lists (cbfile, objects, all_objects); + exit (-1); + } + else if (g_list_length (objects) > g_list_length (all_objects) ) + { + g_print ("ERROR\n"); + write_list (all_objects); + get_difference_of_lists (cbfile, all_objects, objects); + exit (-1); + } + + + g_list_foreach(objects, (GFunc) g_free, NULL); + g_list_free (objects); + g_list_foreach(all_objects, (GFunc) g_free, NULL); + g_list_free (all_objects); +} + +static void +execute_query (ECalBackendFile* cbfile, const char* query) +{ + GList *objects = NULL; + + g_return_if_fail (query != NULL); + + d (g_print ("Query %s\n", query)); + + if (e_cal_backend_file_get_object_list (E_CAL_BACKEND_SYNC (cbfile), NULL, query, &objects) + != GNOME_Evolution_Calendar_Success) + { + g_message (G_STRLOC " failed to get objects\n"); + exit(0); + } + + g_list_foreach(objects, (GFunc) g_free, NULL); + g_list_free (objects); +} + +static gchar *fname = NULL; +static gboolean only_execute = FALSE; +static gchar *calendar_fname = NULL; + +static GOptionEntry entries[] = +{ + { "test-file", 't', 0, G_OPTION_ARG_STRING, &fname, "File with prepared queries", NULL }, + { "only-execute", 'e', 0, G_OPTION_ARG_NONE, &only_execute, "Only execute, do not test query", NULL }, + { "calendar-file", 'c', 0, G_OPTION_ARG_STRING, &calendar_fname, "Path to the calendar.ics file", NULL }, + { NULL } +}; + +int +main(int argc, char **argv) +{ + char * line = NULL; + size_t len = 0; + ssize_t read; + ECalBackendFile* cbfile; + int num = 0; + GError *error = NULL; + GOptionContext *context; + FILE* fin = NULL; + + g_type_init (); + g_thread_init (NULL); + + context = g_option_context_new ("- test utility for e-d-s file backend"); + g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE); + if (!g_option_context_parse (context, &argc, &argv, &error)) + { + g_print ("option parsing failed: %s\n", error->message); + exit (1); + } + + calendar_fname = "calendar.ics"; + + if (!calendar_fname) + { + g_message (G_STRLOC " Please, use -c parameter"); + exit (-1); + } + + cbfile = g_object_new (E_TYPE_CAL_BACKEND_FILE, NULL); + if (open_cal (cbfile, calendar_fname) != GNOME_Evolution_Calendar_Success) + { + g_message (G_STRLOC " Could not open calendar %s", calendar_fname); + exit (-1); + } + + if (fname) + { + fin = fopen (fname, "r"); + + if (!fin) + { + g_message (G_STRLOC " Could not open file %s", fname); + goto err0; + } + } + else + { + g_message (G_STRLOC " Reading from stdin"); + fin = stdin; + } + + while ((read = getline(&line, &len, fin)) != -1) { + g_print ("Query %d: %s", num++, line); + + if (only_execute) + execute_query(cbfile, line); + else + test_query(cbfile, line); + } + + if (line) + free(line); + + if (fname) + fclose (fin); + +err0: + g_object_unref (cbfile); + + return 0; +} +#endif + calendar/backends/file/e-cal-backend-file.c @@ -917,6 +917,66 @@ array_to_list (short *array, int max_elements) return g_list_reverse (l); } +/** + * e_cal_recur_get_enddate + * + * @ir: RRULE or EXRULE recurrence + * @prop: An RRULE or EXRULE #icalproperty. + * @zone: The DTSTART timezone, used for converting the UNTIL property if it + * is given as a DATE value. + * @convert_end_date: TRUE if the saved end date needs to be converted to the + * given @zone timezone. This is needed if the DTSTART is a DATE or floating + * time. + * + * @return End timepoint of giben event + * + * Finds out end time of (reccurent) event. + */ +time_t +e_cal_recur_obtain_enddate (struct icalrecurrencetype *ir, icalproperty *prop, + icaltimezone *zone, gboolean convert_end_date) +{ + time_t enddate = -1; + + g_return_val_if_fail (prop != NULL, 0); + g_return_val_if_fail (ir != NULL, 0); + + if (ir->count != 0) { + /* If COUNT is set, we use the pre-calculated enddate. + Note that this can be 0 if the RULE doesn't actually + generate COUNT instances. */ + enddate = e_cal_recur_get_rule_end_date (prop, convert_end_date ? zone : NULL); + } else { + if (icaltime_is_null_time (ir->until)) { + /* If neither COUNT or UNTIL is set, the event + recurs forever. */ + } else if (ir->until.is_date) { + /* If UNTIL is a DATE, we stop at the end of + the day, in local time (with the DTSTART timezone). + Note that UNTIL is inclusive so we stop before + midnight. */ + ir->until.hour = 23; + ir->until.minute = 59; + ir->until.second = 59; + ir->until.is_date = FALSE; + + enddate = icaltime_as_timet_with_zone (ir->until, zone); +#if 0 + g_print (" until: %li - %s", r->enddate, ctime (&r->enddate)); +#endif + + } else { + /* If UNTIL is a DATE-TIME, it must be in UTC. */ + icaltimezone *utc_zone; + utc_zone = icaltimezone_get_utc_timezone (); + enddate = icaltime_as_timet_with_zone (ir->until, + utc_zone); + } + } + + return enddate; +} + /** * e_cal_recur_from_icalproperty: * @prop: An RRULE or EXRULE #icalproperty. @@ -953,40 +1013,7 @@ e_cal_recur_from_icalproperty (icalproperty *prop, gboolean exception, r->freq = ir.freq; r->interval = ir.interval; - if (ir.count != 0) { - /* If COUNT is set, we use the pre-calculated enddate. - Note that this can be 0 if the RULE doesn't actually - generate COUNT instances. */ - r->enddate = e_cal_recur_get_rule_end_date (prop, convert_end_date ? zone : NULL); - } else { - if (icaltime_is_null_time (ir.until)) { - /* If neither COUNT or UNTIL is set, the event - recurs forever. */ - r->enddate = 0; - } else if (ir.until.is_date) { - /* If UNTIL is a DATE, we stop at the end of - the day, in local time (with the DTSTART timezone). - Note that UNTIL is inclusive so we stop before - midnight. */ - ir.until.hour = 23; - ir.until.minute = 59; - ir.until.second = 59; - ir.until.is_date = FALSE; - - r->enddate = icaltime_as_timet_with_zone (ir.until, - zone); -#if 0 - g_print (" until: %li - %s", r->enddate, ctime (&r->enddate)); -#endif - - } else { - /* If UNTIL is a DATE-TIME, it must be in UTC. */ - icaltimezone *utc_zone; - utc_zone = icaltimezone_get_utc_timezone (); - r->enddate = icaltime_as_timet_with_zone (ir.until, - utc_zone); - } - } + r->enddate = e_cal_recur_obtain_enddate (&ir, prop, zone, convert_end_date); r->week_start_day = e_cal_recur_ical_weekday_to_weekday (ir.week_start); calendar/libecal/e-cal-recur.c @@ -45,6 +45,12 @@ void e_cal_recur_generate_instances (ECalComponent *comp, gpointer tz_cb_data, icaltimezone *default_timezone); +time_t +e_cal_recur_obtain_enddate (struct icalrecurrencetype *ir, + icalproperty *prop, + icaltimezone *zone, + gboolean convert_end_date); + /* Localized nth-day-of-month strings. (Use with _() ) */ #ifdef G_OS_WIN32 extern const char **e_cal_get_recur_nth (void); calendar/libecal/e-cal-recur.h @@ -32,6 +32,7 @@ $(CORBA_GENERATED_C): $(CORBA_GENERATED_H) # The libraray lib_LTLIBRARIES = libedata-cal-1.2.la +noinst_PROGRAMS = test-e-sexp libedata_cal_1_2_la_SOURCES = \ $(CORBA_GENERATED_C) \ @@ -72,6 +73,10 @@ libedata_calinclude_HEADERS = \ %-$(API_VERSION).pc: %.pc cp $< $@ +test_e_sexp_SOURCES = e-cal-backend-sexp.c +test_e_sexp_CFLAGS = $(AM_CFLAGS) -DTESTER +test_e_sexp_LDADD = libedata-cal-1.2.la $(E_DATA_SERVER_LIBS) + pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = libedata-cal-$(API_VERSION).pc calendar/libedata-cal/Makefile.am @@ -1272,6 +1272,25 @@ static struct { }; /** + * e_cal_backend_sexp_evaluate_occur_times: + * @sexp: An #ESExp object. + * @start: Start of the time window will be stored here. + * @end: End of the time window will be stored here. + * + * Determines biggest time window given by expressions "occur-in-range" in sexp. + * + */ +gboolean +e_cal_backend_sexp_evaluate_occur_times(ECalBackendSExp *sexp, time_t *start, time_t *end) +{ + g_return_val_if_fail (sexp != NULL, FALSE); + g_return_val_if_fail (start != NULL, FALSE); + g_return_val_if_fail (end != NULL, FALSE); + + return e_sexp_evaluate_occur_times(sexp->priv->search_sexp, start, end); +} + +/** * e_cal_backend_sexp_match_comp: * @sexp: An #ESExp object. * @comp: Component to match against the expression. @@ -1476,3 +1495,51 @@ e_cal_backend_sexp_get_type (void) return type; } + +#ifdef TESTER +static void +test_query (const char* query) +{ + ECalBackendSExp *sexp = e_cal_backend_sexp_new (query); + time_t start, end; + + gboolean generator = e_cal_backend_sexp_evaluate_occur_times(sexp, &start, &end); + + if (generator) { + printf ("%s: %ld - %ld\n", query, start, end); + } else { + printf ("%s: no time prunning possible\n", query); + } +} + +int main(int argc, char **argv) +{ + g_type_init(); + + /* e_sexp_add_variable(f, 0, "test", NULL); */ + + if (argc < 2 || !argv[1]) + { + test_query ("(occur-in-time-range? (make-time \"20080727T220000Z\") (make-time \"20080907T220000Z\"))"); + test_query ("(due-in-time-range? (make-time \"20080727T220000Z\") (make-time \"20080907T220000Z\"))"); + test_query ("(has-alarms-in-range? (make-time \"20080727T220000Z\") (make-time \"20080907T220000Z\"))"); + test_query ("(completed-before? (make-time \"20080727T220000Z\") )"); + + test_query ("(and (occur-in-time-range? (make-time \"20080727T220000Z\") (make-time \"20080907T220000Z\")) #t)"); + test_query ("(or (occur-in-time-range? (make-time \"20080727T220000Z\")(make-time \"20080907T220000Z\")) #t)"); + + test_query ("(and (contains? \"substring\") (has-categories? \"blah\"))"); + test_query ("(or (occur-in-time-range? (make-time \"20080727T220000Z\") (make-time \"20080907T220000Z\")) (contains? \"substring\"))"); + + test_query ("(and (and (occur-in-time-range? (make-time \"20080727T220000Z\") (make-time \"20080907T220000Z\"))" + " (or (contains? \"substring\") (has-categories? \"blah\"))) (has-alarms?))"); + + test_query ("(or (and (occur-in-time-range? (make-time \"20080727T220000Z\") (make-time \"20080907T220000Z\"))" + " (or (contains? \"substring\") (has-categories? \"blah\"))) (has-alarms?))"); + } + else + test_query(argv[1]); + + return 0; +} +#endif calendar/libedata-cal/e-cal-backend-sexp.c @@ -72,6 +72,9 @@ ESExpResult *e_cal_backend_sexp_func_time_add_day (ESExp *esexp, int argc, ESE ESExpResult *e_cal_backend_sexp_func_time_day_begin (ESExp *esexp, int argc, ESExpResult **argv, void *data); ESExpResult *e_cal_backend_sexp_func_time_day_end (ESExp *esexp, int argc, ESExpResult **argv, void *data); +gboolean e_cal_backend_sexp_evaluate_occur_times (ECalBackendSExp *sexp, time_t *start, time_t *end); +gboolean e_cal_backend_sexp_is_a_time_function(const char *function_name); +gboolean e_cal_backend_sexp_is_a_generator_function(const char *function_name); G_END_DECLS calendar/libedata-cal/e-cal-backend-sexp.h @@ -109,6 +109,12 @@ static void parse_dump_term(struct _ESExpTerm *t, int depth); static GObjectClass *parent_class; #endif +typedef gboolean (ESGeneratorFunc)(int argc, struct _ESExpResult **argv, struct _ESExpResult *r); +typedef gboolean (ESOperatorFunc)(int argc, struct _ESExpResult **argv, struct _ESExpResult *r); +/* FIXME: constant _TIME_MAX used in different files, move it somewhere */ +#define _TIME_MAX ((time_t) INT_MAX) /* Max valid time_t */ + + static const GScannerConfig scanner_config = { ( " \t\r\n") /* cset_skip_characters */, @@ -173,6 +179,9 @@ e_sexp_result_new(struct _ESExp *f, int type) { struct _ESExpResult *r = e_memchunk_alloc0(f->result_chunks); r->type = type; + r->occuring_start = 0; + r->occuring_end = _TIME_MAX; + r->time_generator = FALSE; return r; } @@ -699,7 +708,7 @@ e_sexp_term_eval(struct _ESExp *f, struct _ESExpTerm *t) r->value.bool = t->value.bool; break; case ESEXP_TERM_TIME: - r(printf(" (time_t %d)\n", t->value.time)); + r(printf(" (time_t %ld)\n", t->value.time)); r = e_sexp_result_new (f, ESEXP_RES_TIME); r->value.time = t->value.time; break; @@ -814,6 +823,236 @@ parse_dump_term(struct _ESExpTerm *t, int depth) printf("\n"); } +const char *time_functions[] = { + "time-now", + "make-time", + "time-add-day", + "time-day-begin", + "time-day-end" +}; + +static gboolean +binary_generator (int argc, struct _ESExpResult **argv, struct _ESExpResult *r) +{ + g_return_val_if_fail (r != NULL, FALSE); + g_return_val_if_fail (argc == 2, FALSE); + + if ((argv[0]->type != ESEXP_RES_TIME) || (argv[1]->type != ESEXP_RES_TIME)) + return FALSE; + + r->occuring_start = argv[0]->value.time; + r->occuring_end = argv[1]->value.time; + + return TRUE; +} + +static gboolean +unary_generator(int argc, struct _ESExpResult **argv, struct _ESExpResult *r) +{ + /* unary generator with end time */ + g_return_val_if_fail (r != NULL, FALSE); + g_return_val_if_fail (argc == 1, FALSE); + + if (argv[0]->type != ESEXP_RES_TIME) + return FALSE; + + r->occuring_start = 0; + r->occuring_end = argv[0]->value.time; + + return TRUE; +} + +static const struct { + char *name; + ESGeneratorFunc *func; +} generators[] = { + {"occur-in-time-range?", binary_generator}, + {"due-in-time-range?", binary_generator}, + {"has-alarms-in-range?", binary_generator}, + {"completed-before?", unary_generator}, +}; + +const int generators_count = sizeof(generators) / sizeof(generators[0]); + +static gboolean +or_operator(int argc, struct _ESExpResult **argv, struct _ESExpResult *r) +{ + /* + A B A or B + ---- ---- ------ + norm(0) norm(0) norm(0) + gen(1) norm(0) norm(0) + norm(0) gen(1) norm(0) + gen(1) gen(1) gen*(1) + */ + + g_return_val_if_fail (r != NULL, FALSE); + g_return_val_if_fail (argc == 2, FALSE); + + if ((r->time_generator = argv[0]->time_generator & argv[1]->time_generator)) { + r->occuring_start = MIN(argv[0]->occuring_start, argv[1]->occuring_start); + r->occuring_end = MAX(argv[0]->occuring_end, argv[1]->occuring_end); + } + + return TRUE; +} + +static gboolean +and_operator(int argc, struct _ESExpResult **argv, struct _ESExpResult *r) +{ + /* + A B A and B + ---- ---- ------- - + norm(0) norm(0) norm(0) + gen(1) norm(0) gen(1) + norm(0) gen(1) gen(1) + gen(1) gen(1) gen(1) + */ + + g_return_val_if_fail (r != NULL, FALSE); + g_return_val_if_fail (argc == 2, FALSE); + + if ((r->time_generator = argv[0]->time_generator | argv[1]->time_generator)) { + /* constraint interval */ + r->occuring_start = MAX(argv[0]->occuring_start, argv[1]->occuring_start); + r->occuring_end = MIN(argv[0]->occuring_end, argv[1]->occuring_end); + } + + return TRUE; +} + +static const struct { + char *name; + ESOperatorFunc *func; +} operators[] = { + {"or", or_operator}, + {"and", and_operator} +}; + +const int operators_count = sizeof(operators) / sizeof(operators[0]); + + +static ESOperatorFunc* +get_operator_function(const char *fname) +{ + int i; + + g_return_val_if_fail (fname != NULL, NULL); + + for (i = 0; i < sizeof(operators) / sizeof(operators[0]); i++) + if (strcmp(operators[i].name, fname) == 0) + return operators[i].func; + + return NULL; +} + +static inline gboolean +is_time_function(const char *fname) +{ + int i; + + g_return_val_if_fail (fname != NULL, FALSE); + + for (i = 0; i < sizeof(time_functions) / sizeof(time_functions[0]); i++) + if (strcmp(time_functions[i], fname) == 0) + return TRUE; + + return FALSE; +} + +static ESGeneratorFunc* +get_generator_function(const char *fname) +{ + int i; + + g_return_val_if_fail (fname != NULL, NULL); + + for (i = 0; i < sizeof(generators) / sizeof(generators[0]); i++) + if (strcmp(generators[i].name, fname) == 0) + return generators[i].func; + + return NULL; +} + +/* this must only be called from inside term evaluation callbacks! */ +static struct _ESExpResult * +e_sexp_term_evaluate_occur_times(struct _ESExp *f, struct _ESExpTerm *t, time_t *start, time_t *end) +{ + struct _ESExpResult *r = NULL; + int i; + struct _ESExpResult **argv; + gboolean ok = TRUE; + + g_return_val_if_fail(t != NULL, NULL); + g_return_val_if_fail(start != NULL, NULL); + g_return_val_if_fail(end != NULL, NULL); + + /* + printf("eval term :\n"); + parse_dump_term(t, 0); + */ + + switch (t->type) { + case ESEXP_TERM_STRING: + r(printf(" (string \"%s\")\n", t->value.string)); + r = e_sexp_result_new(f, ESEXP_RES_STRING); + r->value.string = g_strdup(t->value.string); + break; + case ESEXP_TERM_IFUNC: + case ESEXP_TERM_FUNC: + r(printf(" (function \"%s\"\n", t->value.func.sym->name)); + + r = e_sexp_result_new(f, ESEXP_RES_UNDEFINED); + int argc = t->value.func.termcount; + argv = alloca(sizeof(argv[0]) * argc); + + for (i=0;i<t->value.func.termcount;i++) { + argv[i] = e_sexp_term_evaluate_occur_times (f, t->value.func.terms[i], + start, end); + } + + ESGeneratorFunc *generator = NULL; + ESOperatorFunc *operator = NULL; + + if (is_time_function(t->value.func.sym->name)) { + /* evaluate time */ + if (t->value.func.sym->f.func) + r = t->value.func.sym->f.func(f, t->value.func.termcount, + argv, t->value.func.sym->data); + } else if ((generator = get_generator_function(t->value.func.sym->name)) != NULL) { + /* evaluate generator function */ + r->time_generator = TRUE; + ok = generator(argc, argv, r); + } else if ((operator = get_operator_function(t->value.func.sym->name)) != NULL) + /* evaluate operator function */ + ok = operator(argc, argv, r); + else { + /* normal function: we need to scan all objects */ + r->time_generator = FALSE; + } + + e_sexp_resultv_free(f, t->value.func.termcount, argv); + break; + + case ESEXP_TERM_INT: + case ESEXP_TERM_BOOL: + case ESEXP_TERM_TIME: + break; + default: + ok = FALSE; + break; + } + + if (!ok) + e_sexp_fatal_error(f, "Error in parse tree"); + + if (r==NULL) + r = e_sexp_result_new(f, ESEXP_RES_UNDEFINED); + + return r; +} + + /* PARSER */ @@ -1321,6 +1560,43 @@ e_sexp_eval(ESExp *f) } /** + * e_cal_backend_sexp_evaluate_occur_times: + * @f: An #ESExp object. + * @start: Start of the time window will be stored here. + * @end: End of the time window will be stored here. + * + * Determines biggest time window given by expressions "occur-in-range" in sexp. + * + */ +gboolean +e_sexp_evaluate_occur_times(ESExp *f, time_t *start, time_t *end) +{ + g_return_val_if_fail (IS_E_SEXP (f), FALSE); + g_return_val_if_fail (f->tree != NULL, FALSE); + g_return_val_if_fail (start != NULL, FALSE); + g_return_val_if_fail (end != NULL, FALSE); + + *start = *end = -1; + + if (setjmp(f->failenv)) { + g_warning("Error in execution: %s", f->error); + return FALSE; + } + + struct _ESExpResult *r = e_sexp_term_evaluate_occur_times(f, f->tree, start, end); + gboolean generator = r->time_generator; + + if (generator) { + *start = r->occuring_start; + *end = r->occuring_end; + } + + e_sexp_result_free(f, r); + + return generator; +} + +/** * e_sexp_encode_bool: * @s: * @state: @@ -1378,7 +1654,10 @@ int main(int argc, char **argv) e_sexp_add_variable(f, 0, "test", NULL); - e_sexp_input_text(f, t, strlen(t)); + if (argc < 2 || !argv[1]) + return; + + e_sexp_input_text(f, t, t); e_sexp_parse(f); if (f->tree) { libedataserver/e-sexp.c @@ -57,6 +57,9 @@ struct _ESExpResult { int bool; time_t time; } value; + gboolean time_generator; + time_t occuring_start; + time_t occuring_end; }; typedef struct _ESExpResult *(ESExpFunc)(struct _ESExp *sexp, int argc, @@ -176,6 +179,7 @@ const char *e_sexp_error (struct _ESExp *f); ESExpTerm * e_sexp_parse_value(ESExp *f); +gboolean e_sexp_evaluate_occur_times (ESExp *f, time_t *start, time_t *end); G_END_DECLS #endif /* _E_SEXP_H */ libedataserver/e-sexp.h 11deffa20b97ca2aa4d8a1d20a091e67b4ee02a6 Stanislav Slusny stanislav.slusny@zonio.net http://github.com/slusnys/evolution-data-server/commit/de2890881d06cd77c9e9207a175a3dbd9287731e de2890881d06cd77c9e9207a175a3dbd9287731e 2008-08-18T14:20:04-07:00 2008-08-18T11:10:01-07:00 Adding interval trees to speed up queries in file backend Using interval trees to solve queries in calendar file backend. Adding tests for interval trees. e4562ee09a3ad1a37b1b3ae53ceff647897b3838 Stanislav Slusny stanislav.slusny@zonio.net