src/query_builder.c

/*
 * Copyright (c) 2005 Jukka Zitting <jz@yukatan.fi>
 * Copyright (c) 2005 Piotr Pokora <piotr.pokora@infoglob.pl>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <config.h>
#include "midgard/midgard_schema.h"
#include "midgard/query_builder.h"
#include "midgard/midgard_legacy.h"
#include "query_constraint.h"
#include "simple_constraint.h"
#include "group_constraint.h"
#include "query_order.h"
#include "midgard/midgard_object_property.h"
#include "midgard/midgard_object.h"
#include "schema.h"
#include "midgard_mysql.h"
#include "midgard_core_query_builder.h"
#include "midgard/midgard_error.h"
#include "midgard_core_object.h"

/* Internal prototypes , I am not sure if should be included in API */

gchar *midgard_query_builder_get_object_select(MidgardQueryBuilder *builder, guint select_type);

GList *_mqb_set_object_from_query(MidgardQueryBuilder *builder, guint select_type) ;

/* Adds table string for the given builder instance. */
void _midgard_core_qb_add_table(
                MidgardQueryBuilder *builder, const gchar *table)
{
        g_assert(builder);
        
        if(builder->tables){
                guint tlen = strlen(builder->tables); /* tlen doesn't mean oxygen ;) */
                gchar *table_found = g_strstr_len(
                                builder->tables,
                                tlen,
                                table);
                if(!table_found){
                        gchar *tmptable  = g_strconcat(builder->tables,
                                        ",",
                                        table,
                                        NULL);
                        g_free(builder->tables);
                        builder->tables = g_strdup(tmptable);
                        g_free(tmptable);
                }
        }
}

/* Appends SQL query part with particular "AND ..." comparison */
void _midgard_core_qb_add_join(
                MidgardQueryBuilder *builder, 
                const gchar *table_a, const gchar *column_a,
                const gchar *table_b, const gchar *column_b)
{
        g_assert(table_a != NULL && column_a != NULL 
                        && table_b != NULL && column_b != NULL);

        g_string_append(builder->join, " AND ");
        g_string_append_printf(builder->join,
                        "%s.%s = %s.%s",
                        table_a, column_a,
                        table_b, column_b);
}

static void _mqb_type_pop(MidgardQueryBuilder *builder){

        g_assert(builder != NULL);
        builder->type = (guint)g_list_nth_data(builder->types, 0);
}

static gchar **_mqb_parse_constraint_property(
                MidgardQueryBuilder *builder, gchar **name)
{
        g_assert(builder != NULL);
        
        if(!name[2])
                return name;
        guint i, n = 0;
        MgdObject *ref_object = NULL; 
        const gchar *reftype = NULL;
        MidgardObjectClass *klass =
                (MidgardObjectClass*) g_type_class_peek(builder->type);
        MidgardObjectClass *ref_klass =
                midgard_object_property_get_link_class(
                                klass, name[0]);
        if(ref_klass)
                reftype = G_OBJECT_CLASS_NAME(G_OBJECT_CLASS(ref_klass));
        
        if (reftype != NULL)
                ref_object = midgard_object_new(builder->mgd, reftype, NULL);
        if(ref_object == NULL) {
                g_warning("Type %s in not registered in application schema",
                                reftype);
                return NULL;
        }
        GType new_type = G_TYPE_FROM_INSTANCE(ref_object);
        builder->parent_type = new_type;
        builder->type = new_type;
        builder->types = g_list_append(builder->types, (gpointer)builder->type);
        
        for(i = 0 ; name[i]; i++){
                n++;
        }
        gchar **str_array = g_new (gchar *, n);
        for(i = 0 ; name[i]; i++){
                str_array[i] = g_strdup(name[i+1]);
        }
        g_strfreev(name);
        return _mqb_parse_constraint_property(builder, str_array);                      
}


/* Internal function to set tables member and get referenced object 
 * or property of object type.
 */
