Package org.projectnessie.versioned.persist.nontx

Class NonTransactionalDatabaseAdapter<CONFIG extends NonTransactionalDatabaseAdapterConfig>

java.lang.Object

org.projectnessie.versioned.persist.adapter.spi.AbstractDatabaseAdapter<NonTransactionalOperationContext,CONFIG>

org.projectnessie.versioned.persist.nontx.NonTransactionalDatabaseAdapter<CONFIG>

All Implemented Interfaces:

org.projectnessie.versioned.persist.adapter.DatabaseAdapter

public abstract class NonTransactionalDatabaseAdapter<CONFIG extends NonTransactionalDatabaseAdapterConfig>
extends org.projectnessie.versioned.persist.adapter.spi.AbstractDatabaseAdapter<NonTransactionalOperationContext,CONFIG>

Non-transactional database-adapter implementation suitable for no-sql databases.

Relies on three main entities:

• Global state pointer points to the current HEAD in the global state log and also contains all named-references and their current HEADs.
• Global state log entry is organized as a linked list and contains the new global states for all content-keys and a (list of) its parents..
• Commit log entry is organized as a linked list and contains the changes to content-keys, the commit-metadata and a (list of) its parents.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static interface	NonTransactionalDatabaseAdapter.CasOp<R>	"Body" of a Compare-And-Swap loop that returns the value to apply.
protected static class	NonTransactionalDatabaseAdapter.CasOpResult<R>

Nested classes/interfaces inherited from class org.projectnessie.versioned.persist.adapter.spi.AbstractDatabaseAdapter

org.projectnessie.versioned.persist.adapter.spi.AbstractDatabaseAdapter.CommonAncestorState, org.projectnessie.versioned.persist.adapter.spi.AbstractDatabaseAdapter.ConflictingKeyCheckResult

Field Summary

Fields

Modifier and Type	Field	Description
static java.lang.String	TAG_COMMIT_COUNT
static java.lang.String	TAG_KEY_LIST_COUNT
static java.lang.String	TAG_REF

Fields inherited from class org.projectnessie.versioned.persist.adapter.spi.AbstractDatabaseAdapter

COMMIT_LOG_HASH_SEED, config, NO_ANCESTOR, STORE_WORKER, TAG_COUNT, TAG_HASH

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	NonTransactionalDatabaseAdapter(CONFIG config, org.projectnessie.versioned.persist.adapter.events.AdapterEventConsumer eventConsumer)

Method Summary

