src/mgdschema.c

/* Midgard schema , records and objects definition.
   
  Copyright (C) 2004,2005 Piotr Pokora <pp@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/types.h"
#include "midgard/midgard_legacy.h"
#include <libxml/parser.h>
#include <libxml/tree.h>
#include "midgard/midgard_datatypes.h"
#include "midgard/midgard_type.h"
#include "schema.h"

/* TODO tune header files , no need to include string.h while we need to include midgard.h in almost every case */

/* Global schema_trash used when MgdSchema is destroyed 
 * Trash must be global as we share pointers between different schemas.
 * Especially Midgard core object's MgdSchemaTypes are shared.
 * */
static GSList *schema_trash = NULL;

/* Global schema file path, it's a pointer to filename being parsed.
 * Only for warning purposes */
static const gchar *parsed_schema = NULL;

/* prototypes */ 
void _copy_schemas(gpointer key, gpointer value, gpointer userdata);

static MgdSchemaPropertyAttr *_mgd_schema_property_attr_new(){
        
        MgdSchemaPropertyAttr *prop = g_new(MgdSchemaPropertyAttr, 1);
        prop->gtype = G_TYPE_NONE;
        prop->type = NULL;
        prop->dbtype = NULL;
        prop->field = NULL;
        prop->table = NULL;
        prop->upfield = NULL;
        prop->parentfield = NULL;
        prop->primaryfield = NULL;
        prop->is_multilang = FALSE;
        prop->link = NULL;
        prop->link_target = NULL;
        prop->is_primary = FALSE;
        prop->is_reversed = FALSE;
        prop->is_link = FALSE;
        
        return prop; 
}

static void _mgd_schema_property_attr_free(MgdSchemaPropertyAttr *prop)
{
        g_assert(prop != NULL);

        g_free((gchar *)prop->type);
        g_free((gchar *)prop->dbtype);
        g_free((gchar *)prop->field);
        g_free((gchar *)prop->table);
        g_free((gchar *)prop->upfield);
        g_free((gchar *)prop->parentfield);
        g_free((gchar *)prop->primaryfield);
        g_free((gchar *)prop->link);
        g_free((gchar *)prop->link_target);

        g_free(prop);
}

void _destroy_property_hash(gpointer key, gpointer value, gpointer userdata)
{
        MgdSchemaPropertyAttr *prop = (MgdSchemaPropertyAttr *) value;
        gchar *name = (gchar *) key;
        
        if(prop)
                _mgd_schema_property_attr_free(prop);

        if(name)
                g_free(name);
}

static MgdSchemaTypeQuery *_mgd_schema_type_query_new()
{
        MgdSchemaTypeQuery *query = g_new(MgdSchemaTypeQuery, 1);
        query->select = NULL;
        query->select_full = NULL;
        query->from = NULL;
        query->where = NULL;
        query->table = NULL;
        query->link = NULL;
        query->tables = g_strdup("");
        query->primary = NULL;
        query->parentfield = NULL;
        query->upfield = NULL;
        query->use_lang = FALSE;

        return query;
}

static void _mgd_schema_type_query_free(MgdSchemaTypeQuery *query)
{
        g_assert(query != NULL);
        
        g_free((gchar *)query->select);
        g_free((gchar *)query->select_full);
        /* pointer to type->table, g_free((gchar *)query->from); */
        g_free((gchar *)query->where);
        g_free((gchar *)query->table);
        g_free((gchar *)query->primary);
        g_free((gchar *)query->link);
        g_free((gchar *)query->tables);
        g_free((gchar *)query->parentfield);
        g_free((gchar *)query->upfield);
        

        g_free(query);
}

void _destroy_query_hash(gpointer key, gpointer value, gpointer userdata)
{
        MgdSchemaTypeQuery *query = (MgdSchemaTypeQuery *) value;
        gchar *name = (gchar *) key;
        
        if(query)
                _mgd_schema_type_query_free(query);

        if(name)
                g_free(name);
}

static MgdSchemaTypeAttr *_mgd_schema_type_attr_new()
{
        MgdSchemaTypeAttr *type = g_new(MgdSchemaTypeAttr, 1);
        type->base_index = 0;
        type->num_properties = 0;
        type->params = NULL;
        type->properties = NULL;
        type->table = NULL;
        type->parent = NULL;
        type->primary = NULL;
        type->property_up = NULL;
        type->property_parent = NULL;                           
        type->property_count = 0;
        type->use_lang = FALSE;
        type->tables = g_hash_table_new(g_str_hash, g_str_equal);
        type->prophash = g_hash_table_new(g_str_hash, g_str_equal);
        type->query = _mgd_schema_type_query_new();
        type->childs = NULL;
        
        return type;
}

static void _mgd_schema_type_attr_free(MgdSchemaTypeAttr *type)
{
        g_assert(type != NULL);

        g_free((gchar *)type->table);
        g_free((gchar *)type->parent);
        g_free((gchar *)type->primary);
        g_free((gchar *)type->property_up);
        g_free((gchar *)type->property_parent);

        g_hash_table_foreach(type->tables, _destroy_query_hash, NULL);
        g_hash_table_destroy(type->tables);     
        
        g_hash_table_foreach(type->prophash, _destroy_property_hash, NULL);
        g_hash_table_destroy(type->prophash);

        _mgd_schema_type_query_free(type->query);

        g_free(type->params);
        g_free(type->properties);
        
        g_free(type);
}