static gchar * _mqb_get_new_property(
        MidgardQueryBuilder *builder, const gchar *name){

        g_assert(builder);

        gchar *new_name = (gchar *)name;
        guint strl = 0;

        builder->ext_type = 0;
        builder->parent_type = 0;
        
        if((strl = strlen(name)) == 0)
                return new_name;

        gchar **spltd, *tmpstr;
        MgdObject *ref_object = NULL;
        
        /* We're getting referenced object from schema, or reserved object type */
        tmpstr = g_strstr_len(name, strl, ".");
        if(tmpstr != NULL){                             
                spltd = g_strsplit(name, ".", 0);
                
                if(spltd[2])
                        spltd = _mqb_parse_constraint_property(builder, spltd);
                if(!spltd){             
                        g_strfreev(spltd);
                        return new_name;
                }
                        
                if (spltd[1] !=  NULL) {
                        new_name = g_strdup(spltd[1]);
                
                        /* METADATA */
                        /* This is an exception , midgard_metadata is assigned as metadata property */
                        if(g_str_equal(spltd[0], "metadata"))  {
                                /* parent type is set from current type or from type set 
                                 * while constraint property was parsed. */
                                builder->parent_type = builder->type;
                                builder->type = g_type_from_name("midgard_metadata");
                                builder->ext_type = builder->type;
                                builder->types = g_list_append(builder->types, (gpointer)builder->type);
                                g_strfreev(spltd);
                                return new_name;
                        }
                        
                        /* PARAMETER */
                        if(g_str_equal(spltd[0], "parameter")) {
                                builder->parent_type = builder->type;
                                builder->type = g_type_from_name("midgard_parameter");
                                builder->ext_type = builder->type;
                                builder->types = g_list_append(builder->types, (gpointer)builder->type); 
                                g_strfreev(spltd);
                                _midgard_core_qb_add_table(builder, "record_extension");
                                MidgardObjectClass *klass = 
                                        (MidgardObjectClass*) g_type_class_peek(builder->parent_type);
                                _midgard_core_qb_add_join(builder,
                                                midgard_object_class_get_table(klass), "guid",
                                                "record_extension", "parent_guid");
                                return new_name;
                        }                               
                        
                        /* ATTACHMENT */
                        if(g_str_equal(spltd[0], "attachment")) {
                                builder->parent_type = builder->type;
                                builder->type = g_type_from_name("midgard_attachment");
                                builder->ext_type = builder->type;
                                builder->types = g_list_append(builder->types, (gpointer)builder->type);
                                g_strfreev(spltd);
                                _midgard_core_qb_add_table(builder, "blobs");
                                MidgardObjectClass *klass =
                                        (MidgardObjectClass*) g_type_class_peek(builder->parent_type);
                                _midgard_core_qb_add_join(builder,
                                                midgard_object_class_get_table(klass), "guid",
                                                "blobs", "parent_guid");
                                return new_name;
                        }
                                                
                        /* We're getting link type defined for property in schema */
                        const gchar *reftype = NULL;
                        MidgardObjectClass *klass = 
                                (MidgardObjectClass*) g_type_class_peek(builder->type);
                        MidgardObjectClass *ref_klass = 
                                midgard_object_property_get_link_class(
                                                klass, spltd[0]);
                        if(ref_klass)
                                reftype = G_OBJECT_CLASS_NAME(G_OBJECT_CLASS(ref_klass));               

                        /* Referenced type exists so let's make new instance */
                        if (reftype != NULL) 
                                ref_object = midgard_object_new(builder->mgd, reftype, NULL);

                        /* This should never happen in good applications , however we have 
                         * such "persistant" package like midgard-php used with apache module */
                        if(ref_object == NULL) {
                                g_warning("Type %s in not registered in application schema",
                                                reftype);
                                return FALSE;
                        }
                
                        const gchar *target_name;
                        GParamSpec *spec = NULL;

                        /* Find property to get nick and table */
                        MidgardReflectionProperty *mrp = 
                                midgard_reflection_property_new(klass);

                        if(mrp) {

                                target_name = 
                                        midgard_reflection_property_get_link_target(
                                                        mrp, spltd[0]);                 
                                g_object_unref(mrp);

                                spec = g_object_class_find_property(
                                                G_OBJECT_CLASS(g_type_class_peek(ref_object->type)),
                                                target_name);
                        } else {
                                g_warning("Failed to initialize midgard_reflection_property");
                        }

                        if (spec) {

                                if(g_str_equal(target_name, "guid"))
                                        builder->link = 
                                                g_strjoin(".",
                                                                midgard_object_class_get_table(ref_klass),
                                                                "guid", NULL);
                                else
                                        builder->link = g_strdup(g_param_spec_get_nick(spec));          

                                GParamSpec *ospec = g_object_class_find_property(
                                                G_OBJECT_CLASS(
                                                        g_type_class_peek(builder->type)),
                                                        spltd[0]);
                                if(!ospec) {
                                        g_warning("Property '%s' not found for referenced "
                                                        "'%s' type",
                                                        spltd[0],
                                                        g_type_name(builder->type));
                                        return FALSE;
                                }

                                /* Set internal builder->type */
                                builder->type = G_TYPE_FROM_INSTANCE(ref_object);
                                //builder->types = g_list_append(builder->types, (gpointer)builder->type);
                                
                                g_string_append_printf(builder->join,
                                                " AND %s = ",
                                                g_param_spec_get_nick(ospec));
                                
                                g_string_append(builder->join, builder->link);
                                                                
                                /*Avoid adding table names which arleady exists in build->tables string */
                                gchar **duptables = g_strsplit(builder->tables, ",", 0);
                                guint i = 0, j = 0;
                                for(i = 0 ; duptables[i]; i++){
                                        if (g_ascii_strcasecmp(duptables[i],
                                                                midgard_object_class_get_table(ref_klass)) == 0 )
                                                j++;
                                }

                                /* We have new table string so we need to concat all tables */
                                if (j == 0) {
                                        gchar *tmptable  = g_strconcat(builder->tables,
                                                        ",", 
                                                        midgard_object_class_get_table(ref_klass), 
                                                        NULL);
                                        
                                        g_free(builder->tables);
                                        builder->tables = g_strdup(tmptable);
                                        g_free(tmptable);
                                }
                                g_strfreev(duptables);                                                  
                        }                               
                        g_object_unref(ref_object);                                                     
                }
                g_strfreev(spltd);
                return new_name;
        }       
        return new_name;
}