Modifier and Type	Method	Description
void	assertCleanStateForTests()
org.projectnessie.versioned.ReferenceAssignedResult	assign(org.projectnessie.versioned.NamedRef assignee, java.util.Optional<org.projectnessie.versioned.Hash> expectedHead, org.projectnessie.versioned.Hash assignTo)
NonTransactionalOperationContext	borrowConnection()
protected org.projectnessie.versioned.Hash	branchHead(NonTransactionalOperationContext ctx, org.projectnessie.versioned.NamedRef ref)	Retrieves the current HEAD of the given named reference.
protected <R> R	casOpLoop(java.lang.String opName, org.projectnessie.versioned.NamedRef ref, org.projectnessie.versioned.persist.nontx.NonTransactionalDatabaseAdapter.CasOpVariant opVariant, NonTransactionalDatabaseAdapter.CasOp<R> casOp, java.util.function.Supplier<java.lang.String> retryErrorMessage)	This is the actual CAS-loop, which applies an operation onto a named-ref.
protected void	cleanUpCommitCas(NonTransactionalOperationContext ctx, java.util.Set<org.projectnessie.versioned.Hash> branchCommits, java.util.Set<org.projectnessie.versioned.Hash> newKeyLists)	If a refLogParentsCas(NonTransactionalOperationContext, int, RefLogParents, RefLogParents) failed, DatabaseAdapter.commit(CommitParams) calls this function to remove the optimistically written data.
protected void	cleanUpRefLogWrite(NonTransactionalOperationContext ctx, org.projectnessie.versioned.Hash refLogId)
org.projectnessie.versioned.CommitResult<org.projectnessie.versioned.persist.adapter.CommitLogEntry>	commit(org.projectnessie.versioned.persist.adapter.CommitParams commitParams)
java.util.stream.Stream<org.projectnessie.versioned.persist.adapter.CommitLogEntry>	commitLog(org.projectnessie.versioned.Hash offset)
org.projectnessie.versioned.ReferenceCreatedResult	create(org.projectnessie.versioned.NamedRef ref, org.projectnessie.versioned.Hash target)
protected boolean	createNamedReference(NonTransactionalOperationContext ctx, org.projectnessie.versioned.NamedRef ref, org.projectnessie.versioned.Hash newHead)
org.projectnessie.versioned.ReferenceDeletedResult	delete(org.projectnessie.versioned.NamedRef reference, java.util.Optional<org.projectnessie.versioned.Hash> expectedHead)
protected boolean	deleteNamedReference(NonTransactionalOperationContext ctx, org.projectnessie.versioned.NamedRef ref, org.projectnessie.versioned.persist.serialize.AdapterTypes.RefPointer refHead)
java.util.stream.Stream<org.projectnessie.versioned.persist.adapter.Difference>	diff(org.projectnessie.versioned.Hash from, org.projectnessie.versioned.Hash to, org.projectnessie.versioned.persist.adapter.KeyFilterPredicate keyFilter)
protected abstract void	doAddToNamedReferences(NonTransactionalOperationContext ctx, java.util.stream.Stream<org.projectnessie.versioned.NamedRef> refStream, int addToSegment)
protected abstract void	doCleanUpCommitCas(NonTransactionalOperationContext ctx, java.util.Set<org.projectnessie.versioned.Hash> branchCommits, java.util.Set<org.projectnessie.versioned.Hash> newKeyLists)
protected abstract void	doCleanUpRefLogWrite(NonTransactionalOperationContext ctx, org.projectnessie.versioned.Hash refLogId)
protected abstract boolean	doCreateNamedReference(NonTransactionalOperationContext ctx, org.projectnessie.versioned.persist.serialize.AdapterTypes.NamedReference namedReference)
protected abstract boolean	doDeleteNamedReference(NonTransactionalOperationContext ctx, org.projectnessie.versioned.NamedRef ref, org.projectnessie.versioned.persist.serialize.AdapterTypes.RefPointer refHead)
protected abstract void	doEraseRepo()
protected abstract org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStateLogEntry	doFetchFromGlobalLog(NonTransactionalOperationContext ctx, org.projectnessie.versioned.Hash id)
protected abstract org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer	doFetchGlobalPointer(NonTransactionalOperationContext ctx)
protected java.util.Map<org.projectnessie.versioned.persist.adapter.ContentId,org.projectnessie.nessie.relocated.protobuf.ByteString>	doFetchGlobalStates(NonTransactionalOperationContext ctx, java.util.Set<org.projectnessie.versioned.persist.adapter.ContentId> contentIds)
protected abstract java.util.List<org.projectnessie.versioned.persist.serialize.AdapterTypes.NamedReference>	doFetchNamedReference(NonTransactionalOperationContext ctx, java.util.List<java.lang.String> refNames)
protected abstract java.util.List<org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStateLogEntry>	doFetchPageFromGlobalLog(NonTransactionalOperationContext ctx, java.util.List<org.projectnessie.versioned.Hash> hashes)
protected abstract java.util.List<org.projectnessie.versioned.persist.serialize.AdapterTypes.ReferenceNames>	doFetchReferenceNames(NonTransactionalOperationContext ctx, int segment, int prefetchSegments)
protected abstract org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents	doFetchRefLogParents(NonTransactionalOperationContext ctx, int stripe)
protected abstract org.projectnessie.versioned.persist.adapter.RepoDescription	doFetchRepositoryDescription(NonTransactionalOperationContext ctx)
protected abstract boolean	doGlobalPointerCas(NonTransactionalOperationContext ctx, org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer expected, org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer newPointer)
protected abstract boolean	doRefLogParentsCas(NonTransactionalOperationContext ctx, int stripe, org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents previousEntry, org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents newEntry)
protected abstract void	doRemoveFromNamedReferences(NonTransactionalOperationContext ctx, org.projectnessie.versioned.NamedRef ref, int removeFromSegment)
protected abstract boolean	doTryUpdateRepositoryDescription(NonTransactionalOperationContext ctx, org.projectnessie.versioned.persist.adapter.RepoDescription expected, org.projectnessie.versioned.persist.adapter.RepoDescription updateTo)
protected abstract boolean	doUpdateNamedReference(NonTransactionalOperationContext ctx, org.projectnessie.versioned.NamedRef ref, org.projectnessie.versioned.persist.serialize.AdapterTypes.RefPointer refHead, org.projectnessie.versioned.Hash newHead)
protected abstract void	doWriteRefLog(NonTransactionalOperationContext ctx, org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogEntry entry)
void	eraseRepo()
protected org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStateLogEntry	fetchFromGlobalLog(NonTransactionalOperationContext ctx, org.projectnessie.versioned.Hash id)	Load the global-log entry with the given id.
protected org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer	fetchGlobalPointer(NonTransactionalOperationContext ctx)	Load the current global-state-pointer.
protected org.projectnessie.versioned.persist.serialize.AdapterTypes.NamedReference	fetchNamedReference(NonTransactionalOperationContext ctx, java.lang.String refName)
protected java.util.List<org.projectnessie.versioned.persist.serialize.AdapterTypes.NamedReference>	fetchNamedReference(NonTransactionalOperationContext ctx, java.util.List<java.lang.String> refNames)
protected java.util.stream.Stream<org.projectnessie.versioned.persist.serialize.AdapterTypes.NamedReference>	fetchNamedReferences(NonTransactionalOperationContext ctx)
protected java.util.List<org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStateLogEntry>	fetchPageFromGlobalLog(NonTransactionalOperationContext ctx, java.util.List<org.projectnessie.versioned.Hash> hashes)
protected java.util.Spliterator<org.projectnessie.versioned.persist.serialize.AdapterTypes.ReferenceNames>	fetchReferenceNames(NonTransactionalOperationContext ctx)
protected java.util.List<org.projectnessie.versioned.persist.serialize.AdapterTypes.ReferenceNames>	fetchReferenceNames(NonTransactionalOperationContext ctx, int segment, int prefetchSegments)
protected org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents	fetchRefLogParents(NonTransactionalOperationContext ctx, int stripe)
org.projectnessie.versioned.persist.adapter.RepoDescription	fetchRepositoryDescription()
protected org.projectnessie.versioned.persist.adapter.RepoDescription	fetchRepositoryDescription(NonTransactionalOperationContext ctx)
protected int	findAvailableNamedReferencesSegment(NonTransactionalOperationContext ctx)	Find the segment that has enough room for another AdapterTypes.NamedReference.
java.util.Optional<org.projectnessie.versioned.persist.adapter.ContentIdAndBytes>	globalContent(org.projectnessie.versioned.persist.adapter.ContentId contentId)
protected static org.projectnessie.nessie.relocated.protobuf.ByteString	globalLogHead(org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer pointer)
protected boolean	globalPointerCas(NonTransactionalOperationContext ctx, org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer expected, org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer newPointer)	Atomically update the global-commit-pointer to the given new-global-head, if the value in the database is the given expected-global-head.
protected org.projectnessie.versioned.Hash	hashOnRef(NonTransactionalOperationContext ctx, org.projectnessie.versioned.NamedRef reference, java.util.Optional<org.projectnessie.versioned.Hash> hashOnRef)	Convenience method for hashOnRef(ctx, reference.getReference(), branchHead(fetchGlobalPointer(ctx), reference), reference.getHashOnReference()).
org.projectnessie.versioned.Hash	hashOnReference(org.projectnessie.versioned.NamedRef namedReference, java.util.Optional<org.projectnessie.versioned.Hash> hashOnReference)
void	initializeRepo(java.lang.String defaultBranchName)
java.util.stream.Stream<org.projectnessie.versioned.persist.adapter.KeyListEntry>	keys(org.projectnessie.versioned.Hash commit, org.projectnessie.versioned.persist.adapter.KeyFilterPredicate keyFilter)
org.projectnessie.versioned.MergeResult<org.projectnessie.versioned.persist.adapter.CommitLogEntry>	merge(org.projectnessie.versioned.persist.adapter.MergeParams mergeParams)
org.projectnessie.versioned.ReferenceInfo<org.projectnessie.nessie.relocated.protobuf.ByteString>	namedRef(java.lang.String ref, org.projectnessie.versioned.GetNamedRefsParams params)
protected static org.projectnessie.versioned.ReferenceInfo<org.projectnessie.nessie.relocated.protobuf.ByteString>	namedReferenceToReferenceInfo(org.projectnessie.versioned.persist.serialize.AdapterTypes.NamedReference r)
java.util.stream.Stream<org.projectnessie.versioned.ReferenceInfo<org.projectnessie.nessie.relocated.protobuf.ByteString>>	namedRefs(org.projectnessie.versioned.GetNamedRefsParams params)
protected static org.projectnessie.versioned.persist.serialize.AdapterTypes.RefType	protoTypeForRef(org.projectnessie.versioned.NamedRef target)	Get the protobuf-enum-value for a named-reference.
protected java.util.Spliterator<org.projectnessie.versioned.persist.adapter.RefLog>	readRefLog(NonTransactionalOperationContext ctx, org.projectnessie.versioned.Hash initialHash)
protected org.projectnessie.versioned.ReferenceInfo<org.projectnessie.nessie.relocated.protobuf.ByteString>	referenceHead(NonTransactionalOperationContext ctx, java.lang.String ref)
java.util.stream.Stream<org.projectnessie.versioned.persist.adapter.RefLog>	refLog(org.projectnessie.versioned.Hash offset)
protected boolean	refLogParentsCas(NonTransactionalOperationContext ctx, int stripe, org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents previousEntry, org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents newEntry)
protected int	refLogStripeForName(java.lang.String refName)
java.util.Map<java.lang.String,java.util.Map<java.lang.String,java.lang.String>>	repoMaintenance(org.projectnessie.versioned.persist.adapter.RepoMaintenanceParams params)
protected static org.projectnessie.versioned.NamedRef	toNamedRef(org.projectnessie.versioned.persist.serialize.AdapterTypes.RefType type, java.lang.String name)	Transform the protobuf-enum-value for the named-reference-type plus the reference name into a NamedRef.
org.projectnessie.versioned.MergeResult<org.projectnessie.versioned.persist.adapter.CommitLogEntry>	transplant(org.projectnessie.versioned.persist.adapter.TransplantParams transplantParams)
protected boolean	tryUpdateRepositoryDescription(NonTransactionalOperationContext ctx, org.projectnessie.versioned.persist.adapter.RepoDescription expected, org.projectnessie.versioned.persist.adapter.RepoDescription updateTo)
protected abstract void	unsafeWriteGlobalPointer(NonTransactionalOperationContext ctx, org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer pointer)	Unsafe operation to initialize a repository: unconditionally writes the global-state-pointer.
protected abstract void	unsafeWriteRefLogStripe(NonTransactionalOperationContext ctx, int stripe, org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents refLogParents)
void	updateMultipleCommits(java.util.List<org.projectnessie.versioned.persist.adapter.CommitLogEntry> commitLogEntries)
protected boolean	updateNamedReference(NonTransactionalOperationContext ctx, org.projectnessie.versioned.NamedRef ref, org.projectnessie.versioned.persist.serialize.AdapterTypes.RefPointer refHead, org.projectnessie.versioned.Hash newHead)
void	updateRepositoryDescription(java.util.function.Function<org.projectnessie.versioned.persist.adapter.RepoDescription,org.projectnessie.versioned.persist.adapter.RepoDescription> updater)
java.util.Map<org.projectnessie.model.ContentKey,org.projectnessie.versioned.persist.adapter.ContentAndState>	values(org.projectnessie.versioned.Hash commit, java.util.Collection<org.projectnessie.model.ContentKey> keys, org.projectnessie.versioned.persist.adapter.KeyFilterPredicate keyFilter)
void	writeMultipleCommits(java.util.List<org.projectnessie.versioned.persist.adapter.CommitLogEntry> commitLogEntries)
protected void	writeRefLog(NonTransactionalOperationContext ctx, org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogEntry entry)	Write a new refLog-entry with a best-effort approach to prevent hash-collisions but without any other consistency checks/guarantees.
protected org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogEntry	writeRefLogEntry(NonTransactionalOperationContext ctx, org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents refLogParents, java.util.function.Consumer<org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogEntry.Builder> refLogEntryBuilder)