/* return type's struct  or NULL if type is not in schema */
MgdSchemaTypeAttr *
midgard_schema_lookup_type (MidgardSchema *schema, gchar *name)
{
        g_assert(schema != NULL);
        g_assert(name != NULL);

        return (MgdSchemaTypeAttr *) g_hash_table_lookup(schema->types, name);  
}


GHashTable *
midgard_schema_lookup_type_member(MidgardSchema *schema, const gchar *typename, gchar *property)
{
        g_assert(schema != NULL);
        g_assert(typename != NULL);
        g_assert(property != NULL);
        
        MgdSchemaTypeAttr *sts;
        
        sts = midgard_schema_lookup_type(schema, (gchar *)typename);
        
        if (sts != NULL) 
                return g_hash_table_lookup(sts->prophash, property);

        return NULL;
}

/* Define which element names should be addedd to schema. 
 * We change them only here , and in xml file itself.
 */
static const gchar *mgd_complextype[] = { "type", "property", "Schema", "description", "include", NULL };
static const gchar *mgd_attribute[] = { "name", "table", "parent", "parentfield", 
        "type", "link", "upfield", "field", "multilang", "reverse", "primaryfield", "dbtype", NULL };

/* RESERVED type names */
static const gchar *rtypes[] = { 
        "midgard_sitegroup", 
        "midgard_account",
        NULL
};

/* RESERVED table names */
static const gchar *rtables[] = {
        "sitegroup",
        "repligard",
        "midgard_account",
        NULL
};

/* RESERVED column names */
static const gchar *rcolumns[] = {
        "metadata_",
        "sitegroup",
        "group", /* This is MySQL reserved word */
        NULL
};

static gboolean strv_contains(const char **strv, const xmlChar *str) {
        g_assert(strv != NULL);
        g_assert(str != NULL);
        while (*strv != NULL) {
                if (g_str_equal(*strv++, str)) {
                        return TRUE;
                }
        }
        return FALSE;
}

static void check_metadata_column(const xmlChar *column){
        
        if(g_str_has_prefix((const gchar *)column, "metadata_"))
                g_critical("Column names prefixed with 'metadata_' are reserved ones");
}

static void check_property_name(const xmlChar *name, const gchar *typename){
        
        g_assert(name != NULL);

        if(g_strrstr_len((const gchar *)name, strlen((const gchar *)name), "_") != NULL)
                g_critical("Type '%s', property '%s'. Underscore not allowed in property names!",
                                typename, name);

        /* temporary solution for midgard_quota */
        if(!g_str_equal(typename, "midgard_quota"))
                if(g_str_equal(name, "sitegroup"))
                        g_critical("Type '%s'.Property name 'sitegroup' is reserved!",
                                        typename);

        if(g_str_equal(name, "guid"))
                g_critical("Type '%s'.Property name 'guid' is reserved!",
                                typename);
                
}


/* Get all type attributes */
static void
_get_type_attributes(xmlNode * node, MgdSchemaTypeAttr *type_attr)
{
        xmlAttr *attr;
        xmlChar *attrval;

        if (node != NULL){

                attr = node->properties;
                attr = attr->next; /* avoid getting already added */

                while (attr != NULL){

                        if(!strv_contains(mgd_attribute, attr->name)){
                                g_warning("Wrong attribute '%s' in '%s' on line %ld",
                                                attr->name, parsed_schema, xmlGetLineNo(node)); 
                        }       
                        attrval = xmlNodeListGetString (node->doc, attr->children, 1);
                                        
                        if(g_str_equal(attr->name, "table")) {
                                /* Check if table name is reserved one */
                                if (strv_contains(rtables, attrval)) {
                                        g_critical("'%s' is reserved table name",
                                                        attrval);
                                }                                                               
                                type_attr->table = g_strdup((const gchar *)attrval);
                        }

                        if(g_str_equal(attr->name, "parent"))
                                type_attr->parent = g_strdup((gchar *)attrval);
        
                        xmlFree(attrval);
                        attr = attr->next;                      
                }
        }
}

