Blocking API
- Client
- Transactions

Blocking API

Client

function

create_client()

create_client(dsn = None, *, host = None, port = None, user = None, password = None, database = None, timeout = 60, concurrency = None)

Create a blocking client with a lazy connection pool.

The connection parameters may be specified either as a connection URI in dsn, or as specific keyword arguments, or both. If both dsn and keyword arguments are specified, the latter override the corresponding values parsed from the connection URI.

If no connection parameter is specified, the client will try to search in environment variables and then the current project, see Client Library Connection docs for more information.

Returns a new Client object.

Parameters

dsn – If this parameter does not start with edgedb:// then this is interpreted as the name of a local instance.Otherwise it specifies a single string in the following format: edgedb://user:password@host:port/database?option=value. The following options are recognized: host, port, user, database, password. For a complete reference on DSN, see the DSN Specification.
host – Database host address as one of the following:
- an IP address or a domain name;
- an absolute path to the directory containing the database server Unix-domain socket (not supported on Windows);
- a sequence of any of the above, in which case the addresses will be tried in order, and the host of the first successful connection will be used for the whole connection pool.
If not specified, the following will be tried, in order:
- host address(es) parsed from the dsn argument,
- the value of the EDGEDB_HOST environment variable,
- on Unix, common directories used for EdgeDB Unix-domain sockets: "/run/edgedb" and "/var/run/edgedb",
- "localhost".
port – Port number to connect to at the server host (or Unix-domain socket file extension). If multiple host addresses were specified, this parameter may specify a sequence of port numbers of the same length as the host sequence, or it may specify a single port number to be used for all host addresses.If not specified, the value parsed from the dsn argument is used, or the value of the EDGEDB_PORT environment variable, or 5656 if neither is specified.
user – The name of the database role used for authentication.If not specified, the value parsed from the dsn argument is used, or the value of the EDGEDB_USER environment variable, or the operating system name of the user running the application.
database – The name of the database to connect to.If not specified, the value parsed from the dsn argument is used, or the value of the EDGEDB_DATABASE environment variable, or the operating system name of the user running the application.
password – Password to be used for authentication, if the server requires one. If not specified, the value parsed from the dsn argument is used, or the value of the EDGEDB_PASSWORD environment variable. Note that the use of the environment variable is discouraged as other users and applications may be able to read it without needing specific privileges.
timeout (float) – Connection timeout in seconds.

Returns

An instance of Client.

The APIs on the returned client instance can be safely used by different threads, because under the hood they are checking out different connections from the pool to run the queries:

Client.query()
Client.query_single()
Client.query_required_single()
Client.query_json()
Client.query_single_json()
Client.query_required_single_json()
Client.execute()
Client.transaction()

client = edgedb.create_client()
client.query('SELECT {1, 2, 3}')

The same for transactions:

client = edgedb.create_client()
for tx in client.transaction():
    with tx:
        tx.query('SELECT {1, 2, 3}')

class

Client

A thread-safe blocking client with a connection pool.

Blocking clients are created by calling create_client().

method

Client.query()

Client.query(query, * args, ** kwargs)

Acquire a connection and use it to run a query and return the results as an edgedb.Set instance. The temporary connection is automatically returned back to the pool.

Parameters

query (str) – Query text.
args – Positional query arguments.
kwargs – Named query arguments.

Returns

An instance of edgedb.Set containing the query result.

Note that positional and named query arguments cannot be mixed.

method

Client.query_single()

Client.query_single(query, * args, ** kwargs)

Acquire a connection and use it to run an optional singleton-returning query and return its element. The temporary connection is automatically returned back to the pool.

Parameters

query (str) – Query text.
args – Positional query arguments.
kwargs – Named query arguments.

Returns

Query result.

The query must return no more than one element. If the query returns more than one element, an edgedb.ResultCardinalityMismatchError is raised, if it returns an empty set, None is returned.

Note, that positional and named query arguments cannot be mixed.

method

Client.query_required_single()

Client.query_required_single(query, * args, ** kwargs)

Acquire a connection and use it to run a singleton-returning query and return its element. The temporary connection is automatically returned back to the pool.

Parameters

query (str) – Query text.
args – Positional query arguments.
kwargs – Named query arguments.

Returns

Query result.

