com.eldrix.hermes.impl.mapdb — com.eldrix/hermes 0.12.602-lmdb-alpha

A store implemented using mapdb

close clj

(close store)

compact clj

(compact store)

ConceptSerializer clj

default-opts clj

DescriptionSerializer clj

get-component-refset-ids clj

(get-component-refset-ids store component-id)

Return the refset-ids to which this component belongs.

get-component-refset-items clj

(get-component-refset-items store component-id)

(get-component-refset-items store component-id refset-id)

Get the refset items for the given component, optionally limited to the refset specified.

• store : MapDBStore
• component-id : id of the component (e.g concept-id or description-id)
• refset-id : (optional) - limit to this refset.

get-concept clj

(get-concept store concept-id)

Returns the concept specified.

get-concept-descriptions clj

(get-concept-descriptions store concept-id)

Return the descriptions for the concept specified.

get-description clj

(get-description store description-id)

Return the description with the given description-id. This uses the descriptionId-conceptId index to determine the concept-id, as all descriptions are actually stored by conceptId-descriptionId-concept because that's a more common operation that finding a description by identifier alone.

get-installed-reference-sets clj

(get-installed-reference-sets store)

Returns a set of identifiers representing installed reference sets.

While it is possible to use the SNOMED ontology to find all reference sets:

(get-leaves store (get-all-children store 900000000000455006))

That might return reference sets with no actual members in the installed edition. Instead, we keep track of installed reference sets as we import reference set items, thus ensuring we have a list that contains only reference sets with members.

get-raw-child-relationships clj

(get-raw-child-relationships store concept-id)

(get-raw-child-relationships store concept-id type-id)

Return the child relationships of the given concept. Returns a list of tuples (from--type--group--to).

get-raw-parent-relationships clj

(get-raw-parent-relationships store concept-id)

(get-raw-parent-relationships store concept-id type-id)

Return the parent relationships of the given concept. Returns a list of tuples (from--type--group--to).

get-refset-field-names clj

(get-refset-field-names store refset-id)

Returns the field names for the given reference set.

The reference set descriptors provide a human-readable description and a type for each column in a reference set, but do not include the camel-cased column identifier in the original source file. On import, we store those column names and provide the lookup here.

get-refset-item clj

(get-refset-item store uuid)

(get-refset-item store msb lsb)

Get the specified refset item. Parameters:

• store : MapDBStore
• UUID : the UUID of the refset item to fetch
• msb/lsb : the most and least significant 64-bit longs representing the UUID.

get-relationship clj

(get-relationship store relationship-id)

get-source-association-referenced-components clj

(get-source-association-referenced-components store component-id refset-id)

Returns a sequence of component identifiers that reference the specified component in the specified association reference set.

get-source-associations clj

(get-source-associations store component-id)

(get-source-associations store component-id refset-id)

Returns the associations in which this component is the target. targetComponentId - refsetId - itemId1 -itemId2.

open-bucket clj

(open-bucket db nm key-serializer value-serializer)

Create or open the named b-tree map with the specified value and key serializers.

Parameters:

• db - mapdb database (org.mapdb.DB)
• key-serializer - serializer for key
• value-serializer - serializer for value.

open-index clj

(open-index db nm)

(open-index db nm serializer)

Create or open the named set, by default, made up of an array of java long primitives.

• db : mapdb database
• nm : name of index
• serializer : serializer to use, by default LONG_ARRAY

open-store clj

(open-store)

(open-store filename)

(open-store filename opts)

RefsetFieldNamesSerializer clj

RefsetItemSerializer clj

RelationshipSerializer clj

status clj

(status store)

stream-all-concepts clj

(stream-all-concepts store ch)

(stream-all-concepts store ch close?)

Asynchronously stream all concepts to the channel specified, and, by default, closing the channel when done unless specified. Returns a channel which, by default, will be closed when done.

stream-all-refset-items clj

(stream-all-refset-items store ch)

(stream-all-refset-items store ch close?)

write-concepts clj

(write-concepts store concepts)

write-descriptions clj

(write-descriptions store descriptions)

Write a batch of descriptions, updating indices when appropriate.

Note unlike other indices, we write in both active and inactive. | Index | Compound key | |:------------------------|:-----------------------------| | .descriptionsConcept | descriptionId -- conceptId |

write-object clj

(write-object bucket o)

(write-object bucket o k)

(write-object bucket o k attempt)

Write an object into a bucket. Parameters:

• bucket : bucket to which to write
• o : object
• k : (optional; the key to use). Correctly handles atomicity and only writes the object if the effectiveTime of the entity is newer than the version that already exists in that bucket. Returns true if object was written.

write-refset-items clj

(write-refset-items store headings items)

Write a batch of refset items, updating indices when appropriate.

Processes each refset item, recording an index to allow lookup of items in the following buckets using the defined keys: | index | simple or compound key | |:--------------------|:-----------------------------------------------------| | .componentRefsets | referencedComponentId - refsetId - itemId1 - itemId2 | | .refsetFieldNames | refsetId -- headings | .associations | targetComponentId - refsetId - | | | - referencedComponentId - itemId1 -itemId2 |

An itemID is a 128 bit integer (UUID) so is stored as two longs (itemId1 itemId2).

write-relationships clj

(write-relationships store relationships)

Write a batch of relationships, updating indices when appropriate.

This populates the child and parent relationship indices. | Index | Compound key | |:----------------------------|:---------------------------------------------| | .conceptChildRelationships | destinationId -- typeId -- group -- sourceId | | .conceptParentRelationships | sourceId -- typeId -- group -- destinationId |