Methods inherited from class org.projectnessie.versioned.persist.adapter.spi.AbstractDatabaseAdapter

buildDiff, buildIndividualCommit, buildKeyList, checkConflictingKeysForCommit, checkExpectedGlobalStates, checkForModifiedKeysBetweenExpectedAndCurrentCommit, commitAttempt, copyCommits, doFetchFromCommitLog, doFetchFromRefLog, doFetchKeyLists, doFetchMultipleFromCommitLog, doFetchPageFromRefLog, doScanAllCommitLogEntries, doUpdateMultipleCommits, doWriteIndividualCommit, doWriteKeyListEntities, doWriteMultipleCommits, entitySize, entitySize, fetchCommitLogEntries, fetchFromCommitLog, fetchFromRefLog, fetchGlobalStates, fetchKeyLists, fetchPageFromRefLog, fetchValues, findCommonAncestor, findCommonAncestor, getConfig, getEventConsumer, hashOnRef, hashOnRef, hasKeyCollisions, individualCommitHash, keysForCommitEntry, keysForCommitEntry, logFetcher, logFetcherWithPage, maxEntitySize, mergeAttempt, mergeTransplantCommon, namedReferenceWithCommitMeta, namedRefsAnyRetrieves, namedRefsFilterAndEnhance, namedRefsMaybeFilter, namedRefsRequiresBaseReference, namedRefsRequiresBaseReference, namedRefsRetrieveOptionsForReference, namedRefsRetrieveOptionsForReference, namedRefsWithDefaultBranchRelatedInfo, noAncestorHash, readCommitLog, readCommitLogHashes, readCommitLogHashesStream, readCommitLogStream, readCommitLogStream, readRefLogStream, rebuildKeyList, repositoryEvent, scanAllCommitLogEntries, squashCommits, transplantAttempt, tryLoopStateCompletion, validateHashExists, writeIndividualCommit, writeKeyListEntities, writeMultipleCommits

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