/* Get property attributes */
static void 
_get_property_attributes(xmlNode * node, 
                MgdSchemaTypeAttr *type_attr, MgdSchemaPropertyAttr *prop_attr)
{
        xmlAttr *attr;
        xmlChar *attrval;

        if (node != NULL){

                attr = node->properties;
                attr = attr->next;

                while (attr != NULL){

                        attrval = xmlNodeListGetString (node->doc, attr->children, 1);
                
                        if(!strv_contains(mgd_attribute, attr->name)){
                                g_warning("Wrong attribute '%s' in '%s' on line %ld",
                                                attr->name, parsed_schema, xmlGetLineNo(node));
                        }

                        if(g_str_equal(attr->name, "type")){
                                prop_attr->type = g_strdup((const gchar*)attrval);
                        
                                if(g_str_equal(attrval, "string"))
                                        prop_attr->gtype = MGD_TYPE_STRING;

                                if(g_str_equal(attrval, "integer"))
                                        prop_attr->gtype = MGD_TYPE_INT;

                                if(g_str_equal(attrval, "unsigned integer"))
                                        prop_attr->gtype = MGD_TYPE_UINT;

                                if(g_str_equal(attrval, "float"))
                                        prop_attr->gtype = MGD_TYPE_FLOAT;

                                if(g_str_equal(attrval, "boolean"))
                                        prop_attr->gtype = MGD_TYPE_BOOLEAN;

                                if(g_str_equal(attrval, "bool"))
                                        prop_attr->gtype = MGD_TYPE_BOOLEAN;
                                
                                if(g_str_equal(attrval, "datetime"))
                                        prop_attr->gtype = MGD_TYPE_TIMESTAMP;
                                
                                if(g_str_equal(attrval, "longtext"))
                                        prop_attr->gtype = MGD_TYPE_LONGTEXT;
                                
                                if(g_str_equal(attrval, "text"))
                                        prop_attr->gtype = MGD_TYPE_LONGTEXT;                           

                                if(g_str_equal(attrval, "guid"))
                                        prop_attr->gtype = MGD_TYPE_GUID;
                                
                        }
                        
                        if(g_str_equal(attr->name, "dbtype"))
                                prop_attr->dbtype = g_strdup((gchar *)attrval);
                        
                        if(g_str_equal(attr->name, "field")){
                                /* Check if column name is reserved one */
                                check_metadata_column(attrval);
                                if (strv_contains(rcolumns, attrval)) {
                                        g_critical("'%s' is reserved column name",
                                                        attrval);
                                }                                                               
                                prop_attr->field = g_strdup((gchar *)attrval);
                        }
                        
                        if(g_str_equal(attr->name, "table")){
                                /* Check if table name is reserved one */
                                if (strv_contains(rtables, attrval)) {
                                        g_critical("'%s' is reserved table name",
                                                        attrval);
                                }
                                prop_attr->table = g_strdup((gchar *)attrval);
                        }

                        if(g_str_equal(attr->name, "upfield")){
                                check_metadata_column(attrval);
                                /* Check if column name is reserved one */
                                if (strv_contains(rcolumns, attrval)) {
                                        g_critical("'%s' is reserved column name",
                                                        attrval);
                                }                               
                                if(!type_attr->property_up){
                                        xmlChar *tmpattr = 
                                                xmlGetProp (node, (const xmlChar *)"name");
                                        type_attr->property_up = g_strdup((gchar *)tmpattr);
                                        type_attr->query->upfield = g_strdup((gchar *)attrval);
                                        xmlFree(tmpattr);
                                } else {
                                        g_warning("upfield redefined!");
                                }
                                prop_attr->upfield = g_strdup((gchar *)attrval);                        
                        }

                        if(g_str_equal(attr->name, "parentfield")){
                                check_metadata_column(attrval);
                                /* Check if column name is reserved one */
                                if (strv_contains(rcolumns, attrval)) {
                                        g_critical("'%s' is reserved column name",
                                                        attrval);
                                }
                                if(!type_attr->property_parent){
                                        xmlChar *tmpattr = xmlGetProp (node, (const xmlChar *)"name");
                                        type_attr->property_parent = g_strdup((gchar *)tmpattr);
                                        type_attr->query->parentfield = g_strdup((gchar *)attrval);
                                        xmlFree(tmpattr);
                                } else {                         
                                        g_warning("parentfield redefined!");
                                }
                                prop_attr->parentfield = g_strdup((gchar *)attrval);
                        }                       

                        if(g_str_equal(attr->name, "multilang")) {
                                if(g_str_equal(attrval, "yes")) {
                                        prop_attr->is_multilang = TRUE; 
                                        type_attr->use_lang = TRUE;
                                }
                        }

                        if(g_str_equal(attr->name, "primaryfield")) {
                                check_metadata_column(attrval);
                                /* Check if column name is reserved one */
                                if (strv_contains(rcolumns, attrval)) {
                                        g_critical("'%s' is reserved column name",
                                                        attrval);
                                }
                                prop_attr->primaryfield = g_strdup((gchar *)attrval);
                                prop_attr->is_primary = TRUE;
                                xmlChar *tmpattr = xmlGetProp (node, (const xmlChar *)"name");
                                type_attr->primary = g_strdup((gchar *)tmpattr);
                                type_attr->query->primary = g_strdup((gchar *)attrval);
                                xmlFree(tmpattr);
                        }

                        if(g_str_equal(attr->name, "reverse")) {
                                if(g_str_equal(attrval, "yes"))
                                        prop_attr->is_reversed = TRUE;  
                        }
                        
                        if(g_str_equal(attr->name, "link")) {
                                gchar **link = g_strsplit((gchar *)attrval, ":", -1);
                                prop_attr->link = g_strdup((gchar *)link[0]);
                                prop_attr->is_link = TRUE;
                                if(link[1])
                                        prop_attr->link_target = 
                                                g_strdup((gchar *)link[1]);
                                else 
                                        prop_attr->link_target =
                                                g_strdup("guid");

                                g_strfreev(link);
                        }

                        xmlFree(attrval);
                        attr = attr->next;                                                              
                }
        }
}

/* Parse the whole file and make tree with nodes and properties.
 * Create huge hash of hashes, according to names which are defined
 * in ondef and attrdef chars. The only one hardcoded node's name is 
 * "name". I do not think it should force anyone to hardcode more things.
 * The rest is automagic :)
 */
