@spec async_await_schema_agreement(
  ExScylla.Types.session(),
  opaque()
) :: {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.await_schema_agreement

Async version of await_schema_agreement, returns: {:ok, opaque} | {:error, any()}

Actual result (:ok | {:error, QueryError.t()}) is sent to the calling process:

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> Session.await_schema_agreement(session)
:ok

@spec async_await_timed_schema_agreement(
  ExScylla.Types.session(),
  pos_integer(),
  opaque()
) ::
  {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.await_schema_agreement

Async version of await_timed_schema_agreement, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, boolean()} | {:error, QueryError.t()}) is sent to the calling process:

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> Session.await_timed_schema_agreement(session, 15_000)
{:ok, true}

@spec async_batch(
  ExScylla.Types.session(),
  ExScylla.Types.batch(),
  ExScylla.Types.values(),
  opaque()
) ::
  {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.batch

Async version of batch, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, QueryResult.t()} | {:error, QueryError.t()}) is sent to the calling process:

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> batch = Batch.new(:unlogged)
...>   |> Batch.append_statement("INSERT INTO test.session_doc (a, b, c) VALUES (?, ?, ?)")
iex> values = [
...>   [{:text, "test"}, {:int, 2}, {:double, 1.0}]
...> ]
iex> {:ok, opaque} = Session.async_batch(session, batch, values)
iex> {:ok, %QueryResult{}}  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end

@spec async_batch_raw(
  ExScylla.Types.session(),
  ExScylla.Types.batch(),
  ExScylla.Types.values(),
  opaque()
) :: {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.batch

Async version of batch_raw, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, QueryResultRaw.t()} | {:error, QueryError.t()}) is sent to the calling process:

@spec async_check_schema_agreement(
  ExScylla.Types.session(),
  opaque()
) :: {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.check_schema_agreement

Async version of check_schema_agreement, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, boolean()} | {:error, QueryError.t()}) is sent to the calling process:

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> {:ok, opaque} = Session.async_check_schema_agreement(session)
iex> {:ok, true}  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end

@spec async_execute(
  ExScylla.Types.session(),
  ExScylla.Types.prepared_statement(),
  ExScylla.Types.values(),
  opaque()
) :: {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.execute_unpaged

Async version of execute, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, QueryResult.t()} | {:error, QueryError.t()}) is sent to the calling process:

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> {:ok, ps} = Session.prepare(session, "INSERT INTO test.session_doc (a, b, c) VALUES (?, ?, ?)")
iex> values = [{:text, "test"}, {:int, 2}, {:double, 1.0}]
iex> {:ok, opaque} = Session.async_execute(session, ps, values)
iex> {:ok, %QueryResult{}}  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end

@spec async_execute_paged(
  ExScylla.Types.session(),
  ExScylla.Types.prepared_statement(),
  ExScylla.Types.values(),
  ExScylla.Types.paging_state() | nil,
  opaque()
) :: {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.execute_single_page

Async version of execute_paged, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, QueryResult.t()} | {:error, QueryError.t()}) is sent to the calling process:

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> query = "INSERT INTO test.session_doc (a, b, c) VALUES (?, ?, ?)"
iex> values = [{:text, "test_execute_paged"}, {:int, 1}, {:double, 1.0}]
iex> {:ok, %QueryResult{}} = Session.query(session, query, values)
iex> {:ok, ps} = Session.prepare(session, "SELECT * FROM test.session_doc WHERE a = ?;")
iex> ps = Prepared.set_page_size(ps, 1)
iex> values = [{:text, "test_execute_paged"}]
iex> {:ok, opaque} = Session.async_execute_paged(session, ps, values, nil)
iex> {:ok, %QueryResult{paging_state: pgs}}  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end
iex> true = is_binary(pgs)
iex> {:ok, opaque} = Session.async_execute_paged(session, ps, values, pgs)
iex> {:ok, %QueryResult{}}  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end

@spec async_execute_raw(
  ExScylla.Types.session(),
  ExScylla.Types.prepared_statement(),
  ExScylla.Types.values(),
  opaque()
) :: {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.execute_unpaged

Async version of execute_raw, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, QueryResultRaw.t()} | {:error, QueryError.t()}) is sent to the calling process:

