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

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.

Does a hash correspond to an object?

All objects have corresponding hashes.

Expect a decl component object.

Load a decl component object.

Expect a namespace object.

Load a namespace object.

Expect a patch object.

Load a patch object.

Load a term component object.

Expect a term component object.

Save statistics about a given branch.

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

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

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

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

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

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

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

Delete all watches that were put by putWatch.

Does a project exist with this id?

Check if any projects exist

Does a project exist by this name?

Load all projects.

Load all projects whose name matches a prefix.

Insert a project row.

Rename a project row.

Precondition: the new name is available.

Does a project branch exist by this name?

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

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.

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

Insert a project branch.

Rename a project branch.

Precondition: the new name is available.

Delete a project branch.

Re-parenting happens in the obvious way:

Before:

main <- topic <- topic2

After deleting topic:

main <- topic2

Set project branch HEAD

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.

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

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.

Get dependents of a dependency.

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

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

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}

`getDirectDependentsWithinScope scope query` returns all direct dependents of query that are in scope (not including query itself).

`getTransitiveDependentsWithinScope scope query` returns all transitive dependents of query that are in scope (not including query itself).

Copies existing name lookup rows but replaces their branch hash id; This is a low-level operation used as part of deriving a new name lookup index from an existing one as performantly as possible.

Insert the given set of term names into the name lookup table

Insert the given set of type names into the name lookup table

Remove the given set of term names into the name lookup table

Remove the given set of term names into the name lookup table

NOTE: requires that the codebase has an up-to-date name lookup index. As of writing, this is only true on Share.

Get the list of a term names in the provided name lookup and relative namespace. Includes dependencies, but not transitive dependencies.

NOTE: requires that the codebase has an up-to-date name lookup index. As of writing, this is only true on Share.

Get the list of a type names in the provided name lookup and relative namespace. Includes dependencies, but not transitive dependencies.

NOTE: requires that the codebase has an up-to-date name lookup index. As of writing, this is only true on Share.

Get the list of term names for a given Referent within a given namespace. Considers one level of dependencies, but not transitive dependencies.

NOTE: requires that the codebase has an up-to-date name lookup index. As of writing, this is only true on Share.

Get the list of type names for a given Reference within a given namespace. Considers one level of dependencies, but not transitive dependencies.

NOTE: requires that the codebase has an up-to-date name lookup index. As of writing, this is only true on Share.

Searches all dependencies transitively looking for the provided referent. Prefer termNamesForRefWithinNamespace in most cases. This is slower and only necessary when resolving the name of references when you don't know which dependency it may exist in.

Searching transitive dependencies is exponential so we want to replace this with a more efficient approach as soon as possible.

Note: this returns the first name it finds by searching in order of: Names in the current namespace, then names in the current namespace's dependencies, then through the current namespace's dependencies' dependencies, etc.

NOTE: requires that the codebase has an up-to-date name lookup index. As of writing, this is only true on Share.

Searches all dependencies transitively looking for the provided referent. Prefer typeNamesForRefWithinNamespace in most cases. This is slower and only necessary when resolving the name of references when you don't know which dependency it may exist in.

Searching transitive dependencies is exponential so we want to replace this with a more efficient approach as soon as possible.

Note: this returns the first name it finds by searching in order of: Names in the current namespace, then names in the current namespace's dependencies, then through the current namespace's dependencies' dependencies, etc.

NOTE: requires that the codebase has an up-to-date name lookup index. As of writing, this is only true on Share.

Get the set of refs for an exact name. This will only return results which are within the name lookup for the provided branch hash id. It's the caller's job to select the correct name lookup for your exact name.

See termRefsForExactName in U.Codebase.Sqlite.Operations

NOTE: requires that the codebase has an up-to-date name lookup index. As of writing, this is only true on Share.

Get the set of refs for an exact name. This will only return results which are within the name lookup for the provided branch hash id. It's the caller's job to select the correct name lookup for your exact name.

See termRefsForExactName in U.Codebase.Sqlite.Operations

Check if we've already got an index for the desired root branch hash.

Inserts a new record into the name_lookups table

Delete the specified name lookup. This should only be used if you're sure it's unused, or if you're going to re-create it in the same transaction.

NOTE: requires that the codebase has an up-to-date name lookup index. As of writing, this is only true on Share.

Get the list of term names within a given namespace which have the given suffix.

NOTE: requires that the codebase has an up-to-date name lookup index. As of writing, this is only true on Share.

Get the list of type names within a given namespace which have the given suffix.

NOTE: requires that the codebase has an up-to-date name lookup index. As of writing, this is only true on Share.

The goal of this query is to search the codebase for the single name which has a different hash from the provided name, but shares longest matching suffix for for that name.

Including this name in the pretty-printer object causes it to suffixify the name so that it is unambiguous from other names in scope.

Sqlite doesn't provide enough functionality to do this query in a single query, so we do it iteratively, querying for longer and longer suffixes we no longer find matches. Then we return the name with longest matching suffix.

This is still relatively efficient because we can use an index and LIMIT 1 to make each individual query fast, and in the common case we'll only need two or three queries to find the longest matching suffix.

Considers one level of dependencies, but not transitive dependencies.

NOTE: requires that the codebase has an up-to-date name lookup index. As of writing, this is only true on Share.

The goal of this query is to search the codebase for the single name which has a different hash from the provided name, but shares longest matching suffix for for that name.

Including this name in the pretty-printer object causes it to suffixify the name so that it is unambiguous from other names in scope.

Sqlite doesn't provide enough functionality to do this query in a single query, so we do it iteratively, querying for longer and longer suffixes we no longer find matches. Then we return the name with longest matching suffix.

This is still relatively efficient because we can use an index and LIMIT 1 to make each individual query fast, and in the common case we'll only need two or three queries to find the longest matching suffix.

Considers one level of dependencies, but not transitive dependencies.

Associate name lookup indexes for dependencies to specific mounting points within another name lookup.

Fetch the name lookup mounts for a given name lookup index.

Delete any name lookup that's not in the provided list.

This can be used to garbage collect unreachable name lookups.

Searches for all names within the given name lookup which contain the provided list of segments in order. Search is case insensitive.

Searches for all names within the given name lookup which contain the provided list of segments in order.

Search is case insensitive.

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

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

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

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.

Delete all

Where an entity is stored.

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

Where is an entity stored?

Read an entity out of main storage.

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

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.

Save a temp entity in main storage.

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

Read an entity out of temp storage.

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

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 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}).

Get the most recent namespace the user has visited.

Set the most recent namespace the user has visited.

Deprecated in favour of project-branch reflog

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

Deprecated in favour of project-branch reflog

Expect the given schema version.

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.

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

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

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

Unlocalize a decl.

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

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

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

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

A namespace rendered as a path, no leading . E.g. "base.data"