MidgardQueryBuilder *midgard_query_builder_new(
        midgard *mgd, const gchar *classname)
{
        g_assert(mgd);
        g_assert(classname);

        MidgardQueryBuilder *builder = 
                g_object_new(MIDGARD_TYPE_QUERY_BUILDER, NULL);
        
        builder->mgd = mgd;
        builder->type = g_type_from_name(classname);
        builder->parent_type = 0;
        builder->ext_type = 0;
        builder->types = g_list_append(NULL, (gpointer)builder->type);
        builder->lang = -1;
        builder->unset_lang = FALSE;
        builder->include_deleted = FALSE;
        builder->tables = NULL;
        builder->link = NULL;
        builder->join = g_string_new(" ");
        builder->error = 0;

        MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(classname);
        builder->schema = klass->data;
        builder->tables = g_strdup(midgard_object_class_get_tables(klass));
        
        MidgardGroupConstraint *group =
                midgard_group_constraint_new(MIDGARD_GROUP_CONSTRAINT_TYPE_AND);
        builder->stack = g_slist_prepend(NULL, group);
        builder->orders =
                g_array_new(FALSE, FALSE, sizeof(MidgardQueryOrder *));
        builder->offset = 0;
        builder->limit = G_MAXUINT;

        if (builder->type && builder->schema) {
                return builder;
        } else {
                g_object_unref(builder);
                return NULL;
        }
}

void midgard_query_builder_free(MidgardQueryBuilder *builder) {
        g_assert(builder);

        while (g_slist_next(builder->stack) != NULL) {
                g_warning("Constraint groups not properly nested");
                GSList *item = builder->stack;
                builder->stack = g_slist_remove_link(builder->stack, item);
                g_slist_free_1(item);
        }
        g_object_unref(G_OBJECT(builder->stack->data));
        g_slist_free(builder->stack);

        guint i;
        for (i = 0; i < builder->orders->len; i++) {
                midgard_query_order_free(g_array_index(
                        builder->orders, MidgardQueryOrder *, i));
        }
        g_array_free(builder->orders, TRUE);
        if(builder->join) {
                gchar *tmpstr = g_string_free(builder->join, FALSE);
                g_free(tmpstr);
        }
        g_free((gchar *)builder->tables);
        g_free((gchar *)builder->link);
}