static void
_get_element_names (xmlNode * curn , MgdSchemaTypeAttr *type_attr, MidgardSchema *schema)
{
        xmlNode *obj = NULL;
        xmlChar *nv = NULL, *dparent;
        MgdSchemaTypeAttr *duplicate;
        MgdSchemaPropertyAttr *prop_attr;
        gchar *tmpstr;

        for (obj = curn; obj; obj = obj->next){
                
                if (obj->type == XML_ELEMENT_NODE){
                        /* Get nodes with "name" name. Check if obj->name was defined */
                        nv = xmlGetProp (obj, (const xmlChar *)"name"); 
                        
                        if(!strv_contains(mgd_complextype, obj->name)){
                                g_warning("Wrong node name '%s' in '%s' on line %ld",
                                                obj->name, parsed_schema, xmlGetLineNo(obj));
                        }

                        if(g_str_equal(obj->name, "type")) {

                                /* Check if type name is reserved one */
                                if (strv_contains(rtypes, nv)) {
                                        g_critical("'%s' is reserved type name",
                                                        nv);

                                }
                                
                                if (g_str_equal(obj->name, "type")) {
                                        duplicate = midgard_schema_lookup_type(
                                                        schema, (gchar *)nv);
                                        
                                        if (duplicate != NULL) {
                                                g_error("%s:%s already added to schema!",
                                                                obj->name, nv);
                                        } else {
                                                type_attr = _mgd_schema_type_attr_new();
                                                g_hash_table_insert(schema->types,
                                                                g_strdup((gchar *)nv), type_attr);
                                                _get_type_attributes (obj, type_attr);
                                        }
                                } 
                        }

                        if (g_str_equal(obj->name, "property")){
                                
                                dparent = xmlGetProp(obj->parent,
                                                (const xmlChar *)"name");
                                check_property_name(nv, (const gchar *)dparent);
                                /* g_debug("\t Property: %s ", nv); */ 
                                prop_attr = g_hash_table_lookup(
                                                type_attr->prophash, (gchar *)nv);
                                
                                if (prop_attr != NULL) {
                                        g_warning("Property '%s' already added to %s",
                                                        nv ,dparent);
                                } else {
                                        /* FIXME
                                         * one prop_attr seems to be assigned nowhere */
                                        prop_attr = _mgd_schema_property_attr_new();
                                        _get_property_attributes(obj, type_attr, prop_attr);
                                        if(prop_attr->is_primary 
                                                        && prop_attr->gtype != MGD_TYPE_UINT){
                                                tmpstr = (gchar *)xmlGetProp(obj->parent,
                                                                (const xmlChar *)"name");
                                                g_message(" %s - type for primaryfield not defined"
                                                                " as 'unsigned integer'."
                                                                " Forcing uint type"
                                                                , tmpstr);
                                                g_free(tmpstr);
                                        }
                                        g_hash_table_insert(type_attr->prophash, 
                                                        g_strdup((gchar *)nv), prop_attr);
                                }                                       
                                xmlFree(dparent);                               
                        }
                        if(g_str_equal(obj->name, "description")){

                                xmlChar *value = xmlGetProp(obj, (const xmlChar *)"value");
                                xmlFree(value);                         
                        }
                        xmlFree(nv);
                        if (obj->children != NULL)
                                _get_element_names (obj->children, type_attr, schema);   
                }
        }
}

/* Start processing type's properties data. 
 * This function is called from __get_tdata_foreach 
 */
