Safe Haskell	Safe-Inferred
Language	Haskell2010

U.Codebase.Sqlite.Queries

Contents

text table
- name segments
hash table
hash_object table
object table
namespace_statistics table
causals
- causal table
- causal_parent table
watch table
projects
indexes
hash prefix lookup
Reflog
garbage collection
sync temp entities
elaborate hashes
current project path
migrations
- schema version
- helpers for various migrations
db misc
Types

Description

Some naming conventions used in this module:

32: the base32 representation of a hash
expect: retrieve something that's known to exist
load: retrieve something that's not known to exist (so the return type is a Maybe, or another container that could be empty)
save: idempotent (on conflict do nothing) insert, and return the id of the thing (usually)

Synopsis

saveText :: Text -> Transaction TextId
saveTexts :: Traversable f => f Text -> Transaction (f TextId)
loadTextId :: Text -> Transaction (Maybe TextId)
expectTextId :: Text -> Transaction TextId
expectText :: TextId -> Transaction Text
expectTextCheck :: SqliteExceptionReason e => TextId -> (Text -> Either e a) -> Transaction a
saveNameSegment :: NameSegment -> Transaction TextId
expectNameSegment :: TextId -> Transaction NameSegment
saveHash :: Hash32 -> Transaction HashId
saveHashes :: Traversable f => f Hash32 -> Transaction (f HashId)
saveHashHash :: Hash -> Transaction HashId
loadHashId :: Hash32 -> Transaction (Maybe HashId)
expectHash :: HashId -> Transaction Hash
expectHash32 :: HashId -> Transaction Hash32
expectBranchHash :: BranchHashId -> Transaction BranchHash
expectBranchHashId :: BranchHash -> Transaction BranchHashId
loadHashIdByHash :: Hash -> Transaction (Maybe HashId)
expectHashIdByHash :: Hash -> Transaction HashId
saveCausalHash :: CausalHash -> Transaction CausalHashId
expectCausalHash :: CausalHashId -> Transaction CausalHash
expectBranchHashForCausalHash :: CausalHash -> Transaction BranchHash
saveBranchHash :: BranchHash -> Transaction BranchHashId
saveHashObject :: HashId -> ObjectId -> HashVersion -> Transaction ()
expectHashIdsForObject :: ObjectId -> Transaction (NonEmpty HashId)
hashIdWithVersionForObject :: ObjectId -> Transaction [(HashId, HashVersion)]
loadObjectIdForPrimaryHashId :: HashId -> Transaction (Maybe ObjectId)
expectObjectIdForPrimaryHashId :: HashId -> Transaction ObjectId
loadObjectIdForPrimaryHash :: Hash -> Transaction (Maybe ObjectId)
expectObjectIdForPrimaryHash :: Hash -> Transaction ObjectId
loadPatchObjectIdForPrimaryHash :: PatchHash -> Transaction (Maybe PatchObjectId)
loadObjectIdForAnyHash :: Hash -> Transaction (Maybe ObjectId)
loadObjectIdForAnyHashId :: HashId -> Transaction (Maybe ObjectId)
expectObjectIdForAnyHashId :: HashId -> Transaction ObjectId
recordObjectRehash :: ObjectId -> ObjectId -> Transaction ()
saveObject :: HashHandle -> HashId -> ObjectType -> ByteString -> Transaction ObjectId
isObjectHash :: HashId -> Transaction Bool
expectObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction a
expectPrimaryHashByObjectId :: ObjectId -> Transaction Hash
expectPrimaryHashIdForObject :: ObjectId -> Transaction HashId
expectObjectWithHashIdAndType :: ObjectId -> Transaction (HashId, ObjectType, ByteString)
expectDeclObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction a
loadDeclObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction (Maybe a)
expectNamespaceObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction a
loadNamespaceObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction (Maybe a)
expectPatchObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction a
loadPatchObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction (Maybe a)
loadTermObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction (Maybe a)
expectTermObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction a
saveNamespaceStats :: BranchHashId -> NamespaceStats -> Transaction ()
loadNamespaceStatsByHashId :: BranchHashId -> Transaction (Maybe NamespaceStats)
saveCausal :: HashHandle -> CausalHashId -> BranchHashId -> [CausalHashId] -> Transaction ()
isCausalHash :: HashId -> Transaction Bool
causalExistsByHash32 :: Hash32 -> Transaction Bool
expectCausal :: CausalHashId -> Transaction SyncCausalFormat
loadCausalHashIdByCausalHash :: CausalHash -> Transaction (Maybe CausalHashId)
expectCausalHashIdByCausalHash :: CausalHash -> Transaction CausalHashId
expectCausalValueHashId :: CausalHashId -> Transaction BranchHashId
loadCausalByCausalHash :: CausalHash -> Transaction (Maybe (CausalHashId, BranchHashId))
expectCausalByCausalHash :: CausalHash -> Transaction (CausalHashId, BranchHashId)
loadBranchObjectIdByCausalHashId :: CausalHashId -> Transaction (Maybe BranchObjectId)
loadBranchObjectIdByBranchHashId :: BranchHashId -> Transaction (Maybe BranchObjectId)
expectBranchObjectIdByCausalHashId :: CausalHashId -> Transaction BranchObjectId
expectBranchObjectIdByBranchHashId :: BranchHashId -> Transaction BranchObjectId
tryGetSquashResult :: BranchHashId -> Transaction (Maybe CausalHashId)
saveSquashResult :: BranchHashId -> CausalHashId -> Transaction ()
saveCausalParents :: CausalHashId -> [CausalHashId] -> Transaction ()
loadCausalParents :: CausalHashId -> Transaction [CausalHashId]
loadCausalParentsByHash :: Hash32 -> Transaction [Hash32]
before :: CausalHashId -> CausalHashId -> Transaction Bool
lca :: CausalHashId -> CausalHashId -> Transaction (Maybe CausalHashId)
saveWatch :: WatchKind -> IdH -> ByteString -> Transaction ()
loadWatch :: SqliteExceptionReason e => WatchKind -> IdH -> (ByteString -> Either e a) -> Transaction (Maybe a)
loadWatchesByWatchKind :: WatchKind -> Transaction [IdH]
loadWatchKindsByReference :: IdH -> Transaction [WatchKind]
clearWatches :: Transaction ()
projectExists :: ProjectId -> Transaction Bool
doProjectsExist :: Transaction Bool
projectExistsByName :: ProjectName -> Transaction Bool
loadProject :: ProjectId -> Transaction (Maybe Project)
loadProjectByName :: ProjectName -> Transaction (Maybe Project)
expectProject :: ProjectId -> Transaction Project
loadAllProjects :: Transaction [Project]
loadAllProjectsByRecentlyAccessed :: Transaction [Project]
loadAllProjectsBeginningWith :: Maybe Text -> Transaction [Project]
insertProject :: ProjectId -> ProjectName -> Transaction ()
renameProject :: ProjectId -> ProjectName -> Transaction ()
deleteProject :: ProjectId -> Transaction ()
projectBranchExists :: ProjectId -> ProjectBranchId -> Transaction Bool
projectBranchExistsByName :: ProjectId -> ProjectBranchName -> Transaction Bool
loadProjectBranchByName :: ProjectId -> ProjectBranchName -> Transaction (Maybe ProjectBranch)
loadProjectBranchByNames :: ProjectName -> ProjectBranchName -> Transaction (Maybe ProjectBranch)
expectProjectBranch :: ProjectId -> ProjectBranchId -> Transaction ProjectBranch
loadAllProjectBranchesBeginningWith :: ProjectId -> Maybe Text -> Transaction [(ProjectBranchId, ProjectBranchName)]
loadAllProjectBranchInfo :: ProjectId -> Transaction (Map ProjectBranchName (Map URI (ProjectName, ProjectBranchName)))
loadProjectAndBranchNames :: ProjectId -> ProjectBranchId -> Transaction (Maybe (ProjectName, ProjectBranchName))
loadAllProjectBranchNamePairs :: Transaction [(ProjectAndBranch ProjectName ProjectBranchName, ProjectAndBranch ProjectId ProjectBranchId)]
loadProjectBranch :: ProjectId -> ProjectBranchId -> Transaction (Maybe ProjectBranch)
insertProjectBranch :: HasCallStack => Text -> CausalHashId -> ProjectBranchRow -> Transaction ()
renameProjectBranch :: ProjectId -> ProjectBranchId -> ProjectBranchName -> Transaction ()
deleteProjectBranch :: HasCallStack => ProjectId -> ProjectBranchId -> Transaction ()
setProjectBranchHead :: Text -> ProjectId -> ProjectBranchId -> CausalHashId -> Transaction ()
loadProjectBranchHead :: ProjectId -> ProjectBranchId -> Transaction (Maybe CausalHashId)
expectProjectBranchHead :: HasCallStack => ProjectId -> ProjectBranchId -> Transaction CausalHashId
expectProjectBranchHeadHash :: HasCallStack => ProjectId -> ProjectBranchId -> Transaction CausalHash
setMostRecentBranch :: ProjectId -> ProjectBranchId -> Transaction ()
loadMostRecentBranch :: ProjectId -> Transaction (Maybe ProjectBranchId)
loadProjectBranchParent :: ProjectId -> ProjectBranchId -> Transaction (Maybe ProjectBranchId)
loadMergeBranchParents :: ProjectId -> ProjectBranchId -> Transaction (Maybe (Maybe ProjectBranchId, CausalHashId, Maybe ProjectBranchId, CausalHashId))
insertMergeBranchLocal :: ProjectId -> ProjectBranchId -> (ProjectBranchId, CausalHashId) -> (ProjectBranchId, CausalHashId) -> Transaction ()
insertMergeBranchRemote :: ProjectId -> ProjectBranchId -> (RemoteProjectId, RemoteProjectBranchId, URI, CausalHashId) -> (ProjectBranchId, CausalHashId) -> Transaction ()
insertMergeBranchLooseCode :: ProjectId -> ProjectBranchId -> CausalHashId -> (ProjectBranchId, CausalHashId) -> Transaction ()
loadNamespaceUniqueTypeGuid :: BranchHashId -> Name -> Transaction (Maybe Text)
existsAnyNamespaceUniqueTypeGuidForNamespace :: BranchHashId -> Transaction Bool
ensureUniqueTypeToGuidMappingForCausalHashId :: CausalHashId -> Map Name Text -> Transaction ()
insertNamespaceUniqueTypeGuid :: BranchHashId -> Name -> Text -> Transaction ()
loadUpdateBranchParentCausalHashId :: ProjectId -> ProjectBranchId -> Transaction (Maybe CausalHashId)
setProjectBranchIsUpdateBranch :: ProjectId -> ProjectBranchId -> CausalHashId -> Transaction ()
loadUpgradeBranchParentCausalHashId :: ProjectId -> ProjectBranchId -> Transaction (Maybe CausalHashId)
setProjectBranchIsUpgradeBranch :: ProjectId -> ProjectBranchId -> CausalHashId -> Transaction ()
loadRemoteProject :: RemoteProjectId -> URI -> Transaction (Maybe RemoteProject)
ensureRemoteProject :: RemoteProjectId -> URI -> ProjectName -> Transaction ()
expectRemoteProjectName :: RemoteProjectId -> URI -> Transaction ProjectName
setRemoteProjectName :: RemoteProjectId -> ProjectName -> Transaction ()
loadRemoteProjectBranch :: ProjectId -> URI -> ProjectBranchId -> Transaction (Maybe (RemoteProjectId, Maybe RemoteProjectBranchId))
loadDefaultMergeTargetForLocalProjectBranch :: ProjectId -> URI -> ProjectBranchId -> Transaction (Maybe (RemoteProjectId, RemoteProjectBranchId))
loadRemoteBranch :: RemoteProjectId -> URI -> RemoteProjectBranchId -> Transaction (Maybe RemoteProjectBranch)
ensureRemoteProjectBranch :: RemoteProjectId -> URI -> RemoteProjectBranchId -> ProjectBranchName -> Transaction ()
expectRemoteProjectBranchName :: URI -> RemoteProjectId -> RemoteProjectBranchId -> Transaction ProjectBranchName
setRemoteProjectBranchName :: RemoteProjectId -> URI -> RemoteProjectBranchId -> ProjectBranchName -> Transaction ()
insertBranchRemoteMapping :: ProjectId -> ProjectBranchId -> RemoteProjectId -> URI -> RemoteProjectBranchId -> Transaction ()
ensureBranchRemoteMapping :: ProjectId -> ProjectBranchId -> RemoteProjectId -> URI -> RemoteProjectBranchId -> Transaction ()
deleteBranchRemoteMapping :: ProjectId -> ProjectBranchId -> URI -> Transaction ()
addToDependentsIndex :: [Reference] -> Id -> Transaction ()
data DependentsSelector
- = IncludeAllDependents
- | ExcludeSelf
- | ExcludeOwnComponent
getDependentsForDependency :: DependentsSelector -> Reference -> Transaction (Set Id)
getDependentsForDependencyComponent :: ObjectId -> Transaction [Id]
getDependencyIdsForDependent :: Id -> Transaction [Id]
getDependenciesBetweenTerms :: ObjectId -> ObjectId -> Transaction (Set ObjectId)
getDirectDependenciesOfScope :: (Reference -> Transaction Bool) -> DefnsF Set TermReferenceId TypeReferenceId -> Transaction (DefnsF Set TermReference TypeReference)
getDirectDependentsWithinScope :: DefnsF Set TermReferenceId TypeReferenceId -> DefnsF Set TermReference TypeReference -> Transaction (DefnsF Set TermReferenceId TypeReferenceId)
getTransitiveDependentsWithinScope :: DefnsF Set TermReferenceId TypeReferenceId -> DefnsF Set TermReference TypeReference -> Transaction (DefnsF Set TermReferenceId TypeReferenceId)
addToTypeIndex :: ReferenceH -> Id -> Transaction ()
getReferentsByType :: ReferenceH -> Transaction [Id]
getTypeReferenceForReferent :: Id -> Transaction ReferenceH
getTypeReferencesForComponent :: ObjectId -> Transaction [(ReferenceH, Id)]
filterTermsByReferenceHavingType :: ReferenceH -> [Id] -> Transaction [Id]
filterTermsByReferentHavingType :: ReferenceH -> [Id] -> Transaction [Id]
addToTypeMentionsIndex :: ReferenceH -> Id -> Transaction ()
getReferentsByTypeMention :: ReferenceH -> Transaction [Id]
getTypeMentionsReferencesForComponent :: ObjectId -> Transaction [(ReferenceH, Id)]
objectIdByBase32Prefix :: ObjectType -> Text -> Transaction [ObjectId]
namespaceHashIdByBase32Prefix :: Text -> Transaction [BranchHashId]
causalHashIdByBase32Prefix :: Text -> Transaction [CausalHashId]
getDeprecatedRootReflog :: Int -> Transaction [Entry CausalHashId Text]
appendProjectBranchReflog :: Entry ProjectId ProjectBranchId CausalHashId -> Transaction ()
getProjectReflog :: Int -> ProjectId -> Transaction [Entry ProjectId ProjectBranchId CausalHashId]
getProjectBranchReflog :: Int -> ProjectBranchId -> Transaction [Entry ProjectId ProjectBranchId CausalHashId]
getGlobalReflog :: Int -> Transaction [Entry ProjectId ProjectBranchId CausalHashId]
garbageCollectObjectsWithoutHashes :: Transaction ()
garbageCollectWatchesWithoutObjects :: Transaction ()
data EntityLocation
- = EntityInMainStorage
- | EntityInTempStorage
entityExists :: Hash32 -> Transaction Bool
entityLocation :: Hash32 -> Transaction (Maybe EntityLocation)
expectEntity :: Hash32 -> Transaction SyncEntity
syncToTempEntity :: SyncEntity -> Transaction TempEntity
insertTempEntity :: Hash32 -> TempEntity -> NEMap Hash32 Text -> Transaction ()
saveTempEntityInMain :: HashHandle -> Hash32 -> TempEntity -> Transaction (Either CausalHashId ObjectId)
expectTempEntity :: Hash32 -> Transaction TempEntity
deleteTempEntity :: Hash32 -> Transaction ()
clearTempEntityTables :: Transaction ()
elaborateHashes :: NonEmpty Hash32 -> Transaction [Text]
expectCurrentProjectPath :: HasCallStack => Transaction (ProjectId, ProjectBranchId, [NameSegment])
setCurrentProjectPath :: ProjectId -> ProjectBranchId -> [NameSegment] -> Transaction ()
runCreateSql :: Transaction ()
addTempEntityTables :: Transaction ()
addReflogTable :: Transaction ()
fixScopedNameLookupTables :: Transaction ()
addNamespaceStatsTables :: Transaction ()
addProjectTables :: Transaction ()
addMostRecentBranchTable :: Transaction ()
addNameLookupMountTables :: Transaction ()
addMostRecentNamespaceTable :: Transaction ()
addSquashResultTable :: Transaction ()
addSquashResultTableIfNotExists :: Transaction ()
cdToProjectRoot :: Transaction ()
addCurrentProjectPathTable :: Transaction ()
addProjectBranchReflogTable :: Transaction ()
addProjectBranchCausalHashIdColumn :: Transaction ()
addProjectBranchLastAccessedColumn :: Transaction ()
addMergeBranchTables :: Transaction ()
addUpdateBranchTable :: Transaction ()
addDerivedDependentsByDependencyIndex :: Transaction ()
addUpgradeBranchTable :: Transaction ()
currentSchemaVersion :: SchemaVersion
expectSchemaVersion :: SchemaVersion -> Transaction ()
setSchemaVersion :: SchemaVersion -> Transaction ()
countObjects :: Transaction Int
countCausals :: Transaction Int
countWatches :: Transaction Int
getCausalsWithoutBranchObjects :: Transaction [CausalHashId]
removeHashObjectsByHashingVersion :: HashVersion -> Transaction ()
addTypeMentionsToIndexForTerm :: Id -> Set Reference -> Transaction ()
addTypeToIndexForTerm :: Id -> Reference -> Transaction ()
c2xTerm :: forall m t d. Monad m => (Text -> m t) -> (Hash -> m d) -> Term Symbol -> Maybe (Type Symbol) -> m (LocalIds' t d, Term, Maybe Type)
localIdsToLookups :: Monad m => (t -> m Text) -> (d -> m Hash) -> LocalIds' t d -> m (LocalTextId -> Text, LocalDefnId -> Hash)
s2cDecl :: LocalIds -> Decl Symbol -> Transaction (Decl Symbol)
s2cTermWithType :: LocalIds -> Term -> Type -> Transaction (Term Symbol, Type Symbol)
saveDeclComponent :: HashHandle -> Maybe ByteString -> Hash -> [Decl Symbol] -> Transaction ObjectId
saveReferenceH :: Reference -> Transaction ReferenceH
saveSyncEntity :: HashHandle -> Hash32 -> SyncEntity -> Transaction (Either CausalHashId ObjectId)
saveTermComponent :: HashHandle -> Maybe ByteString -> Hash -> [(Term Symbol, Type Symbol)] -> Transaction ObjectId
schemaVersion :: Transaction SchemaVersion
x2cTType :: (LocalTextId -> Text) -> (LocalDefnId -> Hash) -> Type -> Type Symbol
x2cTerm :: (LocalTextId -> Text) -> (LocalDefnId -> Hash) -> Term -> Term Symbol
x2cDecl :: (r -> r1) -> DeclR r Symbol -> DeclR r1 Symbol
checkBranchExistsForCausalHash :: CausalHash -> Transaction Bool
type TextPathSegments = [Text]
data JsonParseFailure = JsonParseFailure {
- bytes :: !Text
- failure :: !Text
}

text table

saveText :: Text -> Transaction TextId Source #

saveTexts :: Traversable f => f Text -> Transaction (f TextId) Source #

loadTextId :: Text -> Transaction (Maybe TextId) Source #

expectTextId :: Text -> Transaction TextId Source #

expectText :: TextId -> Transaction Text Source #

expectTextCheck :: SqliteExceptionReason e => TextId -> (Text -> Either e a) -> Transaction a Source #

name segments

saveNameSegment :: NameSegment -> Transaction TextId Source #

expectNameSegment :: TextId -> Transaction NameSegment Source #

hash table

saveHash :: Hash32 -> Transaction HashId Source #

saveHashes :: Traversable f => f Hash32 -> Transaction (f HashId) Source #

saveHashHash :: Hash -> Transaction HashId Source #

loadHashId :: Hash32 -> Transaction (Maybe HashId) Source #

expectHash :: HashId -> Transaction Hash Source #

expectHash32 :: HashId -> Transaction Hash32 Source #

expectBranchHash :: BranchHashId -> Transaction BranchHash Source #

expectBranchHashId :: BranchHash -> Transaction BranchHashId Source #

loadHashIdByHash :: Hash -> Transaction (Maybe HashId) Source #

expectHashIdByHash :: Hash -> Transaction HashId Source #

saveCausalHash :: CausalHash -> Transaction CausalHashId Source #

expectCausalHash :: CausalHashId -> Transaction CausalHash Source #

expectBranchHashForCausalHash :: CausalHash -> Transaction BranchHash Source #

saveBranchHash :: BranchHash -> Transaction BranchHashId Source #

hash_object table

saveHashObject :: HashId -> ObjectId -> HashVersion -> Transaction () Source #

expectHashIdsForObject :: ObjectId -> Transaction (NonEmpty HashId) Source #

hashIdWithVersionForObject :: ObjectId -> Transaction [(HashId, HashVersion)] Source #

loadObjectIdForPrimaryHashId :: HashId -> Transaction (Maybe ObjectId) Source #

expectObjectIdForPrimaryHashId :: HashId -> Transaction ObjectId Source #

Not all hashes have corresponding objects; e.g., hashes of term types

loadObjectIdForPrimaryHash :: Hash -> Transaction (Maybe ObjectId) Source #

expectObjectIdForPrimaryHash :: Hash -> Transaction ObjectId Source #

loadPatchObjectIdForPrimaryHash :: PatchHash -> Transaction (Maybe PatchObjectId) Source #

loadObjectIdForAnyHash :: Hash -> Transaction (Maybe ObjectId) Source #

loadObjectIdForAnyHashId :: HashId -> Transaction (Maybe ObjectId) Source #

expectObjectIdForAnyHashId :: HashId -> Transaction ObjectId Source #

recordObjectRehash :: ObjectId -> ObjectId -> Transaction () Source #

recordObjectRehash old new records that object old was rehashed and inserted as a new object, new.

This function rewrites old's hash_object rows in place to point at the new object.

object table

saveObject :: HashHandle -> HashId -> ObjectType -> ByteString -> Transaction ObjectId Source #

isObjectHash :: HashId -> Transaction Bool Source #

Does a hash correspond to an object?

expectObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction a Source #

expectPrimaryHashByObjectId :: ObjectId -> Transaction Hash Source #

All objects have corresponding hashes.

expectPrimaryHashIdForObject :: ObjectId -> Transaction HashId Source #

expectObjectWithHashIdAndType :: ObjectId -> Transaction (HashId, ObjectType, ByteString) Source #

expectDeclObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction a Source #

Expect a decl component object.

loadDeclObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction (Maybe a) Source #

Load a decl component object.

expectNamespaceObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction a Source #

Expect a namespace object.

loadNamespaceObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction (Maybe a) Source #

Load a namespace object.

expectPatchObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction a Source #

Expect a patch object.

loadPatchObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction (Maybe a) Source #

Load a patch object.

loadTermObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction (Maybe a) Source #

Load a term component object.

expectTermObject :: SqliteExceptionReason e => ObjectId -> (ByteString -> Either e a) -> Transaction a Source #

Expect a term component object.

namespace_statistics table

saveNamespaceStats :: BranchHashId -> NamespaceStats -> Transaction () Source #

Save statistics about a given branch.

loadNamespaceStatsByHashId :: BranchHashId -> Transaction (Maybe NamespaceStats) Source #

Looks up statistics for a given branch, there's no guarantee that we have computed and saved stats for any given branch.

causals

causal table

saveCausal :: HashHandle -> CausalHashId -> BranchHashId -> [CausalHashId] -> Transaction () Source #

Maybe we would generalize this to something other than NamespaceHash if we end up wanting to store other kinds of Causals here too.

isCausalHash :: HashId -> Transaction Bool Source #

causalExistsByHash32 :: Hash32 -> Transaction Bool Source #

Return whether or not a causal exists with the given hash32.

expectCausal :: CausalHashId -> Transaction SyncCausalFormat Source #

loadCausalHashIdByCausalHash :: CausalHash -> Transaction (Maybe CausalHashId) Source #

expectCausalHashIdByCausalHash :: CausalHash -> Transaction CausalHashId Source #

expectCausalValueHashId :: CausalHashId -> Transaction BranchHashId Source #

loadCausalByCausalHash :: CausalHash -> Transaction (Maybe (CausalHashId, BranchHashId)) Source #

expectCausalByCausalHash :: CausalHash -> Transaction (CausalHashId, BranchHashId) Source #

loadBranchObjectIdByCausalHashId :: CausalHashId -> Transaction (Maybe BranchObjectId) Source #

loadBranchObjectIdByBranchHashId :: BranchHashId -> Transaction (Maybe BranchObjectId) Source #

expectBranchObjectIdByCausalHashId :: CausalHashId -> Transaction BranchObjectId Source #

expectBranchObjectIdByBranchHashId :: BranchHashId -> Transaction BranchObjectId Source #

tryGetSquashResult :: BranchHashId -> Transaction (Maybe CausalHashId) Source #

Get the causal hash result from squashing the provided branch hash if we've squashed it at some point in the past.

saveSquashResult :: BranchHashId -> CausalHashId -> Transaction () Source #

Save the result of running a squash on the provided branch hash id.

causal_parent table

saveCausalParents :: CausalHashId -> [CausalHashId] -> Transaction () Source #

loadCausalParents :: CausalHashId -> Transaction [CausalHashId] Source #

loadCausalParentsByHash :: Hash32 -> Transaction [Hash32] Source #

Like loadCausalParents, but the input and outputs are hashes, not hash ids.

before :: CausalHashId -> CausalHashId -> Transaction Bool Source #

before x y returns whether or not x occurred before y, i.e. x is an ancestor of y.

lca :: CausalHashId -> CausalHashId -> Transaction (Maybe CausalHashId) Source #

watch table

saveWatch :: WatchKind -> IdH -> ByteString -> Transaction () Source #

loadWatch :: SqliteExceptionReason e => WatchKind -> IdH -> (ByteString -> Either e a) -> Transaction (Maybe a) Source #

loadWatchesByWatchKind :: WatchKind -> Transaction [IdH] Source #

loadWatchKindsByReference :: IdH -> Transaction [WatchKind] Source #

clearWatches :: Transaction () Source #

Delete all watches that were put by putWatch.

projects

projectExists :: ProjectId -> Transaction Bool Source #

Does a project exist with this id?

doProjectsExist :: Transaction Bool Source #

Check if any projects exist

projectExistsByName :: ProjectName -> Transaction Bool Source #

Does a project exist by this name?

loadProject :: ProjectId -> Transaction (Maybe Project) Source #

loadProjectByName :: ProjectName -> Transaction (Maybe Project) Source #

expectProject :: ProjectId -> Transaction Project Source #

loadAllProjects :: Transaction [Project] Source #

Load all projects.

loadAllProjectsByRecentlyAccessed :: Transaction [Project] Source #

Load all projects.

loadAllProjectsBeginningWith :: Maybe Text -> Transaction [Project] Source #

Load all projects whose name matches a prefix.

insertProject :: ProjectId -> ProjectName -> Transaction () Source #

Insert a project row.

renameProject :: ProjectId -> ProjectName -> Transaction () Source #

Rename a project row.

Precondition: the new name is available.

deleteProject :: ProjectId -> Transaction () Source #

project branches

projectBranchExists :: ProjectId -> ProjectBranchId -> Transaction Bool Source #

Does a project branch exist?

projectBranchExistsByName :: ProjectId -> ProjectBranchName -> Transaction Bool Source #

Does a project branch exist by this name?

loadProjectBranchByName :: ProjectId -> ProjectBranchName -> Transaction (Maybe ProjectBranch) Source #

loadProjectBranchByNames :: ProjectName -> ProjectBranchName -> Transaction (Maybe ProjectBranch) Source #

expectProjectBranch :: ProjectId -> ProjectBranchId -> Transaction ProjectBranch Source #

loadAllProjectBranchesBeginningWith :: ProjectId -> Maybe Text -> Transaction [(ProjectBranchId, ProjectBranchName)] Source #

Load all branch id/name pairs in a project whose name matches an optional prefix.

loadAllProjectBranchInfo :: ProjectId -> Transaction (Map ProjectBranchName (Map URI (ProjectName, ProjectBranchName))) Source #

Load info about all branches in a project, for display by the branches command.

Each branch name maps to a possibly-empty collection of associated remote branches.

loadProjectAndBranchNames :: ProjectId -> ProjectBranchId -> Transaction (Maybe (ProjectName, ProjectBranchName)) Source #

loadAllProjectBranchNamePairs :: Transaction [(ProjectAndBranch ProjectName ProjectBranchName, ProjectAndBranch ProjectId ProjectBranchId)] Source #

Load ALL project/branch name pairs Useful for autocomplete/fuzzy-finding

loadProjectBranch :: ProjectId -> ProjectBranchId -> Transaction (Maybe ProjectBranch) Source #

insertProjectBranch :: HasCallStack => Text -> CausalHashId -> ProjectBranchRow -> Transaction () Source #

Insert a project branch.

renameProjectBranch :: ProjectId -> ProjectBranchId -> ProjectBranchName -> Transaction () Source #

Rename a project branch.

Precondition: the new name is available.

deleteProjectBranch :: HasCallStack => ProjectId -> ProjectBranchId -> Transaction () Source #

Delete a project branch.

Re-parenting happens in the obvious way:

Before:

main <- topic <- topic2

After deleting topic:

main <- topic2

setProjectBranchHead :: Text -> ProjectId -> ProjectBranchId -> CausalHashId -> Transaction () Source #

Set project branch HEAD

loadProjectBranchHead :: ProjectId -> ProjectBranchId -> Transaction (Maybe CausalHashId) Source #

expectProjectBranchHead :: HasCallStack => ProjectId -> ProjectBranchId -> Transaction CausalHashId Source #

expectProjectBranchHeadHash :: HasCallStack => ProjectId -> ProjectBranchId -> Transaction CausalHash Source #

setMostRecentBranch :: ProjectId -> ProjectBranchId -> Transaction () Source #

loadMostRecentBranch :: ProjectId -> Transaction (Maybe ProjectBranchId) Source #

loadProjectBranchParent :: ProjectId -> ProjectBranchId -> Transaction (Maybe ProjectBranchId) Source #

loadMergeBranchParents :: ProjectId -> ProjectBranchId -> Transaction (Maybe (Maybe ProjectBranchId, CausalHashId, Maybe ProjectBranchId, CausalHashId)) Source #

insertMergeBranchLocal :: ProjectId -> ProjectBranchId -> (ProjectBranchId, CausalHashId) -> (ProjectBranchId, CausalHashId) -> Transaction () Source #

insertMergeBranchRemote :: ProjectId -> ProjectBranchId -> (RemoteProjectId, RemoteProjectBranchId, URI, CausalHashId) -> (ProjectBranchId, CausalHashId) -> Transaction () Source #

insertMergeBranchLooseCode :: ProjectId -> ProjectBranchId -> CausalHashId -> (ProjectBranchId, CausalHashId) -> Transaction () Source #

loadNamespaceUniqueTypeGuid :: BranchHashId -> Name -> Transaction (Maybe Text) Source #

existsAnyNamespaceUniqueTypeGuidForNamespace :: BranchHashId -> Transaction Bool Source #

ensureUniqueTypeToGuidMappingForCausalHashId :: CausalHashId -> Map Name Text -> Transaction () Source #

insertNamespaceUniqueTypeGuid :: BranchHashId -> Name -> Text -> Transaction () Source #

update branches

loadUpdateBranchParentCausalHashId :: ProjectId -> ProjectBranchId -> Transaction (Maybe CausalHashId) Source #

Load whether the given branch is an update branch, and if it is, return its parent's causal hash id.

setProjectBranchIsUpdateBranch :: ProjectId -> ProjectBranchId -> CausalHashId -> Transaction () Source #

Record that a project branch is an "update branch".

upgrade branches

loadUpgradeBranchParentCausalHashId :: ProjectId -> ProjectBranchId -> Transaction (Maybe CausalHashId) Source #

Load whether the given branch is an upgrade branch, and if it is, return its parent's causal hash id.

setProjectBranchIsUpgradeBranch :: ProjectId -> ProjectBranchId -> CausalHashId -> Transaction () Source #

Record that a project branch is an "upgrade branch".

remote projects

loadRemoteProject :: RemoteProjectId -> URI -> Transaction (Maybe RemoteProject) Source #

ensureRemoteProject :: RemoteProjectId -> URI -> ProjectName -> Transaction () Source #

expectRemoteProjectName :: RemoteProjectId -> URI -> Transaction ProjectName Source #

setRemoteProjectName :: RemoteProjectId -> ProjectName -> Transaction () Source #

loadRemoteProjectBranch :: ProjectId -> URI -> ProjectBranchId -> Transaction (Maybe (RemoteProjectId, Maybe RemoteProjectBranchId)) Source #

Determine the remote mapping for a local project/branch by looking at the mapping for the given pair, then falling back to the project of the nearest ancestor.

loadDefaultMergeTargetForLocalProjectBranch :: ProjectId -> URI -> ProjectBranchId -> Transaction (Maybe (RemoteProjectId, RemoteProjectBranchId)) Source #

Load the default merge target for a local branch (i.e. The nearest ancestor's remote mapping)

remote project branches

loadRemoteBranch :: RemoteProjectId -> URI -> RemoteProjectBranchId -> Transaction (Maybe RemoteProjectBranch) Source #

ensureRemoteProjectBranch :: RemoteProjectId -> URI -> RemoteProjectBranchId -> ProjectBranchName -> Transaction () Source #

expectRemoteProjectBranchName :: URI -> RemoteProjectId -> RemoteProjectBranchId -> Transaction ProjectBranchName Source #

setRemoteProjectBranchName :: RemoteProjectId -> URI -> RemoteProjectBranchId -> ProjectBranchName -> Transaction () Source #

insertBranchRemoteMapping :: ProjectId -> ProjectBranchId -> RemoteProjectId -> URI -> RemoteProjectBranchId -> Transaction () Source #

ensureBranchRemoteMapping :: ProjectId -> ProjectBranchId -> RemoteProjectId -> URI -> RemoteProjectBranchId -> Transaction () Source #

deleteBranchRemoteMapping :: ProjectId -> ProjectBranchId -> URI -> Transaction () Source #

indexes

dependents index

addToDependentsIndex :: [Reference] -> Id -> Transaction () Source #

data DependentsSelector Source #

Which dependents should be returned?

IncludeAllDependents. Include all dependents, including references from one's own component-mates, and references from oneself (e.g. those in recursive functions)
ExcludeSelf. Include all dependents, including references from one's own component-mates, but excluding actual self references (e.g. those in recursive functions).
ExcludeOwnComponent. Include all dependents outside of one's own component.

Constructors

IncludeAllDependents
ExcludeSelf
ExcludeOwnComponent

getDependentsForDependency :: DependentsSelector -> Reference -> Transaction (Set Id) Source #

Get dependents of a dependency.

getDependentsForDependencyComponent :: ObjectId -> Transaction [Id] Source #

getDependencyIdsForDependent :: Id -> Transaction [Id] Source #

Get non-self, user-defined dependencies of a user-defined dependent.

getDependenciesBetweenTerms :: ObjectId -> ObjectId -> Transaction (Set ObjectId) Source #

Given two term (components) A and B, return the set of all terms that are along any "dependency path" from A to B, not including A nor B; i.e., the transitive dependencies of A that are transitive dependents of B.

For example, if A depends on X and Y, X depends on Q, Y depends on Z, and X and Z depend on B...

-X-----Q / A B / Y---Z

...then `getDependenciesBetweenTerms A B` would return the set {X Y Z}

getDirectDependenciesOfScope :: (Reference -> Transaction Bool) -> DefnsF Set TermReferenceId TypeReferenceId -> Transaction (DefnsF Set TermReference TypeReference) Source #

getDirectDependentsWithinScope :: DefnsF Set TermReferenceId TypeReferenceId -> DefnsF Set TermReference TypeReference -> Transaction (DefnsF Set TermReferenceId TypeReferenceId) Source #

`getDirectDependentsWithinScope scope query` returns all direct dependents of query that are in scope.

getTransitiveDependentsWithinScope :: DefnsF Set TermReferenceId TypeReferenceId -> DefnsF Set TermReference TypeReference -> Transaction (DefnsF Set TermReferenceId TypeReferenceId) Source #

`getTransitiveDependentsWithinScope scope query` returns all transitive dependents of query that are in scope.

type index

addToTypeIndex :: ReferenceH -> Id -> Transaction () Source #

getReferentsByType :: ReferenceH -> Transaction [Id] Source #

getTypeReferenceForReferent :: Id -> Transaction ReferenceH Source #

getTypeReferencesForComponent :: ObjectId -> Transaction [(ReferenceH, Id)] Source #

filterTermsByReferenceHavingType :: ReferenceH -> [Id] -> Transaction [Id] Source #

filterTermsByReferentHavingType :: ReferenceH -> [Id] -> Transaction [Id] Source #

type mentions index

addToTypeMentionsIndex :: ReferenceH -> Id -> Transaction () Source #

getReferentsByTypeMention :: ReferenceH -> Transaction [Id] Source #

getTypeMentionsReferencesForComponent :: ObjectId -> Transaction [(ReferenceH, Id)] Source #

hash prefix lookup

objectIdByBase32Prefix :: ObjectType -> Text -> Transaction [ObjectId] Source #

namespaceHashIdByBase32Prefix :: Text -> Transaction [BranchHashId] Source #

causalHashIdByBase32Prefix :: Text -> Transaction [CausalHashId] Source #

Reflog

getDeprecatedRootReflog :: Int -> Transaction [Entry CausalHashId Text] Source #

appendProjectBranchReflog :: Entry ProjectId ProjectBranchId CausalHashId -> Transaction () Source #

getProjectReflog :: Int -> ProjectId -> Transaction [Entry ProjectId ProjectBranchId CausalHashId] Source #

Get x number of entries from the project reflog for the provided project

getProjectBranchReflog :: Int -> ProjectBranchId -> Transaction [Entry ProjectId ProjectBranchId CausalHashId] Source #

Get x number of entries from the project reflog for the provided branch.

getGlobalReflog :: Int -> Transaction [Entry ProjectId ProjectBranchId CausalHashId] Source #

Get x number of entries from the global reflog spanning all projects

garbage collection

garbageCollectObjectsWithoutHashes :: Transaction () Source #

Delete objects without hashes. An object typically *would* have a hash, but (for example) during a migration in which an object's hash may change, its corresponding hash_object row may be updated to point at a new version of that object. This procedure clears out all references to objects that do not have any corresponding hash_object rows.

garbageCollectWatchesWithoutObjects :: Transaction () Source #

Delete all

sync temp entities

data EntityLocation Source #

Where an entity is stored.

Constructors

EntityInMainStorage	`object` / `causal`
EntityInTempStorage	`temp_entity`

Instances

Instances details

Show EntityLocation Source #
Instance details Defined in U.Codebase.Sqlite.Queries Methods showsPrec :: Int -> EntityLocation -> ShowS # show :: EntityLocation -> String # showList :: [EntityLocation] -> ShowS #
Eq EntityLocation Source #
Instance details Defined in U.Codebase.Sqlite.Queries Methods (==) :: EntityLocation -> EntityLocation -> Bool # (/=) :: EntityLocation -> EntityLocation -> Bool #
Ord EntityLocation Source #
Instance details Defined in U.Codebase.Sqlite.Queries Methods compare :: EntityLocation -> EntityLocation -> Ordering # (<) :: EntityLocation -> EntityLocation -> Bool # (<=) :: EntityLocation -> EntityLocation -> Bool # (>) :: EntityLocation -> EntityLocation -> Bool # (>=) :: EntityLocation -> EntityLocation -> Bool # max :: EntityLocation -> EntityLocation -> EntityLocation # min :: EntityLocation -> EntityLocation -> EntityLocation #

entityExists :: Hash32 -> Transaction Bool Source #

Does this entity already exist in the database, i.e. in the object or causal table?

entityLocation :: Hash32 -> Transaction (Maybe EntityLocation) Source #

Where is an entity stored?

expectEntity :: Hash32 -> Transaction SyncEntity Source #

Read an entity out of main storage.

syncToTempEntity :: SyncEntity -> Transaction TempEntity Source #

looking up all of the text and hashes is the first step of converting a SyncEntity to a Share.Entity

insertTempEntity :: Hash32 -> TempEntity -> NEMap Hash32 Text -> Transaction () Source #

Insert a new temp_entity row, and its associated 1+ temp_entity_missing_dependency rows.

Preconditions: 1. The entity does not already exist in "main" storage (object / causal) 2. The entity does not already exist in temp_entity.

saveTempEntityInMain :: HashHandle -> Hash32 -> TempEntity -> Transaction (Either CausalHashId ObjectId) Source #

Save a temp entity in main storage.

Precondition: all of its dependencies are already in main storage.

expectTempEntity :: Hash32 -> Transaction TempEntity Source #

Read an entity out of temp storage.

deleteTempEntity :: Hash32 -> Transaction () Source #

Delete a row from the temp_entity table, if it exists.

clearTempEntityTables :: Transaction () Source #

Clears the temp_entity and temp_entity_missing_dependency tables. The hashjwts stored in temp entity tables can sometimes go stale, so we clear them out. This is safe because temp entities are generally considered ephemeral except during an active pull.

elaborate hashes

elaborateHashes :: NonEmpty Hash32 -> Transaction [Text] Source #

Elaborate a set of temp_entity hashes.

Given a set of temp_entity hashes, returns the (known) set of transitive dependencies that haven't already been downloaded (i.e. aren't in the temp_entity table)

For example, if we have temp entities A and B, where A depends on B and B depends on C...

| temp_entity | | temp_entity_missing_dependency | |=============| |================================| | hash | | dependent | dependency | |-------------| |--------------|-----------------| | A | | A | B | | B | | B | C |

... then `elaborateHashes {A}` would return the singleton set {C} (because we take the set of transitive dependencies {A,B,C} and subtract the set we already have, {A,B}).

current project path

expectCurrentProjectPath :: HasCallStack => Transaction (ProjectId, ProjectBranchId, [NameSegment]) Source #

Get the most recent namespace the user has visited.

setCurrentProjectPath :: ProjectId -> ProjectBranchId -> [NameSegment] -> Transaction () Source #

Set the most recent namespace the user has visited.

migrations

runCreateSql :: Transaction () Source #

addTempEntityTables :: Transaction () Source #

addReflogTable :: Transaction () Source #

Deprecated in favour of project-branch reflog

fixScopedNameLookupTables :: Transaction () Source #

addNamespaceStatsTables :: Transaction () Source #

addProjectTables :: Transaction () Source #

addMostRecentBranchTable :: Transaction () Source #

addNameLookupMountTables :: Transaction () Source #

addMostRecentNamespaceTable :: Transaction () Source #

addSquashResultTable :: Transaction () Source #

addSquashResultTableIfNotExists :: Transaction () Source #

Added as a fix because addSquashResultTable was missed in the createSchema action for a portion of time.

cdToProjectRoot :: Transaction () Source #

addCurrentProjectPathTable :: Transaction () Source #

addProjectBranchReflogTable :: Transaction () Source #

Deprecated in favour of project-branch reflog

addProjectBranchCausalHashIdColumn :: Transaction () Source #

addProjectBranchLastAccessedColumn :: Transaction () Source #

addMergeBranchTables :: Transaction () Source #

addUpdateBranchTable :: Transaction () Source #

addDerivedDependentsByDependencyIndex :: Transaction () Source #

addUpgradeBranchTable :: Transaction () Source #

schema version

currentSchemaVersion :: SchemaVersion Source #

expectSchemaVersion :: SchemaVersion -> Transaction () Source #

Expect the given schema version.

setSchemaVersion :: SchemaVersion -> Transaction () Source #

helpers for various migrations

countObjects :: Transaction Int Source #

countCausals :: Transaction Int Source #

countWatches :: Transaction Int Source #

getCausalsWithoutBranchObjects :: Transaction [CausalHashId] Source #

Finds all causals that refer to a branch for which we don't have an object stored. Although there are plans to support this in the future, currently all such cases are the result of database inconsistencies and are unexpected.

removeHashObjectsByHashingVersion :: HashVersion -> Transaction () Source #

Delete all hash objects of a given hash version. Leaves the corresponding hashes in the hash table alone.

db misc

addTypeMentionsToIndexForTerm :: Id -> Set Reference -> Transaction () Source #

addTypeToIndexForTerm :: Id -> Reference -> Transaction () Source #

c2xTerm :: forall m t d. Monad m => (Text -> m t) -> (Hash -> m d) -> Term Symbol -> Maybe (Type Symbol) -> m (LocalIds' t d, Term, Maybe Type) Source #

implementation detail of c2{s,w}Term The Type is optional, because we don't store them for watch expression results.

localIdsToLookups :: Monad m => (t -> m Text) -> (d -> m Hash) -> LocalIds' t d -> m (LocalTextId -> Text, LocalDefnId -> Hash) Source #

implementation detail of {s,w}2c*Term* & s2cDecl

s2cDecl :: LocalIds -> Decl Symbol -> Transaction (Decl Symbol) Source #

Unlocalize a decl.

s2cTermWithType :: LocalIds -> Term -> Type -> Transaction (Term Symbol, Type Symbol) Source #

saveDeclComponent :: HashHandle -> Maybe ByteString -> Hash -> [Decl Symbol] -> Transaction ObjectId Source #

saveReferenceH :: Reference -> Transaction ReferenceH Source #

Save the text and hash parts of a Reference to the database and substitute their ids.

saveSyncEntity :: HashHandle -> Hash32 -> SyncEntity -> Transaction (Either CausalHashId ObjectId) Source #

saveTermComponent Source #

Arguments

:: HashHandle
-> Maybe ByteString	The serialized term component if we already have it e.g. via sync
-> Hash	term component hash
-> [(Term Symbol, Type Symbol)]	term component
-> Transaction ObjectId

schemaVersion :: Transaction SchemaVersion Source #

x2cTType :: (LocalTextId -> Text) -> (LocalDefnId -> Hash) -> Type -> Type Symbol Source #

implementation detail of {s,w}2c*Term*

x2cTerm :: (LocalTextId -> Text) -> (LocalDefnId -> Hash) -> Term -> Term Symbol Source #

implementation detail of {s,w}2c*Term*

x2cDecl :: (r -> r1) -> DeclR r Symbol -> DeclR r1 Symbol Source #

checkBranchExistsForCausalHash :: CausalHash -> Transaction Bool Source #

Checks whether the codebase contains the actual branch value for a given causal hash.

Types

type TextPathSegments = [Text] Source #

data JsonParseFailure Source #

Constructors

JsonParseFailure
Fields bytes :: !Text failure :: !Text

Instances

Instances details

Show JsonParseFailure Source #
Instance details Defined in U.Codebase.Sqlite.Queries Methods showsPrec :: Int -> JsonParseFailure -> ShowS # show :: JsonParseFailure -> String # showList :: [JsonParseFailure] -> ShowS #
SqliteExceptionReason JsonParseFailure Source #
Instance details Defined in U.Codebase.Sqlite.Queries