TAG_COMMIT_COUNT

public static final java.lang.String TAG_COMMIT_COUNT

See Also:

Constant Field Values

TAG_KEY_LIST_COUNT

public static final java.lang.String TAG_KEY_LIST_COUNT

See Also:

Constant Field Values

TAG_REF

public static final java.lang.String TAG_REF

See Also:

Constant Field Values

Constructor Detail

NonTransactionalDatabaseAdapter

protected NonTransactionalDatabaseAdapter(CONFIG config,
                                          org.projectnessie.versioned.persist.adapter.events.AdapterEventConsumer eventConsumer)

Method Detail

borrowConnection

public NonTransactionalOperationContext borrowConnection()

Specified by:

borrowConnection in class org.projectnessie.versioned.persist.adapter.spi.AbstractDatabaseAdapter<NonTransactionalOperationContext,CONFIG extends NonTransactionalDatabaseAdapterConfig>

hashOnReference

public org.projectnessie.versioned.Hash hashOnReference(org.projectnessie.versioned.NamedRef namedReference,
                                                        java.util.Optional<org.projectnessie.versioned.Hash> hashOnReference)
                                                 throws org.projectnessie.versioned.ReferenceNotFoundException

Throws:

org.projectnessie.versioned.ReferenceNotFoundException

values

public java.util.Map<org.projectnessie.model.ContentKey,org.projectnessie.versioned.persist.adapter.ContentAndState> values(org.projectnessie.versioned.Hash commit,
                                                                                                                                  java.util.Collection<org.projectnessie.model.ContentKey> keys,
                                                                                                                                  org.projectnessie.versioned.persist.adapter.KeyFilterPredicate keyFilter)
                                                                                                                           throws org.projectnessie.versioned.ReferenceNotFoundException

Throws:

org.projectnessie.versioned.ReferenceNotFoundException

commitLog

@MustBeClosed
public java.util.stream.Stream<org.projectnessie.versioned.persist.adapter.CommitLogEntry> commitLog(org.projectnessie.versioned.Hash offset)
                                                                                              throws org.projectnessie.versioned.ReferenceNotFoundException

Throws:

org.projectnessie.versioned.ReferenceNotFoundException

namedRef

public org.projectnessie.versioned.ReferenceInfo<org.projectnessie.nessie.relocated.protobuf.ByteString> namedRef(java.lang.String ref,
                                                                                                                  org.projectnessie.versioned.GetNamedRefsParams params)
                                                                                                           throws org.projectnessie.versioned.ReferenceNotFoundException

Throws:

org.projectnessie.versioned.ReferenceNotFoundException

namedRefs

