TypeDB Files

Download from TypeDB Package Repository:

Distributions for 3.13.6

Pull the Docker image:

:::docker pull typedb/typedb:3.13.6```


## New Features

- **Add hardware info log line on bootup**

  Add log line on bootup printing the available hardware information.

  Example output:
  ```
  2026-09-14T21:04:09.512143Z  INFO ThreadId(01) server/lib.rs:502: Hardware info - cpu: 10, memory: 64 GB (15 GB free), data directory: 1858 GB (236 GB free)
  ```



- **Support fully qualified names for builtin functions to emulate namespacing**
  Support using fully qualified function names to invoke built-in functions (e.g. `let $rounded = std::math::round(1.5);`).
  Using the name directly is still supported for existing functions, but most future functions will need to be invoked using fully qualified names till namespacing is fully supported.

  This change introduces one new function, and fully qualified aliases for existing ones:

  - New function: `std::math::log10`
  - Aliased function: global `abs` is an alias for `std::math::abs`
  - Aliased function: global `ceil` is an alias for `std::math::ceil`
  - Aliased function: global `floor` is an alias for `std::math::floor`
  - Aliased function: global `max` is an alias for `std::math::max`
  - Aliased function: global `min` is an alias for `std::math::min`
  - Aliased function: global `string` is an alias for `std::string::len`



- **Reduce isolation conflicts from concurrent large attribute writes**

  We reduce number of the isolation conflicts generated by concurrent string attribute writing, trading off for the less frequent concurrent create-delete conflicts.

  "Large" attribute values are hashed and stored using a chaining probe; these attribute ID creation actions are locked with an exclusive lock on the 64-bit hash bucket. Previously, this locking occurs even when creating an attribute that already exists in the database, which can cause a large number of conflicts during concurrent data loading. This was required for correctness, because without this the attributes' _put_ semantics kick in and re-create the key identically if the attribute is concurrently deleted - by which point the same bucket hash position could have been used by another colliding string value in rare cases.

  Instead, when the value pre-exists we switch the exclusive bucket lock (which prevented concurrent re-creation) for an unmodifiable lock (which prevents concurrent deletion). We consider concurrent deletion to be a significantly less frequent conflict than concurrent attribute writing or rewriting.


## Bugs Fixed

- **Fix function calls copying row where input row is narrower output row**
  This can happen when a function call is the first instruction after a stage that may narrow a row, such as select or delete. fixes #7930


- **Lower commit validation memory consumption**

  Introduce a series of changes to lower the RAM consumption of a TypeDB server during different schema validation operations.

  ### Database import excessive relaxation
  Relaxation of cardinality constraints only affects annotations that are set to non-zero lower bounds. Previously, the rule was to relax any non-`0..` cardinality, which is too wide. Now, all capabilities with default cardinalities and many other user-defined cases are untouched, which makes the finalisation step much faster in many cases (it skips the whole data cardinality verification -- one of the heaviest operations in the process).

  ### Cardinality validation
  Cardinality validation is used to collect all the affected instances in RAM to combine changes from different sources: various schema changes and instance inserts and deletions. This is too greedy for small machines or huge datasets, so the algorithm was refactored.

  Now, only types (a logically limited number) and a small portion of instances are kept in memory at a time, processed in batches. With this, the uncapped memory consumption (up to tens of GB) went to about a hundred MB. Instead, in rare cases, the server might need to revisit the same instance and/or capability multiple (fewer than 4) times, which could potentially lead to slightly slower processing.

  **This does not affect the memory used by the storage or snapshot while running queries or recovering**. However, this introduces a significant improvement for query commits.

  ### Relation index excessive rebuilding
  Relation index now rebuilds only if the schema changes the way the relation's cardinality crosses the index boundary (either becomes available for caching or stops qualifying for caching). It used to refresh for any schema change, which could become catastrophic, especially for database import relaxations.

  Additionally, relation index regeneration had bugs. E.g., deleting relations and role players inside a schema transaction used to leave stale entries in the relation index, and bringing a relation type into the index used to build it incompletely in some cases. A couple of issues have been closed.



- **Reduce memory pressure and accelerate database import**

  Importing or migrating a large database no longer grows memory without bound. Previously, the importer held every reference to a not-yet-imported instance in memory and, when a heavily shared concept finally arrived, wrote all of its capabilities in a single commit. On a multi-GB database, that was tens of millions of parked references plus a hundreds-of-MB commit, so the server's memory climbed with the dataset.

  Import memory is now flat regardless of dataset size (max a few GB), and a single hot attribute no longer produces an oversized commit.



- **Ignore internal variables of parent when seeding positions in subpattern**
  Since a subpattern (may) extend the row from its parent pattern, it uses the same positions in the row for the shared/input variables as the parent pattern does. In certain cases such as disjunctions in negations: 
  * a variable that is in all branches of the disjunction is considered visible to the parent. 
  * If it is not used outside the disjunction, the parent pattern considers it "internal" to the disjunction.
  * Since the parent passes positions down to the subpatterns, the disjunction branches wrongly assume "internal" to be the position of the variable, though it may be used in different constraints within the branch.




## Code Refactors


- **Add API for decoding arbitrary storage keys**

  We add `encoding::DecodableKey` enum which can wrap an arbitrary key, and the corresponding decoding routine.



- **Simplify optional handling in write stage executables**
  Leverage the PatternVariables recently added to the conjunction IR to determine input variables to each pattern, and unify the root & optional write patterns. The root is just one with no pre-conditions to execute.



## Other Improvements

- **Refresh plan heuristic when stashing a trivial pattern extension**

  The query planner's beam search ranks partial plans by their heuristic cost. When a plan was extended with a trivial pattern (one that has become a pure check because all of its variables are already bound, such as $p isa person once $p is produced by an index), the extended plan kept the heuristic it had before the extension. The beam and the final selection therefore compared stale estimates from the previous step, and could select a plan that the cost model itself rate more expensive.

  For example in
  ```
  match
    $p isa person;
    follows (follower: $f, followee: $p);
  ```

  The planner costed a single scan of the follows relation index below the alternative of scanning every person and seeking into the index per person, but chose the latter because the stale heuristics ranked it first. With this change the index scan is chosen (one seek instead of one per person), and its output is sorted by $p. Plans for queries without trivially satisfied patterns are unaffected.



- **Use old brew install script from before deprecation**
  Use old brew install script from before deprecation so that our CI chugs along.
  see Homebrew/install#1140


- **Replace ContextualisedBindingMode with PatternVariables**
  PatternVariables has enough information in it, so we can dissolve `ContextualisedBindingMode`.


- **Split impl of the embedded Checker which extracts from TupleIterator and the standalone Checker**
  Splitting the impl block and removing the `self` parameter clears us to execute a `Vec<CheckInstruction<_>>` without having to create a `Checker`