/**
 * midgard_query_storage_new:
 * @classname: name of the #MidgardDBObject derived class 
 *
 * Initializes new object which represents #MidgardDBObject derived one's storage
 *
 * Returns: new #MidgardQueryStorage or %NULL on failure
 * Since: 10.05
 */ 
MidgardQueryStorage*
midgard_query_storage_new (const gchar *classname)
{
	g_return_val_if_fail (classname != NULL, NULL);

	GType type = g_type_from_name (classname);
	if (!type) {
		g_warning ("Class %s is not registered in GType system", classname);
		return NULL;
	}

	GObjectClass *klass = G_OBJECT_CLASS (g_type_class_peek (type));
	if (!klass) {
		g_warning ("Can not find %s class", classname);
		return NULL;
	}

	g_return_val_if_fail (MIDGARD_IS_DBOBJECT_CLASS (klass), NULL);

	MidgardDBObjectClass *dbklass = MIDGARD_DBOBJECT_CLASS (klass);

	MidgardQueryStorage *self = g_object_new (MIDGARD_TYPE_QUERY_STORAGE, "dbclass", classname, NULL);
	self->priv->klass = dbklass;
	self->priv->table = midgard_core_class_get_table (dbklass);

	return self;
}
static void
__statement_update_add_metadata_fields (MidgardDBObjectClass *klass, GString *sql)
{
	MidgardMetadataClass *mklass = MGD_DBCLASS_METADATA_CLASS (klass);
	if (!mklass)
		return;

	guint i;
	guint n_prop;
	GParamSpec **pspecs = g_object_class_list_properties (G_OBJECT_CLASS (mklass), &n_prop);

	if (!pspecs)
		return;

	for (i = 0; i < n_prop; i++) {
		const gchar *col_name = midgard_core_class_get_property_colname (MIDGARD_DBOBJECT_CLASS (mklass), pspecs[i]->name);
		if (!col_name)
			continue;
		const gchar *type_name = g_type_name (pspecs[i]->value_type);
		if (pspecs[i]->value_type == MIDGARD_TYPE_TIMESTAMP)
			type_name = "string";
		g_string_append_printf (sql, ", %s=##%s::%s", col_name, col_name, type_name);
	}

	g_free (pspecs);
}
Esempio n. 3
0
/**
 * midgard_query_builder_new():
 * @mgd: #MidgardConnection instance
 * @classname: any #MidgardDBObjectClass derived class' name
 *
 * Returns: new #MidgardQueryBuilder instance or %NULL if target class is not registered in GType system 
 * or it's not #MidgardDBObjectClass class derived one.
 */
MidgardQueryBuilder *midgard_query_builder_new(
        MidgardConnection *mgd, const gchar *classname)
{
        g_assert(mgd != NULL);
        g_assert(classname != NULL);

	GType class_type = g_type_from_name(classname);

	if(!__type_is_valid(class_type)) {

		g_warning("Can not initialize Midgard Query Builder for '%s'. It's not registered GType system class", classname);
		MIDGARD_ERRNO_SET(mgd, MGD_ERR_INVALID_OBJECT);
		return NULL;
	}

        MidgardQueryBuilder *builder = 
		g_object_new(MIDGARD_TYPE_QUERY_BUILDER, NULL);
	
	builder->priv = midgard_query_builder_private_new();

        builder->priv->mgd = mgd;
        builder->priv->type = g_type_from_name(classname);
	builder->priv->include_deleted = FALSE;
        builder->priv->error = 0;	
	
	MidgardDBObjectClass *klass = 
		(MidgardDBObjectClass*) g_type_class_peek(class_type);

	if (klass->dbpriv == NULL) {
		
		g_warning("Given %s class has no storage definitions", g_type_name(class_type));
		g_object_unref(builder);
		return NULL;
	}

	builder->priv->schema = klass->dbpriv->storage_data;
       	
	gchar **tables = g_strsplit(midgard_core_class_get_tables(MIDGARD_DBOBJECT_CLASS(klass)), ",", 0);
	guint i = 0;
	while(tables[i] != NULL) {	
		midgard_core_qb_add_table(builder, 
				(const gchar *)g_strchug(tables[i]));
		i++;
	}
	g_strfreev(tables);

        builder->priv->offset = 0;
        builder->priv->limit = G_MAXUINT;

        if (builder->priv->type && builder->priv->schema) {
                return builder;
        } else {
		g_object_unref(builder);
                return NULL;
        }
}
Esempio n. 4
0
/**
 * midgard_query_builder_add_constraint():
 * @builder: #MidgardQueryBuilder instance
 * @name: property name used for this constraint 
 * @op: comparison operator
 * @value: value used in comparison
 *
 * Adds a constraint to the given query builder. The constraint is
 * expressed as a triple of a field name, a comparison operator, and
 * a comparison value. 
 * 
 * <para>
 * @name referes to a property of the queried Midgard object class. 
 * For example: #MidgardQueryBuilder has been initialized for person 
 * class which has lastname property registered.
 * <example>
 * <programlisting>
 * 
 * GValue value = {0, };
 * g_value_init(&value, G_TYPE_STRING);
 * g_value_set_string(&value, "smith");
 *
 * midgard_query_builder_add_constraint(builder, "lastname", "=", &value);
 * 
 * </programlisting>
 * </example>
 * </para>
 * <para>
 * It also can be name of the linked class property or reserved one. 
 * A dot '.' is used to separate properties for special constraints.
 * If such special constraint property is used, #MidgardQueryBuilder
 * performs right join.
 * <itemizedlist>
 * <listitem><para>
 * First property is the one registered for given class which is a link
 * to property of different class. Second is a property of target class.
 * For example: person object has property 'friend' which holds some identifier
 * (id or guid) to friend class property, and friend class has property 'nick'.
 * In such case we can use constraint and comparison using friend property,
 * even if #MidgardQueryBuilder has been initialized for person class.
 * <example>
 * <programlisting>
 * 
 * GValue value = {0, };
 * g_value_init(&value, G_TYPE_STRING);
 * g_value_set_string(&value, "Lancelot");
 *
 * midgard_query_builder_add_constraint(builder, "friend.nick", "=", &value);
 *
 * </programlisting>
 * </example>
 * </para></listitem>
 * <listitem><para>
 * There are three reserved words which have special meaning for query builder.
 * 'metadata', 'parameter' and 'attachment'. If one of them is used, query builder
 * will make (if necessary) right join and query objects against dependent class table.
 * <example>
 * <programlisting>
 * 
 * GValue value = {0, };
 * g_value_init(&value, G_TYPE_STRING);
 * g_value_set_string(&value, "avatar");
 *
 * midgard_query_builder_add_constraint(builder, "attachment.name", "=", &value);
 *
 * </programlisting>
 * </example>
 * </para></listitem>
 * </itemizedlist>
 * </para>
 *
 * <para>
 * The comparison operator is a string representation of the requested comparison. 
 * Available operators are =, <>, <, >, <=, >=, LIKE, NOT LIKE, IN, INTREE. 
 * </para>
 * 
 * <para>
 * The given @value is copied and converted into the property type before comparison.
 * </para>
 *  
 * Returns: %TRUE if constraint is valid, %FALSE otherwise
 */
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);
     
	MidgardCoreQueryConstraint *constraint = midgard_core_query_constraint_new();
	midgard_core_query_constraint_set_builder(constraint, builder);
	midgard_core_query_constraint_set_class(constraint, MIDGARD_DBOBJECT_CLASS(g_type_class_peek(builder->priv->type)));
	
	if(!midgard_core_query_constraint_add_operator(constraint, op))
		return FALSE;
		
	if(!midgard_core_query_constraint_parse_property(&constraint, MIDGARD_DBOBJECT_CLASS(g_type_class_peek(builder->priv->type)), name))
		return FALSE;

	if(!midgard_core_query_constraint_add_value(constraint, value))
		return FALSE;
	
	midgard_core_query_constraint_build_condition(constraint);

	/* FIXME, table should be stored per every constraint, order, whatever */
	midgard_core_qb_add_table(builder, constraint->priv->prop_left->table);
	
	if(builder->priv->grouping_ref > 0) {

		MidgardGroupConstraint *group = 
			(MidgardGroupConstraint *)builder->priv->group_constraint;
		midgard_group_constraint_add_constraint(group, constraint);
		return TRUE;
	
	} 

	midgard_core_qb_add_constraint(builder, constraint);	

	return TRUE;
}
Esempio n. 5
0
static const gchar *_collector_find_class_property(
		MidgardCollector *self, const gchar *propname)
{
	const gchar *table_field = 
		midgard_core_class_get_property_tablefield(
				MIDGARD_DBOBJECT_CLASS(self->priv->klass), 
				propname);

	/* Let's try metadata class */
	if(table_field == NULL) {
		 
		MidgardMetadataClass *mklass =
			(MidgardMetadataClass*) g_type_class_peek(g_type_from_name("MidgardMetadata"));

		table_field =
			midgard_core_class_get_property_tablefield(
					MIDGARD_DBOBJECT_CLASS(mklass),
					propname);
	}

	return table_field;
}
gboolean
_midgard_metadata_dbpriv_get_property (MidgardDBObject *self, const gchar *name, GValue *value)
{
	gchar *datamodel_property = g_strconcat ("metadata_", name, NULL);
	MidgardDBObject *dbobject = MIDGARD_METADATA(self)->priv->object;

	if (!dbobject || !dbobject->dbpriv)
		return FALSE;

	gboolean rv = MIDGARD_DBOBJECT_CLASS (__parent_class)->dbpriv->get_property (dbobject, datamodel_property, value);
	g_free (datamodel_property);

	return rv;
}
gchar*
get_real_table_field (MidgardQueryExecutor *executor, MidgardSqlQueryColumn *column)
{
	g_return_val_if_fail (executor != NULL, NULL);
	g_return_val_if_fail (column != NULL, NULL);

	MidgardConnection *mgd = executor->priv->mgd;
	g_return_val_if_fail (executor != NULL, NULL);
	
	/* Set default dbclass by default */
	MidgardDBObjectClass *dbklass = NULL;
	if (executor->priv->storage)
		dbklass = executor->priv->storage->priv->klass;

       	gchar *classname = NULL;
	gchar *pname = NULL;
	MidgardQueryStorage *storage = NULL;

	/* Set property's dbclass if defined */
	MidgardQueryProperty *qproperty = midgard_query_column_get_query_property (MIDGARD_QUERY_COLUMN(column), NULL);
	g_object_get (qproperty, "storage", &storage, "property", &pname, NULL);
	if (storage)
		g_object_get (storage, "dbclass", &classname, NULL);
	g_object_unref (qproperty);
	if (classname) {
		GType dbtype = g_type_from_name (classname);
		/* TODO , handle invalid type error */
		dbklass = MIDGARD_DBOBJECT_CLASS (g_type_class_peek (dbtype));
	}	

	/* Get real fieldname */
	const gchar *fieldname = (const gchar *)pname;
	if (dbklass)
		fieldname = midgard_core_class_get_property_colname (dbklass, pname);

	const gchar *qualifier = midgard_query_column_get_qualifier (MIDGARD_QUERY_COLUMN (column), NULL);
	if (*qualifier == '\0')
		qualifier = NULL;

	gchar *table_alias_field = g_strdup_printf("%s%s%s",
			qualifier ? qualifier : "",
			qualifier ? "." : "",
			fieldname);

	g_free (classname);
	g_free (pname);	

	return table_alias_field;
}
Esempio n. 8
0
MidgardQueryOrder *midgard_core_query_order_new(
		MidgardQueryBuilder *builder, const gchar *name, const gchar *dir)
{
	g_assert(builder != NULL);
	g_assert(name != NULL);

	const gchar *user_dir = dir;

	if(user_dir == NULL)
		user_dir = "ASC";

	guint i = 0;
	while(valid_dirs[i] != NULL) {
		
		if (g_str_equal(user_dir, valid_dirs[i])) 
			break;

		i++;
	}

	if(valid_dirs[i] == NULL) {
		
		 g_warning("Invalid order direction: %s", dir);
		 return NULL;
	}

        MidgardQueryOrder *order = g_new(MidgardQueryOrder, 1);

	order->constraint = midgard_core_query_constraint_new();
	order->constraint->priv->order_dir = g_strdup(dir);

	/* Explicitly set builder. It's required for proper constraint's property "parser".
	 * Without builder, implicit joins (for example) are not added */
	midgard_core_query_constraint_set_builder(order->constraint, builder);

	MidgardDBObjectClass *klass = MIDGARD_DBOBJECT_CLASS(g_type_class_peek(builder->priv->type));

	if(!midgard_core_query_constraint_parse_property(&(order->constraint), klass, name)) {

		midgard_core_query_order_free(order);
		return FALSE;
	}

	midgard_core_qb_add_table(builder, order->constraint->priv->prop_left->table);

        return order;
}
Esempio n. 9
0
static void __mgdschematype_from_node(xmlNode *node, GSList **list)
{
	g_assert(node != NULL);
	
	xmlChar *viewname = xmlGetProp(node, (const xmlChar *)MGD_VIEW_RW_NAME);
	if (!viewname) 	
		__view_error(node, "Empty view name. Can not define any type.", NULL);

	MgdSchemaTypeAttr *type = midgard_core_schema_type_attr_new();
	type->name = g_strdup((gchar *)viewname);
	type->is_view = TRUE;

	/* Determine base view table */
	xmlChar *table = xmlGetProp(node, (const xmlChar *) TYPE_RW_TABLE);

	/* Table not defined, try classtable */	
	if (!table) {

		xmlChar *classname = xmlGetProp(node, (const xmlChar *) "class");

		if (!classname)
			__view_error(node, "'table' or 'class' attribute not found", NULL);

		MidgardDBObjectClass *dbklass = 
			MIDGARD_DBOBJECT_CLASS(g_type_class_peek(g_type_from_name((const gchar *)classname)));
		table = (xmlChar *)g_strdup(midgard_core_class_get_table(dbklass));

		if (!table)
			__view_error(node, "NULL table for %s class", classname);

		xmlFree(classname);
	}
	
	midgard_core_schema_type_set_table(type, (const gchar *)table);		

	xmlFree(table);

	__get_view_properties(node, type);
	__get_view_joins(node, type);
	__get_view_constraints(node, type);

	midgard_core_schema_type_build_static_sql(type);

	*list = g_slist_append(*list, type);

	xmlFree(viewname);
}
gboolean php_midgard_is_property_timestamp(MidgardDBObjectClass *klass, const gchar *property)
{
	g_assert(klass != NULL);
	g_assert(property != NULL);

	MidgardReflectionProperty *mrp =
		midgard_reflection_property_new(MIDGARD_DBOBJECT_CLASS(klass));
	GType midgard_type =
		midgard_reflection_property_get_midgard_type(mrp, property);

	g_object_unref(mrp);

	if (midgard_type == MGD_TYPE_TIMESTAMP)
		return TRUE;

	return FALSE;
}
Esempio n. 11
0
/**
 * midgard_query_builder_add_constraint_with_property:
 * @builder: #MidgardQueryBuilder instance
 * @property_a: property name
 * @op: comparison operator
 * @property_b: property name
 *
 * Adds named property constraint to the given query builder.
 * Unlike add_constraint method, this one accepts property name
 * instead of scalar value. The difference is that with add_constraint
 * method you can compare property with particular value, while using 
 * add_constraint_with_property method you can compare two different 
 * properties without any need to know their values. 
 * For example, you should use this method if you want to select only 
 * those objects which has been revised after publication time, and particular 
 * date doesn't matter.
 *
 * <example>
 * <programlisting>
 * 
 * midgard_query_builder_add_constraint_with_property(builder, "metadata.revised", ">", "metadata.published");
 *
 * </programlisting>
 * </example>
 *
 * @See: midgard_query_builder_add_constraint()
 *
 * Returns: %TRUE if properties' names are valid, %FALSE otherwise
 */ 