@spec async_execute_raw_paged(
  ExScylla.Types.session(),
  ExScylla.Types.prepared_statement(),
  ExScylla.Types.values(),
  ExScylla.Types.paging_state() | nil,
  opaque()
) :: {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.execute_single_page

Async version of execute_raw_paged, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, QueryResultRaw.t()} | {:error, QueryError.t()}) is sent to the calling process:

@spec async_fetch_schema_version(
  ExScylla.Types.session(),
  opaque()
) :: {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.await_schema_agreement

Async version of fetch_schema_version, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, T.uuid()} | {:error, QueryError.t()}) is sent to the calling process:

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> {:ok, opaque} = Session.async_fetch_schema_version(session)
iex> {:ok, version}  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end
iex> true = is_binary(version)

@spec async_get_tracing_info(ExScylla.Types.session(), binary(), opaque()) ::
  {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.get_tracing_info

Async version of get_tracing_info, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, TracingInfo.t()} | {:error, QueryError.t()}) is sent to the calling process:

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> alias ExScylla.Types.TracingInfo
iex> # Tracing must be enabled on statement/query
iex> q = ExScylla.Statement.Query.new("SELECT * FROM test.session_doc") |> ExScylla.Statement.Query.set_tracing(true)
iex> {:ok, %QueryResult{tracing_id: tid}} = Session.query(session, q, [])
iex> {:ok, opaque} = Session.async_get_tracing_info(session, tid)
iex> {:ok, %TracingInfo{}}  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end

@spec async_prepare(
  ExScylla.Types.session(),
  String.t() | ExScylla.Types.query(),
  opaque()
) ::
  {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.prepare

Async version of prepare, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, T.prepared_statement()} | {:error, QueryError.t()}) is sent to the calling process:

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> {:ok, opaque} = Session.async_prepare(session, "SELECT * FROM test.session_doc WHERE a = ?;")
iex> {:ok, ps}  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end
iex> true = is_reference(ps)

@spec async_prepare_batch(ExScylla.Types.session(), ExScylla.Types.batch(), opaque()) ::
  {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.prepare_batch

Async version of prepare_batch, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, T.batch()} | {:error, QueryError.t()}) is sent to the calling process:

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> alias ExScylla.Statement.Batch
iex> batch = Batch.new(:unlogged)
...>   |> Batch.append_statement("INSERT INTO test.session_doc (a, b, c) VALUES (?, ?, ?)")
iex> {:ok, opaque} = Session.async_prepare_batch(session, batch)
iex> {:ok, prepared_batch}  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end
iex> true = is_reference(prepared_batch)

@spec async_query(
  ExScylla.Types.session(),
  String.t() | ExScylla.Types.query(),
  ExScylla.Types.values(),
  opaque()
) :: {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.query_unpaged

Async version of query, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, QueryResult.t()} | {:error, QueryError.t()}) is sent to the calling process:

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> query = "INSERT INTO test.session_doc (a, b, c) VALUES (?, ?, ?)"
iex> values = [{:text, "test"}, {:int, 3}, {:double, 1.0}]
iex> {:ok, opaque} = Session.async_query(session, query, values)
iex> {:ok, %QueryResult{}}  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end
iex> # Test Decimal and Varint
iex> t = "CREATE TABLE IF NOT EXISTS test.types_test (id INT PRIMARY KEY, d DECIMAL, v VARINT);"
iex> {:ok, opaque} = Session.async_query(session, t, [])
iex> {:ok, _}  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end
iex> query = "INSERT INTO test.types_test (id, d, v) VALUES (?, ?, ?)"
iex> values = [{:int, 1}, {:decimal, "1.23"}, {:varint, "12345678901234567890"}]
iex> {:ok, opaque} = Session.async_query(session, query, values)
iex> {:ok, _}  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end
iex> {:ok, opaque} = Session.async_query(session, "SELECT * FROM test.types_test WHERE id = 1", [])
iex> {:ok, %QueryResult{rows: [%ExScylla.Types.Row{columns: [id, d, v]}]}}  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end
iex> {:int, 1} = id
iex> {:decimal, "1.23"} = d
iex> {:varint, "12345678901234567890"} = v