The query must return exactly one element. If the query returns more than one element, an edgedb.ResultCardinalityMismatchError is raised, if it returns an empty set, an edgedb.NoDataError is raised.

Note, that positional and named query arguments cannot be mixed.

method

Client.query_json()

Client.query_json(query, * args, ** kwargs)

Acquire a connection and use it to run a query and return the results as JSON. The temporary connection is automatically returned back to the pool.

Parameters

query (str) – Query text.
args – Positional query arguments.
kwargs – Named query arguments.

Returns

A JSON string containing an array of query results.

Note, that positional and named query arguments cannot be mixed.

Caution is advised when reading decimal values using this method. The JSON specification does not have a limit on significant digits, so a decimal number can be losslessly represented in JSON. However, the default JSON decoder in Python will read all such numbers as float values, which may result in errors or precision loss. If such loss is unacceptable, then consider casting the value into str and decoding it on the client side into a more appropriate type, such as Decimal.

method

Client.query_single_json()

Client.query_single_json(query, * args, ** kwargs)

Acquire a connection and use it to run an optional singleton-returning query and return its element in JSON. The temporary connection is automatically returned back to the pool.

Parameters

query (str) – Query text.
args – Positional query arguments.
kwargs – Named query arguments.

Returns

Query result encoded in JSON.

The query must return no more than one element. If the query returns more than one element, an edgedb.ResultCardinalityMismatchError is raised, if it returns an empty set, "null" is returned.

Note, that positional and named query arguments cannot be mixed.

method

Client.query_required_single_json()

Client.query_required_single_json(query, * args, ** kwargs)

Acquire a connection and use it to run a singleton-returning query and return its element in JSON. The temporary connection is automatically returned back to the pool.

Parameters

query (str) – Query text.
args – Positional query arguments.
kwargs – Named query arguments.

Returns

Query result encoded in JSON.

Note, that positional and named query arguments cannot be mixed.

method

Client.execute()

Client.execute(query)

Acquire a connection and use it to execute an EdgeQL command (or commands). The temporary connection is automatically returned back to the pool.

Parameters

query (str) – Query text.

The commands must take no arguments.

Example:

>>> 
... 
... 
... 
... 
... 
...

client.execute('''
    CREATE TYPE MyType {
        CREATE PROPERTY a -> int64
    };
    FOR x IN {100, 200, 300}
    UNION INSERT MyType { a := x };
''')

If the results of query are desired, query(), query_single() or query_required_single() should be used instead.

method

Client.transaction()

Open a retryable transaction loop.

This is the preferred method of initiating and running a database transaction in a robust fashion. The transaction() transaction loop will attempt to re-execute the transaction loop body if a transient error occurs, such as a network error or a transaction serialization error.

Returns an instance of Retry.

See Transactions for more details.

Example:

for tx in client.transaction():
    with tx:
        value = tx.query_single("SELECT Counter.value")
        tx.execute(
            "UPDATE Counter SET { value := <int64>$value }",
            value=value + 1,
        )

Note that we are executing queries on the tx object rather than on the original connection.

The transaction starts lazily. A connection is only acquired from the pool when the first query is issued on the transaction instance.

method

Client.close()

Client.close(timeout = None)

Attempt to gracefully close all connections in the pool.

Wait until all pool connections are released, close them and shut down the pool. If any error (including timeout) occurs in close() the pool will terminate by calling terminate().

Parameters

timeout (float) – Seconds to wait, None for wait forever.

method

Client.terminate()

Terminate all connections in the pool.

method

Client.ensure_connected()

If the client does not yet have any open connections in its pool, attempts to open a connection, else returns immediately.

Since the client lazily creates new connections as needed (up to the configured concurrency limit), the first connection attempt will only occur when the first query is run on a client. ensureConnected can be useful to catch any errors resulting from connection mis-configuration by triggering the first connection attempt explicitly.

method

Client.with_transaction_options()

Client.with_transaction_options(options = None)

Returns a shallow copy of the client with adjusted transaction options.

Parameters

options (TransactionOptions) – Object that encapsulates transaction options.

See Transaction Options for details.

method

Client.with_retry_options()

Client.with_retry_options(options = None)

Returns a shallow copy of the client with adjusted retry options.

Parameters

options (RetryOptions) – Object that encapsulates retry options.

See Retry Options for details.

method

Client.with_state()