@MustBeClosed
public java.util.stream.Stream<org.projectnessie.versioned.ReferenceInfo<org.projectnessie.nessie.relocated.protobuf.ByteString>> namedRefs(org.projectnessie.versioned.GetNamedRefsParams params)
                                                                                                                                     throws org.projectnessie.versioned.ReferenceNotFoundException

Throws:

org.projectnessie.versioned.ReferenceNotFoundException

keys

@MustBeClosed
public java.util.stream.Stream<org.projectnessie.versioned.persist.adapter.KeyListEntry> keys(org.projectnessie.versioned.Hash commit,
                                                                                              org.projectnessie.versioned.persist.adapter.KeyFilterPredicate keyFilter)
                                                                                       throws org.projectnessie.versioned.ReferenceNotFoundException

Throws:

org.projectnessie.versioned.ReferenceNotFoundException

merge

public org.projectnessie.versioned.MergeResult<org.projectnessie.versioned.persist.adapter.CommitLogEntry> merge(org.projectnessie.versioned.persist.adapter.MergeParams mergeParams)
                                                                                                          throws org.projectnessie.versioned.ReferenceNotFoundException,
                                                                                                                 org.projectnessie.versioned.ReferenceConflictException

Throws:

org.projectnessie.versioned.ReferenceNotFoundException

org.projectnessie.versioned.ReferenceConflictException

transplant

public org.projectnessie.versioned.MergeResult<org.projectnessie.versioned.persist.adapter.CommitLogEntry> transplant(org.projectnessie.versioned.persist.adapter.TransplantParams transplantParams)
                                                                                                               throws org.projectnessie.versioned.ReferenceNotFoundException,
                                                                                                                      org.projectnessie.versioned.ReferenceConflictException

Throws:

org.projectnessie.versioned.ReferenceNotFoundException

org.projectnessie.versioned.ReferenceConflictException

commit

public org.projectnessie.versioned.CommitResult<org.projectnessie.versioned.persist.adapter.CommitLogEntry> commit(org.projectnessie.versioned.persist.adapter.CommitParams commitParams)
                                                                                                            throws org.projectnessie.versioned.ReferenceConflictException,
                                                                                                                   org.projectnessie.versioned.ReferenceNotFoundException

Throws:

org.projectnessie.versioned.ReferenceConflictException

org.projectnessie.versioned.ReferenceNotFoundException

create

public org.projectnessie.versioned.ReferenceCreatedResult create(org.projectnessie.versioned.NamedRef ref,
                                                                 org.projectnessie.versioned.Hash target)
                                                          throws org.projectnessie.versioned.ReferenceAlreadyExistsException,
                                                                 org.projectnessie.versioned.ReferenceNotFoundException

Throws:

org.projectnessie.versioned.ReferenceAlreadyExistsException

org.projectnessie.versioned.ReferenceNotFoundException

delete

public org.projectnessie.versioned.ReferenceDeletedResult delete(org.projectnessie.versioned.NamedRef reference,
                                                                 java.util.Optional<org.projectnessie.versioned.Hash> expectedHead)
                                                          throws org.projectnessie.versioned.ReferenceNotFoundException,
                                                                 org.projectnessie.versioned.ReferenceConflictException

Throws:

org.projectnessie.versioned.ReferenceNotFoundException

org.projectnessie.versioned.ReferenceConflictException

assign

public org.projectnessie.versioned.ReferenceAssignedResult assign(org.projectnessie.versioned.NamedRef assignee,
                                                                  java.util.Optional<org.projectnessie.versioned.Hash> expectedHead,
                                                                  org.projectnessie.versioned.Hash assignTo)
                                                           throws org.projectnessie.versioned.ReferenceNotFoundException,
                                                                  org.projectnessie.versioned.ReferenceConflictException

Throws:

org.projectnessie.versioned.ReferenceNotFoundException

org.projectnessie.versioned.ReferenceConflictException

diff

@MustBeClosed
public java.util.stream.Stream<org.projectnessie.versioned.persist.adapter.Difference> diff(org.projectnessie.versioned.Hash from,
                                                                                            org.projectnessie.versioned.Hash to,
                                                                                            org.projectnessie.versioned.persist.adapter.KeyFilterPredicate keyFilter)
                                                                                     throws org.projectnessie.versioned.ReferenceNotFoundException

Throws:

org.projectnessie.versioned.ReferenceNotFoundException

initializeRepo

public void initializeRepo(java.lang.String defaultBranchName)

eraseRepo

public void eraseRepo()

doEraseRepo

protected abstract void doEraseRepo()

globalContent

public java.util.Optional<org.projectnessie.versioned.persist.adapter.ContentIdAndBytes> globalContent(org.projectnessie.versioned.persist.adapter.ContentId contentId)

fetchRepositoryDescription

public org.projectnessie.versioned.persist.adapter.RepoDescription fetchRepositoryDescription()

updateRepositoryDescription

public void updateRepositoryDescription(java.util.function.Function<org.projectnessie.versioned.persist.adapter.RepoDescription,org.projectnessie.versioned.persist.adapter.RepoDescription> updater)
                                 throws org.projectnessie.versioned.ReferenceConflictException

Throws:

org.projectnessie.versioned.ReferenceConflictException

repoMaintenance

public java.util.Map<java.lang.String,java.util.Map<java.lang.String,java.lang.String>> repoMaintenance(org.projectnessie.versioned.persist.adapter.RepoMaintenanceParams params)