gboolean midgard_query_builder_add_constraint_with_property(
		MidgardQueryBuilder *builder, const gchar *property_a,
		const gchar *op, const gchar *property_b)
{
	g_assert(builder != NULL);
	g_assert(property_a != NULL);
	g_assert(op != NULL);
	g_assert(property_b != NULL);

	MidgardDBObjectClass *klass = MIDGARD_DBOBJECT_CLASS(g_type_class_peek(builder->priv->type));

	MidgardCoreQueryConstraint *constraint = midgard_core_query_constraint_new();
	midgard_core_query_constraint_set_builder(constraint, builder);
	midgard_core_query_constraint_set_class(constraint, klass);

	if(!midgard_core_query_constraint_parse_property(&constraint, klass, property_a))
		return FALSE;
	constraint->priv->current = constraint->priv->prop_right;
	if(!midgard_core_query_constraint_parse_property(&constraint, klass, property_b))
		return FALSE;

	constraint->priv->condition_operator = g_strdup(op);

	midgard_core_query_constraint_build_condition(constraint);

	midgard_core_qb_add_table(builder, constraint->priv->prop_left->table);
	midgard_core_qb_add_table(builder, constraint->priv->prop_right->table);

	if(builder->priv->grouping_ref > 0) {
		
		MidgardGroupConstraint *group = builder->priv->group_constraint;
		midgard_group_constraint_add_constraint(group, constraint);
		return TRUE;
	
	} else {
		
		midgard_core_qb_add_constraint(builder, constraint);
	}
	
	return TRUE;
}
Esempio n. 12
0
static const gchar *_collector_find_class_property(
		MidgardCollector *self, const gchar *propname)
{
	const gchar *table_field = 
		midgard_core_class_get_property_tablefield(
				MIDGARD_DBOBJECT_CLASS(self->priv->klass), 
				propname);

	/* Let's try metadata class */
	if(table_field == NULL) {
		 
		MidgardMetadataClass *mklass =
			(MidgardMetadataClass*) g_type_class_peek(g_type_from_name("MidgardMetadata"));
		GParamSpec *pspec = g_object_class_find_property (G_OBJECT_CLASS (mklass), propname);
		/* We do not need table.col alias, so dummy empty string is fine in this case */
		if (pspec)
			return "";
	}

	return table_field;
}
Esempio n. 13
0
static void __get_property_attribute (xmlNode *node, gchar **property_string, 
		gchar **target_name, MgdSchemaPropertyAttr **prop_attr, MidgardDBObjectClass *klass)
{
	*target_name = property_string[1];

	if (property_string[2] != NULL && !g_str_equal (*target_name, "metadata")) {
		__view_error (node, "%s not allowed in view configuration", target_name);
		return;	
	}

	/* Check metadata */
	if (property_string[2] != NULL && g_str_equal (*target_name, "metadata")) {

		if (!MGD_DBCLASS_METADATA_CLASS (klass)) {
			__view_error (node, "No metadata registered for %s class", G_OBJECT_CLASS_NAME (klass));
			return;
		}

		*target_name = property_string[2];
		*prop_attr = g_hash_table_lookup (MIDGARD_DBOBJECT_CLASS (MGD_DBCLASS_METADATA_CLASS (klass))->dbpriv->storage_data->prophash, *target_name);
	
		if (!*prop_attr)
			__view_error (node, "%s not found. Not registered for %s.metadata ?", *target_name, property_string[0]);
	}

	/* Fallback to custom properties, metadata class doesn't exist in MgdSchema scope */	
	if (!*prop_attr) {
		*prop_attr = g_hash_table_lookup (klass->dbpriv->storage_data->prophash, *target_name);
		if (!*prop_attr)
			__view_error(node, "%s not found. Not registered for %s ?", *target_name, property_string[0]);

		if ((*prop_attr)->is_private)
			__view_error (node, "Private property %s.%s can not be added to view.",
					G_OBJECT_CLASS_NAME (G_OBJECT_CLASS (klass)), (*prop_attr)->name);
	}
}
static void _write_nodes(GObject *object, xmlNodePtr node)
{
	g_assert(object);
	g_assert(node);

	guint prop_n;
	MidgardObject *mgdobject = (MidgardObject *)object;
	MidgardReflectionProperty *mrp = NULL;
	MidgardObjectClass *klass = NULL;
	GParamSpec **pspec = g_object_class_list_properties(
			G_OBJECT_GET_CLASS(G_OBJECT(object)), &prop_n);
	
	if(MIDGARD_IS_OBJECT(object)) {
		klass = 
			MIDGARD_OBJECT_GET_CLASS(object);
		if(klass)
			mrp = midgard_reflection_property_new(
					MIDGARD_DBOBJECT_CLASS(klass));
	}

	GValue pval = {0, }, *lval;
	GString *gstring;
	gchar *strprop = NULL;
	xmlChar *escaped;
	guint i;
	xmlNodePtr op_node = NULL;
	const gchar *linktype;
	MidgardCollector *mc;
	guint _uint;
	gint _int;
	GObject *_object;

	if(MIDGARD_IS_OBJECT(mgdobject)) {

		gint object_action = -1;	

		if(MGD_OBJECT_GUID (mgdobject)) {

			GString *_sql = g_string_new(" ");
			g_string_append_printf(_sql, "guid = '%s' ",	
					MGD_OBJECT_GUID (mgdobject));
			
			gchar *tmpstr = g_string_free(_sql, FALSE);
						
			GValue *avalue =
				midgard_core_query_get_field_value(
						MGD_OBJECT_CNC (mgdobject),	
						"object_action",
						"repligard", 
						(const gchar*)tmpstr);

			if(avalue) {
				
				MIDGARD_GET_UINT_FROM_VALUE(object_action, avalue);
				g_value_unset(avalue);
				g_free(avalue);
			}
			
			g_free(tmpstr);
		}

		gchar *_action;
		if(object_action > -1) {
			
			switch(object_action) {
				
				case MGD_OBJECT_ACTION_CREATE:
					_action = "created";		
					break;
				
				case MGD_OBJECT_ACTION_UPDATE:
					_action = "updated";
					break;
				
				case MGD_OBJECT_ACTION_DELETE:
					_action = "deleted";
					break;
				
				case MGD_OBJECT_ACTION_PURGE:
					_action = "purged";
					break;
				
				default:
					_action = "none";
					break;
			}
			
			xmlNewProp(node, BAD_CAST "action",
					BAD_CAST _action);
		}
	}

	for(i = 0; i < prop_n; i++) {
		
		g_value_init(&pval,pspec[i]->value_type);
		g_object_get_property(G_OBJECT(object), 
				pspec[i]->name, &pval);

		if(g_str_equal("guid", pspec[i]->name)) {
			/* Add guid attribute */
			xmlNewProp(node, BAD_CAST "guid", 
					BAD_CAST MGD_OBJECT_GUID (object));
			g_value_unset(&pval);
			continue;
		}
				
		/* Object is not fetched from database. Skip references */
		if(MGD_OBJECT_GUID (mgdobject) == NULL)
			goto export_unchecked_property;

		/* If property is a link we need to query guid 
		 * which identifies link object. Only if property 
		 * is not of guid or string type */
		if(mrp){	
			if(midgard_reflection_property_is_link(mrp, 
						pspec[i]->name)){

				lval = g_new0(GValue, 1);
				switch(pspec[i]->value_type) {
					
					case G_TYPE_UINT:
						g_value_init(lval, G_TYPE_UINT);
						_uint = g_value_get_uint(&pval);
						if(!_uint){
							g_value_unset(lval);
							g_free(lval);
							goto export_unchecked_property;
						}
						g_value_set_uint(lval, _uint);
						break;

					case G_TYPE_INT:
						g_value_init(lval, G_TYPE_INT);
						_int = g_value_get_int(&pval);
						if(!_int){
							g_value_unset(lval);
							g_free(lval);
							goto export_unchecked_property;
						}
						g_value_set_int(lval, _int);
						break;

					default:
						g_free(lval);
						goto export_unchecked_property;
				}
					
				linktype = 
					midgard_reflection_property_get_link_name(
							mrp, pspec[i]->name);
				
				if(linktype){
					mc = midgard_collector_new(
							MGD_OBJECT_CNC (mgdobject),
							linktype,
							"id",
							lval);
					
					midgard_collector_set_key_property(
							mc,
							"guid", NULL);
					if(!midgard_collector_execute(mc)){
						g_object_unref(mc);
						g_value_unset(&pval);
						continue;
					}				
					gchar **linkguid = 
						midgard_collector_list_keys(mc);
					if(linkguid){
						if(linkguid[0])
							strprop = g_strdup(linkguid[0]);
					}
					if(!strprop)
						strprop = g_strdup("");
					
					/* Create node */
					escaped = xmlEncodeEntitiesReentrant(
							NULL, (const xmlChar*)strprop);
					xmlNewTextChild(node, NULL,
							BAD_CAST pspec[i]->name,
							BAD_CAST escaped);
					
					g_free(linkguid);
					g_free(strprop);
					g_free(escaped);
					g_object_unref(mc);	
				}
				g_value_unset(&pval);
				continue;
			}
		}	
		
		export_unchecked_property:
		switch (G_TYPE_FUNDAMENTAL(pspec[i]->value_type)) {
			
			case G_TYPE_STRING:				
				strprop = g_value_dup_string(&pval);
				if(!strprop)
					strprop = g_strdup("");
				escaped = xmlEncodeEntitiesReentrant(
						NULL, (const xmlChar*)strprop);
				xmlNewTextChild(node, NULL, 
						BAD_CAST pspec[i]->name,
						BAD_CAST escaped);
			         
				g_free(strprop);
				g_free(escaped);
				break;

			case G_TYPE_INT:
				gstring = g_string_new("");
				g_string_append_printf(gstring,
						"%d", g_value_get_int(&pval));
				xmlNewChild(node, NULL, 
						BAD_CAST pspec[i]->name,
						BAD_CAST (xmlChar *)gstring->str);
				g_string_free (gstring, TRUE);
				break;

			case G_TYPE_UINT:
				gstring = g_string_new("");
				g_string_append_printf(gstring,
						"%d", g_value_get_uint(&pval));
				xmlNewChild(node, NULL, 
						BAD_CAST pspec[i]->name,
						BAD_CAST (xmlChar *)gstring->str);
				g_string_free (gstring, TRUE);
				break;

			case G_TYPE_FLOAT:
				gstring = g_string_new("");
				g_string_append_printf(gstring,
						"%g", g_value_get_float(&pval));
				xmlNewChild(node, NULL,
						BAD_CAST pspec[i]->name,
						BAD_CAST (xmlChar *)gstring->str);
				g_string_free (gstring, TRUE);
				break;

			case G_TYPE_BOOLEAN:
				if(g_value_get_boolean(&pval))
					strprop = "1";
				else 
					strprop = "0";

				xmlNewChild(node, NULL,
						BAD_CAST pspec[i]->name,
						BAD_CAST (xmlChar *)strprop);
				break;

			case G_TYPE_OBJECT:
	
				_object = g_value_get_object (&pval);
				
				if (_object) {
					op_node = xmlNewNode(NULL, BAD_CAST pspec[i]->name);
					_write_nodes(_object, op_node);
					xmlAddChild(node, op_node);
				}
				break;

			default:

				if (pspec[i]->value_type == MIDGARD_TYPE_TIMESTAMP) {
		
					GValue strval = {0, };
					g_value_init (&strval, G_TYPE_STRING);
					g_value_transform (&pval, &strval);
					xmlNewChild(node, NULL, 
						BAD_CAST pspec[i]->name,
						BAD_CAST (xmlChar *)g_value_get_string (&strval));
					g_value_unset (&strval);

				} else {
					g_warning ("midgard_replicator_serialize: unhandled %s property type (%s)", 
							pspec[i]->name, g_type_name (pspec[i]->value_type)); 
				}
		}
		g_value_unset(&pval);
	}

	g_free(pspec);

	if(mrp)
		g_object_unref(mrp);
}		
gboolean _nodes2object(GObject *object, xmlNode *node, gboolean force)
{
	g_assert(object);
	g_assert(node);

	xmlNode *cur = NULL;
	GObject *prop_object;
	gchar *nodeprop = NULL;
	xmlChar *decoded;
	xmlParserCtxtPtr parser;
	MidgardObject *mobject = NULL;
	MidgardObject *lobject = NULL;
	MidgardReflectionProperty *mrp = NULL;
	const gchar *linktype = NULL;

	if(MIDGARD_IS_OBJECT(object)) {
		mobject = MIDGARD_OBJECT(object);
		MidgardObjectClass *klass =
			MIDGARD_OBJECT_GET_CLASS(mobject);
		if(klass)
			mrp = midgard_reflection_property_new(
					MIDGARD_DBOBJECT_CLASS(klass));
	}

	gpointer set_from_xml_func = MIDGARD_DBOBJECT_GET_CLASS(object)->dbpriv->set_from_xml_node;
	if(set_from_xml_func != NULL) {
		MIDGARD_DBOBJECT_GET_CLASS(object)->dbpriv->set_from_xml_node(MIDGARD_DBOBJECT(object), node);
		return TRUE;
	}

	for (cur = node; cur; cur = cur->next) {
		if (cur->type == XML_ELEMENT_NODE) {
		
			linktype = NULL;
	
			GParamSpec *pspec = g_object_class_find_property(
					G_OBJECT_GET_CLASS(G_OBJECT(object)), 
					(const gchar *)cur->name);
			if(pspec) {
				GValue pval = {0, };
				g_value_init(&pval, pspec->value_type);
				
				if(nodeprop)
					g_free(nodeprop);

				nodeprop = (gchar *)xmlNodeGetContent(cur);

				if(mrp) {
					if(midgard_reflection_property_is_link(
								mrp, pspec->name)){
						linktype =
							midgard_reflection_property_get_link_name(
									mrp, pspec->name);
					}
				}

				/* moved out from mrp condition check to avoid nested indents */

				if(linktype && midgard_is_guid(
							(const gchar *) nodeprop)){

					/* Just set property quickly, if property holds a guid */
					GType mtype = midgard_reflection_property_get_midgard_type(mrp, pspec->name);
					if (mtype == MGD_TYPE_GUID) {
						
						g_value_unset(&pval);
						g_object_set(mobject, (const gchar *)cur->name, nodeprop, NULL);
						continue;	
					}

					/* we can use nodeprop directly */
					lobject = midgard_schema_object_factory_get_object_by_guid (
							MIDGARD_DBOBJECT (mobject)->dbpriv->mgd,
							(const gchar *) nodeprop);

					if(!lobject && !force){
						g_object_unref(mrp);
						g_value_unset(&pval);
						midgard_set_error(MGD_OBJECT_CNC (mobject), 
								MGD_GENERIC_ERROR, 
								MGD_ERR_MISSED_DEPENDENCE, 
								" Can not import %s. "
								"No '%s' object identified by '%s'",
								G_OBJECT_TYPE_NAME(object),
								linktype, nodeprop); 
						g_clear_error(&MIDGARD_DBOBJECT (mobject)->dbpriv->mgd->err);	
						return FALSE;
					}
					
					/* When force parameter is set we do not translate guids to ids */
					if(force && !lobject && midgard_is_guid(
								(const gchar *) nodeprop)) {
						
						switch(pspec->value_type) {
							
							case G_TYPE_UINT:
								g_value_set_uint(&pval, 0);
								break;
							
							case G_TYPE_INT:
								g_value_set_int(&pval, 0);
								break;
							
							default:
								goto set_property_unchecked;
								break;
						}
						
						g_object_set_property(
								G_OBJECT(object),
								(const gchar *) cur->name,
								&pval);
						g_value_unset(&pval);
						continue;
					}

					GValue tval = {0, };
					g_value_init(&tval, pspec->value_type);

					g_object_get_property(G_OBJECT(lobject),
							"id", &tval);

					if(G_VALUE_TYPE(&pval) == G_TYPE_INT)
						g_value_transform((const GValue *) &tval,
								&pval);
					else
						g_value_copy((const GValue*) &tval,
								&pval);

					g_object_set_property(
							G_OBJECT(object),
							(const gchar *) cur->name,
							&pval);
					g_value_unset(&pval);
					g_object_unref(lobject);
					g_value_unset(&tval);
					continue;					
				}

				set_property_unchecked:
				switch (G_TYPE_FUNDAMENTAL (pspec->value_type)) {
				
					case G_TYPE_STRING:
						parser = xmlNewParserCtxt();
						decoded = 
							xmlStringDecodeEntities(parser,
									(const xmlChar *) nodeprop, 	
									XML_SUBSTITUTE_REF, 
									0, 0, 0);
						g_value_set_string(&pval, 
								(gchar *)decoded);
						g_free(decoded);
						xmlFreeParserCtxt(parser);
						break;

					case G_TYPE_INT:
						if(nodeprop) 
							g_value_set_int(&pval, 
									(gint)atoi((gchar *)nodeprop));
						break;

					case G_TYPE_UINT:
						if(nodeprop)
							g_value_set_uint(&pval,
									(guint)atoi((gchar *)nodeprop));
						break;

					case G_TYPE_FLOAT:
						g_value_set_float(&pval,
								(gfloat)atof((gchar *)nodeprop));
						break;

					case G_TYPE_BOOLEAN:
						g_value_set_boolean(&pval,
								(gboolean)atoi((gchar*)nodeprop));
						break;

					case G_TYPE_OBJECT:
						g_object_get(G_OBJECT(object),
								(const gchar *) cur->name,
								&prop_object, NULL);
						if (prop_object) {
							_nodes2object(prop_object, cur->children, force);	
							g_value_set_object(&pval, prop_object);
						} else {
							g_warning ("Failed to unserialize '%s' object property. Expected to be initialized by given '%s' instance", (const gchar *) cur->name, G_OBJECT_TYPE_NAME (object));
						}

						break;

					default:
						/* do nothing */
						break;						
				}
				g_object_set_property(
						G_OBJECT(object), 
						(const gchar *) cur->name, 
						&pval);
				g_value_unset(&pval);
			} else {
				g_warning("Undefined property '%s' for '%s'",
						cur->name, G_OBJECT_TYPE_NAME(object));
			}
		}		
	}

	if(nodeprop)
		g_free(nodeprop);

	if(mrp)
		g_object_unref(mrp);

	return TRUE;
}
static gboolean __set_schema_property_attr(
		MidgardQueryBuilder *builder, MidgardDBObjectClass **klass, 
		MidgardCoreQueryConstraint **constraint, const gchar *name, gboolean do_link)
{
	MgdSchemaPropertyAttr *attr = NULL;
	const gchar *target_property = NULL;
	const gchar *link_property = NULL;

	/* Set klass and property so later we use this info when 
	 * gvalue typecasting should be done */
	(*constraint)->priv->klass = G_OBJECT_CLASS(*klass);
	(*constraint)->priv->propname = name;

	/* Reserved properties */
	/* METADATA */
	if (g_str_equal("metadata", name)) {	
		*klass = g_type_class_peek(MIDGARD_TYPE_METADATA);
		return TRUE;
	}

	/* ATTACHMENT */
	if (g_str_equal(_RESERVED_BLOB_NAME, name)) {
		if (builder && !builder->priv->blob_join_exists) {
			__join_reference(builder, (const gchar *)(*constraint)->priv->current->table, _RESERVED_BLOB_TABLE);
			builder->priv->blob_join_exists = TRUE;
		}

		*klass = 
			g_type_class_peek(g_type_from_name("midgard_attachment"));
		(*constraint)->priv->current->table = _RESERVED_BLOB_TABLE;
		
		return TRUE;
	}

	/* PARAMETER */
	if (g_str_equal(_RESERVED_PARAM_NAME, name)) {
		if (builder && !builder->priv->param_join_exists) {
			__join_reference(builder, (const gchar *)(*constraint)->priv->current->table, _RESERVED_PARAM_TABLE);
			builder->priv->param_join_exists = TRUE;
		}

		*klass = g_type_class_peek(g_type_from_name("midgard_parameter"));
		(*constraint)->priv->current->table = _RESERVED_PARAM_TABLE;

		/* Select DISTINCT.
		 * Constraints might be grouped with "OR" operator and duplicated 
		 * records can be returned explicitly */
		if (builder) {
			builder->priv->select_distinct = TRUE;
		}

		return TRUE;
	}
	
	/* User defined properties */
	GParamSpec *pspec = g_object_class_find_property(G_OBJECT_CLASS(*klass), name);
	if(!pspec) {
		g_warning("%s is not registered property of %s class", name, G_OBJECT_CLASS_NAME(*klass)); 
		return FALSE;
	}

	/* Set klass and property so later we use this info when gvalue typecasting should be done */
	(*constraint)->priv->klass = G_OBJECT_CLASS(*klass);
	(*constraint)->priv->propname = pspec->name;
	(*constraint)->priv->pspec = pspec;

	attr = midgard_core_class_get_property_attr (MIDGARD_DBOBJECT_CLASS(*klass), name);
	target_property = NULL;
	link_property = NULL;

	MidgardReflectionProperty *mrp = midgard_reflection_property_new (MIDGARD_DBOBJECT_CLASS (*klass));
		
	if (midgard_reflection_property_is_link (mrp, name) && do_link) {
		const gchar *target_property = midgard_reflection_property_get_link_target(mrp, name);
		const gchar *link_klass = midgard_reflection_property_get_link_name(mrp, name);
		gboolean is_link = TRUE;
	
		if ((*constraint)->priv->current->link_target == NULL) {
			MidgardCoreQueryConstraintPrivate *mqcp = midgard_core_query_constraint_private_new();
			mqcp->current->is_link = is_link;
			mqcp->current->link_target = target_property;
			mqcp->condition_operator = g_strdup("=");
	
			mqcp->prop_left->table = midgard_core_class_get_property_table (MIDGARD_DBOBJECT_CLASS(*klass), name);
			mqcp->prop_left->field = midgard_core_class_get_property_colname (MIDGARD_DBOBJECT_CLASS(*klass), name); 
			MidgardObjectClass *lclass = g_type_class_peek (g_type_from_name(link_klass));
			mqcp->prop_right->table = midgard_core_class_get_property_table (MIDGARD_DBOBJECT_CLASS(lclass), target_property);
			mqcp->prop_right->field = midgard_core_class_get_property_colname (MIDGARD_DBOBJECT_CLASS(lclass), target_property);

			GString *cond = g_string_new ("");
			g_string_append_printf (cond, 
					"%s.%s %s %s.%s",
					mqcp->prop_left->table,
					mqcp->prop_left->field,
					mqcp->condition_operator,
					mqcp->prop_right->table,
					mqcp->prop_right->field);

			mqcp->condition = g_string_free (cond, FALSE);

			if (builder) {
				midgard_core_qb_add_table(builder, mqcp->prop_left->table);
				midgard_core_qb_add_table(builder, mqcp->prop_right->table);
			}

			if (builder) {
				if(!__add_join(&builder->priv->joins, mqcp)) {
					midgard_core_query_constraint_private_free(mqcp);
				}
			}
		}
			

		*klass = (MidgardDBObjectClass *) midgard_reflection_property_get_link_class(mrp, name);
		(*constraint)->priv->current->table = midgard_core_class_get_table(MIDGARD_DBOBJECT_CLASS(*klass));
		g_object_unref(mrp);
		return TRUE;
	}	
	
	g_object_unref(mrp);
	
	const gchar *table, *field;

	if (g_str_equal (name, "guid")) {	
		table = midgard_core_class_get_table(MIDGARD_DBOBJECT_CLASS(*klass));
		field = "guid";
	} else {
		table = attr->table;
		field = attr->field;
	}

	if(table != NULL)
		(*constraint)->priv->current->table = table;
	
	(*constraint)->priv->current->field = field;		

	return TRUE;
}
Esempio n. 17
0
GList *
midgard_core_qb_set_object_from_query (MidgardQueryBuilder *builder, guint select_type, MidgardObject **nobject)
{
        g_assert(builder != NULL);
 
        guint ret_rows, ret_fields;
	MidgardConnection *mgd = builder->priv->mgd;
      
	gchar *sql = midgard_core_qb_get_sql(
			builder, select_type, 
			midgard_query_builder_get_object_select(builder, select_type));

	GSList *olist = NULL;
	MidgardDBObjectClass *dbklass = MIDGARD_DBOBJECT_CLASS(g_type_class_peek(builder->priv->type));

	if (!dbklass) {

		MIDGARD_ERRNO_SET_STRING (mgd, MGD_ERR_INTERNAL, "Failed to peek MidgardDBObjectClass pointer");
		return NULL;
	}

	if (dbklass->dbpriv->set_from_sql) {

		if (select_type != MQB_SELECT_GUID) {

			olist = dbklass->dbpriv->set_from_sql(mgd, builder->priv->type, ((const gchar *)sql));
			g_free(sql);

			return (GList *)olist;
		}
	}

	GdaDataModel *model = midgard_core_query_get_model(builder->priv->mgd, sql);
	g_free(sql);

	if(!model) 
		return NULL;	

	MidgardObject *object = NULL;
	gint rows, columns;
	const GValue *gvalue = NULL;

	ret_rows = gda_data_model_get_n_rows(model);
	ret_fields =  gda_data_model_get_n_columns(model);

	/* records found , allocate as many objects as many returned rows */ 
	GList *list = NULL;

	if(ret_rows == 0) {
		g_object_unref(model);
		return list;
	}

	/* We count rows only */
	if(select_type == MQB_SELECT_GUID) {
		
		gvalue = midgard_data_model_get_value_at(model, 0, 0);	
	
		if (!gvalue || !G_IS_VALUE (gvalue)) {
			
			g_object_unref (model);
			return 0;
		}

		MidgardTypeHolder *holder = g_new(MidgardTypeHolder, 1);

		GValue val = {0, };
		g_value_init (&val, G_TYPE_INT64);
		g_value_transform (gvalue, &val);

		holder->elements = (guint)g_value_get_int64((GValue*)&val);
		
		list = g_list_append(list, holder);	
		
		g_object_unref(model);
		g_value_unset (&val);

		return list;		
	}

	/* Get every row */
	for (rows = 0; rows < ret_rows; rows++) {
	
		if(!nobject)
			object = g_object_new (builder->priv->type, "connection", mgd, NULL);
		else 
			object = *nobject;

		MGD_OBJECT_IN_STORAGE (object) = TRUE;	
				
		if(dbklass->dbpriv->__set_from_sql != NULL) {
			
			dbklass->dbpriv->__set_from_sql(MIDGARD_DBOBJECT(object), 
					model, rows); 

		} else {
		
			/* Compute number of metadata properties */
			guint n_md_props = 0;
			MidgardMetadata *mklass = (MidgardMetadata *)MGD_DBCLASS_METADATA_CLASS (dbklass);
			if (mklass) 
				n_md_props = g_hash_table_size (MGD_DBCLASS_STORAGE_DATA (mklass)->prophash);

			guint __cols = n_md_props + 1; /* Add one for guid */

			/* we have guid and metadata columns first */
			for (columns = __cols; columns < ret_fields; columns++) {	
				
				gvalue = midgard_data_model_get_value_at(model, columns, rows);
				const gchar *coltitle =
					gda_data_model_get_column_title(model, columns);
				GParamSpec *pspec =
					g_object_class_find_property(G_OBJECT_GET_CLASS(object), coltitle);

				if(G_IS_VALUE(gvalue)) {

					if (!pspec) {
						
						g_warning("Failed to found (unregistered) %s property (%s class)", 
								coltitle, G_OBJECT_TYPE_NAME(object));
						continue;
					}

					if (G_VALUE_TYPE (gvalue) == GDA_TYPE_BINARY
							&& G_TYPE_FUNDAMENTAL (pspec->value_type) == G_TYPE_STRING) {

						gchar *stringified = midgard_core_query_binary_stringify ((GValue *)gvalue);
						g_object_set (G_OBJECT (object), coltitle, stringified, NULL);
				   		g_free (stringified);
					
					} else if (pspec->value_type != G_VALUE_TYPE (gvalue)) {

						GValue _convert = {0, };
						g_value_init (&_convert, pspec->value_type);	
				
						if (g_value_transform (gvalue, &_convert)) {

							/* FIXME, remove workaround once it's fixed in GDA */
							/* https://bugzilla.gnome.org/show_bug.cgi?id=617550 */
							guint dbtype = mgd->priv->config->priv->dbtype;
							if (dbtype == MIDGARD_DB_TYPE_MYSQL && G_VALUE_TYPE (gvalue) == GDA_TYPE_BLOB) {
								gchar *tmp_str = __default_unescape_string (g_value_get_string (&_convert));
								if (tmp_str)
									g_value_take_string (&_convert, tmp_str);
							}

							g_object_set_property (G_OBJECT (object), coltitle, &_convert);
					
						} else {

							g_warning ("Failed to convert %s to %s for %s property",
									G_VALUE_TYPE_NAME (gvalue),
									G_VALUE_TYPE_NAME (&_convert), 
									coltitle);
						}

						g_value_unset (&_convert);

					} else {

						g_object_set_property(G_OBJECT(object), coltitle, gvalue);
					}	
				
				} else if (gda_value_is_null(gvalue)) {			

					switch (pspec->value_type) {

						case G_TYPE_INT:
						case G_TYPE_UINT:
							g_object_set(G_OBJECT(object), coltitle, 0, NULL);
							break;

						case G_TYPE_STRING:
							g_object_set(G_OBJECT(object), coltitle, "", NULL);
							break;

						default:
							g_warning("Found (%s) not a value at %d.%d (%s)", 
									g_type_name(pspec->value_type), 
									columns, rows, 
									gda_data_model_get_column_title(model, columns));
							break;
					}
				}
			}	
		}

		/* Set guid */
		const gchar *guid;
		gvalue = midgard_data_model_get_value_at(model, 0, rows);
		if(G_IS_VALUE(gvalue) && G_VALUE_HOLDS_STRING(gvalue)){
			guid = g_value_get_string(gvalue);   
			g_free((gchar *)MIDGARD_DBOBJECT(object)->dbpriv->guid);
			MIDGARD_DBOBJECT(object)->dbpriv->guid = g_strdup(guid);
		}
		
		/* Set metadata */
		MidgardMetadata *metadata = MGD_DBOBJECT_METADATA (object);
	     	if (metadata) {
			GParamSpec *pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(object), "metadata");
			if (pspec)
				__mqb_set_metadata(metadata, model, rows);
		}	

		list = g_list_append(list, G_OBJECT(object));                		
	}

	g_object_unref(model);
	return list;	
}
Esempio n. 18
0
gchar *midgard_query_builder_get_object_select(
        MidgardQueryBuilder *builder, guint select_type){

        g_assert(builder != NULL);
        g_assert(builder->priv->type);
	
	MidgardObjectClass *klass = (MidgardObjectClass*) g_type_class_peek(builder->priv->type);
	const gchar *table = midgard_core_class_get_table(MIDGARD_DBOBJECT_CLASS(klass));

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

	/* We are getting only guids */
	if(select_type == MQB_SELECT_GUID){
		
		g_string_append(select, "COUNT(*) ");
		return g_string_free(select, FALSE);
	}
	
        /* guid hardcoded ( inherited from MidgardObjectClass )
         * metadata properties hardcoded ( defined in midgard_metadata )
         */ 
	/* FIXME, move this to particular class implementation, so we can reuse MidgardDBObject derived class data only */
	if (MIDGARD_IS_OBJECT_CLASS (klass))
			 g_string_append_printf(select, "%s.guid, ", table);

	if (MIDGARD_DBOBJECT_CLASS(klass)->dbpriv->has_metadata) {

		g_string_append_printf(select, 	
				"%s.metadata_creator, "
				"%s.metadata_created, "
				"%s.metadata_revisor, "
				"%s.metadata_revised, "
				"%s.metadata_revision, "
				"%s.metadata_locker, "
				"%s.metadata_locked, "
				"%s.metadata_approver, "
				"%s.metadata_approved, "
				"%s.metadata_authors, "
				"%s.metadata_owner, "
				"%s.metadata_schedule_start, "
				"%s.metadata_schedule_end, "
				"%s.metadata_hidden, "
				"%s.metadata_nav_noentry, "
				"%s.metadata_size, "
				"%s.metadata_published, "
				"%s.metadata_exported, "
				"%s.metadata_imported, "
				"%s.metadata_deleted, "
				"%s.metadata_score, "
				"%s.metadata_islocked, "
				"%s.metadata_isapproved "
				", ", 
			table, table, table, table, table, table, table, table, table,
			table, table, table, table, table, table, table, table, table,
			table, table, table, table, table); 
		/* TODO, Set select which suits better */	
	} 

	if(builder->priv->schema->sql_select_full != NULL) {
		g_string_append_printf(select, " %s", 
				builder->priv->schema->sql_select_full);
	}

        return g_string_free(select, FALSE);        
}
Esempio n. 19
0
static void __get_view_constraints(xmlNode *node, MgdSchemaTypeAttr *type)
{
	xmlNode *cur;

	for (cur = node->children; cur; cur = cur->next) {
	
		if (cur->type == XML_ELEMENT_NODE 
				&& g_str_equal(cur->name, "constraint")) { /* FIXME, add constraint to reserved words constants */
			
			xmlChar *property = xmlGetProp(cur, (const xmlChar *)"property");

			if (!property || (property && *property == '\0'))
				__view_error(cur, "Can not add constraint with empty property", NULL);

			gchar **classprop = g_strsplit((gchar *)property, ":", 2);
			if (!classprop || classprop[0] == NULL || classprop[1] == NULL) {
				__view_error(cur, "Constraint property misconfigured", NULL);
				return;
			}

			MidgardDBObjectClass *klass = 
				MIDGARD_DBOBJECT_CLASS(MIDGARD_OBJECT_GET_CLASS_BY_NAME((const gchar *)classprop[0]));
			if (!klass)
				__view_error(cur, "Class %s not registered", classprop[0]);

			MidgardCoreQueryConstraint *constraint = midgard_core_query_constraint_new();
			if (!midgard_core_query_constraint_parse_property(&constraint, klass, classprop[1]))
				__view_error(cur, "Can not parse %s constraint property", classprop[1]);

			g_strfreev(classprop);
			xmlFree(property);
			
			/* Add operator */
			xmlChar *operator = xmlGetProp(cur, (const xmlChar *)"operator");
			if (!operator || (operator && *operator == '\0'))
				__view_error(cur, "Can not add constraint with empty operator", NULL);
			if (!midgard_core_query_constraint_add_operator(constraint, (const gchar *)operator))
				__view_error(cur, "Invalid operator", NULL);
			xmlFree(operator);

			/* Add value */
			xmlChar *valtype = xmlGetProp(cur, (const xmlChar *)"value_type");
			if (!valtype || (valtype && *valtype == '\0'))
				__view_error(cur, "Can not add constraint with empty value_type", NULL);

			GType vtype = midgard_core_schema_gtype_from_string((const gchar *)valtype);
			if (!vtype)
				__view_error(cur, "Invalid %s value_type", valtype);

			xmlFree(valtype);

			xmlChar *value = xmlGetProp(cur, (const xmlChar *)"value");
			if (!value || (value && *value == '\0'))
				__view_error(cur, "Can not add constraint with empty value", NULL);

			/* Get value as string and convert to declared type */
			GValue strval = {0, };
			g_value_init(&strval, G_TYPE_STRING);
			g_value_set_string(&strval, (const gchar *)value);

			GValue val = {0, };
			g_value_init(&val, vtype);
			g_value_transform((const GValue *) &strval, &val);
		
			midgard_core_query_constraint_add_value(constraint, &val);
			midgard_core_query_constraint_build_condition(constraint);

			type->constraints = g_slist_append(type->constraints, (gpointer) constraint);
			
			g_value_unset(&val);
			g_value_unset(&strval);
			xmlFree(value);
		}
	}
}
gboolean 
midgard_core_query_constraint_parse_property (MidgardCoreQueryConstraint **constraint, MidgardDBObjectClass *klass, const gchar *name)
{
	g_assert(name != NULL);

	if (!klass)
		klass = MIDGARD_DBOBJECT_CLASS((*constraint)->priv->klass);

	(*constraint)->priv->current->table = midgard_core_class_get_table(MIDGARD_DBOBJECT_CLASS(klass)); 

	/* This is optional and might be set to NULL explicitly.
	   We need to parse property for any class which needs this */
	MidgardQueryBuilder *builder = (*constraint)->priv->builder;

	gchar **spltd = g_strsplit(name, ".", 0);
	guint i = 0;

	/* We can support max 3 tokens */
	while(spltd[i] != NULL)
		i++;

	if(i == 1) {
	
		g_strfreev(spltd);

		/* FIXME , it should be done by some more generic function */
		GParamSpec *pspec = 
			g_object_class_find_property(G_OBJECT_CLASS(klass), name);

		if(!pspec) {
			
			g_warning("%s is not a member of %s", 
					name, G_OBJECT_CLASS_NAME(klass));
			return FALSE;
		}

		const gchar *stable = 
			midgard_core_class_get_property_table(
					MIDGARD_DBOBJECT_CLASS(klass), name);
		(*constraint)->priv->pspec = pspec;
		(*constraint)->priv->current->field = 
			midgard_core_class_get_property_colname(
					MIDGARD_DBOBJECT_CLASS(klass), name);
		(*constraint)->priv->current->table = stable;
		
		if (builder)
			midgard_core_qb_add_table(builder, stable);

		(*constraint)->priv->klass = G_OBJECT_CLASS(klass);
		(*constraint)->priv->propname = name;
					
		if(g_str_equal(name, "guid")) 
			(*constraint)->priv->current->field = "guid";

		return TRUE;
	}

	if(i > 3) {
		g_warning("Failed to parse '%s'. At most 3 tokens allowed",
				name);
		g_strfreev(spltd);
		
		return FALSE;
	}

	gboolean parsed = FALSE;
	gboolean do_link = TRUE;
	guint j = 0;
	while(spltd[j] != NULL) {
		
		if(j+1 == i)
			do_link = FALSE;

		parsed = __set_schema_property_attr (builder, &klass, constraint, (const gchar *) spltd[j], do_link);
		
		if(!parsed) {
			g_strfreev(spltd);
			return FALSE;
		}
		j++;
	}

	g_strfreev(spltd);

	return TRUE;
}
Esempio n. 21
0
static void _midgard_workspace_class_init(
		gpointer g_class, gpointer g_class_data)
{
	GObjectClass *gobject_class = G_OBJECT_CLASS (g_class);
	MidgardWorkspaceClass *klass = MIDGARD_WORKSPACE_CLASS (g_class);
	__parent_class = g_type_class_peek_parent (g_class);
	
	gobject_class->constructor = _midgard_workspace_constructor;
	gobject_class->dispose = _midgard_workspace_dispose;
	gobject_class->finalize = _midgard_workspace_finalize;
	gobject_class->set_property = _midgard_workspace_set_property;
	gobject_class->get_property = _midgard_workspace_get_property;

	/* PROPERTIES */
	MgdSchemaPropertyAttr *prop_attr;
	MgdSchemaTypeAttr *type_attr = midgard_core_schema_type_attr_new();

	GParamSpec *pspec;
	const gchar *property_name;

	/* parent workspace */
	property_name = "parent_workspace";
	pspec = g_param_spec_object (property_name,
			"Parent workspace",
			"",
			MIDGARD_TYPE_WORKSPACE,
			G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
	g_object_class_install_property (gobject_class, PROPERTY_PARENT_WS, pspec);
	 
	/* id */
	property_name = "id";
	pspec = g_param_spec_uint (property_name,
			"Local storage id which identifies workspace",
			"",
			0, G_MAXUINT32, 0, G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,	PROPERTY_ID, pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_UINT;
	prop_attr->field = g_strdup(property_name);
	prop_attr->table = g_strdup(MGD_WORKSPACE_TABLE);
	prop_attr->tablefield = g_strjoin(".", MGD_WORKSPACE_TABLE, property_name, NULL);
	/* Set id property and field as Primary Key */
	prop_attr->primaryfield = g_strdup (property_name);
	prop_attr->is_primary = TRUE;
	type_attr->primary = g_strdup (property_name);
	type_attr->primaryfield = g_strdup (property_name);
	g_hash_table_insert(type_attr->prophash, g_strdup((gchar *)property_name), prop_attr);
	type_attr->_properties_list = g_slist_append (type_attr->_properties_list, (gpointer) property_name);

	/* up */
	property_name = "up";
	pspec = g_param_spec_uint (property_name,
			"Local storage id which identifies up workspace",
			"",
			0, G_MAXUINT32, 0, G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,	PROPERTY_UP, pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_UINT;
	prop_attr->field = g_strdup(property_name);
	prop_attr->table = g_strdup(MGD_WORKSPACE_TABLE);
	prop_attr->tablefield = g_strjoin(".", MGD_WORKSPACE_TABLE, property_name, NULL);
	g_hash_table_insert(type_attr->prophash, g_strdup((gchar *)property_name), prop_attr);
	type_attr->_properties_list = g_slist_append (type_attr->_properties_list, (gpointer) property_name);

	/* guid */
	property_name = "guid";
	pspec = g_param_spec_string (property_name,
			"Guid which identifies workspace object.",
			"",
			"",
			G_PARAM_READABLE);
	g_object_class_install_property (gobject_class, PROPERTY_GUID, pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_GUID;
	prop_attr->field = g_strdup (property_name);
	prop_attr->table = g_strdup (MGD_WORKSPACE_TABLE);
	prop_attr->tablefield = g_strjoin (".", MGD_WORKSPACE_TABLE, property_name, NULL);
	g_hash_table_insert (type_attr->prophash, g_strdup((gchar *)property_name), prop_attr);
	type_attr->_properties_list = g_slist_append (type_attr->_properties_list, (gpointer) property_name);

	/* path */
	property_name = "path";
	pspec = g_param_spec_string (property_name,
			"A path workspace is at",
			"",
			"",
			G_PARAM_READABLE);
	g_object_class_install_property (gobject_class, PROPERTY_PATH, pspec);

	/* name */
	property_name = "name";
	pspec = g_param_spec_string (property_name,
			"WorkspaceStorage name",
			"",
			"",
			G_PARAM_READWRITE);
	g_object_class_install_property (gobject_class, PROPERTY_NAME, pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_STRING;
	prop_attr->field = g_strdup (property_name);
	prop_attr->table = g_strdup (MGD_WORKSPACE_TABLE);
	prop_attr->tablefield = g_strjoin (".", MGD_WORKSPACE_TABLE, property_name, NULL);
	g_hash_table_insert (type_attr->prophash, g_strdup((gchar *)property_name), prop_attr);
	type_attr->_properties_list = g_slist_append (type_attr->_properties_list, (gpointer )property_name);

	MIDGARD_DBOBJECT_CLASS (klass)->dbpriv = midgard_core_dbobject_private_new ();
	MIDGARD_DBOBJECT_CLASS (klass)->dbpriv->storage_data = type_attr;
	MIDGARD_DBOBJECT_CLASS (klass)->dbpriv->storage_data->table = g_strdup(MGD_WORKSPACE_TABLE);
	MIDGARD_DBOBJECT_CLASS (klass)->dbpriv->storage_data->tables = g_strdup(MGD_WORKSPACE_TABLE);
	MIDGARD_DBOBJECT_CLASS (klass)->dbpriv->has_metadata = FALSE;
	
	MIDGARD_DBOBJECT_CLASS (klass)->dbpriv->create_storage = midgard_core_query_create_class_storage;
	MIDGARD_DBOBJECT_CLASS (klass)->dbpriv->update_storage = midgard_core_query_update_class_storage;
	MIDGARD_DBOBJECT_CLASS (klass)->dbpriv->storage_exists = _workspace_storage_exists;
	MIDGARD_DBOBJECT_CLASS (klass)->dbpriv->delete_storage = _workspace_storage_delete;
	MIDGARD_DBOBJECT_CLASS (klass)->dbpriv->get_statement_insert = MIDGARD_DBOBJECT_CLASS (__parent_class)->dbpriv->get_statement_insert;
	MIDGARD_DBOBJECT_CLASS (klass)->dbpriv->get_statement_insert_params = MIDGARD_DBOBJECT_CLASS (__parent_class)->dbpriv->get_statement_insert_params;
	MIDGARD_DBOBJECT_CLASS (klass)->dbpriv->get_statement_update = MIDGARD_DBOBJECT_CLASS (__parent_class)->dbpriv->get_statement_update;
	MIDGARD_DBOBJECT_CLASS (klass)->dbpriv->get_statement_update_params = MIDGARD_DBOBJECT_CLASS (__parent_class)->dbpriv->get_statement_update_params;
	MIDGARD_DBOBJECT_CLASS (klass)->dbpriv->add_fields_to_select_statement = MIDGARD_DBOBJECT_CLASS (__parent_class)->dbpriv->add_fields_to_select_statement;	
	MIDGARD_DBOBJECT_CLASS (klass)->dbpriv->set_from_data_model = _set_from_data_model;
}
Esempio n. 22
0
static void __get_view_joins(xmlNode *node, MgdSchemaTypeAttr *type)
{
	xmlNode *cur;
	gchar *property_name = NULL;	
	MgdSchemaPropertyAttr *propright = NULL;
	MgdSchemaPropertyAttr *propleft = NULL;

	for (cur = node->children; cur; cur = cur->next) {
	
		if (cur->type == XML_ELEMENT_NODE 
				&& g_str_equal(cur->name, "join")) { /* FIXME, add join to reserved words constants */

			property_name = NULL;
			propright = NULL;
			propleft = NULL;

			xmlChar *jointype = xmlGetProp(cur, (const xmlChar *)"type");

			if (!jointype || (jointype && *jointype == '\0'))
				__view_error(cur, "Can not create join with empty type", NULL);

			if (!midgard_core_xml_attribute_is_allowed(__allowed_joins, jointype))
				__view_error(cur, "%s join type is not allowed", jointype);

			xmlChar *classname = xmlGetProp(cur, (const xmlChar *)"class");
			xmlChar *table = NULL;

			if (!classname || (classname && *classname == '\0')) {

				table = xmlGetProp(cur, (const xmlChar *) TYPE_RW_TABLE);

				if (!table)
					__view_error(cur, "Can not create join. Empty, not defined class or table", NULL);
			}

			MidgardDBObjectClass *klass = NULL;
			MidgardDBObjectClass *joinklass = NULL;

			if (classname) 
				joinklass = MIDGARD_DBOBJECT_CLASS(MIDGARD_OBJECT_GET_CLASS_BY_NAME((const gchar *)classname));

			if (!joinklass) {
				g_warning ("%s is not registered in GType system", classname);
				__view_error (cur, "Invalid classname for defined join");
				return;
			}

			gchar *left = midgard_core_xml_get_child_attribute_content_by_name(cur, "condition", "left");
			if (!left)
				__view_error(cur, "Condition left is missing", NULL);

			gchar *right = midgard_core_xml_get_child_attribute_content_by_name(cur, "condition", "right");
			if (!right)
				__view_error(cur, "Condition right is missing", NULL);

			/* Get left property attribute */
			gchar **classprop = g_strsplit_set(left, ":.", -1);
			if (!classprop || classprop[0] == NULL || classprop[1] == NULL) {
				__view_error(cur, "Condition left problem", NULL);
				return;
			}

			klass = MIDGARD_DBOBJECT_CLASS(MIDGARD_OBJECT_GET_CLASS_BY_NAME((const gchar *)classprop[0]));
			if (!klass) {
				__view_error(cur, "Class %s not registered", classprop[0]);
				return;
			}

			MgdSchemaPropertyAttr *propleft = 
				g_hash_table_lookup(klass->dbpriv->storage_data->prophash, classprop[1]);
			if (!propleft)
				__view_error(cur, "Property %s not registered for %s", classprop[1], classprop[0]); 
			/* __get_property_attribute (cur, classprop, &property_name, &propleft, klass); */ 
			g_strfreev(classprop);

			/* Get right property attribute */
			classprop = g_strsplit_set(right, ":.", -1);
			if (!classprop || classprop[0] == NULL || classprop[1] == NULL) {
				__view_error(cur, "Condition right problem", NULL);
				return;
			}

			klass = MIDGARD_DBOBJECT_CLASS(MIDGARD_OBJECT_GET_CLASS_BY_NAME((const gchar *)classprop[0]));
			if (!klass) {
				__view_error(cur, "Class %s not registered", classprop[0]);
				return;
			}

			MgdSchemaPropertyAttr *propright = 
				g_hash_table_lookup(klass->dbpriv->storage_data->prophash, classprop[1]);
			if (!propright)
				__view_error(cur, "Property %s not registered for %s", classprop[1], classprop[0]);
			/* __get_property_attribute (cur, classprop, &property_name, &propright, klass); */
			g_strfreev(classprop);

			MidgardDBJoin *mdbj = midgard_core_dbjoin_new();
			mdbj->type = g_utf8_strup((const gchar *)jointype, strlen((gchar *)jointype));

			/* configure table, if there's class, get it's table, in other case, get table directly */
			if (classname)
				mdbj->table = g_strdup(midgard_core_class_get_table(joinklass));
			else 
				mdbj->table = g_strdup((gchar *)table);
	
			mdbj->left = propleft;
			mdbj->right = propright;

			g_free(left);
			g_free(right);

			type->joins = g_slist_append(type->joins, (gpointer) mdbj);

			xmlFree(jointype);
			xmlFree(classname);
			if (table)
				xmlFree(table);
		}
	}
}
Esempio n. 23
0
	g_assert(domain != NULL);
	g_assert(value != NULL);

	MidgardCollector *self = 
		(MidgardCollector *)g_object_new(MIDGARD_TYPE_COLLECTOR, NULL);
	
	self->priv->klass =
		MIDGARD_OBJECT_GET_CLASS_BY_NAME(typename);
	
	 /* Initialize private QB instance and set domain as constraint */
	self->priv->builder = midgard_query_builder_new(mgd, typename);
	midgard_query_builder_add_constraint(self->priv->builder,
			domain,
			"=", value);

	MidgardDBObjectClass *klass = MIDGARD_DBOBJECT_CLASS(self->priv->klass);
	MidgardCoreQueryConstraint *constraint = midgard_core_query_constraint_new();
	midgard_core_query_constraint_set_builder(constraint, self->priv->builder);
	midgard_core_query_constraint_set_class(constraint, klass);

	if(!midgard_core_query_constraint_parse_property(&constraint, klass, domain)) {
		
		g_object_unref(constraint);
		
		/* FIXME */
		if(value) {
			
			g_value_unset(value);
			g_free(value);
		}
		
Esempio n. 24
0
static void __get_view_properties(xmlNode *node, MgdSchemaTypeAttr *type)
{
	xmlNode *cur;
	MgdSchemaPropertyAttr *rprop_attr = NULL;
	gchar *property_name = NULL;

	for (cur = node->children; cur; cur = cur->next) {

		if (cur->type == XML_ELEMENT_NODE 
				&& g_str_equal(cur->name, "property")) { /* FIXME, add property to reserved words constants */

			property_name = NULL;
			rprop_attr = NULL;

			xmlChar *name = xmlGetProp(cur, (const xmlChar *)TYPE_RW_NAME);

			if (!name || (name && *name == '\0'))
				__view_error(cur, "Can not register view with empty property", NULL);

			xmlChar *use_prop = xmlGetProp(cur, (const xmlChar *) "use"); /* FIXME, use reserved word */
			
			if (!use_prop || (use_prop && *use_prop == '\0'))
				__view_error(cur, "Referenced class:property can not be empty", NULL);

			gchar **rprop = g_strsplit_set ((const gchar *)use_prop, ":.", -1);
			xmlFree (use_prop);
			if (!rprop || rprop[0] == NULL || rprop[1] == NULL) {
				__view_error(cur, "Referenced property can not be empty", NULL);
				return;
			}

			MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(rprop[0]);		
			if (!klass)
				__view_error (cur, "Defined '%s' class is not registered as midagrd_object derived one", rprop[0]);

			const gchar *table = midgard_core_class_get_table (MIDGARD_DBOBJECT_CLASS (klass));
			if (table == NULL)
				__view_error (cur, "Can not create proper view. Defined '%s' class has NULL storage", rprop[0]);

			__get_property_attribute (cur, rprop, &property_name, &rprop_attr, MIDGARD_DBOBJECT_CLASS (klass));

			midgard_core_schema_type_property_copy(rprop_attr, type);
			
			/* TODO, refactor with some usable TypeAttr related API */
			/* Create property attributes copy using original property.
			   Then change name. */
			MgdSchemaPropertyAttr *prop_attr = g_hash_table_lookup(type->prophash, property_name);
	
			if (!prop_attr)
				g_warning("Can not find  %s.%s in newly registered view", type->name, name); 

			if (prop_attr) {

				g_free((gchar *)prop_attr->name);
				prop_attr->name = g_strdup((gchar *)name);

				/* Free old key and remove new one in hash table */
				g_hash_table_remove(type->prophash, (gconstpointer) rprop[1]);

				gchar *property_name = g_strdup ((gchar *)name);
				g_hash_table_insert(type->prophash, property_name, prop_attr);

				/* FIXME
				 * Workaround for properties not being registered in the same order as defined 
				 * in view xml file */	
				type->_properties_list = g_slist_append (type->_properties_list, property_name);	
			}

			g_strfreev(rprop);
			xmlFree(name);	
		}
	}
}
Esempio n. 25
0
/* Create GdaSqlSelectField for every property registered for the class. */
void
_add_fields_to_select_statement (MidgardDBObjectClass *klass, MidgardConnection *mgd, GdaSqlStatementSelect *select, const gchar *table_name)
{
	guint n_prop;
	guint i;
	GdaSqlSelectField *select_field;
	GdaSqlExpr *expr;
	GValue *val;
	gchar *table_field;
	GdaConnection *cnc = mgd->priv->connection;

	GParamSpec **pspecs = g_object_class_list_properties (G_OBJECT_CLASS (klass), &n_prop);
	if (!pspecs)
		return;

	const gchar *property_table = NULL;

	for (i = 0; i < n_prop; i++) {

		const gchar *property = pspecs[i]->name;
		const gchar *property_field = midgard_core_class_get_property_colname (klass, property);
		property_table = midgard_core_class_get_property_table (klass, property); 
		if (property_table && table_name)
			property_table = table_name;

		/* Ignore properties with NULL storage and those of object type */
		if (!property_table || pspecs[i]->value_type == G_TYPE_OBJECT)
			continue;

       		select_field = gda_sql_select_field_new (GDA_SQL_ANY_PART (select));
		/*select_field->field_name = g_strdup (property_field);
		select_field->table_name = g_strdup (property_table);*/
		select_field->as = gda_connection_quote_sql_identifier (cnc, property);
		select->expr_list = g_slist_append (select->expr_list, select_field);
		expr = gda_sql_expr_new (GDA_SQL_ANY_PART (select_field));
		val = g_new0 (GValue, 1);
		g_value_init (val, G_TYPE_STRING);
		gchar *q_table = gda_connection_quote_sql_identifier (cnc, property_table);
		gchar *q_field = gda_connection_quote_sql_identifier (cnc, property_field);
		table_field = g_strconcat (q_table, ".", q_field, NULL);
		g_value_set_string (val, table_field);
		g_free (q_table);
		g_free (q_field);
		g_free (table_field);
		expr->value = val;
		select_field->expr = expr;
	}	

	g_free (pspecs);

	if (!klass->dbpriv->has_metadata)
		return;

	/* Check if metadata provides own method to add fields. If not, use given class storage. */
	if (MIDGARD_IS_OBJECT_CLASS (klass)) {

		MidgardMetadataClass *mklass = MGD_DBCLASS_METADATA_CLASS (klass);
		if (!mklass)
			return;

		if (MIDGARD_DBOBJECT_CLASS (mklass)->dbpriv->add_fields_to_select_statement) {
			MIDGARD_DBOBJECT_CLASS (mklass)->dbpriv->add_fields_to_select_statement (MIDGARD_DBOBJECT_CLASS (mklass), mgd, select, table_name);
			return;
		}

		const gchar *table = midgard_core_class_get_table (klass);
		if (table_name)
			table = table_name;

		/* TODO, Once we stabilize use case, refactor this below to minimize code usage */
		GParamSpec **pspecs = g_object_class_list_properties (G_OBJECT_CLASS (mklass), &n_prop);
		if (!pspecs)
			return;
		
		for (i = 0; i < n_prop; i++) {

			const gchar *property = pspecs[i]->name;
			const gchar *property_field = midgard_core_class_get_property_colname (MIDGARD_DBOBJECT_CLASS (mklass), property);	

			if (pspecs[i]->value_type == G_TYPE_OBJECT || !property_field)
				continue;
			
			select_field = gda_sql_select_field_new (GDA_SQL_ANY_PART (select));
			/*select_field->field_name = g_strdup (property_field);
			select_field->table_name = g_strdup (table);*/
			select_field->as = g_strconcat ("metadata_", property, NULL);
			select->expr_list = g_slist_append (select->expr_list, select_field);
			expr = gda_sql_expr_new (GDA_SQL_ANY_PART (select_field));
			val = g_new0 (GValue, 1);
			g_value_init (val, G_TYPE_STRING);
			table_field = g_strconcat (table, ".", property_field, NULL);
			g_value_set_string (val, table_field);
			g_free (table_field);
			expr->value = val;
			select_field->expr = expr;
		}

		g_free (pspecs);
	}

	return;
}
/**
 * midgard_replicator_export_by_guid:
 * @mgd: #MidgardConnection instance
 * @guid: guid which identifies object to be exported
 *
 * Marks object's storage record as exported.
 *
 * Cases to return %FALSE:
 * <itemizedlist>
 * <listitem><para>
 * Given guid is NULL or empty string (MGD_ERR_INVALID_PROPERTY_VALUE)
 * </para></listitem>
 * <listitem><para>
 * Object identified by given guid doesn't exist (MGD_ERR_NOT_EXISTS)
 * </para></listitem>
 * <listitem><para>
 * Object identified by given guid is purged (MGD_ERR_OBJECT_PURGED)
 * </para></listitem>
 * <listitem><para>
 * Internal storage error (MGD_ERR_INTERNAL)
 * </para></listitem>
 * </itemizedlist>
 *
 * Returns: %TRUE on success, %FALSE otherwise
 */ 
gboolean 
midgard_replicator_export_by_guid (MidgardConnection *mgd, const gchar *guid)
{
	g_return_val_if_fail (mgd != NULL, FALSE);

	if(guid == NULL || (guid && (*guid == '\0'))) {
		MIDGARD_ERRNO_SET_STRING (mgd, MGD_ERR_INVALID_PROPERTY_VALUE, "Empty or NULL guid given");
		return FALSE;
	}

	MIDGARD_ERRNO_SET(mgd, MGD_ERR_OK);

	MidgardDBObject *repligard = NULL;
	GError *error = NULL;
	GValue gval = {0, };
	g_value_init (&gval, G_TYPE_STRING);
	g_value_set_string (&gval, guid);
	midgard_core_query_get_object (mgd, g_type_name (MIDGARD_TYPE_REPLIGARD), &repligard, FALSE, &error, "guid", &gval, NULL);
	g_value_unset (&gval);

	if (error) {
		MIDGARD_ERRNO_SET_STRING (mgd, error->code, "%s", error->message);
		g_clear_error (&error);
		if (repligard)
			g_object_unref (G_OBJECT (repligard));
		return FALSE;
	}

	guint action;
	gchar *classname;
	g_object_get (repligard, 
			"action", &action,
			"type", &classname, NULL);
	g_object_unref (repligard);

	MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(classname);

	if(klass == NULL) {
		g_warning("Failed to get class pointer for '%s', an object identified with '%s'", classname, guid);
		MIDGARD_ERRNO_SET(mgd, MGD_ERR_INTERNAL);
		g_free (classname);
		return FALSE;
	}

	g_free (classname);

	const gchar *table = midgard_core_class_get_table(MIDGARD_DBOBJECT_CLASS(klass)); 
	GValue tval = {0, };
	gchar *timeupdated;
	gint qr;
	GString *sql = NULL;

	switch(action) {
		
		case MGD_OBJECT_ACTION_PURGE:
			MIDGARD_ERRNO_SET(mgd, MGD_ERR_OBJECT_PURGED);
			return FALSE;
			break;

		default:
			sql = g_string_new ("UPDATE ");
			g_string_append_printf(sql, "%s SET ", table);

			midgard_timestamp_new_current (&tval);
			timeupdated = midgard_timestamp_get_string_from_value (&tval);
			
			g_string_append_printf(sql, "metadata_exported='%s' WHERE guid = '%s' ", 
					timeupdated, guid);

			qr = midgard_core_query_execute(mgd, sql->str, TRUE);
			g_string_free(sql, TRUE);

			g_value_unset (&tval);
			g_free(timeupdated);

			if (qr == 0) {
				MIDGARD_ERRNO_SET(mgd, MGD_ERR_INTERNAL);
				return FALSE;
			}

			return TRUE;

			break;
	}

	return FALSE;
}
static void
_midgard_query_select_validable_iface_validate (MidgardValidable *iface, GError **error)
{
	g_return_if_fail (iface != NULL);
	MidgardQuerySelect *self = MIDGARD_QUERY_SELECT (iface);
	MIDGARD_QUERY_EXECUTOR (self)->priv->is_valid = FALSE;

	GError *err = NULL;
	MidgardQueryStorage *storage = MIDGARD_QUERY_EXECUTOR (self)->priv->storage;
	GObjectClass *klass = (GObjectClass *) storage->priv->klass;
	if (klass == NULL || (!G_IS_OBJECT_CLASS(klass))) {
		g_set_error (error, MIDGARD_VALIDATION_ERROR, MIDGARD_VALIDATION_ERROR_TYPE_INVALID,
				"Invalid '%s' classname associated with QueryStorage", storage->priv->classname);
		return;
	}
	const gchar *table = midgard_core_class_get_table (MIDGARD_DBOBJECT_CLASS (klass));

	/* Class table */
	if (!table) {
		g_set_error (error, MIDGARD_VALIDATION_ERROR, MIDGARD_VALIDATION_ERROR_LOCATION_INVALID,
				"No SQL table defined for '%s' class", G_OBJECT_CLASS_NAME (klass));
		return;
	}

	/* Storage */
	if (!storage) {
		g_set_error (error, MIDGARD_VALIDATION_ERROR, MIDGARD_VALIDATION_ERROR_LOCATION_INVALID,
				"No QueryStorage associated with QuerySelect");
		return;
	}

	if (storage->priv->klass && !storage->priv->klass->dbpriv->add_fields_to_select_statement) {
		g_set_error (error, MIDGARD_VALIDATION_ERROR, MIDGARD_VALIDATION_ERROR_INTERNAL,
				"'%s' DBObjectClass doesn't provide select statement.", G_OBJECT_CLASS_NAME (storage->priv->klass));
		return;
	}

	/* Limit */
	if (MIDGARD_QUERY_EXECUTOR (self)->priv->limit == 0) {
		g_set_error (error, MIDGARD_VALIDATION_ERROR, MIDGARD_VALIDATION_ERROR_VALUE_INVALID,
				"Invalid limit value (0). Expected > 0");
		return;
	}

	/* Orders */
	GSList *l = NULL;
	for (l = MIDGARD_QUERY_EXECUTOR (self)->priv->orders; l != NULL; l = l->next) {
		qso *_so = (qso*) l->data;
		gboolean asc = FALSE;
		gchar *lorder = g_ascii_strdown (_so->order_type, -1);
		if (g_str_equal (lorder, "asc")) {
			_so->asc = TRUE;
		} else if (g_str_equal (lorder, "desc")) {
			_so->asc = FALSE;
		} else {
			g_set_error (error, MIDGARD_VALIDATION_ERROR, MIDGARD_VALIDATION_ERROR_VALUE_INVALID,
					"Invalid order type '%s'. Expected ASC or DESC", _so->order_type);
			g_free (lorder); 
			return;
		}		
		g_free (lorder);
	}

	/* Gather all objects required for execution */
	GSList *o_list = NULL;
	o_list = g_slist_prepend (o_list, storage);
	_get_all_constraints (self, NULL, &o_list);

	for (l = o_list; l != NULL; l = l->next) {
		if (!midgard_validable_is_valid (MIDGARD_VALIDABLE (l->data))) {
			midgard_validable_validate (MIDGARD_VALIDABLE (l->data), &err);
			if (err) {
				g_propagate_error (error, err);
				g_slist_free (o_list);
				return;
			}
		}
	}

	if (o_list)
		g_slist_free (o_list);

	MIDGARD_QUERY_EXECUTOR (self)->priv->is_valid = TRUE;
	return;
}
Esempio n. 28
0
/* Initialize class */
static void
_metadata_class_init (gpointer g_class, gpointer g_class_data)
{	
	GObjectClass *gobject_class = G_OBJECT_CLASS (g_class);
	MidgardMetadataClass *klass = MIDGARD_METADATA_CLASS (g_class); 
	GParamSpec *pspec;
	__parent_class = g_type_class_peek_parent (g_class);

	gobject_class->constructor = _metadata_constructor;	
	gobject_class->set_property = _metadata_set_property;
	gobject_class->get_property = _metadata_get_property;
	gobject_class->dispose = _metadata_dispose;
	gobject_class->finalize = _metadata_object_finalize;

	MgdSchemaPropertyAttr *prop_attr;
	MgdSchemaTypeAttr *type_attr = midgard_core_schema_type_attr_new();
	
	/* Register properties */        

	/* creator */
	pspec = g_param_spec_string ("creator",
			"metadata_creator",
			"Guid of the person who created object's record",
			NULL /* We can set midgard admin */,
			G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_CREATOR,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_GUID;
	prop_attr->field = g_strdup("metadata_creator");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("creator");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"creator"), prop_attr);

	/* created */
	pspec = g_param_spec_boxed ("created",
			"metadata_created",
			"ISO datetime when object's record has been created",
			MGD_TYPE_TIMESTAMP,
			G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_CREATED,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_TIMESTAMP;
	prop_attr->field = g_strdup("metadata_created");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("created");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"created"), prop_attr);

	/* revisor */
	pspec = g_param_spec_string ("revisor",
			"metadata_revisor",
			"Guid of the person who revised object's record",
			NULL, 
			G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_REVISOR,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_GUID;
	prop_attr->field = g_strdup("metadata_revisor");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("revisor");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"revisor"), prop_attr);

	/* revised */
	pspec = g_param_spec_boxed ("revised",
			"metadata_revised",
			"ISO datetime when object's record has been revised",
			MIDGARD_TYPE_TIMESTAMP,
			G_PARAM_READABLE); 
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_REVISED,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_TIMESTAMP;
	prop_attr->field = g_strdup("metadata_revised");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("revised");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"revised"), prop_attr);

	/* revision */
	pspec = g_param_spec_uint ("revision",
			"metadata_revision",
			"Object's record revision number",
			0, G_MAXUINT32, 0, G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_REVISION,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_UINT;
	prop_attr->field = g_strdup("metadata_revision");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("revision");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"revision"), prop_attr);

	/* locker */
	pspec = g_param_spec_string ("locker",
			"metadata_locker",
			"Guid of the person who (un)locked object's record",
			NULL,
			G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_LOCKER,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_GUID;
	prop_attr->field = g_strdup("metadata_locker");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("locker");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"locker"), prop_attr);

	/* locked */
	pspec = g_param_spec_boxed ("locked",
			"metadata_locked",
			"ISO datetime when object's record has been (un)locked",
			MGD_TYPE_TIMESTAMP,
			G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_LOCKED,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_TIMESTAMP;
	prop_attr->field = g_strdup("metadata_locked");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("locked");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"locked"), prop_attr);

	/* approver */
	pspec = g_param_spec_string ("approver",
			"metadata_approver",
			"Guid of the person who (un)approved object's record",
			NULL,
			G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_APPROVER,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_GUID;
	prop_attr->field = g_strdup("metadata_approver");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("approver");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"approver"), prop_attr);

	/* approved */
	pspec = g_param_spec_boxed ("approved",
			"metadata_approved",
			"ISO datetime when object's record has been (un)approved",
			MGD_TYPE_TIMESTAMP,
			G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_APPROVED,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_TIMESTAMP;
	prop_attr->field = g_strdup("metadata_approved");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("approved");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"approved"), prop_attr);

	/* authors */
	pspec = g_param_spec_string ("authors",
			"metadata_authors",
			"The person who is an author.",
			"",
			G_PARAM_READWRITE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_AUTHORS,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_STRING;
	prop_attr->field = g_strdup("metadata_authors");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("authors");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"authors"), prop_attr);

	/* owner */
	pspec = g_param_spec_string ("owner",
			"metadata_owner",
			"Group's guid which is an owner of the object",
			"",
			G_PARAM_READWRITE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_OWNER,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_GUID;
	prop_attr->field = g_strdup("metadata_owner");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("owner");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"owner"), prop_attr);

	/* schedulestart */
	pspec = g_param_spec_boxed ("schedulestart",
			"metadata_schedule_start",
			"ISO datetime when publication time starts.",
			MGD_TYPE_TIMESTAMP,
			G_PARAM_READWRITE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_SCHEDULE_START,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_TIMESTAMP;
	prop_attr->field = g_strdup("metadata_schedule_start");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("schedulestart");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"schedulestart"), prop_attr);

	/* scheduleend */
	pspec = g_param_spec_boxed ("scheduleend",
			"metadata_schedule_end",
			"ISO datetime when publication time ends.",
			MGD_TYPE_TIMESTAMP,
			G_PARAM_READWRITE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_SCHEDULE_END,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_TIMESTAMP;
	prop_attr->field = g_strdup("metadata_schedule_end");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("scheduleend");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"scheduleend"), prop_attr);

	/* hidden */
	pspec = g_param_spec_boolean ("hidden",
			"metadata_hidden",
			"Whether object should be hidden or not.",
			FALSE,
			G_PARAM_READWRITE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_HIDDEN,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_BOOLEAN;
	prop_attr->field = g_strdup("metadata_hidden");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("hidden");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"hidden"), prop_attr);

	/* nav no entry */
	pspec = g_param_spec_boolean ("navnoentry",
			"metadata_nav_noentry",
			"Whether object is part of navigation (e.g. menu).",
			FALSE,
			G_PARAM_READWRITE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_NAV_NOENTRY,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_BOOLEAN;
	prop_attr->field = g_strdup("metadata_nav_noentry");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("navnoentry");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"navnoentry"), prop_attr);

	/* size */
	pspec = g_param_spec_uint ("size",
			"metadata_size",
			"Object's size in bytes",
			0, G_MAXUINT32, 0, G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_SIZE,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_UINT;
	prop_attr->field = g_strdup("metadata_size");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("size");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"size"), prop_attr);

	/* published */
	pspec = g_param_spec_boxed ("published",
			"metadata_published",
			"ISO datetime when object should be published (by default it's created time)",
			MGD_TYPE_TIMESTAMP,
			G_PARAM_READWRITE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_PUBLISHED,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_TIMESTAMP;
	prop_attr->field = g_strdup("metadata_published");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("published");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"published"), prop_attr);

	/* score */
	pspec = g_param_spec_int ("score",
			"metadata_score",
			"Object's record score",
			G_MININT32, G_MAXINT32, 0, G_PARAM_READWRITE);
	g_object_class_install_property (gobject_class,      
			MIDGARD_METADATA_SCORE,        
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_INT;
	prop_attr->field = g_strdup("metadata_score");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("score");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"score"), prop_attr);

	/* exported */
	pspec = g_param_spec_boxed ("exported",
			"metadata_exported",
			"Whether object has been exported or not.",
			MGD_TYPE_TIMESTAMP,
			G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_EXPORTED,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_TIMESTAMP;
	prop_attr->field = g_strdup("metadata_exported");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("exported");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"exported"), prop_attr);

	/* imported */
	pspec = g_param_spec_boxed ("imported",
			"metadata_imported",
			"Whether object has been imported or not.",
			MGD_TYPE_TIMESTAMP,
			G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_IMPORTED,
			pspec);
    	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_TIMESTAMP;
	prop_attr->field = g_strdup("metadata_imported");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("imported");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"imported"), prop_attr);

	/* deleted */
	pspec = g_param_spec_boolean ("deleted",
			"metadata_deleted",
			"Whether object is deleted or not.",
			FALSE,
			G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_DELETED,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_BOOLEAN;
	prop_attr->field = g_strdup("metadata_deleted");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("deleted");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"deleted"), prop_attr);

	/* isapproved */
	pspec = g_param_spec_boolean ("isapproved",
			"metadata_isapproved",
			"Whether object is approved or not.",
			FALSE,
			G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_ISAPPROVED,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_BOOLEAN;
	prop_attr->field = g_strdup("metadata_isapproved");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("isapproved");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"isapproved"), prop_attr);

	/* islocked */
	pspec = g_param_spec_boolean ("islocked",
			"metadata_islocked",
			"Whether object is locked or unlocked.",
			FALSE,
			G_PARAM_READABLE);
	g_object_class_install_property (gobject_class,
			MIDGARD_METADATA_ISLOCKED,
			pspec);
	prop_attr = midgard_core_schema_type_property_attr_new();
	prop_attr->gtype = MGD_TYPE_BOOLEAN;
	prop_attr->field = g_strdup("metadata_islocked");
	prop_attr->table = NULL;
	prop_attr->tablefield = NULL;
	prop_attr->name = g_strdup ("islocked");
	g_hash_table_insert(type_attr->prophash,
			g_strdup((gchar *)"islocked"), prop_attr);

	/* Initialize private member */
	MidgardDBObjectClass *dbklass = MIDGARD_DBOBJECT_CLASS (klass);
	dbklass->dbpriv = g_new(MidgardDBObjectPrivate, 1);
	dbklass->dbpriv->storage_data = type_attr;
	dbklass->dbpriv->set_from_xml_node = __set_from_xml_node;
	dbklass->dbpriv->add_fields_to_select_statement = NULL;
	dbklass->dbpriv->has_metadata = FALSE;
	dbklass->dbpriv->get_property = _midgard_metadata_dbpriv_get_property;
	dbklass->dbpriv->set_property = midgard_core_metadata_dbpriv_set_property;
	dbklass->dbpriv->set_from_data_model = _midgard_metadata_set_from_data_model;
}