gboolean midgard_query_builder_add_constraint(
        MidgardQueryBuilder *builder,
        const gchar *name, const gchar *op, const GValue *value) {
        g_assert(builder);
        g_assert(name);
        g_assert(op);
        g_assert(value);
       
        GObjectClass *tmpklass = g_type_class_peek(builder->type);

        gchar *new_name = _mqb_get_new_property(builder, name);
                
        MidgardSimpleConstraint *simple = midgard_simple_constraint_new(
                builder->mgd, G_OBJECT_CLASS(g_type_class_peek(builder->type)),
                new_name, op, value);

        /* We need to know "initial" klass when builder type is "overwritten"
         * with metadata klass or another one */
        /* FIXME */
        if(simple != NULL){
                simple->ext_type = builder->ext_type;
                simple->parent_type = builder->parent_type;
                simple->initial_klass = tmpklass;
                simple->types = builder->types;
        }               
        _mqb_type_pop(builder);
              
        if (simple != NULL) {
                midgard_group_constraint_add_constraint(
                        MIDGARD_GROUP_CONSTRAINT(builder->stack->data),
                        MIDGARD_QUERY_CONSTRAINT(simple));
                g_object_unref(G_OBJECT(simple));
                return TRUE;
        } else {
                g_log(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
                        "Invalid query constraint specification");
                /* FIXME, error reporting for QB needed.
                 * This is temporary set to avoid selecting all records from tables
                 * when comparison operator is invalid */
                builder->error = 1;
                return FALSE;
        }
}

gboolean midgard_query_builder_begin_group(
                MidgardQueryBuilder *builder, const gchar *type) {
        g_assert(builder);
        g_assert(type);
        MidgardGroupConstraint *group = midgard_group_constraint_new(type);
        if (group != NULL) {
                midgard_group_constraint_add_constraint(
                        MIDGARD_GROUP_CONSTRAINT(builder->stack->data),
                        MIDGARD_QUERY_CONSTRAINT(group));
                builder->stack = g_slist_prepend(builder->stack, group);
                return TRUE;
        } else {
                g_warning("Invalid query group type: %s", type);
                return FALSE;
        }
}

gboolean midgard_query_builder_end_group(MidgardQueryBuilder *builder) {
        g_assert(builder);
        if (g_slist_next(builder->stack) != NULL) {
                g_object_unref(G_OBJECT(builder->stack->data));
                builder->stack = g_slist_next(builder->stack);
                return TRUE;
        } else {
                g_warning("Invalid number of query group endings");
                return FALSE;
        }
}

gboolean midgard_query_builder_add_order(
        MidgardQueryBuilder *builder, const gchar *name, const gchar *dir)
{
        g_assert(builder);
        g_assert(name);
        g_assert(dir);
        
        gchar *new_name = _mqb_get_new_property(builder, name); 
        MidgardQueryOrder *order = midgard_query_order_new(
                builder->mgd, G_OBJECT_CLASS(g_type_class_peek(builder->type)),
                new_name, dir);
        _mqb_type_pop(builder);
        
        if (order) {
                order->ext_type = builder->ext_type;
                order->parent_type = builder->parent_type;
                g_array_append_val(builder->orders, order);
                return TRUE;
        } else {
                g_warning("Skipping a ordering constraint specification");
                return FALSE;
        }
}

void midgard_query_builder_set_limit(
        MidgardQueryBuilder *builder, guint limit)
{
        g_assert(builder);
        builder->limit = limit;
}

void midgard_query_builder_set_offset(
        MidgardQueryBuilder *builder, guint offset)
{
        g_assert(builder);
        builder->offset = offset;
}

void midgard_query_builder_set_lang(MidgardQueryBuilder *builder, gint lang)
{
    g_assert(builder);
    builder->lang = lang;
}

void midgard_query_builder_unset_languages(MidgardQueryBuilder *builder)
{
        g_assert(builder);
        builder->unset_lang = TRUE;
}

gint _compare_ml_guid(gconstpointer a, gconstpointer b){

        if(g_ascii_strcasecmp(a,b) == 0) return 0;
        return 1;
}