void __get_pdata_foreach(gpointer key, gpointer value, gpointer user_data)
{
        MgdSchemaTypeAttr *type_attr  = (MgdSchemaTypeAttr *) user_data;  
        MgdSchemaPropertyAttr *prop_attr = (MgdSchemaPropertyAttr *) value;
        const gchar *table, *tables, *primary, *parentname, *ext_table = NULL;
        gchar *tmp_sql = NULL , *nick = "";
        MgdSchemaTypeQuery *tquery;
        /* type_attr->num_properties is used ( and is mandatory! ) 
         * when we register new object types and set class properties */
        guint n = ++type_attr->num_properties;;
        const gchar *pname = (gchar *) key;
        const gchar *fname = NULL, *upfield = NULL, *parentfield = NULL; 
        gchar *tmpstr = NULL;
        GParamSpec **params = type_attr->params;
        GString *tmp_gstring_sql, *table_sql;
        
        /* Set default string type if not set */
        if(!prop_attr->type) {
                prop_attr->type = g_strdup("string");
                prop_attr->gtype = MGD_TYPE_STRING;
        }               
        
        table = prop_attr->table;
        tables = type_attr->query->tables;
        parentname = table;

        /* TODO
         * Set ACL data, create sql queries, add additional data
         * All data required is present at this moment.
         */
        
        /* Search for upfield and parentfield definition.
         * We will use them ( if found ) for nick ( table.field ) definition 
         * without need to define field attribute.  */
        
        upfield = prop_attr->upfield;
        parentfield = prop_attr->parentfield;
        primary = prop_attr->primaryfield;
        
        ext_table = table;
        
        /* "external" tables for type */
        
        /* Create GHashTable for all tables described in type's schema definition */
        if (ext_table != NULL){
                
                /* Check if table key already exists , and create one if not */
                if ((tquery = g_hash_table_lookup(type_attr->tables, ext_table)) == NULL){
                        tquery = _mgd_schema_type_query_new();
                        g_hash_table_insert(type_attr->tables, g_strdup(ext_table), tquery);      
                }
                
                if(g_strstr_len (tables, strlen(tables), ext_table) == NULL){
                        tmpstr = g_strconcat(tables, ext_table, ",", NULL);
                        g_free((gchar *)tables);
                        type_attr->query->tables = g_strdup(tmpstr);
                        g_free(tmpstr);
                }
                
                table_sql = g_string_new("");
                if(tquery->select)
                        g_string_append(table_sql, tquery->select);
                
                if (prop_attr->is_multilang)
                        tquery->use_lang = TRUE;
                
                tquery->from = (gchar *)ext_table;
                fname = prop_attr->field;
        
                if (fname != NULL) {
                        tmpstr = g_strjoin(".", ext_table, fname,NULL);
                } else {
                        tmpstr = g_strjoin(".", ext_table, pname,NULL);
                }
                nick = g_strdup(tmpstr);
                
                tmp_gstring_sql = g_string_new(" ");            
                if(prop_attr->gtype == MGD_TYPE_TIMESTAMP) {                    
                        g_string_append_printf(tmp_gstring_sql,
                                        "NULLIF(%s,'0000-00-00 00:00:00') AS %s",
                                        tmpstr, pname);
                } else {
                        g_string_append_printf(tmp_gstring_sql,
                                        "%s AS %s",
                                        tmpstr, pname);
                }
                g_free(tmpstr);
                tmpstr = g_string_free(tmp_gstring_sql, FALSE);
                /* Avoid duplicated coma */
                if(tquery->select)
                        g_string_append(table_sql, ", ");
                g_string_append(table_sql, tmpstr);
                g_free(tmpstr);
                g_free(tquery->select);
                tquery->select = g_string_free(table_sql, FALSE);
                
                g_hash_table_insert(type_attr->tables, (gchar *)ext_table, tquery);
                /* "external" tables end */
        } 
        
        table = type_attr->table;
        
        if (ext_table == NULL) {
                tmpstr = NULL;
                type_attr->query->from = (gchar *)table;
                fname = prop_attr->field;
                if ( (fname == NULL ) && ((upfield == NULL) && (parentfield == NULL)) 
                                && (primary == NULL)){
                        tmpstr = g_strjoin(".", table, pname,NULL);
                } else if((fname != NULL) && ((parentfield == NULL) || (upfield == NULL))) {
                        tmpstr = g_strjoin(".", table, fname,NULL);
                }
                if(tmpstr){
                        table_sql = g_string_new("");
                        if(type_attr->query->select)
                                g_string_append(table_sql, type_attr->query->select);                   
                        nick = g_strdup(tmpstr);
                        tmp_gstring_sql = g_string_new(" ");
                        if(prop_attr->gtype == MGD_TYPE_TIMESTAMP) {
                                g_string_append_printf(tmp_gstring_sql,
                                                "NULLIF(%s,'0000-00-00 00:00:00') AS %s",
                                                tmpstr, pname);
                        } else {
                                g_string_append_printf(tmp_gstring_sql,
                                                "%s AS %s",
                                                tmpstr, pname);
                        }
                        g_free(tmpstr);
                        tmpstr = g_string_free(tmp_gstring_sql, FALSE);
                        /* Do not prepend coma if type select is empty */
                        if(type_attr->query->select)
                                g_string_append(table_sql, ",");
                        g_string_append(table_sql, tmpstr);     
                        g_free(tmpstr);
                        g_free(type_attr->query->select);
                        type_attr->query->select = g_string_free(table_sql, FALSE);
                }
        }
        /* FIXME , this needs to be refactored for real property2field mapping */
        if(!type_attr->query->primary)
                type_attr->query->primary =  g_strdup("guid");

        if(!type_attr->primary){
                type_attr->primary = g_strdup("guid");
        }
        

        if(primary != NULL) {
                nick = g_strjoin(".", table, primary, NULL);
                tmpstr = g_strconcat(nick, " AS ", pname, NULL);
                tmp_sql = g_strjoin(",", tmpstr, type_attr->query->select,NULL);
                if(type_attr->query->select)
                        g_free(type_attr->query->select);
                type_attr->query->select = g_strdup(tmp_sql);
                g_free(tmpstr);
                g_free(tmp_sql);                        
        }

        /* Set field which is used as up.
         * At the same time we define property_up which is keeps such data  */ 
        if(upfield != NULL) {
                nick = g_strjoin(".", table, upfield, NULL);
                tmpstr = g_strconcat(nick, " AS ", pname, NULL);
                tmp_sql = g_strjoin(",", tmpstr, type_attr->query->select,NULL);
                if(type_attr->query->select)
                        g_free(type_attr->query->select);
                type_attr->query->select = g_strdup(tmp_sql);
                g_free(tmpstr);
                g_free(tmp_sql);
        }
        
        /* Set parentfield and property_parent */
        if(parentfield != NULL) {    
                nick = g_strjoin(".", table, parentfield, NULL);
                tmpstr = g_strconcat(nick, " AS ", pname, NULL);
                tmp_sql = g_strjoin(",", tmpstr, type_attr->query->select,NULL);
                if(type_attr->query->select)
                        g_free(type_attr->query->select);
                type_attr->query->select = g_strdup(tmp_sql);
                g_free(tmpstr);
                g_free(tmp_sql);
        }
        
        /* Force G_TYPE_UINT type for primaryfield */
        if((prop_attr->is_primary) && (prop_attr->gtype != G_TYPE_UINT))
                prop_attr->gtype = G_TYPE_UINT;
                        
        /* Create param_specs for object's properties */
        switch (prop_attr->gtype) {
                
                case MGD_TYPE_STRING:
                        params[n-1] = g_param_spec_string(
                                        pname, nick, "",
                                        "",  G_PARAM_READWRITE);
                        break;

                case MGD_TYPE_UINT:
                        params[n-1] = g_param_spec_uint(
                                        pname, nick, "",
                                        0, G_MAXUINT32, 0, G_PARAM_READWRITE);
                        break;

                case MGD_TYPE_INT:
                        params[n-1] = g_param_spec_int(
                                        pname, nick, "",
                                        G_MININT32, G_MAXINT32, 0, G_PARAM_READWRITE);
                        break;

                case MGD_TYPE_FLOAT:
                        params[n-1] = g_param_spec_float(
                                        pname, nick, "",
                                        -G_MAXFLOAT, G_MAXFLOAT, 0, G_PARAM_READWRITE);
                        break;

                case MGD_TYPE_BOOLEAN:
                        params[n-1] = g_param_spec_boolean(
                                        pname, nick, "",
                                        FALSE, G_PARAM_READWRITE);
                        break;

                default:
                        params[n-1] = g_param_spec_string(
                                        pname, nick, "",
                                        "", G_PARAM_READWRITE);                 
                                        
        }
        g_free(nick);    
}