@spec async_query_paged(
  ExScylla.Types.session(),
  String.t() | ExScylla.Types.query(),
  ExScylla.Types.values(),
  ExScylla.Types.paging_state() | nil,
  opaque()
) :: {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.query_single_page

Async version of query_paged, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, QueryResult.t()} | {:error, QueryError.t()}) is sent to the calling process:

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> query = "INSERT INTO test.session_doc (a, b, c) VALUES (?, ?, ?)"
iex> values = [{:text, "test_query_paged"}, {:int, 1}, {:double, 1.0}]
iex> {:ok, %QueryResult{}} = Session.query(session, query, values)
iex> q = Query.new("SELECT * FROM test.session_doc WHERE a = ?;")
...>              |> Query.with_page_size(1)
iex> values = [{:text, "test_query_paged"}]
iex> {:ok, opaque} = Session.async_query_paged(session, q, values, nil)
iex> {:ok, %QueryResult{paging_state: pgs}}  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end
iex> true = is_binary(pgs)
iex> {:ok, opaque} = Session.async_query_paged(session, q, values, pgs)
iex> {:ok, %QueryResult{}}  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end

@spec async_query_raw(
  ExScylla.Types.session(),
  String.t() | ExScylla.Types.query(),
  ExScylla.Types.values(),
  opaque()
) :: {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.query_unpaged

Async version of query_raw, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, QueryResultRaw.t()} | {:error, QueryError.t()}) is sent to the calling process:

