# Transactions

## [](#_transactionality)Transactionality

Every TypeDB query runs inside a **transaction**.

TypeDB transactions come in 3 flavors: **read**, **write**, and **schema**. All transactions operate over **snapshots** of the database taken when the transaction is opened, providing a consistent view regardless of the operations performed in concurrent transactions. Thus, a transaction never sees either committed or uncommitted changes made in other transactions that were opened after it.

TypeDB transactions provide **ACID guarantees** up to snapshot isolation.

All transactions that can do writes in TypeDB are _stateful_: queries that mutate the schema or data have their changes buffered, and those changes are accessible to later stages in the query, and to later queries in the transaction. After a commit, the changes are written into the global database state and made accessible to new transactions.

## [](#_read_transactions)Read transactions

Read transactions can execute only read queries. When provided a data update query or a schema mutation query, a read transaction will error.

*   They are the most lightweight and should be used whenever possible.
    
*   **Any number of read transactions can be opened concurrently**, and they will never fail to open even when write or schema transactions are open.
    

## [](#_write_transactions)Write transactions

Write transactions can execute read queries and data update queries. When provided a schema mutation query, a write transaction will error.

*   Write transactions can be opened concurrently to other write transactions and read transactions.
    
*   An active schema transaction will prevent a new write transaction from being opened.
    
*   Write transactions **may fail on commit**, as required to enforce data consistency and isolation, such as when two write transactions concurrently update same piece of data and commit.
    

Example of conflicting writes

1.  We open transaction 1 and modify the owned attribute of an entity.
    
2.  We then open transaction 2 before transaction 1 has been committed, and modify the same ownership.
    
3.  If we commit first transaction 1, then transaction 2, the commit of transaction 2 will fail.
    

## [](#_schema_transactions)Schema transactions

Schema transactions can execute read queries, data update queries, and schema mutation queries.

*   Schema transactions are **exclusive** both against other schema transactions and write transactions. An open write transactions will block schema transactions from opening. Similarly, a schema transaction will block write and other schema transactions from opening. This prevents the data from being mutated while the schema is being updated.
    
*   Schema transactions can **mutate both data and schema** at the same time, allowing atomic migrations from one database state to another.
    

[Databases](../databases/index.md) [CRUD](../crud/index.md)

[Edit on GitHub](https://github.com/typedb/typedb-docs/edit/3.x-development/core-concepts/modules/ROOT/pages/typedb/transactions.adoc) Edit this page on GitHub.