Skip to main content
Jump to: navigation, search

EntityId Requirements

Revision as of 11:28, 15 September 2008 by (Talk | contribs) (Drummond)


Higgins logo 76Wx100H.jpg


This page is for working out the requirements and design decisions for Higgins EntityIds.

Content Data Model Requirements

In terms of the underlying graph model, following is a summary of the abstract requirements based on recent threads on the email list (~2008-09). Please post a note if you disagree with any of the following:

  1. An Entity is a node in the graph described by the Higgins Context Data Model. The CDM needs a consistent way of representing arcs referencing that node.
  2. There MAY be 0..n such arcs referencing the node. (0 is possible for blank nodes.)
  3. An arc MAY theoretically be represented as either:
    1. A unique identifier (single-part key).
    2. A set of Attributes of that Entity (multi-part key) - none of which itself is required to be a unique identifier.
  4. If the arc is represented as a unique identifier:
    1. It MUST be a Contextually Unique ID (CUID), i.e., locally unique within the Context.
    2. It MAY be globally unique identifier (GUID) (note that all GUIDs are by definition CUIDs provided that the Context recognizing them as IDs).

Higgins API Requirements

Following are the key design decisions we need to make. Drummond is posting votes as they are made in email. Feel free post your votes/comments directly (with your wiki signature).

Q1: Unique Identifier vs. Attribute Set

Must a Higgins EntityId be a single-part CUID or GUID, or can it be a multi-part set of Attributes?

  • Jim: Yes - it must be a CUID or GUID.
  • David: No - I prefer a multi-part key where the parts of the key might also be unique in a context. An example is a EntityID made up of a uniqueName, uniqueId, nativeName, nativeId. Any part of the of the Entity ID could be used to identify the object.
  • Drummond: Abstain - Single-part IDs are easier, but multi-part keys are useful too.

Q2: Representation of an EntityId as a Unique Identifier

If an EntityId is a unique identifier, should this be represented as:

  1. A type of Attribute?
  2. An inherent property of an Entity that MAY be exposed as an Attribute?
  • Jim: #2
  • David: #2
  • Drummond: #2

Q3: Cardinality

What is the cardinality of EntityId? (The answer may depend on the answer to #2.)

  1. 0..n?
  2. 0..1?
  3. 1 (whose value may be null)?
  4. None of the above?
  • Jim: Abstain - I tend to want simple.
  • David: #1 or #2 - 0..1 if the EntityId is mutlipart as in Q1. 0..n if it is a string, and then it needs a type.
  • Drummond: #4 - See comment below.

Q4: Mutability

Is the EntityID of an Entity immutable?

  1. Yes?
  2. No?
  3. Depends?
  • Jim: Yes - I believe it must be as soon as we start tying policy to EntityIDs. Either that, or we need to require a way to ensure referential integrity for places where EntityIDs are stored in policy statements.
  • David: Depends - My vote on Q1 was multipart where the decomposition could contain both mutable (uniqueName) and immutable (uniqueId) parts. They both have their use cases. If the EntityID is a string, then 1..n is needed to accomodate mutable, immutable types and if the id can be used in other protocols (compatability with legacy systems).
  • Drummond: Depends - See comment below.



It seems we're overloading EntityId - one property can't meet all the requirements. A proposal would be to use two properties, both of which could be used to uniquely address an Entity in a Context:

  1. EntityId:
    1. MUST be Context-unique; MAY be globally unique.
    2. MAY be formatted as a UDI.
    3. Cardinality 0..n
    4. Mutable by default; immutability denoted by an attribute on this attribute.
    5. Exposed as an Attribute if present.
  2. EntityCUID:
    1. MUST be Context-unique; MAY be globally unique.
    2. MUST be formatted as a UDI (absolute or relative).
    3. Cardinality of 1, but whose value can be null (representing a blank node).
    4. Immutable.
    5. Not exposed as an Attribute.

If it was also necessary to support the requirement to be able to obtain a globally-unique identifier for an Entity, we could add a third property:

  1. EntityGUID:
    1. MUST be globally unique.
    2. MUST be formatted as an absolute UDI.
    3. Cardinality of 0..1.
    4. Immutable.
    5. Not exposed as an Attribute.

Back to the top