@spec async_query_raw_paged(
  ExScylla.Types.session(),
  String.t() | ExScylla.Types.query(),
  ExScylla.Types.values(),
  ExScylla.Types.paging_state() | nil,
  opaque()
) :: {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.query_single_page

Async version of query_raw_paged, returns: {:ok, opaque} | {:error, any()}

Actual result ({:ok, QueryResultRaw.t()} | {:error, QueryError.t()}) is sent to the calling process:

@spec async_refresh_metadata(
  ExScylla.Types.session(),
  opaque()
) :: {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.refresh_metadata

Async version of refresh_metadata, returns: {:ok, opaque} | {:error, any()}

Actual result (:ok | {:error, QueryError.t()}) is sent to the calling process:

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> {:ok, opaque} = Session.async_refresh_metadata(session)
iex> :ok  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end

@spec async_use_keyspace(ExScylla.Types.session(), String.t(), boolean(), opaque()) ::
  {:ok, opaque()} | {:error, any()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.use_keyspace

Async version of use_keyspace, returns: {:ok, opaque} | {:error, any()}

Actual result (:ok | {:error, QueryError.t()}) is sent to the calling process:

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> case_sensitive = false
iex> {:ok, opaque} = Session.async_use_keyspace(session, "another_test_keyspace", case_sensitive)
iex> :ok  = receive do
...>   {^opaque, r} ->
...>     case r do
...>       {:ok, %ExScylla.Types.QueryResult{} = res} -> {:ok, ExScylla.Types.QueryResult.decode(res)}
...>       other -> other
...>     end
...> after
...>   5_000 -> :timeout
...> end

@spec await_schema_agreement(
  ExScylla.Types.session(),
  pos_integer()
) :: (:ok | {:error, ExScylla.Types.Errors.QueryError.t()}) | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.await_schema_agreement

Sync version of await_schema_agreement

Returns result (:ok | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> Session.await_schema_agreement(session)
:ok

@spec await_timed_schema_agreement(
  ExScylla.Types.session(),
  pos_integer(),
  pos_integer()
) ::
  ({:ok, boolean()} | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.await_schema_agreement

Sync version of await_timed_schema_agreement

Returns result ({:ok, boolean()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> Session.await_timed_schema_agreement(session, 15_000)
{:ok, true}

@spec batch(
  ExScylla.Types.session(),
  ExScylla.Types.batch(),
  ExScylla.Types.values(),
  pos_integer()
) ::
  ({:ok, ExScylla.Types.QueryResult.t()}
   | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.batch

Sync version of batch

Returns result ({:ok, QueryResult.t()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> batch = Batch.new(:unlogged)
...>   |> Batch.append_statement("INSERT INTO test.session_doc (a, b, c) VALUES (?, ?, ?)")
iex> values = [
...>   [{:text, "test"}, {:int, 2}, {:double, 1.0}]
...> ]
iex> {:ok, %QueryResult{}} = Session.batch(session, batch, values)

@spec batch_raw(
  ExScylla.Types.session(),
  ExScylla.Types.batch(),
  ExScylla.Types.values(),
  pos_integer()
) ::
  ({:ok, QueryResultRaw.t()} | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.batch

Sync version of batch_raw

Returns result ({:ok, QueryResultRaw.t()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

@spec calculate_token(
  ExScylla.Types.session(),
  ExScylla.Types.prepared_statement(),
  ExScylla.Types.values()
) ::
  ExScylla.Types.Token.t()
  | nil
  | {:error,
     ExScylla.Types.Errors.SerializeValuesError.t()
     | ExScylla.Types.Errors.QueryError.t()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> {:ok, ps} = Session.prepare(session, "SELECT * FROM test.session_doc WHERE a = ?;")
iex> values = [{:text, "test"}]
iex> %Token{value: t} = Session.calculate_token(session, ps, values)
iex> true = is_integer(t)

@spec calculate_token_for_partition_key(
  ExScylla.Types.session(),
  String.t(),
  String.t(),
  ExScylla.Types.values()
) ::
  ExScylla.Types.Token.t()
  | nil
  | {:error, ExScylla.Types.Errors.SerializeValuesError.t()}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> alias ExScylla.Types.Token
iex> values = [{:text, "test"}]
iex> %Token{value: t} = Session.calculate_token_for_partition_key(session, "test", "session_doc", values)
iex> true = is_integer(t)

@spec check_schema_agreement(
  ExScylla.Types.session(),
  pos_integer()
) ::
  ({:ok, boolean()} | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.check_schema_agreement

Sync version of check_schema_agreement

Returns result ({:ok, boolean()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> {:ok, true} = Session.check_schema_agreement(session)

@spec execute(
  ExScylla.Types.session(),
  ExScylla.Types.prepared_statement(),
  ExScylla.Types.values(),
  pos_integer()
) ::
  ({:ok, ExScylla.Types.QueryResult.t()}
   | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.execute_unpaged

Sync version of execute

Returns result ({:ok, QueryResult.t()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> {:ok, ps} = Session.prepare(session, "INSERT INTO test.session_doc (a, b, c) VALUES (?, ?, ?)")
iex> values = [{:text, "test"}, {:int, 2}, {:double, 1.0}]
iex> {:ok, %QueryResult{}} = Session.execute(session, ps, values)

@spec execute_paged(
  ExScylla.Types.session(),
  ExScylla.Types.prepared_statement(),
  ExScylla.Types.values(),
  ExScylla.Types.paging_state() | nil,
  pos_integer()
) ::
  ({:ok, ExScylla.Types.QueryResult.t()}
   | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.execute_single_page

Sync version of execute_paged

Returns result ({:ok, QueryResult.t()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> query = "INSERT INTO test.session_doc (a, b, c) VALUES (?, ?, ?)"
iex> values = [{:text, "test_execute_paged"}, {:int, 1}, {:double, 1.0}]
iex> {:ok, %QueryResult{}} = Session.query(session, query, values)
iex> {:ok, ps} = Session.prepare(session, "SELECT * FROM test.session_doc WHERE a = ?;")
iex> ps = Prepared.set_page_size(ps, 1)
iex> values = [{:text, "test_execute_paged"}]
iex> {:ok, %QueryResult{paging_state: pgs}} = Session.execute_paged(session, ps, values, nil)
iex> true = is_binary(pgs)
iex> {:ok, %QueryResult{}} = Session.execute_paged(session, ps, values, pgs)

@spec execute_raw(
  ExScylla.Types.session(),
  ExScylla.Types.prepared_statement(),
  ExScylla.Types.values(),
  pos_integer()
) ::
  ({:ok, QueryResultRaw.t()} | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.execute_unpaged

Sync version of execute_raw

Returns result ({:ok, QueryResultRaw.t()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

@spec execute_raw_paged(
  ExScylla.Types.session(),
  ExScylla.Types.prepared_statement(),
  ExScylla.Types.values(),
  ExScylla.Types.paging_state() | nil,
  pos_integer()
) ::
  ({:ok, QueryResultRaw.t()} | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.execute_single_page

Sync version of execute_raw_paged

Returns result ({:ok, QueryResultRaw.t()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

@spec execute_stream(
  ExScylla.Types.session(),
  ExScylla.Types.prepared_statement(),
  ExScylla.Types.values()
) :: Enumerable.t()

Returns a stream of rows (ExScylla.Types.Row.t()) for the given prepared statement and values. If an error occurs during stream evaluation, the stream will yield {:error, reason} as its final element and then halt.

@spec fetch_schema_version(
  ExScylla.Types.session(),
  pos_integer()
) ::
  ({:ok, ExScylla.Types.uuid()}
   | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.await_schema_agreement

Sync version of fetch_schema_version

Returns result ({:ok, T.uuid()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> {:ok, version} = Session.fetch_schema_version(session)
iex> true = is_binary(version)

@spec get_cluster_state(ExScylla.Types.session()) :: ExScylla.Types.ClusterState.t()

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.get_cluster_state

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> alias ExScylla.Types.ClusterState
iex> %ClusterState{nodes: nodes} = Session.get_cluster_state(session)
iex> true = is_list(nodes)

@spec get_default_execution_profile_handle(ExScylla.Types.session()) ::
  ExScylla.Types.execution_profile_handle()

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.get_default_execution_profile_handle

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> eph = Session.get_default_execution_profile_handle(session)
iex> true = is_reference(eph)

@spec get_keyspace(ExScylla.Types.session()) :: String.t() | nil

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.get_keyspace

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> nil = Session.get_keyspace(session)
iex> {:ok, _} = Session.query(session, "CREATE KEYSPACE IF NOT EXISTS test_ks WITH REPLICATION = {'class': 'NetworkTopologyStrategy', 'replication_factor': 1};", [])
iex> :ok = Session.use_keyspace(session, "test_ks", false)
iex> "test_ks" = Session.get_keyspace(session)

@spec get_metrics(ExScylla.Types.session()) :: ExScylla.Types.Metrics.t()

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.get_metrics

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> alias ExScylla.Types.Metrics
iex> %Metrics{} = Session.get_metrics(session)

@spec get_tracing_info(ExScylla.Types.session(), binary(), pos_integer()) ::
  ({:ok, ExScylla.Types.TracingInfo.t()}
   | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.get_tracing_info

Sync version of get_tracing_info

Returns result ({:ok, TracingInfo.t()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> alias ExScylla.Types.TracingInfo
iex> # Tracing must be enabled on statement/query
iex> q = ExScylla.Statement.Query.new("SELECT * FROM test.session_doc") |> ExScylla.Statement.Query.set_tracing(true)
iex> {:ok, %QueryResult{tracing_id: tid}} = Session.query(session, q, [])
iex> {:ok, %TracingInfo{}} = Session.get_tracing_info(session, tid)

@spec prepare(
  ExScylla.Types.session(),
  String.t() | ExScylla.Types.query(),
  pos_integer()
) ::
  ({:ok, ExScylla.Types.prepared_statement()}
   | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.prepare

Sync version of prepare

Returns result ({:ok, T.prepared_statement()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> {:ok, ps} = Session.prepare(session, "SELECT * FROM test.session_doc WHERE a = ?;")
iex> true = is_reference(ps)

@spec prepare_batch(ExScylla.Types.session(), ExScylla.Types.batch(), pos_integer()) ::
  ({:ok, ExScylla.Types.batch()}
   | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.prepare_batch

Sync version of prepare_batch

Returns result ({:ok, T.batch()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> alias ExScylla.Statement.Batch
iex> batch = Batch.new(:unlogged)
...>   |> Batch.append_statement("INSERT INTO test.session_doc (a, b, c) VALUES (?, ?, ?)")
iex> {:ok, prepared_batch} = Session.prepare_batch(session, batch)
iex> true = is_reference(prepared_batch)

@spec query(
  ExScylla.Types.session(),
  String.t() | ExScylla.Types.query(),
  ExScylla.Types.values(),
  pos_integer()
) ::
  ({:ok, ExScylla.Types.QueryResult.t()}
   | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.query_unpaged

Sync version of query

Returns result ({:ok, QueryResult.t()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> query = "INSERT INTO test.session_doc (a, b, c) VALUES (?, ?, ?)"
iex> values = [{:text, "test"}, {:int, 3}, {:double, 1.0}]
iex> {:ok, %QueryResult{}} = Session.query(session, query, values)
iex> # Test Decimal and Varint
iex> t = "CREATE TABLE IF NOT EXISTS test.types_test (id INT PRIMARY KEY, d DECIMAL, v VARINT);"
iex> {:ok, _} = Session.query(session, t, [])
iex> query = "INSERT INTO test.types_test (id, d, v) VALUES (?, ?, ?)"
iex> values = [{:int, 1}, {:decimal, "1.23"}, {:varint, "12345678901234567890"}]
iex> {:ok, _} = Session.query(session, query, values)
iex> {:ok, %QueryResult{rows: [%ExScylla.Types.Row{columns: [id, d, v]}]}} = Session.query(session, "SELECT * FROM test.types_test WHERE id = 1", [])
iex> {:int, 1} = id
iex> {:decimal, "1.23"} = d
iex> {:varint, "12345678901234567890"} = v

@spec query_paged(
  ExScylla.Types.session(),
  String.t() | ExScylla.Types.query(),
  ExScylla.Types.values(),
  ExScylla.Types.paging_state() | nil,
  pos_integer()
) ::
  ({:ok, ExScylla.Types.QueryResult.t()}
   | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.query_single_page

Sync version of query_paged

Returns result ({:ok, QueryResult.t()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> query = "INSERT INTO test.session_doc (a, b, c) VALUES (?, ?, ?)"
iex> values = [{:text, "test_query_paged"}, {:int, 1}, {:double, 1.0}]
iex> {:ok, %QueryResult{}} = Session.query(session, query, values)
iex> q = Query.new("SELECT * FROM test.session_doc WHERE a = ?;")
...>              |> Query.with_page_size(1)
iex> values = [{:text, "test_query_paged"}]
iex> {:ok, %QueryResult{paging_state: pgs}} = Session.query_paged(session, q, values, nil)
iex> true = is_binary(pgs)
iex> {:ok, %QueryResult{}} = Session.query_paged(session, q, values, pgs)

@spec query_raw(
  ExScylla.Types.session(),
  String.t() | ExScylla.Types.query(),
  ExScylla.Types.values(),
  pos_integer()
) ::
  ({:ok, QueryResultRaw.t()} | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.query_unpaged

Sync version of query_raw

Returns result ({:ok, QueryResultRaw.t()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

@spec query_raw_paged(
  ExScylla.Types.session(),
  String.t() | ExScylla.Types.query(),
  ExScylla.Types.values(),
  ExScylla.Types.paging_state() | nil,
  pos_integer()
) ::
  ({:ok, QueryResultRaw.t()} | {:error, ExScylla.Types.Errors.QueryError.t()})
  | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.query_single_page

Sync version of query_raw_paged

Returns result ({:ok, QueryResultRaw.t()} | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

@spec query_stream(
  ExScylla.Types.session(),
  String.t() | ExScylla.Types.query(),
  ExScylla.Types.values()
) :: Enumerable.t()

Returns a stream of rows (ExScylla.Types.Row.t()) for the given query and values. If an error occurs during stream evaluation, the stream will yield {:error, reason} as its final element and then halt.

@spec refresh_metadata(
  ExScylla.Types.session(),
  pos_integer()
) :: (:ok | {:error, ExScylla.Types.Errors.QueryError.t()}) | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.refresh_metadata

Sync version of refresh_metadata

Returns result (:ok | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> :ok = Session.refresh_metadata(session)

@spec use_keyspace(ExScylla.Types.session(), String.t(), boolean(), pos_integer()) ::
  (:ok | {:error, ExScylla.Types.Errors.QueryError.t()}) | {:error, :timeout}

See: https://docs.rs/scylla/1.8.0/scylla/client/session/struct.Session.html#method.use_keyspace

Sync version of use_keyspace

Returns result (:ok | {:error, QueryError.t()})

or {:error, :timeout} after timeout_ms.

Example

iex> node = Application.get_env(:ex_scylla, :test_node, "127.0.0.1:9042")
iex> {:ok, session} = SessionBuilder.new()
...>                  |> SessionBuilder.known_node(node)
...>                  |> SessionBuilder.build()
iex> case_sensitive = false
iex> :ok = Session.use_keyspace(session, "another_test_keyspace", case_sensitive)