Inverse Relations - Revision history

Juha Kortelainen at 15:55, 28 January 2011

2011-01-28T15:55:32Z

← Older revision		Revision as of 15:55, 28 January 2011
Line 6:		Line 6:
	WriteGraph.claim(Resource subject, Resource predicate, Resource inverse, Resource object)		WriteGraph.claim(Resource subject, Resource predicate, Resource inverse, Resource object)
	with a <code>null</code> inverse relation argument to create the sensitive statements such as ''InstanceOf''-relations.		with a <code>null</code> inverse relation argument to create the sensitive statements such as ''InstanceOf''-relations.

			[[Category: Database Development]]

Tuukka Lehtonen at 16:39, 7 October 2010

2010-10-07T16:39:33Z

← Older revision		Revision as of 16:39, 7 October 2010
Line 1:		Line 1:
	According to [[~~Layer0_ontology~~\|Layer0]] semantics, relations <em>can</em> have inverse relations. For the database and client this means that when claiming new statements <code>(s, p, o)</code> using		According to [[:Media:Layer0.pdf\|Layer0]] semantics, relations <em>can</em> have inverse relations. For the database and client this means that when claiming new statements <code>(s, p, o)</code> using
	WriteGraph.claim(Resource subject, Resource predicate, Resource object)		WriteGraph.claim(Resource subject, Resource predicate, Resource object)
	an inverse statement <code>(o, inv(p), s)</code> will be automatically claimed into the database. Some statements are such that they tend to raise the degree of the resource (amount of incoming/outgoing relations) to very large numbers. The database is not built to efficiently handle such resources. One such relation is ''InstanceOf'' which is a statement that pretty much each and every resource in the database has. It does not have an inverse relation, but considering it had one like ''HasInstance'', here's what would happen. For example, for each ''L0.String'' instance created an inverse statement would be added <code>(L0.String, L0.HasInstance, :L0.String)</code> statement into the database, thereby enlarging the degree of ''L0.String''. When working with larger databases this would most likely become a problem.		an inverse statement <code>(o, inv(p), s)</code> will be automatically claimed into the database. Some statements are such that they tend to raise the degree of the resource (amount of incoming/outgoing relations) to very large numbers. The database is not built to efficiently handle such resources. One such relation is ''InstanceOf'' which is a statement that pretty much each and every resource in the database has. It does not have an inverse relation, but considering it had one like ''HasInstance'', here's what would happen. For example, for each ''L0.String'' instance created an inverse statement would be added <code>(L0.String, L0.HasInstance, :L0.String)</code> statement into the database, thereby enlarging the degree of ''L0.String''. When working with larger databases this would most likely become a problem.

Tuukka Lehtonen at 12:41, 29 September 2010

2010-09-29T12:41:14Z

← Older revision		Revision as of 12:41, 29 September 2010
Line 1:		Line 1:
	According to [[Layer0_ontology\|Layer0]] semantics, relations <em>can</em> have inverse relations. For the database and client this means that when claiming new statements <code>(s, p, o)</code> using		According to [[Layer0_ontology\|Layer0]] semantics, relations <em>can</em> have inverse relations. For the database and client this means that when claiming new statements <code>(s, p, o)</code> using
	WriteGraph.claim(Resource subject, Resource predicate, Resource object)		WriteGraph.claim(Resource subject, Resource predicate, Resource object)
	an inverse statement <code>(o, inv(p), s)</code> will be automatically claimed into the database. Some statements are such that they tend to raise the degree of the resource (amount of incoming/outgoing relations) to very large numbers. The database is not built to efficiently handle such resources. One such relation is ''InstanceOf'' which is a statement that pretty much each and every resource in the database has. It does not have an inverse relation, but considering it had one like ''HasInstance'', here's what would happen. For example, for each ''L0.String'' instance created an inverse statement would be added <code>(L0.String, L0.HasInstance, :L0.String)</code> statement into the database, thereby enlarging the degree ~~of statements~~ of ''L0.String''. When working with larger databases this would most likely become a problem.		an inverse statement <code>(o, inv(p), s)</code> will be automatically claimed into the database. Some statements are such that they tend to raise the degree of the resource (amount of incoming/outgoing relations) to very large numbers. The database is not built to efficiently handle such resources. One such relation is ''InstanceOf'' which is a statement that pretty much each and every resource in the database has. It does not have an inverse relation, but considering it had one like ''HasInstance'', here's what would happen. For example, for each ''L0.String'' instance created an inverse statement would be added <code>(L0.String, L0.HasInstance, :L0.String)</code> statement into the database, thereby enlarging the degree of ''L0.String''. When working with larger databases this would most likely become a problem.

	To make it possible to optimize this situation we provide the possibility to skip adding of inverse relations when claiming statements into the database by using		To make it possible to optimize this situation we provide the possibility to skip adding of inverse relations when claiming statements into the database by using
	WriteGraph.claim(Resource subject, Resource predicate, Resource inverse, Resource object)		WriteGraph.claim(Resource subject, Resource predicate, Resource inverse, Resource object)
	with a <code>null</code> inverse relation argument to create the sensitive statements such as ''InstanceOf''-relations.		with a <code>null</code> inverse relation argument to create the sensitive statements such as ''InstanceOf''-relations.