assertCleanStateForTests

public void assertCleanStateForTests()

writeMultipleCommits

public void writeMultipleCommits(java.util.List<org.projectnessie.versioned.persist.adapter.CommitLogEntry> commitLogEntries)
                          throws org.projectnessie.versioned.ReferenceConflictException

Throws:

org.projectnessie.versioned.ReferenceConflictException

updateMultipleCommits

public void updateMultipleCommits(java.util.List<org.projectnessie.versioned.persist.adapter.CommitLogEntry> commitLogEntries)
                           throws org.projectnessie.versioned.ReferenceNotFoundException

Throws:

org.projectnessie.versioned.ReferenceNotFoundException

fetchRepositoryDescription

protected final org.projectnessie.versioned.persist.adapter.RepoDescription fetchRepositoryDescription(NonTransactionalOperationContext ctx)

doFetchRepositoryDescription

protected abstract org.projectnessie.versioned.persist.adapter.RepoDescription doFetchRepositoryDescription(NonTransactionalOperationContext ctx)

tryUpdateRepositoryDescription

protected final boolean tryUpdateRepositoryDescription(NonTransactionalOperationContext ctx,
                                                       org.projectnessie.versioned.persist.adapter.RepoDescription expected,
                                                       org.projectnessie.versioned.persist.adapter.RepoDescription updateTo)

doTryUpdateRepositoryDescription

protected abstract boolean doTryUpdateRepositoryDescription(NonTransactionalOperationContext ctx,
                                                            org.projectnessie.versioned.persist.adapter.RepoDescription expected,
                                                            org.projectnessie.versioned.persist.adapter.RepoDescription updateTo)

protoTypeForRef

protected static org.projectnessie.versioned.persist.serialize.AdapterTypes.RefType protoTypeForRef(org.projectnessie.versioned.NamedRef target)

Get the protobuf-enum-value for a named-reference.

toNamedRef

protected static org.projectnessie.versioned.NamedRef toNamedRef(org.projectnessie.versioned.persist.serialize.AdapterTypes.RefType type,
                                                                 java.lang.String name)

Transform the protobuf-enum-value for the named-reference-type plus the reference name into a NamedRef.

hashOnRef

protected org.projectnessie.versioned.Hash hashOnRef(NonTransactionalOperationContext ctx,
                                                     org.projectnessie.versioned.NamedRef reference,
                                                     java.util.Optional<org.projectnessie.versioned.Hash> hashOnRef)
                                              throws org.projectnessie.versioned.ReferenceNotFoundException

Convenience method for hashOnRef(ctx, reference.getReference(), branchHead(fetchGlobalPointer(ctx), reference), reference.getHashOnReference()).

Throws:

org.projectnessie.versioned.ReferenceNotFoundException

casOpLoop

protected <R> R casOpLoop(java.lang.String opName,
                          org.projectnessie.versioned.NamedRef ref,
                          org.projectnessie.versioned.persist.nontx.NonTransactionalDatabaseAdapter.CasOpVariant opVariant,
                          NonTransactionalDatabaseAdapter.CasOp<R> casOp,
                          java.util.function.Supplier<java.lang.String> retryErrorMessage)
                   throws org.projectnessie.versioned.VersionStoreException

This is the actual CAS-loop, which applies an operation onto a named-ref.

Parameters:

ref - named-reference on which the operation happens

opVariant - influences the behavior, whether the operation adds one or more commits and whether the operation deletes the named reference.

casOp - the implementation of the CAS-operation

retryErrorMessage - provides an error-message for a ReferenceConflictException when the CAS operation failed to complete within the configured time and number of retries.

Throws:

org.projectnessie.versioned.VersionStoreException

namedReferenceToReferenceInfo

protected static org.projectnessie.versioned.ReferenceInfo<org.projectnessie.nessie.relocated.protobuf.ByteString> namedReferenceToReferenceInfo(org.projectnessie.versioned.persist.serialize.AdapterTypes.NamedReference r)

readRefLog

protected java.util.Spliterator<org.projectnessie.versioned.persist.adapter.RefLog> readRefLog(NonTransactionalOperationContext ctx,
                                                                                               org.projectnessie.versioned.Hash initialHash)
                                                                                        throws org.projectnessie.versioned.RefLogNotFoundException

Specified by:

readRefLog in class org.projectnessie.versioned.persist.adapter.spi.AbstractDatabaseAdapter<NonTransactionalOperationContext,CONFIG extends NonTransactionalDatabaseAdapterConfig>

Throws:

org.projectnessie.versioned.RefLogNotFoundException

unsafeWriteRefLogStripe

protected abstract void unsafeWriteRefLogStripe(NonTransactionalOperationContext ctx,
                                                int stripe,
                                                org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents refLogParents)

refLogParentsCas

protected final boolean refLogParentsCas(NonTransactionalOperationContext ctx,
                                         int stripe,
                                         org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents previousEntry,
                                         org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents newEntry)

doRefLogParentsCas

protected abstract boolean doRefLogParentsCas(NonTransactionalOperationContext ctx,
                                              int stripe,
                                              org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents previousEntry,
                                              org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents newEntry)

fetchRefLogParents

protected final org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents fetchRefLogParents(NonTransactionalOperationContext ctx,
                                                                                                            int stripe)