static GList *midgard_query_builder_execute_or_count(
        MidgardQueryBuilder *builder, guint *n_objects, guint select_type)
{
        g_assert(builder);
        g_assert(n_objects);

        GList *tmp_list = NULL;
        
        GList *list = _mqb_set_object_from_query(builder, select_type);
        if(list == NULL){
                *n_objects = 0;
                return NULL; 
        }

        if (builder->schema->use_lang == 1) {
                
                gchar *guid = NULL;
                GList *nlist = NULL;
                
                if(midgard_lang_get(builder->mgd) != 0)
                        list = g_list_reverse(list);

                for(; list ; list = list->next){     
                       
                        /* Bit of hack, records could be returned with lang DESC */
                        
                        if(select_type == MQB_SELECT_OBJECT) {
                                g_object_get(G_OBJECT(list->data), "guid", &guid, NULL);
                        } else if (select_type == MQB_SELECT_GUID) {
                                guid = g_strdup((gchar *)list->data);
                        }
                        /* Changed to find_custom due to bug in GLib docs */
                        /* g_list_find never returns NULL */
                        /* We could use g_hash_table as well */
                        if((tmp_list = g_list_find_custom(tmp_list, 
                                                guid, _compare_ml_guid))) {
                                
                                g_free((gchar *)tmp_list->data);  
                                tmp_list->data = g_strdup(""); /* FIXME */
                                
                                if(select_type == MQB_SELECT_OBJECT) {
                                        g_object_unref(G_OBJECT(list->data));
                                } else if (select_type == MQB_SELECT_GUID) {
                                        /* TODO check leak, none for now */
                                        /* g_free(list->data); */
                                }
                                
                        } else {
                                nlist = g_list_append(nlist, list->data);                          
                        }       
                        tmp_list = g_list_prepend(tmp_list, (gpointer)guid);
                }          
                
                /* Free unused guids */
                for(; tmp_list ; tmp_list = tmp_list->next){
                        g_free((gchar *)tmp_list->data);
                }
                g_list_free(tmp_list);
                g_list_free(list);
                list = nlist;
        }    
        
        *n_objects = g_list_length(list);               
        return list;     
}

GObject **midgard_query_builder_execute(
        MidgardQueryBuilder *builder, guint *n_objects)
{
        guint i = 0;
        MIDGARD_ERRNO_SET(builder->mgd, MGD_ERR_OK);
        GList *list = 
                midgard_query_builder_execute_or_count(builder, n_objects, MQB_SELECT_OBJECT);
        if(list == NULL)
                return NULL;

        MgdObject **objects = g_new(MgdObject *, *n_objects);
        
        for( ; list; list = list->next){
                objects[i] = list->data;
                i++;
        }       
        g_list_free(list);
        return (GObject **)objects;     
}

guint midgard_query_builder_count(MidgardQueryBuilder *builder)
{
        g_assert(builder != NULL);
        guint n_objects = 0;
        MIDGARD_ERRNO_SET(builder->mgd, MGD_ERR_OK);
        GList *list = 
                midgard_query_builder_execute_or_count(builder, &n_objects, MQB_SELECT_GUID);

        if(list != NULL){
                
                for( ; list; list = list->next){                
                        g_free((gchar *)list->data);                                     
                }               
                g_list_free(list);
        }
        return n_objects;
}

GList *midgard_query_builder_get_guid(
                MidgardQueryBuilder *builder)
{
        g_assert(builder != NULL);
        guint n_objects = 0;

        GList *list = 
                midgard_query_builder_execute_or_count(builder, &n_objects, MQB_SELECT_GUID);
        
        return list;    
}


