@spec create_database(conn(), String.t(), keyword()) ::
  :ok | {:error, TypeDB.Error.t()}

Creates a database. A no-op for one that already exists.

@spec create_database!(term(), term(), term()) :: :ok

Creates a database, raising on failure.

@spec create_database_if_not_exists(conn(), String.t(), keyword()) ::
  :ok | {:error, TypeDB.Error.t()}

Creates a database unless it is already there.

@spec create_database_if_not_exists!(term(), term(), term()) :: :ok

Creates a database unless it is there, raising on failure.

@spec databases(
  conn(),
  keyword()
) :: {:ok, [String.t()]} | {:error, TypeDB.Error.t()}

Every database on the server.

@spec databases!(term(), term()) :: [String.t()]

Every database, raising on failure.

@spec delete_database(conn(), String.t(), keyword()) ::
  :ok | {:error, TypeDB.Error.t()}

Deletes a database and everything in it.

@spec delete_database!(term(), term(), term()) :: :ok

Deletes a database, raising on failure.

@spec export_database(conn(), String.t(), Path.t(), Path.t(), keyword()) ::
  :ok | {:error, TypeDB.Error.t()}

Writes a database's schema and data to two files.

The capability the HTTP API does not have at all — see TypeDB.GRPC.Database.export_to_files/5.

@spec export_database!(term(), term(), term(), term(), term()) :: :ok

Exports a database to two files, raising on failure.

@spec health(
  conn(),
  keyword()
) :: :ok | {:error, TypeDB.Error.t()}

Whether the server is reachable and answering.

@spec health!(term(), term()) :: :ok

Server reachability, raising on failure.

@spec import_database(conn(), String.t(), Path.t(), Path.t(), keyword()) ::
  :ok | {:error, TypeDB.Error.t()}

Creates a database from the two files export_database/5 wrote.

@spec import_database!(term(), term(), term(), term(), term()) :: :ok

Imports a database from two files, raising on failure.

@spec query(conn(), String.t(), String.t(), keyword()) ::
  {:ok, TypeDB.Answer.t()} | {:error, TypeDB.Error.t()}

Runs one query in a transaction of its own.

Options

• :transaction_type — :read, :write or :schema. Defaults to :schema, matching TypeDB.query/4: it is the only type that accepts every kind of query, and it is also the one that takes the exclusive schema lock, so pass the type you mean.
• :given_rows — rows for TypeQL's given stage
• :timeout — how long to wait
• :transaction_timeout_millis, :schema_lock_acquire_timeout_millis

A :write or :schema query commits; a :read closes.

@spec query!(conn(), String.t(), String.t(), keyword()) :: TypeDB.Answer.t()

Runs one query, raising TypeDB.Error on failure.

@spec running?(conn()) :: boolean()

Whether conn can serve a call.

Answers about this node's connection process, not about TypeDB — the same caveat as TypeDB.running?/1. health/2 is the question about the server.

@spec start_link(keyword()) :: GenServer.on_start()

Starts a connection. See TypeDB.GRPC.Config.new/1 for the options.

@spec stop(conn() | pid(), term(), timeout()) :: :ok

Stops a connection.

@spec stream(conn(), String.t(), String.t(), keyword()) :: Enumerable.t()

Reads a query as a Stream, pulling from the server as it is consumed.

The thing this transport can do that the other cannot. The stream holds one batch at a time and asks TypeDB for the next only when the consumer wants it, so memory follows the batch rather than the answer:

TypeDB.GRPC.stream(conn, "social", "match $p isa person, has name $n; select $n;")
|> Stream.map(&TypeDB.ConceptRow.typed_value(&1, "n"))
|> Enum.each(&IO.puts/1)

The transaction lives for as long as the stream does and is closed when it ends, including when the consumer stops early — Enum.take/2 over a stream of ten million rows reads a batch, not ten million.

Reads only. :transaction_type defaults to :read here rather than to :schema, because a stream of a define is not a thing anybody wants.

@spec transaction(
  conn(),
  String.t(),
  TypeDB.GRPC.Transaction.type(),
  (TypeDB.GRPC.Transaction.t() -> result),
  keyword()
) :: result | {:error, TypeDB.Error.t()}
when result: term()

Runs fun inside one transaction, committing on success.

Commits when fun returns anything but {:error, _}; closes without committing on an error, a raise, a throw or an exit.

@spec version(
  conn(),
  keyword()
) :: {:ok, map()} | {:error, TypeDB.Error.t()}

The server's distribution and version.

@spec version!(term(), term()) :: map()

The server's version, raising on failure.