/* Append all tables' select to type's full_select */
void _set_object_full_select(gpointer key, gpointer value, gpointer userdata)
{
        GString *fullselect = (GString *) userdata;
        MgdSchemaTypeQuery *query = (MgdSchemaTypeQuery *) value;
        
        g_string_append_printf(fullselect, 
                        ",%s", query->select);
}


/* Get types' data. Type's name and its values.
 * We can not start creating GParamSpec while we parse xml file.
 * This is internally used with _register_types function. At this 
 * moment we can count all properties of type and call sizeof
 * with correct values
 */ 

void __get_tdata_foreach(gpointer key, gpointer value, gpointer user_data)
{
        GType new_type;
        MgdSchemaTypeAttr *type_attr = (MgdSchemaTypeAttr *) value;
        guint np;       
        gchar *tmpstr;
        
        if(g_type_from_name(key))
                return;
        
        np = g_hash_table_size(type_attr->prophash);

        type_attr->params = g_malloc(sizeof(GParamSpec*)*(np+1)); 

        if (np > 0) {
                g_hash_table_foreach(type_attr->prophash, __get_pdata_foreach, type_attr);
                
                /* add NULL as last value, 
                 * we will use ud.param as GParamSpec for object's properties. */ 
                
                type_attr->params[np] = NULL;
                
                /* Define tree management fields and tables */

                if (type_attr->table != NULL ) {
                        tmpstr = g_strconcat(type_attr->query->tables, type_attr->table, NULL); 
                        g_free((gchar *)type_attr->query->tables);
                        type_attr->query->tables = g_strdup(tmpstr);
                        g_free(tmpstr);
                }

                //type_attr->parent = typename;
                
                /* Set NULL to child_cname, we will fill this value when all types
                 * are already registered ( _schema_postconfig ).  */ 
                type_attr->childs = NULL;
                
                GString *fullselect = g_string_new("");
                g_string_append(fullselect , type_attr->query->select );
                g_hash_table_foreach(type_attr->tables,  _set_object_full_select, fullselect);
                type_attr->query->select_full = g_string_free(fullselect, FALSE);

                /* Register type , and initialize class. We can not add properties while 
                 * class is registered and we can not initialize class with properties later.
                 * Or rather "we should not" do this later. */ 
                if (type_attr->params != NULL) {

                        new_type = midgard_type_register(key, type_attr);
                        if (new_type){
                                GObject *foo = g_object_new(new_type, NULL);
                                g_object_unref(foo); 
                        }
                }
        
        } else {
                g_warning("Type %s has less than 1 property!", (gchar *)key);
        }
}

/* Copy source schema types ( class names ) and its MgdSchemaType structures
 * to destination schema */
void _copy_schemas(gpointer key, gpointer value, gpointer userdata)
{
        gchar *typename = (gchar *)key;
        MgdSchemaTypeAttr *type = (MgdSchemaTypeAttr *)value;
        MgdSchema *ts = (MgdSchema *) userdata;

        if(!g_hash_table_lookup(ts->types, typename)) {
                
                if(type != NULL)
                        g_hash_table_insert(ts->types, g_strdup(typename), type); 
        }
}

/* We CAN NOT define some data during __get_tdata_foreach.
 * parent and childs relation ( for example ) must be done AFTER
 * all types are registered and all types internal structures are
 * already initialized and defined
 */ 