Client.with_state(state)

Returns a shallow copy of the client with adjusted state.

Parameters

state (State) – Object that encapsulates state.

See State for details.

method

Client.with_default_module()

Client.with_default_module(module = None)

Returns a shallow copy of the client with adjusted default module.

This is equivalent to using the set module command, or using the reset module command when giving None.

Parameters

module (str or None) – Adjust the default module.

See State.with_default_module() for details.

method

Client.with_module_aliases()

Client.with_module_aliases(aliases_dict = None, /, ** aliases)

Returns a shallow copy of the client with adjusted module aliases.

This is equivalent to using the set alias command.

Parameters

aliases_dict (dict[str, str] or None) – This is an optional positional-only argument.
aliases (dict[str, str]) – Adjust the module aliases after applying aliases_dict if set.

See State.with_module_aliases() for details.

method

Client.without_module_aliases()

Client.without_module_aliases(* aliases)

Returns a shallow copy of the client without specified module aliases.

This is equivalent to using the reset alias command.

Parameters

aliases (tuple[str]) – Module aliases to reset.

See State.without_module_aliases() for details.

method

Client.with_config()

Client.with_config(config_dict = None, /, ** config)

Returns a shallow copy of the client with adjusted session config.

This is equivalent to using the configure session set command.

Parameters

config_dict (dict[str, object] or None) – This is an optional positional-only argument.
config (dict[str, object]) – Adjust the config settings after applying config_dict if set.

See State.with_config() for details.

method

Client.without_config()

Client.without_config(* config_names)

Returns a shallow copy of the client without specified session config.

This is equivalent to using the configure session reset command.

Parameters

config_names (tuple[str]) – Config to reset.

See State.without_config() for details.

method

Client.with_globals()

Client.with_globals(globals_dict = None, /, ** globals_)

Returns a shallow copy of the client with adjusted global values.

This is equivalent to using the set global command.

Parameters

globals_dict (dict[str, object] or None) – This is an optional positional-only argument.
globals (dict[str, object]) – Adjust the global values after applying globals_dict if set.

See State.with_globals() for details.

method

Client.without_globals()

Client.without_globals(* global_names)

Returns a shallow copy of the client without specified globals.

This is equivalent to using the reset global command.

Parameters

global_names (tuple[str]) – Globals to reset.

See State.without_globals() for details.

Transactions

The most robust way to execute transactional code is to use the transaction() loop API:

for tx in client.transaction():
    with tx:
        tx.execute("INSERT User { name := 'Don' }")

Note that we execute queries on the tx object in the above example, rather than on the original client object.

The tx object stores a connection acquired from the pool, so that all queries can be executed on the same connection in the same transaction. Transaction start is lazy. for tx or with tx won’t acquire the connection and start the transaction. It’s only done when executing the first query on the tx object. That connection is pinned to the tx object even when a reconnection is needed, until leaving the final with transaction block.

The transaction() API guarantees that:

Transactions are executed atomically;
If a transaction is failed for any of the number of transient errors (i.e. a network failure or a concurrent update error), the transaction would be retried;
If any other, non-retryable exception occurs, the transaction is rolled back, and the exception is propagated, immediately aborting the transaction() block.

The key implication of retrying transactions is that the entire nested code block can be re-run, including any non-querying Python code. Here is an example:

for tx in client.transaction():
    with tx:
        user = tx.query_single(
            "SELECT User { email } FILTER .login = <str>$login",
            login=login,
        )
        data = httpclient.get(
            'https://service.local/email_info',
            params=dict(email=user.email),
        )
        user = tx.query_single('''
                UPDATE User FILTER .login = <str>$login
                SET { email_info := <json>$data}
            ''',
            login=login,
            data=data,
        )

In the above example, the execution of the HTTP request would be retried too. The core of the issue is that whenever transaction is interrupted user might have the email changed (as the result of concurrent transaction), so we have to redo all the work done.

Generally it’s recommended to not execute any long running code within the transaction unless absolutely necessary.

Transactions allocate expensive server resources and having too many concurrently running long-running transactions will negatively impact the performance of the DB server.

To rollback a transaction that is in progress raise an exception.

class RollBack(Exception):
    "A user defined exception."
try:
    for tx in client.transaction():
        with tx:
            raise RollBack
except RollBack:
    pass