gchar *midgard_query_builder_get_object_select(
        MidgardQueryBuilder *builder, guint select_type){

        g_assert(builder != NULL);
        g_assert(builder->type);

        MidgardObjectClass *klass = (MidgardObjectClass*) g_type_class_peek(builder->type);
        const gchar *table = midgard_object_class_get_table(klass);

        if (midgard_object_class_get_table(klass) == NULL){
                g_warning("Object '%s' has no table or storage defined!", 
                                g_type_name(builder->type));
                return NULL;
        }
                
        GString *select = g_string_new("");

        /* We are getting only guids */
        if(select_type == MQB_SELECT_GUID){
                
                g_string_append_printf(select, "%s.guid", table);
                return g_string_free(select, FALSE);
        }
        
        /* guid , sitegroup hardcoded ( inherited from MgdObjectClass )
         * metadata properties hardcoded ( defined in midgard_metadata )
         */ 
        /* TODO , set switch to disable metadata ( for midgard-infectant) */
        g_string_append_printf(select, 
                        "%s.guid, %s.sitegroup, "
                        "%s.metadata_creator, "
                        "NULLIF(%s.metadata_created,'0000-00-00 00:00:00') AS metadata_created, "
                        "%s.metadata_revisor, "
                        "NULLIF(%s.metadata_revised,'0000-00-00 00:00:00') AS metadata_revised, "
                        "%s.metadata_revision, "
                        "%s.metadata_locker, "
                        "NULLIF(%s.metadata_locked,'0000-00-00 00:00:00') AS metadata_locked, "
                        "%s.metadata_approver, "
                        "NULLIF(%s.metadata_approved,'0000-00-00 00:00:00') AS metadata_approved, "
                        "%s.metadata_authors, %s.metadata_owner, "
                        "NULLIF(%s.metadata_schedule_start,'0000-00-00 00:00:00') AS metadata_schedule_start, "
                        "NULLIF(%s.metadata_schedule_end,'0000-00-00 00:00:00') AS metadata_schedule_end, "
                        "%s.metadata_hidden, "
                        "%s.metadata_nav_noentry, %s.metadata_size, %s.metadata_published, "
                        "NULLIF(%s.metadata_exported,'0000-00-00 00:00:00') AS metadata_exported, "
                        "NULLIF(%s.metadata_imported,'0000-00-00 00:00:00') AS metadata_imported,"
                        "%s.metadata_deleted, %s.metadata_score, %s",
                        table, table, table, table, table, table, table, table, table,
                        table, table, table, table, table, table, table, table, table,
                        table, table, table, table, table,
                        klass->data->query->select_full); /* TODO, Set select which suits better */
        
        return g_string_free(select, FALSE);        
}