void __postconfig_schema_foreach(gpointer key, gpointer value, gpointer user_data)
{
        MgdSchemaTypeAttr *type_attr = (MgdSchemaTypeAttr *) value, *parenttype;
        MidgardSchema *schema = (MidgardSchema *) user_data;
        gchar *typename = (gchar *) key;
        const gchar *parentname;

        parentname = type_attr->parent;
        
        if (parentname  != NULL ){

                /* Set child type name for parent's one */
                /* PP: I use g_type_from_name(typename)) as gslist->data because
                 * typename ( even typecasted to char ) doesn't work.
                 * If you think this is wrong and have better solution , 
                 * feel free to change this code. */
                
                /* WARNING!! , all types which has parenttype defined will be appended to 
                 * this list. It doesn't matter if they are "registered" in such schema.
                 * Every GObjectClass has only one corresponding C structure , so it is impossible
                 * to initialize new MgdSchemaTypeAttr per every classname 
                 * in every schema and keep them  separated for every GObjectClass , 
                 * as we define only one GType.
                 * It may be resolved by expensive hash lookups for every new object instance.
                 */

                if ((parenttype = midgard_schema_lookup_type(schema, (gchar *)parentname)) != NULL){
                        /* g_debug("type %s, parent %s", typename, parentname); */
                        if (!g_slist_find(parenttype->childs, 
                                                (gpointer)g_type_from_name(typename))) {
                                parenttype->childs = 
                                        g_slist_append(parenttype->childs, 
                                                        (gpointer)g_type_from_name(typename));
                        }                       
                }
        }
}

static const char *NAMESPACE = "http://www.midgard-project.org/repligard/1.4";

/* Forward declarations used by read_schema_path() */
static void read_schema_directory(GHashTable *files, const char *directory);
static void read_schema_file(GHashTable *files, const char *file);

static void read_schema_path(GHashTable *files, const char *path) {
        g_assert(files != NULL);
        g_assert(path != NULL);
        if (g_file_test(path, G_FILE_TEST_IS_DIR)) {
                read_schema_directory(files, path);
        } else if (g_file_test(path, G_FILE_TEST_EXISTS)) {
                read_schema_file(files, path);
        } else {
                g_warning("Schema path %s not found", path);
        }
}

static void read_schema_file(GHashTable *files, const char *file) {
        g_assert(files != NULL);
        g_assert(file != NULL);

        /* Guard against duplicate loading of schema files */
        if (g_hash_table_lookup(files, file) != NULL) {
                g_warning("Skipping already seen schema file %s", file);
                return;
        }

        /* Parse this schema file */
        /* g_debug("Reading schema file %s", file); */
        xmlDocPtr doc = xmlParseFile(file);
        if (doc == NULL) {
                g_warning("Skipping malformed schema file %s", file);
                return;
        }
        xmlNodePtr root = xmlDocGetRootElement(doc);
        if (root == NULL
            || root->ns == NULL
            || !g_str_equal(root->ns->href, NAMESPACE)
            || !g_str_equal(root->name, "Schema")) {
                g_warning("Skipping invalid schema file %s", file);
                xmlFreeDoc(doc);
                return;
        }

        /* Add the schema file to the hash table */
        g_hash_table_insert(files, g_strdup(file), doc);

        /* Read all included schema files */
        xmlNodePtr node = root->children;
        while (node != NULL) {
                xmlChar *attr = xmlGetNoNsProp(node, (xmlChar *) "name");
                if (node->type == XML_ELEMENT_NODE
                    && node->ns != NULL
                    && g_str_equal(node->ns->href, NAMESPACE)
                    && g_str_equal(node->name, "include")
                    && attr != NULL) {
                        GError *error = NULL;
                        gchar *name = g_filename_from_utf8(
                                (const gchar *) attr, -1, NULL, NULL, &error);
                        if (name == NULL) {
                                g_warning("g_filename_from_utf8: %s", error->message);
                                g_error_free(error);
                        } else if  (g_path_is_absolute(name)) {
                                read_schema_path(files, name);
                                g_free(name);
                        } else {
                                gchar *dir = g_path_get_dirname(file);
                                gchar *path = g_build_filename(dir, name, NULL);
                                read_schema_path(files, path);
                                g_free(path);
                                g_free(dir);
                                g_free(name);
                        }
                }
                if (attr != NULL) {
                        xmlFree(attr);
                }
                node = node->next;
        }
        /* xmlFreeDoc(doc); */ /* wtf? */       
}

static void read_schema_directory(GHashTable *files, const char *directory) {
        g_assert(files != NULL);
        g_assert(directory != NULL);

        GError *error = NULL;
        GDir *dir = g_dir_open(directory, 0, &error);
        if (dir != NULL) {
                const gchar *file = g_dir_read_name(dir);
                while (file != NULL) {
                        gchar *path = g_build_filename(directory, file, NULL);
                        if (g_str_has_prefix(file, ".")) {
                                /* skip hidden files and directories */
                        } else if (g_str_has_prefix(file, "#")) {
                                /* skip backup files and directories */
                        } else if (!g_file_test(path, G_FILE_TEST_IS_DIR)) {
                                /* recurse into subdirectories */
                                read_schema_directory(files, path);
                        } else if (g_str_has_suffix(file, ".xml")) {
                                /* read xml file, guaranteed to exist */
                                read_schema_file(files, path);
                        }
                        g_free(path);
                        file = g_dir_read_name(dir);
                }
                g_dir_close(dir);
        } else {
                g_warning("g_dir_open: %s", error->message);
                g_error_free(error);
        }
}