Tuukka Lehtonen at 12:40, 29 September 2010

2010-09-29T12:40:47Z

← Older revision		Revision as of 12:40, 29 September 2010
Line 1:		Line 1:
	According to [[Layer0_ontology\|Layer0]] semantics, relations <em>can</em> have inverse relations. For the database and client this means that when claiming new statements <code>(s, p, o)</code> using		According to [[Layer0_ontology\|Layer0]] semantics, relations <em>can</em> have inverse relations. For the database and client this means that when claiming new statements <code>(s, p, o)</code> using
	WriteGraph.claim(Resource subject, Resource predicate, Resource object)		WriteGraph.claim(Resource subject, Resource predicate, Resource object)
	an inverse statement <code>(o, inv(p), s)</code> will be automatically claimed into the database. Some statements are such that they tend to raise the degree of the resource (amount of incoming/outgoing relations) to very large numbers. The database is not built to efficiently handle such resources. One such relation is ~~<code>~~InstanceOf~~</code>~~ which is a statement that pretty much each and every resource in the database has. It does not have an inverse relation, but considering it had one, here's what would happen. For example, for each ~~<code>~~L0.String~~</code>~~ instance created an inverse statement would be added <code>(L0.String, L0.HasInstance, :L0.String)</code> statement into the database, thereby enlarging the degree of statements of ~~<code>~~L0.String~~</code>~~. When working with larger databases this would most likely become a problem.		an inverse statement <code>(o, inv(p), s)</code> will be automatically claimed into the database. Some statements are such that they tend to raise the degree of the resource (amount of incoming/outgoing relations) to very large numbers. The database is not built to efficiently handle such resources. One such relation is ''InstanceOf'' which is a statement that pretty much each and every resource in the database has. It does not have an inverse relation, but considering it had one like ''HasInstance'', here's what would happen. For example, for each ''L0.String'' instance created an inverse statement would be added <code>(L0.String, L0.HasInstance, :L0.String)</code> statement into the database, thereby enlarging the degree of statements of ''L0.String''. When working with larger databases this would most likely become a problem.

	To make it possible to optimize this situation we provide the possibility to skip adding of inverse relations when claiming statements into the database by using		To make it possible to optimize this situation we provide the possibility to skip adding of inverse relations when claiming statements into the database by using
	WriteGraph.claim(Resource subject, Resource predicate, Resource inverse, Resource object)		WriteGraph.claim(Resource subject, Resource predicate, Resource inverse, Resource object)
	with a <code>null</code> inverse relation argument to create the sensitive statements such as InstanceOf-relations.		with a <code>null</code> inverse relation argument to create the sensitive statements such as ''InstanceOf''-relations.

Tuukka Lehtonen at 12:39, 29 September 2010

2010-09-29T12:39:22Z