GList *_mqb_set_object_from_query(MidgardQueryBuilder *builder, guint select_type){

        g_assert(builder != NULL);

        GParamSpec *prop;
        MgdObject *object;
        GValue pval = {0, };
        MidgardObjectClass *klass = (MidgardObjectClass*) g_type_class_peek(builder->type);;
        guint ret_rows, ret_fields, i, j;
       
        gchar *sql = _midgard_core_qb_get_sql(
                        builder, select_type, 
                        midgard_query_builder_get_object_select(builder, select_type));
        
        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "query=%s", sql);

        if(!sql) {
                g_warning("Attempted to execute NULL query");
                return NULL;
        }               

        gint sq = mysql_query(builder->mgd->msql->mysql, sql);

        if (sq != 0) {
                g_warning("\n\nQUERY: \n %s \n\n FAILED: \n %s",
                                sql,
                                mysql_error(builder->mgd->msql->mysql));
                midgard_set_error(builder->mgd->_mgd,
                                MGD_GENERIC_ERROR,
                                MGD_ERR_INTERNAL,
                                " SQL query failed. ");
                g_clear_error(&builder->mgd->_mgd->err);        
                g_free(sql); 
                return FALSE;
        }
        g_free(sql);
      
        /* We use MySQL API directly, no mgd_query and midgard_res usage */
        MYSQL_ROW row;
        MYSQL_FIELD *field;
        MYSQL_RES *results = mysql_store_result(builder->mgd->msql->mysql);
        if (!results)
                return FALSE;
        
        if ((ret_rows = mysql_num_rows(results)) == 0) {
                mysql_free_result(results);
                return NULL;
        }
       
        /* records found , allocate as many objects as many returned rows */ 
        GList *list = NULL;

        /* We get guids only */
        if(select_type == MQB_SELECT_GUID) {
                
                for(i = 0; i < ret_rows; i++){
                        row = mysql_fetch_row(results);
                        ret_fields = mysql_num_fields(results);
                        for (j = 0; j < ret_fields; j++){
                                list = g_list_append(list, g_strdup((gchar *) row[j]));
                        }                       
                }
                mysql_free_result(results);
                return list;
        }
              
        /* Get every row */
        for(i = 0; i < ret_rows; i++){
                
                row = mysql_fetch_row(results);
                object = midgard_object_new(builder->mgd, 
                                g_type_name(builder->type), NULL);
                ret_fields =  mysql_num_fields(results); 
                
                /* We set metadata properties directly , but w get 
                 * additional speed. g_object_set looses 10% of performance here */
                g_free(object->metadata->private->creator);
                object->metadata->private->creator = g_strdup((gchar *)row[2]);
                g_free(object->metadata->private->created);
                object->metadata->private->created = g_strdup((gchar *)row[3]);
                g_free(object->metadata->private->revisor);
                object->metadata->private->revisor = g_strdup((gchar *)row[4]);
                g_free(object->metadata->private->revised);
                object->metadata->private->revised = g_strdup((gchar *)row[5]);
                object->metadata->private->revision = atoi(row[6]);
                g_free(object->metadata->private->locker);
                object->metadata->private->locker = g_strdup((gchar *)row[7]);
                g_free(object->metadata->private->locked);
                object->metadata->private->locked = g_strdup((gchar *)row[8]);
                g_free(object->metadata->private->approver);
                object->metadata->private->approver = g_strdup((gchar *)row[9]);
                g_free(object->metadata->private->approved);
                object->metadata->private->approved = g_strdup((gchar *)row[10]);
                g_free(object->metadata->private->authors);
                object->metadata->private->authors = g_strdup((gchar *)row[11]);
                g_free(object->metadata->private->owner);
                object->metadata->private->owner = g_strdup((gchar *)row[12]);
                g_free(object->metadata->private->schedule_start);
                object->metadata->private->schedule_start = g_strdup((gchar *)row[13]);
                g_free(object->metadata->private->schedule_end);
                object->metadata->private->schedule_end = g_strdup((gchar *)row[14]);
                object->metadata->private->hidden = atoi(row[15]);
                object->metadata->private->nav_noentry = atoi(row[16]);
                object->metadata->private->size = atoi(row[17]);
                g_free(object->metadata->private->published);
                object->metadata->private->published = g_strdup((gchar *)row[18]);
                g_free(object->metadata->private->exported);
                object->metadata->private->exported = g_strdup((gchar *)row[19]);
                g_free(object->metadata->private->imported);
                object->metadata->private->imported = g_strdup((gchar *)row[20]);
                object->metadata->private->deleted = atoi(row[21]);
                object->metadata->private->score = atoi(row[22]);
               
                /* Set core's object private data */
                object->private->exported = g_strdup((gchar *)row[19]);
                object->private->imported = g_strdup((gchar *)row[20]);

                /* Get all fields */
                /* We can set guid and sitegroup as row[0] and row[1]
                 * and start loop from 16 to increase speed. 
                 * All in all metadata won't be changed often */
                for (j = 0; j < ret_fields; j++){
                       
                        if(j < 22 && j > 2)
                                continue;
                        field = mysql_fetch_field_direct(results, j);
                                              
                        if ((prop = g_object_class_find_property(
                                                        (GObjectClass *)klass, field->name)) != NULL) {

                                g_value_init(&pval,prop->value_type);

                                switch(prop->value_type){

                                        case G_TYPE_STRING:
                                                g_value_set_string(&pval, (gchar *)row[j]);
                                                break; 

                                        case G_TYPE_UINT:
                                                g_value_set_uint(&pval, atoi(row[j]));
                                                break;

                                        case G_TYPE_INT:
                                                g_value_set_int(&pval, atoi(row[j]));
                                                break;

                                        case G_TYPE_FLOAT:
                                                g_value_set_float(&pval, g_ascii_strtod(row[j], NULL));
                                                break;
                                        
                                        case G_TYPE_BOOLEAN:
                                                g_value_set_boolean(&pval, atoi(row[j]));
                                                break;                                     
                                                
                                }
                                g_object_set_property(G_OBJECT(object), field->name, &pval);
                                g_value_unset(&pval);                                
                        }                                                        
                }
                list = g_list_append(list, G_OBJECT(object));                
        }
        mysql_free_result(results);
        return list;
}