refLogStripeForName

protected final int refLogStripeForName(java.lang.String refName)

doFetchRefLogParents

protected abstract org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents doFetchRefLogParents(NonTransactionalOperationContext ctx,
                                                                                                                 int stripe)

fetchNamedReference

protected final org.projectnessie.versioned.persist.serialize.AdapterTypes.NamedReference fetchNamedReference(NonTransactionalOperationContext ctx,
                                                                                                              java.lang.String refName)

fetchNamedReference

protected final java.util.List<org.projectnessie.versioned.persist.serialize.AdapterTypes.NamedReference> fetchNamedReference(NonTransactionalOperationContext ctx,
                                                                                                                              java.util.List<java.lang.String> refNames)

doFetchNamedReference

protected abstract java.util.List<org.projectnessie.versioned.persist.serialize.AdapterTypes.NamedReference> doFetchNamedReference(NonTransactionalOperationContext ctx,
                                                                                                                                   java.util.List<java.lang.String> refNames)

fetchNamedReferences

@MustBeClosed
protected final java.util.stream.Stream<org.projectnessie.versioned.persist.serialize.AdapterTypes.NamedReference> fetchNamedReferences(NonTransactionalOperationContext ctx)

createNamedReference

protected final boolean createNamedReference(NonTransactionalOperationContext ctx,
                                             org.projectnessie.versioned.NamedRef ref,
                                             org.projectnessie.versioned.Hash newHead)

findAvailableNamedReferencesSegment

protected int findAvailableNamedReferencesSegment(NonTransactionalOperationContext ctx)

Find the segment that has enough room for another AdapterTypes.NamedReference.

doAddToNamedReferences

protected abstract void doAddToNamedReferences(NonTransactionalOperationContext ctx,
                                               java.util.stream.Stream<org.projectnessie.versioned.NamedRef> refStream,
                                               int addToSegment)

doRemoveFromNamedReferences

protected abstract void doRemoveFromNamedReferences(NonTransactionalOperationContext ctx,
                                                    org.projectnessie.versioned.NamedRef ref,
                                                    int removeFromSegment)

doCreateNamedReference

protected abstract boolean doCreateNamedReference(NonTransactionalOperationContext ctx,
                                                  org.projectnessie.versioned.persist.serialize.AdapterTypes.NamedReference namedReference)

deleteNamedReference

protected final boolean deleteNamedReference(NonTransactionalOperationContext ctx,
                                             org.projectnessie.versioned.NamedRef ref,
                                             org.projectnessie.versioned.persist.serialize.AdapterTypes.RefPointer refHead)

doDeleteNamedReference

protected abstract boolean doDeleteNamedReference(NonTransactionalOperationContext ctx,
                                                  org.projectnessie.versioned.NamedRef ref,
                                                  org.projectnessie.versioned.persist.serialize.AdapterTypes.RefPointer refHead)

updateNamedReference

protected final boolean updateNamedReference(NonTransactionalOperationContext ctx,
                                             org.projectnessie.versioned.NamedRef ref,
                                             org.projectnessie.versioned.persist.serialize.AdapterTypes.RefPointer refHead,
                                             org.projectnessie.versioned.Hash newHead)

doUpdateNamedReference

protected abstract boolean doUpdateNamedReference(NonTransactionalOperationContext ctx,
                                                  org.projectnessie.versioned.NamedRef ref,
                                                  org.projectnessie.versioned.persist.serialize.AdapterTypes.RefPointer refHead,
                                                  org.projectnessie.versioned.Hash newHead)

writeRefLog

protected final void writeRefLog(NonTransactionalOperationContext ctx,
                                 org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogEntry entry)
                          throws org.projectnessie.versioned.ReferenceConflictException

Write a new refLog-entry with a best-effort approach to prevent hash-collisions but without any other consistency checks/guarantees. Some implementations however can enforce strict consistency checks/guarantees.

Throws:

org.projectnessie.versioned.ReferenceConflictException

doWriteRefLog

protected abstract void doWriteRefLog(NonTransactionalOperationContext ctx,
                                      org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogEntry entry)
                               throws org.projectnessie.versioned.ReferenceConflictException

Throws:

org.projectnessie.versioned.ReferenceConflictException

unsafeWriteGlobalPointer

protected abstract void unsafeWriteGlobalPointer(NonTransactionalOperationContext ctx,
                                                 org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer pointer)

Unsafe operation to initialize a repository: unconditionally writes the global-state-pointer.

globalPointerCas

protected final boolean globalPointerCas(NonTransactionalOperationContext ctx,
                                         org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer expected,
                                         org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer newPointer)

Atomically update the global-commit-pointer to the given new-global-head, if the value in the database is the given expected-global-head.

doGlobalPointerCas

protected abstract boolean doGlobalPointerCas(NonTransactionalOperationContext ctx,
                                              org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer expected,
                                              org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer newPointer)

cleanUpCommitCas

protected final void cleanUpCommitCas(NonTransactionalOperationContext ctx,
                                      java.util.Set<org.projectnessie.versioned.Hash> branchCommits,
                                      java.util.Set<org.projectnessie.versioned.Hash> newKeyLists)

If a refLogParentsCas(NonTransactionalOperationContext, int, RefLogParents, RefLogParents) failed, DatabaseAdapter.commit(CommitParams) calls this function to remove the optimistically written data.