← Older revision		Revision as of 12:39, 29 September 2010
Line 1:		Line 1:
	According to [[Layer0_ontology\|Layer0]] semantics, relations <em>can</em> have inverse relations. For the database and client this means that when claiming new statements <code>(s, p, o)</code> using		According to [[Layer0_ontology\|Layer0]] semantics, relations <em>can</em> have inverse relations. For the database and client this means that when claiming new statements <code>(s, p, o)</code> using
	WriteGraph.claim(Resource subject, Resource predicate, Resource object)		WriteGraph.claim(Resource subject, Resource predicate, Resource object)
	an inverse statement <code>(o, inv(p), s)</code> will be automatically claimed into the database. Some statements are such that they tend to raise the degree of the resource (amount of incoming/outgoing relations) to very large numbers. The database is not built to efficiently handle such resources. One such relation~~/inverse relation pair~~ is <code>InstanceOf~~/HasInstance~~</code> which is a statement that pretty much each and every resource in the database has. For example, for each <code>L0.String</code> instance created ~~will add a new~~ <code>(L0.String, L0.HasInstance, :L0.String)</code> statement into the database, thereby enlarging the degree of <code>L0.String</code>. When working with larger databases this ~~will~~ most likely become a problem.		an inverse statement <code>(o, inv(p), s)</code> will be automatically claimed into the database. Some statements are such that they tend to raise the degree of the resource (amount of incoming/outgoing relations) to very large numbers. The database is not built to efficiently handle such resources. One such relation is <code>InstanceOf</code> which is a statement that pretty much each and every resource in the database has. It does not have an inverse relation, but considering it had one, here's what would happen. For example, for each <code>L0.String</code> instance created an inverse statement would be added <code>(L0.String, L0.HasInstance, :L0.String)</code> statement into the database, thereby enlarging the degree of statements of <code>L0.String</code>. When working with larger databases this would most likely become a problem.

	To make it possible to optimize this situation we provide the possibility to skip adding of inverse relations when claiming statements into the database by using		To make it possible to optimize this situation we provide the possibility to skip adding of inverse relations when claiming statements into the database by using
	WriteGraph.claim(Resource subject, Resource predicate, Resource inverse, Resource object)		WriteGraph.claim(Resource subject, Resource predicate, Resource inverse, Resource object)
	with a <code>null</code> inverse relation argument to create the sensitive statements such as InstanceOf-relations.		with a <code>null</code> inverse relation argument to create the sensitive statements such as InstanceOf-relations.

Toni Kalajainen: Created page with 'According to Layer0 semantics, relations can have inverse relations. For the database and client this means that when claiming new statements `(...'`


2010-09-29T11:19:10Z
Created page with 'According to Layer0 semantics, relations <em>can</em> have inverse relations. For the database and client this means that when claiming new statements <code>(...'
New page
According to [[Layer0_ontology|Layer0]] semantics, relations <em>can</em> have inverse relations. For the database and client this means that when claiming new statements <code>(s, p, o)</code> using

 WriteGraph.claim(Resource subject, Resource predicate, Resource object)

an inverse statement <code>(o, inv(p), s)</code> will be automatically claimed into the database. Some statements are such that they tend to raise the degree of the resource (amount of incoming/outgoing relations) to very large numbers. The database is not built to efficiently handle such resources. One such relation/inverse relation pair is <code>InstanceOf/HasInstance</code> which is a statement that pretty much each and every resource in the database has. For example, for each <code>L0.String</code> instance created will add a new <code>(L0.String, L0.HasInstance, :L0.String)</code> statement into the database, thereby enlarging the degree of <code>L0.String</code>. When working with larger databases this will most likely become a problem.



To make it possible to optimize this situation we provide the possibility to skip adding of inverse relations when claiming statements into the database by using

 WriteGraph.claim(Resource subject, Resource predicate, Resource inverse, Resource object)

with a <code>null</code> inverse relation argument to create the sensitive statements such as InstanceOf-relations.

Inverse Relations - Revision history

Juha Kortelainen at 15:55, 28 January 2011

Tuukka Lehtonen at 16:39, 7 October 2010

Tuukka Lehtonen at 12:41, 29 September 2010

Tuukka Lehtonen at 12:40, 29 September 2010

Tuukka Lehtonen at 12:39, 29 September 2010

Toni Kalajainen: Created page with 'According to Layer0 semantics, relations can have inverse relations. For the database and client this means that when claiming new statements (...'

Toni Kalajainen: Created page with 'According to Layer0 semantics, relations can have inverse relations. For the database and client this means that when claiming new statements `(...'`