gboolean midgard_query_builder_join(
                MidgardQueryBuilder *builder, const gchar *prop, 
                const gchar *jobject, const gchar *jprop)
{

        g_assert(prop != NULL);
        g_assert(jobject != NULL);
        g_assert(jprop != NULL);

        /* Find property prop in builder types' class */
        GParamSpec *pspec = g_object_class_find_property(
                        G_OBJECT_CLASS(g_type_class_peek(builder->type)), prop);
        if(pspec == NULL) {
                g_warning("Invalid property '%s' for '%s'!",
                                prop, g_type_name(builder->type));
                return FALSE;
        }

        /* Initialize new instance for joined object typename */
        MgdObject *obj = midgard_object_new(builder->mgd, jobject, NULL);
        if(obj == NULL) {
                g_warning("Type %s in not registered in application schema",
                                jobject);
                return FALSE;                                           
        }
        
        /* Find property jprop in jobject's class */
        GParamSpec *jspec = g_object_class_find_property(
                        G_OBJECT_GET_CLASS(G_OBJECT(obj)), jprop);
        if(jspec == NULL) {
                g_warning("Invalid property '%s' for joined type '%s'!",
                                jprop, G_OBJECT_TYPE_NAME(G_OBJECT(obj)));
                return FALSE;
        }

        /* Create "join" part which should be appended to QB's final query */
        builder->link = g_strdup(g_param_spec_get_nick(jspec));
        g_string_append_printf(builder->join,
                        " AND %s = %s",
                        g_param_spec_get_nick(pspec),
                        builder->link);
        
        /* Get MidgardObjectClass pointer */
        MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS(obj);
        /* Get table name used by class */
        const gchar *table = midgard_object_class_get_table(klass);
        
        /* Do not append table name which is already defined in builder->tables */
        gchar **duptables = g_strsplit(builder->tables, ",", 0);
        guint i = 0, j = 0;
        for(i = 0 ; duptables[i]; i++){
                if (g_ascii_strcasecmp(duptables[i],
                                        table) == 0 )
                        j++;
        }

        /* We have new table string so we need to concat all tables */
        if (j == 0) {
                gchar *tmptable  = g_strconcat(builder->tables,
                                ",", table, NULL);
                g_free(builder->tables);
                builder->tables = g_strdup(tmptable);
                g_free(tmptable);
        }
        g_strfreev(duptables);
        g_free(obj);

        return TRUE;                                                                    
}

 
/* Returns type name of the type which is currently used by Query Builder. */
const gchar *midgard_query_builder_get_type_name(
                MidgardQueryBuilder *builder)
{
        g_assert(builder != NULL);
        return g_type_name(builder->type);
}

void midgard_query_builder_include_deleted(MidgardQueryBuilder *builder)
{
        g_assert(builder);

        builder->include_deleted = TRUE;
}

/* GOBJECT ROUTINES*/

static void _midgard_query_builder_finalize(GObject *object)
{
        midgard_query_builder_free(
                        (MidgardQueryBuilder *)object);
}

static void _midgard_query_builder_class_init(
                gpointer g_class, gpointer g_class_data)
{
        GObjectClass *gobject_class = G_OBJECT_CLASS (g_class);
        MidgardQueryBuilderClass *klass = MIDGARD_QUERY_BUILDER_CLASS (g_class);
        
        gobject_class->finalize = _midgard_query_builder_finalize;
        klass->set_lang = midgard_query_builder_set_lang;
        klass->unset_languages = midgard_query_builder_unset_languages;
        klass->add_constraint = midgard_query_builder_add_constraint;
        klass->begin_group = midgard_query_builder_begin_group;
        klass->end_group = midgard_query_builder_end_group;
        klass->add_order = midgard_query_builder_add_order;
        klass->set_limit = midgard_query_builder_set_limit;
        klass->execute = midgard_query_builder_execute;
        klass->count = midgard_query_builder_count;
}

static void _midgard_query_builder_instance_init(
                GTypeInstance *instance, gpointer g_class)
{

}

/* Registers the type as  a fundamental GType unless already registered. */
GType midgard_query_builder_get_type(void)
{
        static GType type = 0;
        if (type == 0) {
                static const GTypeInfo info = {
                        sizeof (MidgardQueryBuilderClass),
                        NULL,           /* base_init */
                        NULL,           /* base_finalize */
                        (GClassInitFunc) _midgard_query_builder_class_init,
                        NULL,           /* class_finalize */
                        NULL,           /* class_data */
                        sizeof (MidgardQueryBuilder),
                        0,              /* n_preallocs */
                        (GInstanceInitFunc) _midgard_query_builder_instance_init /* instance_init */
                };
                type = g_type_register_static (G_TYPE_OBJECT,
                                "midgard_query_builder",
                                &info, 0);
        }
        return type;
}

---