static GHashTable *read_schema_files(const char *path) {
        g_assert(path != NULL);
        GHashTable *files = g_hash_table_new_full(
                g_str_hash, g_str_equal, g_free, (GDestroyNotify) xmlFreeDoc);
        read_schema_path(files, path);
        return files;
}

static void parse_schema(gpointer key, gpointer value, gpointer user_data) {
        g_assert(key != NULL);
        g_assert(value != NULL);
        g_assert(user_data != NULL);
        parsed_schema = (const gchar *)key;

        MidgardSchema *schema = (MidgardSchema *) user_data;
        xmlDocPtr doc = (xmlDocPtr) value;
        xmlNodePtr root = xmlDocGetRootElement(doc);
        _get_element_names(root, NULL, schema);
}

/* API functions */

/* Initializes basic Midgard classes */
void midgard_schema_init(MidgardSchema *self){
        
        g_assert(self != NULL);
        midgard_schema_read_file(self, MIDGARD_GLOBAL_SCHEMA);
}

/* Checks if classname is registsred for schema. */
gboolean midgard_schema_type_exists(MidgardSchema *self, const gchar *classname)
{
        g_assert(self != NULL);
        g_assert(classname != NULL);
        
        if(g_hash_table_lookup(self->types, classname))
                return TRUE;

        return FALSE;
}

void midgard_schema_read_file(
                MidgardSchema *schema, const gchar *filename) 
{
        g_assert(schema != NULL);
        g_assert(filename != NULL);

        GHashTable *files = read_schema_files(filename);
        g_hash_table_foreach(files, parse_schema, schema);
        g_hash_table_destroy(files);

        /* register types */
        g_hash_table_foreach(schema->types, __get_tdata_foreach, schema);
    
        /* Do postconfig for every initialized schema */
        g_hash_table_foreach(schema->types, __postconfig_schema_foreach, schema);
}

gboolean midgard_schema_read_dir(
                MidgardSchema *gschema, const gchar *dirname)
{
        const gchar *fname = NULL;
        gchar *fpfname = NULL ;
        GDir *dir;
        gint visible = 0;

        dir = g_dir_open(dirname, 0, NULL);
        
        if (dir != NULL) {
                
                while ((fname = g_dir_read_name(dir)) != NULL) {

                        visible = 1;
                        fpfname = g_strconcat(dirname, "/", fname, NULL);
                        
                        /* Get files only with xml extension, 
                         * swap files with '~' suffix will be ignored */
                        if (!g_file_test (fpfname, G_FILE_TEST_IS_DIR) 
                                        && g_str_has_suffix(fname, ".xml")){
                                
                                /* Hide hidden files */
                                if(g_str_has_prefix(fname, "."))
                                        visible = 0;
                                
                                /* Hide recovery files if such exist */
                                if(g_str_has_prefix(fname, "#"))
                                        visible = 0;
                                
                                if ( visible == 0)
                                        g_warning("File %s ignored!", fpfname);
                                
                                if(visible == 1){                                       
                                        /* FIXME, use fpath here */
                                        midgard_schema_read_file(gschema, fpfname);
                                }
                        }
                        g_free(fpfname);
                        
                        /* Do not free ( or change ) fname. 
                         * Glib itself is responsible for data returned from g_dir_read_name */
                }
                g_dir_close(dir);
                return TRUE;
        }
        return FALSE;
}

/* SCHEMA DESTRUCTORS */

/* Free type names, collect all MgdSchemaTypeAttr pointers */
static void _get_schema_trash(gpointer key, gpointer val, gpointer userdata)
{
        MgdSchemaTypeAttr *stype = (MgdSchemaTypeAttr *) val;
        
        /* Collect types data pointers*/
        if(!g_slist_find(schema_trash, stype)) {
                /* g_debug("Adding %s type to trash", (gchar *)key); */ 
                schema_trash = g_slist_append(schema_trash, stype);
        }
}

/* GOBJECT AND CLASS */

/* Create new object instance */
static void 
_schema_instance_init(GTypeInstance *instance, gpointer g_class)
{
        MidgardSchema *self = (MidgardSchema *) instance;
        self->types = g_hash_table_new(g_str_hash, g_str_equal);
}

/* Finalize  */
static void _midgard_schema_finalize(GObject *object)
{
        g_assert(object != NULL); /* just in case */
        MidgardSchema *self = (MidgardSchema *) object; 

        g_hash_table_foreach(self->types, _get_schema_trash, NULL);
        g_hash_table_destroy(self->types);
        
        for( ; schema_trash ; schema_trash = schema_trash->next){
                _mgd_schema_type_attr_free((MgdSchemaTypeAttr *) schema_trash->data);
        }
        g_slist_free(schema_trash);                                     
}

/* Initialize class */
static void _midgard_schema_class_init(
                gpointer g_class, gpointer g_class_data)
{
        GObjectClass *gobject_class = G_OBJECT_CLASS (g_class);
        MidgardSchemaClass *klass = MIDGARD_SCHEMA_CLASS (g_class);
        
        gobject_class->set_property = NULL;
        gobject_class->get_property = NULL;
        gobject_class->finalize = _midgard_schema_finalize;
        
        klass->init = midgard_schema_init;
        klass->read_dir = midgard_schema_read_dir;
        klass->read_file = midgard_schema_read_file;
        klass->type_exists = midgard_schema_type_exists;
}

/* Register MidgardSchema type */
GType
midgard_schema_get_type (void)