[Neo] meta meta classes

Mattias Persson mattias at neotechnology.com
Thu Apr 15 11:59:57 CEST 2010


It seems good to use another key for indexing that, although the
implementation of LuceneIndexService creates a folder in the file system for
each key so maybe we should avoid chars such as ':' and '/' in keys... maybe
just a "_metamodel_" prefix or something instead... I'm not sure what's best
there.

2010/4/14 Niels Hoogeveen <pd_aficionado at hotmail.com>

>
> Thanks for the confidence, Mattias.
>
> I will take a stab at implementing the features I described so far.
>
> There is one more or less open issue, I'd like to tackle while making the
> other changes. That issue is the unicity of MetaModelObjects. We could
> settle on the simplest solution, and create a unique index on the current
> "name" property. Names should always be a full path, even when used with
> namespaces other than GlobalNamespace. No splitting and gluing, no short
> names.
>
> I'd like to support this by adding index setting to MetaModelProperty with
> three options (NO_INDEX (default), INDEXED, UNIQUELY_INDEXED).
>
> Having MetaModelMetaClasses, we can create a MetaModelProperty "name" give
> it index setting UNIQUELY_INDEXED and associate this MetaModelProperty with
> all Nameable MetaModelMetaClasses. Of course MetaModelObject still has to
> implement that functionality, but at least it's described at a higher meta
> level.
>
> Remains the issue with the key of the "name" property. I think "name" is
> not a good key for that property. There may be users of Neo4J who want to
> use that key for entirely different purposes. I suggest we rename the key of
> the name property into "http://neo4j.org/meta#name", and use that same
> naming convention for range_implementation_class, range_specification and
> data_range, changing those in:
>
> http://neo4j.org/meta#range_implementation_class
> http://neo4j.org/meta#range_specification
> http://neo4j.org/meta#data_range
>
> Prepending all property keys and relationships names of the meta model with
> "http://neo4j.org/meta#" guarantees that no naming conflicts can ever
> exist, unless users deliberately define their own properties using keys
> starting with "http://neo4j.org/meta#".
>
> Niels
>
>
> > Date: Wed, 14 Apr 2010 17:03:31 +0200
> > From: mattias at neotechnology.com
> > To: user at lists.neo4j.org
> > Subject: Re: [Neo] meta meta classes
> >
> > I'd say go for it! You seem to have a quite complete view of what needs
> to
> > be done with the meta model to get it really useable and I'd be happy to
> see
> > all this implemented.
> >
> > 2010/4/13 Niels Hoogeveen <pd_aficionado at hotmail.com>
> >
> > >
> > > Before adding the features described so far, let's discuss the issue of
> a
> > > MetaModelMetaClass.
> > >
> > > This entire discussion started with an example of an HTML tag library,
> > > where the need arose to add properties to classes. At the time I
> suggested,
> > > and described, a reification method, that created a MetaModelClass in a
> > > different namespace, that allowed for the modeling of a particular
> > > MetaModelClass.
> > >
> > > That solution is more or less correct, except, the reify method
> shouldn't
> > > return a MetaModelClass, whose single instance is the node of another
> > > MetaModelClass. The proper solution to that issue, requires a
> > > MetaModelMetaClass, whose instance is a MetaModelClass.
> > >
> > > Adding a MetaModelMetaClass to the meta model makes sense, what is a
> meta
> > > model, without having meta classes? UML/MOF recognizes instances,
> classes
> > > and meta classes as well.
> > >
> > > Having meta classes also makes it possible to model the meta model
> itself.
> > > Instead of having "magic" properties and "special" relationships, used
> in
> > > the meta model component, these entities can become ordinary citizens
> of the
> > > meta model.
> > >
> > > Introducing meta classes creates one "magic" property "meta_name" and
> one
> > > "special" relationships of its own "META_META_IS_SUBCLASS_OF" (from
> > > MetaModelMetaClass to MetaModelMetaClass), so the question may arise,
> why
> > > treat those three entities as special?
> > >
> > > The answer to that is quite simple. If we would want to treat that
> "magic"
> > > property and "special" relationship as ordinary citizens, we'd have to
> > > create a MetaModelMetaMetaClass, but that meta meta class would be
> > > strikingly uninteresting, since it would be the sole entity on that
> meta
> > > level, only stating that MetaModelMetaClasses has a "meta_name" and can
> have
> > > subclasses.
> > >
> > > So while theoretically a meta model class consists of 4 layers, for all
> > > practical purposes we need 3: instance, class, meta class.
> > >
> > > Instances are described by classes, while classes are described by meta
> > > classes.
> > >
> > > Assuming a split between MetaModelProperties and MetaModelRelationship
> > > as proposed before, I will use the following abbreviations from now on:
> > >
> > > PP = MetaModelProperty
> > > RS = MetaModelRelationship
> > > CL = MetaModelClass
> > > MC = MetaModelMetaClass
> > > PR = MetaModePropertyRestriction
> > > RR = MetaModelRelationshipRestriction
> > > NS = MetaModelNamespace
> > >
> > > The meta model would have the following default entities:
> > >
> > > PP:
> > >
> > > name - (applies to all entities except the global namespace, and the
> > > MetaModelMetaClassRoot)
> > > range_implementation_class - (applies to PP, RS, PR and RR)
> > > range_specification - (applies to PP and PR)
> > > data_range - (applies to PP and PR)
> > >
> > > RS:
> > >
> > > META_META_IS_INSTANCE_OF (CL --> MC)
> > > META_META_IS_SUBCLASS_OF (MC --> MC)
> > >
> > > META_CLASS  (NS --> CL)
> > > META_CLASS_HAS_PROPERTY (CL --> PP)
> > > META_HAS_INSTANCE (CL --> Node)  //Reversed the relationship, because
> node
> > > is not part of the meta model
> > > META_IS_INVERSE_OF (PP --> PP)
> > > META_IS_SUBCLASS_OF (CL --> CL)
> > > META_IS_SUBPROPERTY_OF (PP --> PP)
> > > META_NAMESPACE (GlobalNamespace --> NameableNamespace)
> > > META_PROPERTY (NS --> PP)
> > > META_RELATIONSHIP_HAS_RANGE (PP --> CL)
> > > META_RESTRICTION_TO_CLASS (PR or RR --> CL)
> > > META_RESTRICTION_TO_PROPERTY (PR --> PP)
> > > META_RESTRICTION_TO_RELATIONSHIP (RR --> RS)
> > > META_SUBREF_TO_REF(GlobalNamespace --> Reference node) //Reversed the
> > > relationship, because reference node is not part of the meta model
> > >
> > > MC:
> > >
> > > MetaModelMetaClassRoot (takes no direct instances and is the root of
> all
> > > MC's)
> > > Nameable (takes no direct instances, and is the root of all nameable
> meta
> > > object, is subclass of MetaModelMetaClassRoot)
> > > NS (takes no direct instances, and is the root of all namespaces, is
> > > subclass of MetaModelMetaClassRoot)
> > >
> > > GlobalNamespace (has one instance, denoting the global namespace, is
> > > subclass of Namespace)
> > > NameableNamespace (is subclass of Namespace and is subclass of
> Nameable)
> > >
> > > MC (is subclass of Nameable)
> > > PP (is subclass of Nameable)
> > > RS (is subclass of Nameable)
> > > PR (is subclass of Nameable)
> > > RR (is subclass of Nameable)
> > >
> > > MC's live in the global namespace, since we only want to have one meta
> > > layer in the database.
> > >
> > > With all this in place, it becomes trivial to implement a "taggable"
> class,
> > > like the HTML tag library example.
> > >
> > > Create PP "tagname" with datatype "String"
> > > Create MC "taggable"
> > > Make PP "tagname" a property of MC "taggable"
> > > Create CL "taggable"
> > > Make CL "taggable" a direct instance of MC "taggable"
> > >
> > >
> > > Now each CL "taggable" will have a PP "tagname", which can be set for
> each
> > > CL "taggable", and which can be seen as a constant for each instance of
> a
> > > subclass of CL "taggable". E.g.  CL "div" is a subclass of CL
> "taggable"
> > > with "tagname" = "div" and PP's "id", "class", "dir", "lang", "style".
> Each
> > > instance of "div" can have different values for "id", "class", "dir",
> "lang"
> > > and "style", but the tagname will be "div" for each instance, since
> that is
> > > defined at the class level.
> > >
> > > Kind regards,
> > > Niels Hoogeveen
> > >
> > > > Date: Mon, 12 Apr 2010 09:28:53 +0200
> > > > From: mattias at neotechnology.com
> > > > To: user at lists.neo4j.org
> > > > Subject: Re: [Neo] meta meta classes
> > > >
> > > > Your thoughts and finding makes a lot of sense and I too would be
> happy
> > > to
> > > > see those features in the meta model.
> > > >
> > > > 2010/4/11 Niels Hoogeveen <pd_aficionado at hotmail.com>
> > > >
> > > > >
> > > > >
> > > > >
> > > > >
> > > > >
> > > > >
> > > > > I would be very happy when this functionally is implemented. Let's
> see
> > > who
> > > > > gets to this first. At the moment I am working on implementing meta
> > > model
> > > > > path expressions that can be used in a traverser, so it may take a
> > > couple of
> > > > > days for me to take a stab at building the instance restriction
> > > > > functionality.
> > > > >
> > > > > I do have another issue with the current implementation. I don't
> think
> > > it's
> > > > > a good idea to treat relationships and properties on the same
> footing.
> > > There
> > > > > may be common functionality, but that doesn't make a property the
> same
> > > as a
> > > > > relationship.
> > > > >
> > > > > I think it would be better to have interfaces PropertyRange and
> > > > > RelationshipRange, and having classes MetaModelProperty and
> > > > > MetaModelRelationship. Treating properties and relationships as
> equal,
> > > > > restricts the modelability of a Neo4J graph.
> > > > >
> > > > > As it stands, it is impossible to model the properties of a
> > > Relationship.
> > > > > Within the current design it is not possible to add that
> functionality,
> > > > > because it would mean the ability to set MetaModelProperties for
> > > > >  MetaModelProperties. This would be correct for MetaModelProperties
> > > that
> > > > > denote relationships, but not for MetaModelProperties that denote
> > > > > properties.
> > > > >
> > > > > For my own project, I also run into problems that MetaModelProperty
> is
> > > not
> > > > > specific enough. I'd like to describe paths by means of their meta
> > > model
> > > > > entities. A path would take a form like this:
> > > > >
> > > > > MetaModelClass("some class name") --> RelationshipType("some
> > > relationship
> > > > > type name") --> MetaModelClass("some other class name") -->
> > > > > MetaModelProperty("some property name")
> > > > >
> > > > > There are two problems here. First of all, I need to use
> > > RelationshipType
> > > > > as a means to denote a relation. RelationshipType is not part of
> the
> > > meta
> > > > > model, and as a result has no cardinality information. Without
> unique
> > > names
> > > > > for PropertyTypes it is impossible to look up the MetaModelProperty
> a
> > > > > RelationshipType is related to, since there can be several
> > > > > MetaModelProperties with the same name. Even if such a lookup were
> > > possible,
> > > > > it is still a clumsy solution. It would be much nicer to be able to
> > > have a
> > > > > class MetaModelRelationship which denotes a relationship, and which
> has
> > > > > cardinality and range methods.
> > > > >
> > > > > Another issue is that I'd like to be able to state that the final
> > > element
> > > > > in a path is a property of some type. In the end, programs interact
> > > with
> > > > > users and other programs through values, not through objects. So
> most
> > > of the
> > > > > paths I would like to describe, will end with something that
> denotes a
> > > > > property value. Using MetaModelProperty for this purpose, doesn't
> work,
> > > > > because MetaModelProperty can denote both a property and a
> > > relationship.
> > > > >
> > > > > So I think we need three main types of ranges:
> > > > >
> > > > > InstanceRange
> > > > > ClassRanges
> > > > > PropertyRanges
> > > > >
> > > > > Each MetaModelRestrictable now takes a combination of the last two
> > > ranges,
> > > > > and, in my opinion, those should be separated:
> > > > >
> > > > > MetaModelProperty (takes PropertyRange and has cardinality methods)
> > > > > MetaModelRelationship (takes ClassRange or InstanceRange* and has
> > > > > cardinality methods)
> > > > > MetaModelClass (takes InstanceRange and has cardinality methods)
> > > > >
> > > > > *An InstanceRange on MetaModelRelationship means that each instance
> of
> > > a
> > > > > class can only have a particular relationship with certain
> instances. A
> > > > > class range on MetaModelRelationship means that each instance of a
> > > class can
> > > > > only have a particular relationship with instances of a certain
> > > classes.
> > > > >
> > > > >
> > > > > MetaModelClass will additionally have:
> > > > >
> > > > > getAllInstances()
> > > > > getDirectInstances()
> > > > > getAllPropertyTypes()
> > > > > getDirectPropertyTypes()
> > > > > getAllRelationshipsTypes()
> > > > > getDirectRelationshipsTypes()
> > > > > getPropertyRestriction(MetaModelProperty, boolean) returns
> > > > > MetaModelPropertyRestriction
> > > > > getRelationshipRestriction(MetaModelRelationship, boolean) returns
> > > > > MetaModelRelationshipRestriction
> > > > >
> > > > > MetaModelRelationship will additionally have:
> > > > >
> > > > > getAllPropertyTypes()
> > > > >
> > > > > getDirectPropertyTypes()
> > > > > getPropertyRestriction(MetaModelProperty, boolean) returns
> > > > > MetaModelPropertyRestriction
> > > > >
> > > > >
> > > > > MetaModelProperty needs no additional methods not already covered
> in
> > > the
> > > > > current implementation.
> > > > >
> > > > > Kind regards,
> > > > > Niels Hoogeveen
> > > > >
> > > > > P.S. I think it should be smart to introduce one more entity
> > > > > MetaModelMetaClass, which I will write about later.
> > > > >
> > > > >
> > > > >
> > > > > > Date: Fri, 9 Apr 2010 13:36:12 +0200
> > > > > > From: mattias at neotechnology.com
> > > > > > To: user at lists.neo4j.org
> > > > > > Subject: Re: [Neo] meta meta classes
> > > > > >
> > > > > > Now we're getting somewhere... I like this solution a lot, thanks
> for
> > > the
> > > > > > great idea. Let me see if I get time to try and implement it
> soon! Or
> > > if
> > > > > you
> > > > > > get to if before me and supply a patch. It's nice either way :)
> > > > > >
> > > > > > 2010/4/9 Niels Hoogeveen <pd_aficionado at hotmail.com>
> > > > > >
> > > > > > >
> > > > > > > Having thought about implementation a little bit more, it would
> be
> > > neat
> > > > > to
> > > > > > > have MetaModelClass implement an interface similar to
> > > > > MetaModelRestrictable,
> > > > > > > with one difference, the setRange and getRange don't refer to a
> > > > > > > PropertyRange but to an InstanceRange.
> > > > > > >
> > > > > > > Like PropertyRange, InstanceRange should be an abstract class
> so
> > > > > several
> > > > > > > different different implementations of InstanceRanges can be
> > > provided:
> > > > > > >
> > > > > > > * InstanceEnumerationRange (enumerates the n instances the
> class
> > > > > contains
> > > > > > > and sets minCardinality = maxCardinality = n )
> > > > > > > * IndexedInstanceRange (indexes the n instances it contains and
> > > sets
> > > > > > > minCardinality = maxCardinality = n, making the class into an
> > > Instance
> > > > > > > array)
> > > > > > > * NullInstanceRange (set minCardinality = maxCardinality = 0,
> > > making
> > > > > the
> > > > > > > class abstract)
> > > > > > > * InstanceClassesRange (states that the instances of a class
> have
> > > to be
> > > > > > > instances of one of a given set of classes)
> > > > > > >
> > > > > > > The first three range types restrict the MetaModelClass to
> having
> > > no
> > > > > > > getDirectInstances.add functionality, and also the setting of
> > > > > cardinality
> > > > > > > should be disabled, which makes me wonder if we need a class
> > > > > > > FixedMetaModelClass, which simply doesn't provide these
> methods, or
> > > if
> > > > > we
> > > > > > > should throw exceptions when methods are inappropriately
> called, or
> > > if
> > > > > we
> > > > > > > allow inconsistent data like the rest of the meta model does.
> > > > > > >
> > > > > > >
> > > > > > > > From: pd_aficionado at hotmail.com
> > > > > > > > To: user at lists.neo4j.org
> > > > > > > > Date: Thu, 8 Apr 2010 23:52:02 +0200
> > > > > > > > Subject: Re: [Neo] meta meta classes
> > > > > > > >
> > > > > > > >
> > > > > > > > I think the best solution here is to have an instance
> enumeration
> > > on
> > > > > > > MetaModelClass. Singletons are special case of an enumeration.
> > > > > > > >
> > > > > > > > See:
> > > > > > > > http://www.w3.org/TR/2002/WD-owl-ref-20021112/#Enumerated
> > > > > > > >
> > > > > > >
> > > > >
> > >
> http://owl.cs.manchester.ac.uk/2007/05/api/javadoc/org/semanticweb/owl/model/OWLObjectOneOf.html
> > > > > > > >
> > > > > > > >
> > > > > > > >
> > > > > > > > > Date: Thu, 8 Apr 2010 22:33:11 +0200
> > > > > > > > > From: mattias at neotechnology.com
> > > > > > > > > To: user at lists.neo4j.org
> > > > > > > > > Subject: Re: [Neo] meta meta classes
> > > > > > > > >
> > > > > > > > > Ok now I get your point! Thank you for clarifying.
> > > > > > > > >
> > > > > > > > > Your singleton proposal could be a good idea then. Could it
> > > > > > > > > potentially be a hindrance in some scenario? I mean should
> we
> > > have
> > > > > a
> > > > > > > > > MetaModelClass#setSingleton(boolean) or something so that
> this
> > > > > > > > > behaviour can be controlled?
> > > > > > > > >
> > > > > > > > > 2010/4/8, Niels Hoogeveen <pd_aficionado at hotmail.com>:
> > > > > > > > > >
> > > > > > > > > > Each country needs to be modeled as classes, because I
> want
> > > to
> > > > > set
> > > > > > > the
> > > > > > > > > > restriction that French regions (which can have different
> > > > > properties
> > > > > > > from
> > > > > > > > > > Canadian provinces) can only have a relationship with the
> > > country
> > > > > > > France,
> > > > > > > > > > and Canadian provinces can only have a relationship with
> the
> > > > > country
> > > > > > > Canada.
> > > > > > > > > > The domain and the range of a PropertyType are classes
> not
> > > > > instances.
> > > > > > > If
> > > > > > > > > > countries were simply instances of the  "country" class,
> it
> > > would
> > > > > be
> > > > > > > > > > possible to say that an instance of a Canadian province
> is a
> > > > > > > subdivision of
> > > > > > > > > > France.
> > > > > > > > > >
> > > > > > > > > > I'd like to be able to iterate over the subdivision of
> France
> > > and
> > > > > > > have
> > > > > > > > > > guaranteed that each instance has the property "region
> code",
> > > a
> > > > > > > property
> > > > > > > > > > unknown to Canadian provinces. Without having a
> restriction
> > > > > stating
> > > > > > > that a
> > > > > > > > > > specific sub-division belongs to a specific country, any
> > > > > sub-division
> > > > > > > can be
> > > > > > > > > > related to any country, so a user may erroneously say
> that
> > > > > Alberta is
> > > > > > > a
> > > > > > > > > > French region. Not only is this factually incorrect, but
> > > > > structurally
> > > > > > > too.
> > > > > > > > > > Alberta, being a Canadian province, doesn't have the
> "region
> > > > > code"
> > > > > > > property,
> > > > > > > > > > which I want French regions to have.
> > > > > > > > > >
> > > > > > > > > >
> > > > > > > > > >> Date: Thu, 8 Apr 2010 20:06:32 +0200
> > > > > > > > > >> From: mattias at neotechnology.com
> > > > > > > > > >> To: user at lists.neo4j.org
> > > > > > > > > >> Subject: Re: [Neo] meta meta classes
> > > > > > > > > >>
> > > > > > > > > >> 2010/4/8 Niels Hoogeveen <pd_aficionado at hotmail.com>
> > > > > > > > > >>
> > > > > > > > > >> >
> > > > > > > > > >> > Your point about the cardinality restriction is a
> correct
> > > > > > > observation.
> > > > > > > > > >> >
> > > > > > > > > >> > In fact it would be better to create a
> "is-subdivision-of"
> > > > > > > PropertyType
> > > > > > > > > >> > on
> > > > > > > > > >> > "sub-division" and give that a range "country" with a
> > > > > cardinality
> > > > > > > of 1.
> > > > > > > > > >> > Then
> > > > > > > > > >> > for each subclass of "sub-division" a restriction
> should
> > > be
> > > > > set,
> > > > > > > naming
> > > > > > > > > >> > the
> > > > > > > > > >> > "country" class this specific "sub-division" class
> applies
> > > to.
> > > > > > > > > >> >
> > > > > > > > > >> > Still, it requires  each country to be defined as both
> a
> > > class
> > > > > and
> > > > > > > an
> > > > > > > > > >> > instance.
> > > > > > > > > >> >
> > > > > > > > > >> Why just countries as classes? why not each subdivision
> as
> > > > > classes
> > > > > > > as
> > > > > > > > > >> well?
> > > > > > > > > >> Why countries as classes at all?
> > > > > > > > > >>
> > > > > > > > > >> >
> > > > > > > > > >> > > Date: Thu, 8 Apr 2010 19:15:30 +0200
> > > > > > > > > >> > > From: mattias at neotechnology.com
> > > > > > > > > >> > > To: user at lists.neo4j.org
> > > > > > > > > >> > > Subject: Re: [Neo] meta meta classes
> > > > > > > > > >> > >
> > > > > > > > > >> > > So, you describe the model (with "country",
> > > "sub-division"
> > > > > and
> > > > > > > > > >> > > "has-sub-division") which is OK! Then you not just
> want
> > > to
> > > > > add
> > > > > > > data
> > > > > > > > > >> > > which
> > > > > > > > > >> > > would conform to it, you also describe the highest
> level
> > > of
> > > > > that
> > > > > > > data
> > > > > > > > > >> > > in
> > > > > > > > > >> > the
> > > > > > > > > >> > > meta model itself with cardinality for how many
> > > > > sub-divisions
> > > > > > > each
> > > > > > > > > >> > > such
> > > > > > > > > >> > > level must contain.
> > > > > > > > > >> > >
> > > > > > > > > >> > > My first though here is: why put actual data into
> the
> > > meta
> > > > > model
> > > > > > > (the
> > > > > > > > > >> > design
> > > > > > > > > >> > > isn't intended for that)?
> > > > > > > > > >> > > The second is: why (since you put actual data into
> the
> > > meta
> > > > > > > model)
> > > > > > > > > >> > > would
> > > > > > > > > >> > you
> > > > > > > > > >> > > stop there? why only say that "France" have 10
> > > subdivisions?
> > > > > You
> > > > > > > don't
> > > > > > > > > >> > say
> > > > > > > > > >> > > exactly which subdivisions or how many/which
> > > subdivisions
> > > > > each
> > > > > > > > > >> > subdivision
> > > > > > > > > >> > > has, a.s.o. Which benefits would modeling only the
> > > highest
> > > > > level
> > > > > > > of
> > > > > > > > > >> > > data
> > > > > > > > > >> > get
> > > > > > > > > >> > > you? And if you could describe the entire data in
> the
> > > meta
> > > > > > > model, you
> > > > > > > > > >> > > end
> > > > > > > > > >> > up
> > > > > > > > > >> > > with a meta model which describes the entire data
> and
> > > then,
> > > > > in
> > > > > > > > > >> > > addition,
> > > > > > > > > >> > the
> > > > > > > > > >> > > data which is exactly the same as the meta model...
> what
> > > > > > > benefits does
> > > > > > > > > >> > that
> > > > > > > > > >> > > give you?
> > > > > > > > > >> > >
> > > > > > > > > >> > > I'm just confused about the fact that you want to
> have
> > > the
> > > > > meta
> > > > > > > model
> > > > > > > > > >> > > (classes, properties, restrictions) and (some of)
> the
> > > actual
> > > > > > > data
> > > > > > > > > >> > > modeled
> > > > > > > > > >> > in
> > > > > > > > > >> > > the meta model, whereas the meta model was intended
> to
> > > model
> > > > > the
> > > > > > > meta
> > > > > > > > > >> > model
> > > > > > > > > >> > > (the UML diagram, so to speak) and not the actual
> data
> > > it
> > > > > would
> > > > > > > have
> > > > > > > > > >> > conform
> > > > > > > > > >> > > to it.
> > > > > > > > > >> > >
> > > > > > > > > >> > > Help me understand which benefits you're after by
> > > modeling
> > > > > the
> > > > > > > "top
> > > > > > > > > >> > level"
> > > > > > > > > >> > > of your actual data into the meta model itself.
> > > > > > > > > >> > >
> > > > > > > > > >> > >
> > > > > > > > > >> > > Best,
> > > > > > > > > >> > > Mattias
> > > > > > > > > >> > >
> > > > > > > > > >> > > 2010/4/8 Niels Hoogeveen <pd_aficionado at hotmail.com
> >
> > > > > > > > > >> > >
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > The example of the tag library and
> > > countries/sub-divisions
> > > > > are
> > > > > > > not
> > > > > > > > > >> > > > necessarily similar. The first shows the need to
> model
> > > the
> > > > > > > > > >> > > > properties
> > > > > > > > > >> > of a
> > > > > > > > > >> > > > class.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > The second example shows the need to have
> singleton
> > > > > classes,
> > > > > > > which
> > > > > > > > > >> > > > is a
> > > > > > > > > >> > > > different concept, and something that cannot be
> done
> > > out
> > > > > of
> > > > > > > the box,
> > > > > > > > > >> > but I
> > > > > > > > > >> > > > will show a solution that requires minimal
> > > modifications
> > > > > to
> > > > > > > the
> > > > > > > > > >> > > > current
> > > > > > > > > >> > > > software.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > Suppose we want to model "countries" and their
> > > > > > > "sub-divisions".
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > We do the following:
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > create class "country"
> > > > > > > > > >> > > > create class "sub-division"
> > > > > > > > > >> > > > create property "has-sub-division"
> > > > > > > > > >> > > > make "has-subdivision" a property of "country"
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > Now we like to populate the database, since all
> > > countries
> > > > > have
> > > > > > > > > >> > different
> > > > > > > > > >> > > > types of sub-divisions we need to create those:
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > create class "french_region"
> > > > > > > > > >> > > > create class "canadian_province"
> > > > > > > > > >> > > > create class "canadian_territory"
> > > > > > > > > >> > > > create class "US_state"
> > > > > > > > > >> > > > etc.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > Populate the various classes with instances:
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > create node for "Alsace" and make it an instance
> of
> > > > > > > "french_region"
> > > > > > > > > >> > > > create node for "Aquitaine" and make it an
> instance of
> > > > > > > > > >> > > > "french_region"
> > > > > > > > > >> > > > create node for "Alberta" and make it an instance
> of
> > > > > > > > > >> > > > "Canadian_province"
> > > > > > > > > >> > > > create node for "Nanavut" and make it an instance
> of
> > > > > > > > > >> > > > "Canadian_territory"
> > > > > > > > > >> > > > create node for "British Columbia" and make it an
> > > instance
> > > > > of
> > > > > > > > > >> > > > "Canadian_province"
> > > > > > > > > >> > > > create node for "Alabama" and make it an instance
> of
> > > > > > > > > >> > > > "US_State"
> > > > > > > > > >> > > > create node for "Alaska" and make it an instance
> of
> > > > > > > > > >> > > > "US_State"
> > > > > > > > > >> > > > etc.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > We'd like to state that each country has its own
> > > > > restriction
> > > > > > > on the
> > > > > > > > > >> > type of
> > > > > > > > > >> > > > subdivision. To do that we need to create classes
> for
> > > each
> > > > > > > country.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > create class "France"
> > > > > > > > > >> > > > create class "Canada"
> > > > > > > > > >> > > > create class "United_States_of_America"
> > > > > > > > > >> > > > etc.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > make class "France" a subclass of "Country"
> > > > > > > > > >> > > > make class "Canada" a subclass of "Country"
> > > > > > > > > >> > > > make class "United_States_of_America" a subclass
> of
> > > > > "Country"
> > > > > > > > > >> > > > etc.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > create restriction for "France" on
> "has-sub-division"
> > > with
> > > > > > > range
> > > > > > > > > >> > > > "french_province" and cardinality = 26
> > > > > > > > > >> > > > create restriction for "Canada" on
> "has-sub-division"
> > > with
> > > > > > > range
> > > > > > > > > >> > > > "canadian_province" and cardinality = 10
> > > > > > > > > >> > > > create restriction for "Canada" on
> "has-sub-division"
> > > with
> > > > > > > range
> > > > > > > > > >> > > > "canadian_territory" and cardinality = 3
> > > > > > > > > >> > > > create restriction for "United_States_of_America"
> on
> > > > > > > > > >> > > > "has-sub-division"
> > > > > > > > > >> > > > with range "US_State" and cardinality = 50
> > > > > > > > > >> > > > etc.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > Now we have classes for each country, but no
> > > instances.
> > > > > > > > > >> > > > Unfortunately
> > > > > > > > > >> > we
> > > > > > > > > >> > > > cannot say that a class is an instance of itself,
> that
> > > > > would
> > > > > > > require
> > > > > > > > > >> > > > a
> > > > > > > > > >> > > > relationsship where the endnode equals the
> startnode,
> > > > > which
> > > > > > > Neo4J
> > > > > > > > > >> > doesn't
> > > > > > > > > >> > > > allow. So we have to create separate instances for
> > > each
> > > > > > > country.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > create node for "France"
> > > > > > > > > >> > > > create node for "Canada"
> > > > > > > > > >> > > > create node for "United_States_Of_America"
> > > > > > > > > >> > > > etc.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > make node "France" an instance of class "France"
> > > > > > > > > >> > > > make node "Canada" an instance of class "Canada"
> > > > > > > > > >> > > > make node "United_States_of_America" an instance
> of
> > > class
> > > > > > > > > >> > > > "United_States_of_America"
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > And finally link the subdivisions to their
> countries:
> > > > > > > > > >> > > >
> > > > > > > > > >> > > >  "France" "has-sub-division" "Alsace"
> > > > > > > > > >> > > > "France" "has-sub-division" "Aquitaine"
> > > > > > > > > >> > > > "Canada" "has-sub-division-of" "Alberta"
> > > > > > > > > >> > > > "Canada" "has-subdivision" "British Columbia"
> > > > > > > > > >> > > > "Canada" "has-subdivision" "Nanavut"
> > > > > > > > > >> > > > "United_States_of_America" "has-sub-division"
> > > "Alabama"
> > > > > > > > > >> > > > "United_States_of_America" "has-sub-division"
> "Alaska"
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > So we end up having a class for each country and
> an
> > > > > instance
> > > > > > > for
> > > > > > > > > >> > > > each
> > > > > > > > > >> > > > country.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > Writing this down, I realize the patch I sent you
> a
> > > few
> > > > > days
> > > > > > > ago,
> > > > > > > > > >> > contains
> > > > > > > > > >> > > > a minor flaw, that needs to be fixed. In that
> patch I
> > > > > added an
> > > > > > > > > >> > > > indexed
> > > > > > > > > >> > > > property "uri" to the meta model, to bring it in
> line
> > > with
> > > > > > > what is
> > > > > > > > > >> > being
> > > > > > > > > >> > > > done in the RDF module, and to make certain that
> the
> > > same
> > > > > URI
> > > > > > > is not
> > > > > > > > > >> > used
> > > > > > > > > >> > > > for two different properties. Without unicity a
> class
> > > can
> > > > > have
> > > > > > > > > >> > > > several
> > > > > > > > > >> > > > different ProperyTypes with the same name. In that
> > > > > situation
> > > > > > > the
> > > > > > > > > >> > > > lookup
> > > > > > > > > >> > of
> > > > > > > > > >> > > > the PropertyType of a property or relationship
> becomes
> > > > > > > impossible.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > The flaw in my patch is the name of the "uri"
> > > property,
> > > > > which
> > > > > > > should
> > > > > > > > > >> > > > be
> > > > > > > > > >> > > > something like "class_uri". That way the class of
> each
> > > > > country
> > > > > > > can
> > > > > > > > > >> > > > be
> > > > > > > > > >> > given
> > > > > > > > > >> > > > the same URI as the instance of each country,
> because
> > > they
> > > > > > > live in
> > > > > > > > > >> > different
> > > > > > > > > >> > > > name spaces.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > This same technique is used in OWL to provide
> > > "punning".
> > > > > An
> > > > > > > instance
> > > > > > > > > >> > and a
> > > > > > > > > >> > > > class can have the same URI, because instances in
> OWL
> > > live
> > > > > in
> > > > > > > a
> > > > > > > > > >> > different
> > > > > > > > > >> > > > namespaces from classes.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > Through the use of the "uri" property and the
> > > "class_uri"
> > > > > > > property
> > > > > > > > > >> > > > we
> > > > > > > > > >> > can
> > > > > > > > > >> > > > also distill that each country class is a
> singleton
> > > class,
> > > > > > > because
> > > > > > > > > >> > there
> > > > > > > > > >> > > > exists an instance with the same URI. That way we
> can
> > > work
> > > > > > > around
> > > > > > > > > >> > > > the
> > > > > > > > > >> > > > limitation that relationships cannot have the same
> > > start
> > > > > and
> > > > > > > end
> > > > > > > > > >> > > > node.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > Furthermore, it allows for some extra restrictions
> to
> > > > > > > MetaModelClass
> > > > > > > > > >> > with
> > > > > > > > > >> > > > the following logic: If a class has exactly one
> > > instance
> > > > > where
> > > > > > > the
> > > > > > > > > >> > "uri" of
> > > > > > > > > >> > > > that instance equals the "class_uri" of the class,
> no
> > > more
> > > > > > > instances
> > > > > > > > > >> > can be
> > > > > > > > > >> > > > added And if there is an instance of a class
> without a
> > > > > "uri"
> > > > > > > that
> > > > > > > > > >> > equals the
> > > > > > > > > >> > > > "class_uri", no instances can be added where the
> "uri"
> > > of
> > > > > the
> > > > > > > > > >> > > > instance
> > > > > > > > > >> > > > equals the "class_uri" of the class. With that
> logic,
> > > we
> > > > > have
> > > > > > > proper
> > > > > > > > > >> > > > singleton classes in the meta model of Neo4J.
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > Kind regards,
> > > > > > > > > >> > > > Niels Hoogeveen
> > > > > > > > > >> > > >
> > > > > > > > > >> > > > > Date: Thu, 8 Apr 2010 11:37:37 +0200
> > > > > > > > > >> > > > > From: mattias at neotechnology.com
> > > > > > > > > >> > > > > To: user at lists.neo4j.org
> > > > > > > > > >> > > > > Subject: Re: [Neo] meta meta classes
> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > 2010/3/30 Niels Hoogeveen <
> > > pd_aficionado at hotmail.com>
> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > MetaModelObject already has a getter (without
> > > using
> > > > > the
> > > > > > > word
> > > > > > > > > >> > > > > > "get")
> > > > > > > > > >> > to
> > > > > > > > > >> > > > > > access the node.
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > Wrapping MetaModelObject to give it a
> > > Node-interface
> > > > > makes
> > > > > > > it
> > > > > > > > > >> > possible
> > > > > > > > > >> > > > to
> > > > > > > > > >> > > > > > directly write:
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > metalObject.setProperty("a", b)
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > instead of
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > metaobject.node.setPropert("a", b)
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > If that were all, I wouldn't make a post about
> it.
> > > The
> > > > > > > more
> > > > > > > > > >> > interesting
> > > > > > > > > >> > > > > > part is the meta modeling of the node gotten
> from
> > > a
> > > > > > > > > >> > MetaModelObject.
> > > > > > > > > >> > > > This
> > > > > > > > > >> > > > > > node represents the class, but it is not an
> > > instance
> > > > > of
> > > > > > > any
> > > > > > > > > >> > > > > > class
> > > > > > > > > >> > > > itself.
> > > > > > > > > >> > > > > > That's where the reify method comes into play,
> > > which
> > > > > takes
> > > > > > > the
> > > > > > > > > >> > > > > > node
> > > > > > > > > >> > > > from a
> > > > > > > > > >> > > > > > MetaModelObject and creates a class with the
> same
> > > > > name,
> > > > > > > but in a
> > > > > > > > > >> > > > different
> > > > > > > > > >> > > > > > namespace, and makes the node an instance of
> this
> > > new
> > > > > > > class.
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > With that construction it becomes possible to
> > > model
> > > > > the
> > > > > > > > > >> > > > > > relationships/properties of a class.
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > There are many examples where this can be
> handy.
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > I already gave the example of HTML tags, where
> the
> > > > > > > attributes
> > > > > > > > > >> > > > > > can
> > > > > > > > > >> > be
> > > > > > > > > >> > > > > > modeled as properties and the tagname as a
> > > property of
> > > > > the
> > > > > > > meta
> > > > > > > > > >> > class.
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > Another example is:
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > All countries have subdivision. Countries and
> > > their
> > > > > > > subdivisions
> > > > > > > > > >> > all
> > > > > > > > > >> > > > are
> > > > > > > > > >> > > > > > instances of a certain class. There is one
> class
> > > for
> > > > > > > country,
> > > > > > > > > >> > > > > > but
> > > > > > > > > >> > there
> > > > > > > > > >> > > > is a
> > > > > > > > > >> > > > > > set of classes for subdivisions. In some
> > > countries, a
> > > > > > > > > >> > > > > > subdivision
> > > > > > > > > >> > is
> > > > > > > > > >> > > > called
> > > > > > > > > >> > > > > > "province", in others it's a "state" or a
> > > "district".
> > > > > > > > > >> > > > > > Subdivision
> > > > > > > > > >> > of
> > > > > > > > > >> > > > various
> > > > > > > > > >> > > > > > countries can have different sets of
> properties
> > > and
> > > > > > > relations.
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > How to model the fact that the instance
> "United
> > > States
> > > > > of
> > > > > > > > > >> > > > > > America"
> > > > > > > > > >> > has
> > > > > > > > > >> > > > > > subdivisions of the class "State_(US)"? Using
> the
> > > > > reify
> > > > > > > method
> > > > > > > > > >> > > > > > we
> > > > > > > > > >> > can
> > > > > > > > > >> > > > make a
> > > > > > > > > >> > > > > > class "United States of America", where we can
> > > model
> > > > > that
> > > > > > > the
> > > > > > > > > >> > > > ClassRange of
> > > > > > > > > >> > > > > > "State_(US)" is "United States of America". Or
> if
> > > we
> > > > > want
> > > > > > > the
> > > > > > > > > >> > > > relationship
> > > > > > > > > >> > > > > > to point the other way, that the "United
> States of
> > > > > > > America" has
> > > > > > > > > >> > > > > > 50
> > > > > > > > > >> > (use
> > > > > > > > > >> > > > of
> > > > > > > > > >> > > > > > cardinality) subdivisions of the class
> > > "State_(US)".
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > Here you take a step into modeling the actual
> data
> > > into
> > > > > the
> > > > > > > meta
> > > > > > > > > >> > model
> > > > > > > > > >> > > > which
> > > > > > > > > >> > > > > describes the data. Is it desirable to first
> model
> > > > > exactly
> > > > > > > how the
> > > > > > > > > >> > data
> > > > > > > > > >> > > > will
> > > > > > > > > >> > > > > look, and then add data so that it looks like
> that?
> > > I
> > > > > get a
> > > > > > > > > >> > > > > feeling
> > > > > > > > > >> > that
> > > > > > > > > >> > > > the
> > > > > > > > > >> > > > > data is described twice here...
> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > Of course all this can directly be expressed
> with
> > > > > nodes
> > > > > > > and
> > > > > > > > > >> > > > relationships,
> > > > > > > > > >> > > > > > but that's what the meta model does anyway.
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > I do have one peeve with the meta model API.
> The
> > > class
> > > > > > > DataRange
> > > > > > > > > >> > has a
> > > > > > > > > >> > > > > > constructor:
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > DataRange(String datatype, Object... values)
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > I'd much rather see a new Restrictable class
> > > > > Datavalue,
> > > > > > > and see
> > > > > > > > > >> > > > > > a
> > > > > > > > > >> > > > > > constructor:
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > DataRange(String datatype, Datavalue...
> values)
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > That way the possible values a property can
> have
> > > > > > > additional
> > > > > > > > > >> > properties
> > > > > > > > > >> > > > and
> > > > > > > > > >> > > > > > relationships (eg. link to Wordnet definition
> or
> > > > > Wikipedia
> > > > > > > > > >> > > > > > entry).
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > Kind regards,
> > > > > > > > > >> > > > > > Niels Hoogeveen
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > > > Date: Tue, 30 Mar 2010 09:30:10 +0200
> > > > > > > > > >> > > > > > > From: mattias at neotechnology.com
> > > > > > > > > >> > > > > > > To: user at lists.neo4j.org
> > > > > > > > > >> > > > > > > Subject: Re: [Neo] meta meta classes
> > > > > > > > > >> > > > > > >
> > > > > > > > > >> > > > > > > Would making the underlying Node publically
> > > > > available
> > > > > > > (via a
> > > > > > > > > >> > getter)
> > > > > > > > > >> > > > be
> > > > > > > > > >> > > > > > > virtually the same thing? In that case the
> meta
> > > > > model
> > > > > > > classes
> > > > > > > > > >> > could
> > > > > > > > > >> > > > have
> > > > > > > > > >> > > > > > > such a getter.
> > > > > > > > > >> > > > > > >
> > > > > > > > > >> > > > > > > 2010/3/26 Niels Hoogeveen <
> > > > > pd_aficionado at hotmail.com>
> > > > > > > > > >> > > > > > >
> > > > > > > > > >> > > > > > > >
> > > > > > > > > >> > > > > > > > Hi Peter,
> > > > > > > > > >> > > > > > > >
> > > > > > > > > >> > > > > > > > I added a Wiki entry in my github repo
> called
> > > > > > > "Reification
> > > > > > > > > >> > > > > > > > of
> > > > > > > > > >> > meta
> > > > > > > > > >> > > > > > classes
> > > > > > > > > >> > > > > > > > and meta properties":
> > > > > > > > > >> > > > > > > >
> > > > > > > > > >> > > > > > > >
> > > > > > > > > >> > > > > > > >
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > >
> > > > > > > > > >> >
> > > > > > >
> > > > >
> > >
> http://wiki.github.com/NielsHoogeveen/Scala-Neo4j-utils/reification-of-meta-classes-and-meta-properties
> > > > > > > > > >> > > > > > > >
> > > > > > > > > >> > > > > > > > The source code for the Scala wrappers can
> be
> > > > > found
> > > > > > > found in
> > > > > > > > > >> > > > > > > > my
> > > > > > > > > >> > > > repo:
> > > > > > > > > >> > > > > > > >
> > > > > > > > > >> > > > > > > >
> > > > > http://github.com/NielsHoogeveen/Scala-Neo4j-utils
> > > > > > > > > >> > > > > > > >
> > > > > > > > > >> > > > > > > > Kind regards,
> > > > > > > > > >> > > > > > > > Niels Hoogeveen
> > > > > > > > > >> > > > > > > >
> > > > > > > > > >> > > > > > > > > From: neubauer.peter at gmail.com
> > > > > > > > > >> > > > > > > > > Date: Fri, 26 Mar 2010 17:25:01 +0100
> > > > > > > > > >> > > > > > > > > To: user at lists.neo4j.org
> > > > > > > > > >> > > > > > > > > Subject: Re: [Neo] meta meta classes
> > > > > > > > > >> > > > > > > > >
> > > > > > > > > >> > > > > > > > > Awesome Niels!
> > > > > > > > > >> > > > > > > > >
> > > > > > > > > >> > > > > > > > > maybe you could blog or document some
> cool
> > > > > example
> > > > > > > on
> > > > > > > > > >> > > > > > > > > this?
> > > > > > > > > >> > > > > > > > >
> > > > > > > > > >> > > > > > > > > Cheers,
> > > > > > > > > >> > > > > > > > >
> > > > > > > > > >> > > > > > > > > /peter neubauer
> > > > > > > > > >> > > > > > > > >
> > > > > > > > > >> > > > > > > > > COO and Sales, Neo Technology
> > > > > > > > > >> > > > > > > > >
> > > > > > > > > >> > > > > > > > > GTalk:      neubauer.peter
> > > > > > > > > >> > > > > > > > > Skype       peter.neubauer
> > > > > > > > > >> > > > > > > > > Phone       +46 704 106975
> > > > > > > > > >> > > > > > > > > LinkedIn
> > > http://www.linkedin.com/in/neubauer
> > > > > > > > > >> > > > > > > > > Twitter
> > > http://twitter.com/peterneubauer
> > > > > > > > > >> > > > > > > > >
> > > > > > > > > >> > > > > > > > > http://www.neo4j.org             - Your
> > > high
> > > > > > > performance
> > > > > > > > > >> > graph
> > > > > > > > > >> > > > > > database.
> > > > > > > > > >> > > > > > > > > http://www.tinkerpop.com      -
> Processing
> > > for
> > > > > > > > > >> > Internet-scale
> > > > > > > > > >> > > > > > graphs.
> > > > > > > > > >> > > > > > > > > http://www.thoughtmade.com -
> Scandinavias
> > > > > coolest
> > > > > > > > > >> > Bring-a-Thing
> > > > > > > > > >> > > > > > party.
> > > > > > > > > >> > > > > > > > >
> > > > > > > > > >> > > > > > > > >
> > > > > > > > > >> > > > > > > > >
> > > > > > > > > >> > > > > > > > > On Fri, Mar 26, 2010 at 5:22 PM, Niels
> > > Hoogeveen
> > > > > > > > > >> > > > > > > > > <pd_aficionado at hotmail.com> wrote:
> > > > > > > > > >> > > > > > > > > >
> > > > > > > > > >> > > > > > > > > > Using Scala, I was actually able to
> extend
> > > > > > > > > >> > > > > > > > > > MetaModelThing
> > > > > > > > > >> > to
> > > > > > > > > >> > > > act as
> > > > > > > > > >> > > > > > a
> > > > > > > > > >> > > > > > > > Node and MetaModelClass to have shadowing
> > > > > > > functionality for
> > > > > > > > > >> > both
> > > > > > > > > >> > > > > > > > MetaModelClasses and for
> MetaModelProperties,
> > > > > without
> > > > > > > > > >> > > > > > > > touching
> > > > > > > > > >> > the
> > > > > > > > > >> > > > > > original
> > > > > > > > > >> > > > > > > > source code.
> > > > > > > > > >> > > > > > > > > >
> > > > > > > > > >> > > > > > > > > >> To: user at lists.neo4j.org
> > > > > > > > > >> > > > > > > > > >> From:
> > > rick.bullotta at burningskysoftware.com
> > > > > > > > > >> > > > > > > > > >> Date: Fri, 26 Mar 2010 14:29:03 +0000
> > > > > > > > > >> > > > > > > > > >> Subject: Re: [Neo] meta meta classes
> > > > > > > > > >> > > > > > > > > >>
> > > > > > > > > >> > > > > > > > > >> Such are the joys and challenges of
> > > > > frameworks
> > > > > > > and
> > > > > > > > > >> > > > abstractions.
> > > > > > > > > >> > > > > > > >  Sometimes you do need to get "close to
> the
> > > metal"
> > > > > > > though,
> > > > > > > > > >> > > > > > > > to
> > > > > > > > > >> > > > achieve
> > > > > > > > > >> > > > > > > > specific functional and performance
> > > requirements.
> > > > > > >  Thus the
> > > > > > > > > >> > reason
> > > > > > > > > >> > > > open
> > > > > > > > > >> > > > > > > > source frameworks are awesome.  At least
> we
> > > can
> > > > > change
> > > > > > > and
> > > > > > > > > >> > extend
> > > > > > > > > >> > > > them
> > > > > > > > > >> > > > > > more
> > > > > > > > > >> > > > > > > > easily!
> > > > > > > > > >> > > > > > > > > >>
> > > > > > > > > >> > > > > > > > > >>
> > > > > > > > > >> > > > > > > > > >>
> > > > > > > > > >> > > > > > > > > >> -----Original Message-----
> > > > > > > > > >> > > > > > > > > >> From: Niels Hoogeveen <
> > > > > pd_aficionado at hotmail.com
> > > > > > > >
> > > > > > > > > >> > > > > > > > > >> Date: Fri, 26 Mar 2010 15:20:15
> > > > > > > > > >> > > > > > > > > >> To: <user at lists.neo4j.org>
> > > > > > > > > >> > > > > > > > > >> Subject: Re: [Neo] meta meta classes
> > > > > > > > > >> > > > > > > > > >>
> > > > > > > > > >> > > > > > > > > >>
> > > > > > > > > >> > > > > > > > > >> Making MetaModelThing implement the
> Node
> > > > > > > interface is
> > > > > > > > > >> > actually
> > > > > > > > > >> > > > > > > > orthogonal to the creation of Shadow
> objects.
> > > > > Though
> > > > > > > it does
> > > > > > > > > >> > make
> > > > > > > > > >> > > > code
> > > > > > > > > >> > > > > > using
> > > > > > > > > >> > > > > > > > classes as objects cleaner, and allows the
> > > node
> > > > > > > property of
> > > > > > > > > >> > > > > > MetaModelThing
> > > > > > > > > >> > > > > > > > to become private.
> > > > > > > > > >> > > > > > > > > >>
> > > > > > > > > >> > > > > > > > > >> > From: pd_aficionado at hotmail.com
> > > > > > > > > >> > > > > > > > > >> > To: user at lists.neo4j.org
> > > > > > > > > >> > > > > > > > > >> > Date: Fri, 26 Mar 2010 14:38:08
> +0100
> > > > > > > > > >> > > > > > > > > >> > Subject: Re: [Neo] meta meta
> classes
> > > > > > > > > >> > > > > > > > > >> >
> > > > > > > > > >> > > > > > > > > >> >
> > > > > > > > > >> > > > > > > > > >> > Or, and this probably the simplest
> > > > > solution.
> > > > > > > Let a
> > > > > > > > > >> > > > > > MetaModelThing
> > > > > > > > > >> > > > > > > > implement the Node interface. This allows
> a
> > > class
> > > > > to
> > > > > > > be an
> > > > > > > > > >> > instance
> > > > > > > > > >> > > > of
> > > > > > > > > >> > > > > > > > another class and/or a SubType of another
> > > class.
> > > > > > > > > >> > > > > > > > > >> >
> > > > > > > > > >> > > > > > > > > >> >
> > > > > > > > > >> > > > > > > > > >> > > From: pd_aficionado at hotmail.com
> > > > > > > > > >> > > > > > > > > >> > > To: user at lists.neo4j.org
> > > > > > > > > >> > > > > > > > > >> > > Date: Fri, 26 Mar 2010 14:20:07
> +0100
> > > > > > > > > >> > > > > > > > > >> > > Subject: Re: [Neo] meta meta
> classes
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > The class as object phenomenon is
> > > > > actually
> > > > > > > quite
> > > > > > > > > >> > > > pervasive,
> > > > > > > > > >> > > > > > and I
> > > > > > > > > >> > > > > > > > think it is possible to have a generalized
> > > > > solution
> > > > > > > for it.
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > After sending this email
> yesterday, I
> > > > > came up
> > > > > > > with
> > > > > > > > > >> > > > > > > > > >> > > a
> > > > > > > > > >> > > > slightly
> > > > > > > > > >> > > > > > > > different solution.
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > val taggable =
> > > > > > > namespace.getMetaClass("taggable",
> > > > > > > > > >> > true)
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > val tagName =
> > > > > > > > > >> > > > metaModelNamespace.getMetaProperty("tagname",
> > > > > > > > > >> > > > > > true)
> > > > > > > > > >> > > > > > > > > >> > > tagName.setCardinality(1)
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > val metaTaggable =
> > > > > > > > > >> > > > metaModelNamespace.getMetaClass("taggable",
> > > > > > > > > >> > > > > > > > true)
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > metaTaggable.getDirectProperties.add(tagName)
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > metaTaggable.getDirectInstances.add(taggable.node)
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > val body =
> > > namespace.getMetaClass("body",
> > > > > > > true)
> > > > > > > > > >> > > > > > > > > >> > > taggable.getDirectSubs.add(body)
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > Instead of directly relating the
> > > class
> > > > > "body"
> > > > > > > to
> > > > > > > > > >> > > > > > > > > >> > > the
> > > > > > > > > >> > meta
> > > > > > > > > >> > > > > > class
> > > > > > > > > >> > > > > > > > "taggable", I create a shadow of the meta
> > > class
> > > > > > > "taggable"
> > > > > > > > > >> > > > > > > > with
> > > > > > > > > >> > the
> > > > > > > > > >> > > > > > same
> > > > > > > > > >> > > > > > > > name in the namespace of the class "body",
> and
> > > > > make
> > > > > > > "body" a
> > > > > > > > > >> > > > subclass
> > > > > > > > > >> > > > > > of
> > > > > > > > > >> > > > > > > > this shadow. That way the sub classing
> > > > > relationship
> > > > > > > remains
> > > > > > > > > >> > nicely
> > > > > > > > > >> > > > in
> > > > > > > > > >> > > > > > one
> > > > > > > > > >> > > > > > > > name space, while the instance
> relationship
> > > > > transcends
> > > > > > > name
> > > > > > > > > >> > spaces,
> > > > > > > > > >> > > > as
> > > > > > > > > >> > > > > > it
> > > > > > > > > >> > > > > > > > should.
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > This could in principle be
> > > generalized by
> > > > > > > adding a
> > > > > > > > > >> > methods
> > > > > > > > > >> > > > to
> > > > > > > > > >> > > > > > > > MetaModelClass:
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > public MetaModelClass
> > > > > > > createShadowClass(NameSpace
> > > > > > > > > >> > > > > > > > > >> > > ns){
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > >     MetaModelClass mc =
> > > > > > > > > >> > ns.getMetaClass(this.getName(),
> > > > > > > > > >> > > > true);
> > > > > > > > > >> > > > > > > > > >> > >
> > > this.getDirectInstances.add(mc.node);
> > > > > > > > > >> > > > > > > > > >> > >     return mc;
> > > > > > > > > >> > > > > > > > > >> > > }
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > This returns a shadow of a given
> > > > > > > MetaModelClass in
> > > > > > > > > >> > > > > > > > > >> > > a
> > > > > > > > > >> > given
> > > > > > > > > >> > > > > > > > namespace and adds it as a an instance of
> > > this.
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > It would of course be nicer to
> have a
> > > > > method
> > > > > > > with
> > > > > > > > > >> > > > > > > > > >> > > the
> > > > > > > > > >> > > > > > signature:
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > public MetaModelClass
> > > getShadow(NameSpace
> > > > > ns,
> > > > > > > > > >> > > > > > > > > >> > > Boolean
> > > > > > > > > >> > > > create)
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > This is much more in line with
> the
> > > rest
> > > > > of
> > > > > > > the API,
> > > > > > > > > >> > but
> > > > > > > > > >> > > > > > requires a
> > > > > > > > > >> > > > > > > > way to find out the namespace a given
> > > > > MetaModelClass
> > > > > > > is
> > > > > > > > > >> > > > > > > > defined
> > > > > > > > > >> > in.
> > > > > > > > > >> > > > I
> > > > > > > > > >> > > > > > didn't
> > > > > > > > > >> > > > > > > > see a method getNamespace() for a given
> class,
> > > and
> > > > > > > didn't
> > > > > > > > > >> > > > > > > > delve
> > > > > > > > > >> > > > deeply
> > > > > > > > > >> > > > > > > > enough in the source code to figure out
> how to
> > > do
> > > > > > > that.
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > A similar approach can of course
> also
> > > be
> > > > > > > applied to
> > > > > > > > > >> > > > > > > > MetaModelProperties, by adding the
> following
> > > > > method to
> > > > > > > > > >> > > > MetaModelClass:
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > public MetaModelProperty
> > > > > > > > > >> > > > > > > > > >> > > createShadowProperty(NameSpace
> ns){
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > >     MetaModelProperty mp =
> > > > > > > > > >> > > > > > > > > >> > >
> ns.getMetaProperty(this.getName(),
> > > true);
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > >
> this.getDirectInstances.add(mp.node);
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > >     return mp;
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > }
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > This way the underlying node of a
> > > > > > > MetaModelProperty
> > > > > > > > > >> > can
> > > > > > > > > >> > > > > > properly
> > > > > > > > > >> > > > > > > > be used as a class of its own and have
> > > properties,
> > > > > > > > > >> > relationships,
> > > > > > > > > >> > > > that
> > > > > > > > > >> > > > > > can
> > > > > > > > > >> > > > > > > > be further modeled in the meta layer. This
> > > e.q.
> > > > > allows
> > > > > > > to
> > > > > > > > > >> > > > > > > > set a
> > > > > > > > > >> > > > default
> > > > > > > > > >> > > > > > > > rendering format for a given property
> class.
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > I don't see a
> MetaModelRelationships,
> > > > > which
> > > > > > > is
> > > > > > > > > >> > > > unfortunate,
> > > > > > > > > >> > > > > > since
> > > > > > > > > >> > > > > > > > that would allow the modeling of the
> > > properties of
> > > > > a
> > > > > > > > > >> > Relationship.
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > Kind regards,
> > > > > > > > > >> > > > > > > > > >> > > Niels Hoogeveen
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > > > Date: Fri, 26 Mar 2010 11:26:29
> > > +0100
> > > > > > > > > >> > > > > > > > > >> > > > From:
> mattias at neotechnology.com
> > > > > > > > > >> > > > > > > > > >> > > > To: user at lists.neo4j.org
> > > > > > > > > >> > > > > > > > > >> > > > Subject: Re: [Neo] meta meta
> > > classes
> > > > > > > > > >> > > > > > > > > >> > > >
> > > > > > > > > >> > > > > > > > > >> > > > That's an interresting case
> you've
> > > got
> > > > > here
> > > > > > > and
> > > > > > > > > >> > > > > > > > > >> > > > it
> > > > > > > > > >> > looks
> > > > > > > > > >> > > > to
> > > > > > > > > >> > > > > > me
> > > > > > > > > >> > > > > > > > like it's
> > > > > > > > > >> > > > > > > > > >> > > > probably the best way to model
> it
> > > in
> > > > > the
> > > > > > > meta
> > > > > > > > > >> > > > > > > > > >> > > > model.
> > > > > > > > > >> > > > > > > > > >> > > >
> > > > > > > > > >> > > > > > > > > >> > > > 2010/3/25 Niels Hoogeveen <
> > > > > > > > > >> > pd_aficionado at hotmail.com>
> > > > > > > > > >> > > > > > > > > >> > > >
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > For my application, I want to
> > > model
> > > > > an
> > > > > > > HTML
> > > > > > > > > >> > template
> > > > > > > > > >> > > > in
> > > > > > > > > >> > > > > > Neo4J,
> > > > > > > > > >> > > > > > > > using the
> > > > > > > > > >> > > > > > > > > >> > > > > MetaModel api.
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > So I started setting up
> > > > > MetaModelClasses
> > > > > > > for
> > > > > > > > > >> > > > > > > > > >> > > > > the
> > > > > > > > > >> > > > various
> > > > > > > > > >> > > > > > HTML
> > > > > > > > > >> > > > > > > > entities.
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > e.g. (code in Scala)
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > val classProp =
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > namespace.getMetaProperty("class",
> > > > > > > > > >> > > > true)
> > > > > > > > > >> > > > > > > > > >> > > > > val idProp =
> > > > > > > > > >> > > > > > > > > >> > > > >
> namespace.getMetaProperty("id",
> > > true)
> > > > > > > > > >> > > > > > > > > >> > > > > idProp.setCardinality(1)
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > val body =
> > > > > namespace.getMetaClass("body",
> > > > > > > true)
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > body.getDirectProperties(classProp)
> > > > > > > > > >> > > > > > > > > >> > > > >
> body.getDirectProperties(idProp)
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > Which creates a class named
> > > "body"
> > > > > which
> > > > > > > has a
> > > > > > > > > >> > > > property
> > > > > > > > > >> > > > > > named
> > > > > > > > > >> > > > > > > > "class"
> > > > > > > > > >> > > > > > > > > >> > > > > without a cardinality
> restriction
> > > and
> > > > > a
> > > > > > > > > >> > > > > > > > > >> > > > > property
> > > > > > > > > >> > named
> > > > > > > > > >> > > > > > "id"
> > > > > > > > > >> > > > > > > > with a
> > > > > > > > > >> > > > > > > > > >> > > > > cardinality restriction of 1.
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > Now I can create nodes of
> class
> > > > > "body"
> > > > > > > with
> > > > > > > > > >> > various
> > > > > > > > > >> > > > values
> > > > > > > > > >> > > > > > for
> > > > > > > > > >> > > > > > > > "class" and
> > > > > > > > > >> > > > > > > > > >> > > > > for "id".
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > So far so good, but now I
> want to
> > > say
> > > > > > > that the
> > > > > > > > > >> > class
> > > > > > > > > >> > > > body
> > > > > > > > > >> > > > > > has
> > > > > > > > > >> > > > > > > > a property
> > > > > > > > > >> > > > > > > > > >> > > > > "tagname" which should get
> the
> > > value
> > > > > > > "body".
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > The meta model itself doesn't
> > > allow
> > > > > > > classes to
> > > > > > > > > >> > have
> > > > > > > > > >> > > > > > > > properties, but it
> > > > > > > > > >> > > > > > > > > >> > > > > allows access to the
> underlying
> > > node
> > > > > of
> > > > > > > the
> > > > > > > > > >> > > > > > > > > >> > > > > class.
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > So I created a separate
> namespace
> > > for
> > > > > the
> > > > > > > meta
> > > > > > > > > >> > meta
> > > > > > > > > >> > > > > > classes
> > > > > > > > > >> > > > > > > > and added the
> > > > > > > > > >> > > > > > > > > >> > > > > following three definitions:
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > val tagName =
> > > > > > > > > >> > metaNamespace.getMetaProperty("tagname",
> > > > > > > > > >> > > > > > true)
> > > > > > > > > >> > > > > > > > > >> > > > > tagName.setCardinality(1)
> > > > > > > > > >> > > > > > > > > >> > > > > val taggable =
> > > > > > > > > >> > metaNamespace.getMetaClass("taggable",
> > > > > > > > > >> > > > > > true)
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > >
> body.node.setProperty("tagname",
> > > > > "body")
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > This creates a property
> "tagname"
> > > > > with
> > > > > > > the
> > > > > > > > > >> > > > > > > > > >> > > > > value
> > > > > > > > > >> > > > "body"
> > > > > > > > > >> > > > > > for
> > > > > > > > > >> > > > > > > > the class named
> > > > > > > > > >> > > > > > > > > >> > > > > "body".
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > Now comes the more ambiguous
> > > part,
> > > > > how to
> > > > > > > link
> > > > > > > > > >> > "body"
> > > > > > > > > >> > > > to
> > > > > > > > > >> > > > > > > > "taggable".
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > I can make body.node an
> instance
> > > of
> > > > > > > taggable.
> > > > > > > > > >> > > > > > > > > >> > > > > Once
> > > > > > > > > >> > > > there
> > > > > > > > > >> > > > > > is a
> > > > > > > > > >> > > > > > > > validator,
> > > > > > > > > >> > > > > > > > > >> > > > > the existence of a "tagname"
> > > property
> > > > > > > with
> > > > > > > > > >> > cardinality
> > > > > > > > > >> > > > 1
> > > > > > > > > >> > > > > > > > should be checked,
> > > > > > > > > >> > > > > > > > > >> > > > > so it is reasonable to make
> > > body.node
> > > > > an
> > > > > > > > > >> > > > > > > > > >> > > > > instance
> > > > > > > > > >> > of
> > > > > > > > > >> > > > > > taggable.
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > At the same time the class
> body
> > > is
> > > > > > > actually a
> > > > > > > > > >> > subclass
> > > > > > > > > >> > > > of
> > > > > > > > > >> > > > > > > > taggable, so I am
> > > > > > > > > >> > > > > > > > > >> > > > > inclined to define that as
> well.
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > So I end up doing the
> following:
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > taggable.getDirectInstances.add(body.node)
> > > > > > > > > >> > > > > > > > > >> > > > >
> taggable.getDirectSubs.add(body)
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > I would like to know if this
> is
> > > the
> > > > > > > correct
> > > > > > > > > >> > approach
> > > > > > > > > >> > > > to
> > > > > > > > > >> > > > > > this
> > > > > > > > > >> > > > > > > > situation, or
> > > > > > > > > >> > > > > > > > > >> > > > > whether there are better
> > > > > alternatives.
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > > Kind regards,
> > > > > > > > > >> > > > > > > > > >> > > > > Niels Hoogeveen
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > >
> > > > > > > > > >> >
> > > > > _________________________________________________________________
> > > > > > > > > >> > > > > > > > > >> > > > > New Windows 7: Find the right
> PC
> > > for
> > > > > you.
> > > > > > > Learn
> > > > > > > > > >> > more.
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > http://windows.microsoft.com/shop
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > _______________________________________________
> > > > > > > > > >> > > > > > > > > >> > > > > Neo mailing list
> > > > > > > > > >> > > > > > > > > >> > > > > User at lists.neo4j.org
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > > > > > >> > > >
> > > > > > > > > >> > > > > > > > > >> > > >
> > > > > > > > > >> > > > > > > > > >> > > >
> > > > > > > > > >> > > > > > > > > >> > > > --
> > > > > > > > > >> > > > > > > > > >> > > > Mattias Persson, [
> > > > > > > mattias at neotechnology.com]
> > > > > > > > > >> > > > > > > > > >> > > > Neo Technology,
> > > www.neotechnology.com
> > > > > > > > > >> > > > > > > > > >> > > >
> > > > > > > _______________________________________________
> > > > > > > > > >> > > > > > > > > >> > > > Neo mailing list
> > > > > > > > > >> > > > > > > > > >> > > > User at lists.neo4j.org
> > > > > > > > > >> > > > > > > > > >> > > >
> > > > > > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > >
> > > > > > >
> _________________________________________________________________
> > > > > > > > > >> > > > > > > > > >> > > Express yourself instantly with
> MSN
> > > > > > > Messenger!
> > > > > > > > > >> > Download
> > > > > > > > > >> > > > today
> > > > > > > > > >> > > > > > it's
> > > > > > > > > >> > > > > > > > FREE!
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > > > >> > > > > >
> > > > > > >
> http://messenger.msn.click-url.com/go/onm00200471ave/direct/01/
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > _______________________________________________
> > > > > > > > > >> > > > > > > > > >> > > Neo mailing list
> > > > > > > > > >> > > > > > > > > >> > > User at lists.neo4j.org
> > > > > > > > > >> > > > > > > > > >> > >
> > > > > > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >> > > > > > > > > >> >
> > > > > > > > > >> > > > > > > > > >> >
> > > > > > > > > >> > > > > >
> > > > > > >
> _________________________________________________________________
> > > > > > > > > >> > > > > > > > > >> > New Windows 7: Find the right PC
> for
> > > you.
> > > > > Learn
> > > > > > > more.
> > > > > > > > > >> > > > > > > > > >> > http://windows.microsoft.com/shop
> > > > > > > > > >> > > > > > > > > >> >
> > > > > _______________________________________________
> > > > > > > > > >> > > > > > > > > >> > Neo mailing list
> > > > > > > > > >> > > > > > > > > >> > User at lists.neo4j.org
> > > > > > > > > >> > > > > > > > > >> >
> > > > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >> > > > > > > > > >>
> > > > > > > > > >> > > > > > > > > >>
> > > > > > > > > >> > > >
> > > > > > >
> _________________________________________________________________
> > > > > > > > > >> > > > > > > > > >> New Windows 7: Find the right PC for
> you.
> > > > > Learn
> > > > > > > more.
> > > > > > > > > >> > > > > > > > > >> http://windows.microsoft.com/shop
> > > > > > > > > >> > > > > > > > > >>
> > > > > _______________________________________________
> > > > > > > > > >> > > > > > > > > >> Neo mailing list
> > > > > > > > > >> > > > > > > > > >> User at lists.neo4j.org
> > > > > > > > > >> > > > > > > > > >>
> > > > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >> > > > > > > > > >>
> > > > > _______________________________________________
> > > > > > > > > >> > > > > > > > > >> Neo mailing list
> > > > > > > > > >> > > > > > > > > >> User at lists.neo4j.org
> > > > > > > > > >> > > > > > > > > >>
> > > > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >> > > > > > > > > >
> > > > > > > > > >> > > > > > > > > >
> > > > > > > > > >> > > >
> > > > > > >
> _________________________________________________________________
> > > > > > > > > >> > > > > > > > > > New Windows 7: Find the right PC for
> you.
> > > > > Learn
> > > > > > > more.
> > > > > > > > > >> > > > > > > > > > http://windows.microsoft.com/shop
> > > > > > > > > >> > > > > > > > > >
> > > > > _______________________________________________
> > > > > > > > > >> > > > > > > > > > Neo mailing list
> > > > > > > > > >> > > > > > > > > > User at lists.neo4j.org
> > > > > > > > > >> > > > > > > > > >
> > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >> > > > > > > > > >
> > > > > > > > > >> > > > > > > > >
> > > _______________________________________________
> > > > > > > > > >> > > > > > > > > Neo mailing list
> > > > > > > > > >> > > > > > > > > User at lists.neo4j.org
> > > > > > > > > >> > > > > > > > >
> > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >> > > > > > > >
> > > > > > > > > >> > > > > > > >
> > > > > > > > > >> >
> > > > > _________________________________________________________________
> > > > > > > > > >> > > > > > > > Express yourself instantly with MSN
> Messenger!
> > > > > > > Download
> > > > > > > > > >> > > > > > > > today
> > > > > > > > > >> > it's
> > > > > > > > > >> > > > > > FREE!
> > > > > > > > > >> > > > > > > >
> > > > > > > > > >> >
> > > > > http://messenger.msn.click-url.com/go/onm00200471ave/direct/01/
> > > > > > > > > >> > > > > > > >
> > > _______________________________________________
> > > > > > > > > >> > > > > > > > Neo mailing list
> > > > > > > > > >> > > > > > > > User at lists.neo4j.org
> > > > > > > > > >> > > > > > > >
> https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >> > > > > > > >
> > > > > > > > > >> > > > > > >
> > > > > > > > > >> > > > > > >
> > > > > > > > > >> > > > > > >
> > > > > > > > > >> > > > > > > --
> > > > > > > > > >> > > > > > > Mattias Persson, [mattias at neotechnology.com
> ]
> > > > > > > > > >> > > > > > > Neo Technology, www.neotechnology.com
> > > > > > > > > >> > > > > > >
> _______________________________________________
> > > > > > > > > >> > > > > > > Neo mailing list
> > > > > > > > > >> > > > > > > User at lists.neo4j.org
> > > > > > > > > >> > > > > > >
> https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > > >
> > > > > > >
> _________________________________________________________________
> > > > > > > > > >> > > > > > Express yourself instantly with MSN Messenger!
> > > > > Download
> > > > > > > today
> > > > > > > > > >> > > > > > it's
> > > > > > > > > >> > > > FREE!
> > > > > > > > > >> > > > > >
> > > > > > >
> http://messenger.msn.click-url.com/go/onm00200471ave/direct/01/
> > > > > > > > > >> > > > > >
> _______________________________________________
> > > > > > > > > >> > > > > > Neo mailing list
> > > > > > > > > >> > > > > > User at lists.neo4j.org
> > > > > > > > > >> > > > > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >> > > > > >
> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > >
> > > > > > > > > >> > > > > --
> > > > > > > > > >> > > > > Mattias Persson, [mattias at neotechnology.com]
> > > > > > > > > >> > > > > Hacker, Neo Technology
> > > > > > > > > >> > > > > www.neotechnology.com
> > > > > > > > > >> > > > > _______________________________________________
> > > > > > > > > >> > > > > Neo mailing list
> > > > > > > > > >> > > > > User at lists.neo4j.org
> > > > > > > > > >> > > > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >> > > >
> > > > > > > > > >> > > >
> > > > > > >
> _________________________________________________________________
> > > > > > > > > >> > > > Express yourself instantly with MSN Messenger!
> > > Download
> > > > > today
> > > > > > > it's
> > > > > > > > > >> > FREE!
> > > > > > > > > >> > > >
> > > > > > >
> http://messenger.msn.click-url.com/go/onm00200471ave/direct/01/
> > > > > > > > > >> > > > _______________________________________________
> > > > > > > > > >> > > > Neo mailing list
> > > > > > > > > >> > > > User at lists.neo4j.org
> > > > > > > > > >> > > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >> > > >
> > > > > > > > > >> > >
> > > > > > > > > >> > >
> > > > > > > > > >> > >
> > > > > > > > > >> > > --
> > > > > > > > > >> > > Mattias Persson, [mattias at neotechnology.com]
> > > > > > > > > >> > > Hacker, Neo Technology
> > > > > > > > > >> > > www.neotechnology.com
> > > > > > > > > >> > > _______________________________________________
> > > > > > > > > >> > > Neo mailing list
> > > > > > > > > >> > > User at lists.neo4j.org
> > > > > > > > > >> > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >> >
> > > > > > > > > >> >
> > > > > _________________________________________________________________
> > > > > > > > > >> > New Windows 7: Find the right PC for you. Learn more.
> > > > > > > > > >> > http://windows.microsoft.com/shop
> > > > > > > > > >> > _______________________________________________
> > > > > > > > > >> > Neo mailing list
> > > > > > > > > >> > User at lists.neo4j.org
> > > > > > > > > >> > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >> >
> > > > > > > > > >>
> > > > > > > > > >>
> > > > > > > > > >>
> > > > > > > > > >> --
> > > > > > > > > >> Mattias Persson, [mattias at neotechnology.com]
> > > > > > > > > >> Hacker, Neo Technology
> > > > > > > > > >> www.neotechnology.com
> > > > > > > > > >> _______________________________________________
> > > > > > > > > >> Neo mailing list
> > > > > > > > > >> User at lists.neo4j.org
> > > > > > > > > >> https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >
> > > > > > > > > >
> > > _________________________________________________________________
> > > > > > > > > > Express yourself instantly with MSN Messenger! Download
> today
> > > > > it's
> > > > > > > FREE!
> > > > > > > > > >
> > > http://messenger.msn.click-url.com/go/onm00200471ave/direct/01/
> > > > > > > > > > _______________________________________________
> > > > > > > > > > Neo mailing list
> > > > > > > > > > User at lists.neo4j.org
> > > > > > > > > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > --
> > > > > > > > > Mattias Persson, [mattias at neotechnology.com]
> > > > > > > > > Hacker, Neo Technology
> > > > > > > > > www.neotechnology.com
> > > > > > > > > _______________________________________________
> > > > > > > > > Neo mailing list
> > > > > > > > > User at lists.neo4j.org
> > > > > > > > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > > >
> > > > > > > >
> _________________________________________________________________
> > > > > > > > Express yourself instantly with MSN Messenger! Download today
> > > it's
> > > > > FREE!
> > > > > > > >
> http://messenger.msn.click-url.com/go/onm00200471ave/direct/01/
> > > > > > > > _______________________________________________
> > > > > > > > Neo mailing list
> > > > > > > > User at lists.neo4j.org
> > > > > > > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > >
> > > > > > >
> _________________________________________________________________
> > > > > > > Express yourself instantly with MSN Messenger! Download today
> it's
> > > > > FREE!
> > > > > > >
> http://messenger.msn.click-url.com/go/onm00200471ave/direct/01/
> > > > > > > _______________________________________________
> > > > > > > Neo mailing list
> > > > > > > User at lists.neo4j.org
> > > > > > > https://lists.neo4j.org/mailman/listinfo/user
> > > > > > >
> > > > > >
> > > > > >
> > > > > >
> > > > > > --
> > > > > > Mattias Persson, [mattias at neotechnology.com]
> > > > > > Hacker, Neo Technology
> > > > > > www.neotechnology.com
> > > > > > _______________________________________________
> > > > > > Neo mailing list
> > > > > > User at lists.neo4j.org
> > > > > > https://lists.neo4j.org/mailman/listinfo/user
> > > > >
> > > > > _________________________________________________________________
> > > > > New Windows 7: Simplify what you do everyday. Find the right PC for
> > > you.
> > > > > http://windows.microsoft.com/shop
> > > > > _______________________________________________
> > > > > Neo mailing list
> > > > > User at lists.neo4j.org
> > > > > https://lists.neo4j.org/mailman/listinfo/user
> > > > >
> > > >
> > > >
> > > >
> > > > --
> > > > Mattias Persson, [mattias at neotechnology.com]
> > > > Hacker, Neo Technology
> > > > www.neotechnology.com
> > > > _______________________________________________
> > > > Neo mailing list
> > > > User at lists.neo4j.org
> > > > https://lists.neo4j.org/mailman/listinfo/user
> > >
> > > _________________________________________________________________
> > > New Windows 7: Find the right PC for you. Learn more.
> > > http://windows.microsoft.com/shop
> > > _______________________________________________
> > > Neo mailing list
> > > User at lists.neo4j.org
> > > https://lists.neo4j.org/mailman/listinfo/user
> > >
> >
> >
> >
> > --
> > Mattias Persson, [mattias at neotechnology.com]
> > Hacker, Neo Technology
> > www.neotechnology.com
> > _______________________________________________
> > Neo mailing list
> > User at lists.neo4j.org
> > https://lists.neo4j.org/mailman/listinfo/user
>
> _________________________________________________________________
> New Windows 7: Simplify what you do everyday. Find the right PC for you.
> http://windows.microsoft.com/shop
> _______________________________________________
> Neo mailing list
> User at lists.neo4j.org
> https://lists.neo4j.org/mailman/listinfo/user
>



-- 
Mattias Persson, [mattias at neotechnology.com]
Hacker, Neo Technology
www.neotechnology.com


More information about the User mailing list