Implementation notes: non-transactional implementations must delete entries for the given keys, no-op for transactional implementations.

doCleanUpCommitCas

protected abstract void doCleanUpCommitCas(NonTransactionalOperationContext ctx,
                                           java.util.Set<org.projectnessie.versioned.Hash> branchCommits,
                                           java.util.Set<org.projectnessie.versioned.Hash> newKeyLists)

cleanUpRefLogWrite

protected final void cleanUpRefLogWrite(NonTransactionalOperationContext ctx,
                                        org.projectnessie.versioned.Hash refLogId)

doCleanUpRefLogWrite

protected abstract void doCleanUpRefLogWrite(NonTransactionalOperationContext ctx,
                                             org.projectnessie.versioned.Hash refLogId)

fetchReferenceNames

protected final java.util.Spliterator<org.projectnessie.versioned.persist.serialize.AdapterTypes.ReferenceNames> fetchReferenceNames(NonTransactionalOperationContext ctx)

fetchReferenceNames

protected final java.util.List<org.projectnessie.versioned.persist.serialize.AdapterTypes.ReferenceNames> fetchReferenceNames(NonTransactionalOperationContext ctx,
                                                                                                                              int segment,
                                                                                                                              int prefetchSegments)

doFetchReferenceNames

protected abstract java.util.List<org.projectnessie.versioned.persist.serialize.AdapterTypes.ReferenceNames> doFetchReferenceNames(NonTransactionalOperationContext ctx,
                                                                                                                                   int segment,
                                                                                                                                   int prefetchSegments)

branchHead

protected org.projectnessie.versioned.Hash branchHead(NonTransactionalOperationContext ctx,
                                                      org.projectnessie.versioned.NamedRef ref)
                                               throws org.projectnessie.versioned.ReferenceNotFoundException

Retrieves the current HEAD of the given named reference.

Parameters:

ref - reference to retrieve the current HEAD for

Returns:

current HEAD, not null

Throws:

org.projectnessie.versioned.ReferenceNotFoundException - if ref does not exist.

referenceHead

protected org.projectnessie.versioned.ReferenceInfo<org.projectnessie.nessie.relocated.protobuf.ByteString> referenceHead(NonTransactionalOperationContext ctx,
                                                                                                                          java.lang.String ref)
                                                                                                                   throws org.projectnessie.versioned.ReferenceNotFoundException

Throws:

org.projectnessie.versioned.ReferenceNotFoundException

fetchGlobalPointer

protected final org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer fetchGlobalPointer(NonTransactionalOperationContext ctx)

Load the current global-state-pointer.

Returns:

the current global points if set, or null if not set.

doFetchGlobalPointer

protected abstract org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer doFetchGlobalPointer(NonTransactionalOperationContext ctx)

globalLogHead

protected static org.projectnessie.nessie.relocated.protobuf.ByteString globalLogHead(org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStatePointer pointer)

doFetchGlobalStates

protected java.util.Map<org.projectnessie.versioned.persist.adapter.ContentId,org.projectnessie.nessie.relocated.protobuf.ByteString> doFetchGlobalStates(NonTransactionalOperationContext ctx,
                                                                                                                                                                java.util.Set<org.projectnessie.versioned.persist.adapter.ContentId> contentIds)

Specified by:

doFetchGlobalStates in class org.projectnessie.versioned.persist.adapter.spi.AbstractDatabaseAdapter<NonTransactionalOperationContext,CONFIG extends NonTransactionalDatabaseAdapterConfig>

fetchFromGlobalLog

protected final org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStateLogEntry fetchFromGlobalLog(NonTransactionalOperationContext ctx,
                                                                                                                  org.projectnessie.versioned.Hash id)

Load the global-log entry with the given id.

Returns:

the loaded entry if it is available, null if it does not exist.

doFetchFromGlobalLog

protected abstract org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStateLogEntry doFetchFromGlobalLog(NonTransactionalOperationContext ctx,
                                                                                                                       org.projectnessie.versioned.Hash id)

fetchPageFromGlobalLog

protected final java.util.List<org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStateLogEntry> fetchPageFromGlobalLog(NonTransactionalOperationContext ctx,
                                                                                                                                      java.util.List<org.projectnessie.versioned.Hash> hashes)

doFetchPageFromGlobalLog

protected abstract java.util.List<org.projectnessie.versioned.persist.serialize.AdapterTypes.GlobalStateLogEntry> doFetchPageFromGlobalLog(NonTransactionalOperationContext ctx,
                                                                                                                                           java.util.List<org.projectnessie.versioned.Hash> hashes)

writeRefLogEntry

protected org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogEntry writeRefLogEntry(NonTransactionalOperationContext ctx,
                                                                                                  org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogParents refLogParents,
                                                                                                  java.util.function.Consumer<org.projectnessie.versioned.persist.serialize.AdapterTypes.RefLogEntry.Builder> refLogEntryBuilder)
                                                                                           throws org.projectnessie.versioned.ReferenceConflictException

Throws:

org.projectnessie.versioned.ReferenceConflictException

refLog

@MustBeClosed
public java.util.stream.Stream<org.projectnessie.versioned.persist.adapter.RefLog> refLog(org.projectnessie.versioned.Hash offset)
                                                                                   throws org.projectnessie.versioned.RefLogNotFoundException

Throws:

org.projectnessie.versioned.RefLogNotFoundException