struct MidgardCollector

struct MidgardCollector;

MidgardCollectorClass

typedef struct MidgardCollectorClass MidgardCollectorClass;

midgard_collector_new ()

MidgardCollector *  midgard_collector_new               (MidgardConnection *mgd,
                                                         const gchar *typename,
                                                         const gchar *domain,
                                                         GValue *value);

typename should be any MidgardDBObject derived class name. domain is property name which is registered for given class, and should not be unique per object or record. In other words, domain is a common property (and value) for group of objects expected in collection. value must be of domain property type, and is owned by MidgardCollector instance. If you need reuse given value, make a copy.

Cases to return NULL:

midgard_collector_set_key_property ()

gboolean            midgard_collector_set_key_property  (MidgardCollector *self,
                                                         const gchar *key,
                                                         GValue *value);

If value is explicitly set to NULL , then all key property name's records are selected from database and set in internal collector's resultset. If not, key property name and its value is used as constraint to limit selected records from database. In latter case add_value_property method should be invoked. GValue value passed as third argument is owned by Midgard Collector. If value should be reused, its copy should be passed to constructor.

Cases to return FALSE:

midgard_collector_add_value_property ()

gboolean            midgard_collector_add_value_property
                                                        (MidgardCollector *self,
                                                         const gchar *value);

Cases to return FALSE:

Number of value properties added to Midgard Collector is limited by the number of properties registered for type which has been initialized for the given MidgardCollector instance.

See: midgard_query_builder_add_constraint() for available property name pattern

midgard_collector_set ()

gboolean            midgard_collector_set               (MidgardCollector *self,
                                                         const gchar *key,
                                                         const gchar *subkey,
                                                         GValue *value);

Cases to return FALSE:

If the key is already added to MidgardCollector then its value (as subkey&value pair) is destroyed and new one is set. In other case new key and its subkey&value pair is added to collector.

Key used in this function is a value returned ( or set ) for collector's key. Keys are collection of values returned from property fields. Subkey is an explicit property name.

GValue value argument is owned by MidgardCollector. If value should be reused, its copy should be passed as method argument.

midgard_collector_get ()

GData *             midgard_collector_get               (MidgardCollector *self,
                                                         const gchar *key);

GData keys ( collector's subkeys ) are inserted to GData as Quarks , so you must call g_quark_to_string if you need to get strings ( e.g. implementing hash table for language bindings ).

midgard_collector_get_subkey ()

GValue *            midgard_collector_get_subkey        (MidgardCollector *self,
                                                         const gchar *key,
                                                         const gchar *subkey);

midgard_collector_list_keys ()

gchar **            midgard_collector_list_keys         (MidgardCollector *self);

midgard_collector_merge ()

gboolean            midgard_collector_merge             (MidgardCollector *self,
                                                         MidgardCollector *mc,
                                                         gboolean overwrite);

If third overwrite parameter is set as TRUE then all keys which exists in self and mc collector's instance will be oberwritten in self colection instance. If set as FALSE , only those keys will be added, which do not exist in self collection and exist in mc collection.

Cases to return FALSE:

midgard_collector_remove_key ()

gboolean            midgard_collector_remove_key        (MidgardCollector *self,
                                                         const gchar *key);

Removes key and associated value from the given MidgardCollector instance.

midgard_collector_add_constraint ()

gboolean            midgard_collector_add_constraint    (MidgardCollector *self,
                                                         const gchar *name,
                                                         const gchar *op,
                                                         const GValue *value);

midgard_collector_add_constraint_with_property ()

gboolean            midgard_collector_add_constraint_with_property
                                                        (MidgardCollector *self,
                                                         const gchar *property_a,
                                                         const gchar *op,
                                                         const gchar *property_b);

midgard_collector_begin_group ()

gboolean            midgard_collector_begin_group       (MidgardCollector *self,
                                                         const gchar *type);

midgard_collector_end_group ()

gboolean            midgard_collector_end_group         (MidgardCollector *self);

midgard_collector_add_order ()

gboolean            midgard_collector_add_order         (MidgardCollector *self,
                                                         const gchar *name,
                                                         const gchar *dir);

midgard_collector_set_offset ()

void                midgard_collector_set_offset        (MidgardCollector *self,
                                                         guint offset);

midgard_collector_set_limit ()

void                midgard_collector_set_limit         (MidgardCollector *self,
                                                         guint limit);

midgard_collector_count ()

void                midgard_collector_count             (MidgardCollector *self);

midgard_collector_execute ()

gboolean            midgard_collector_execute           (MidgardCollector *self);