ExScylla.Session (ex_scylla v0.5.1)

Wrapper around rust module See rust documentation for more usage details: https://docs.rs/scylla/0.9.0/scylla/transport/session/struct.Session.html

Summary

Functions

Types

@type opaque() :: any()

Functions

Link to this function

async_await_schema_agreement(session, opaque \\ {:await_schema_agreement, make_ref()})

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

See: https://docs.rs/scylla/0.9.0/scylla/transport/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
Link to this function

async_await_timed_schema_agreement(session, timeout_ms, opaque \\ {:await_timed_schema_agreement, make_ref()})

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

See: https://docs.rs/scylla/0.9.0/scylla/transport/session/struct.Session.html#method.await_timed_schema_agreement

Async version of await_timed_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_timed_schema_agreement(session, 15_000)
{:ok, true}
Link to this function

async_batch(session, batch, values, opaque \\ {:batch, make_ref()})

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

See: https://docs.rs/scylla/0.9.0/scylla/transport/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.s_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} -> r
...>  after
...>    5_000 -> :timeout
...>  end
Link to this function

async_check_schema_agreement(session, opaque \\ {:check_schema_agreement, make_ref()})

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

See: https://docs.rs/scylla/0.9.0/scylla/transport/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} -> r
...>  after
...>    5_000 -> :timeout
...>  end
Link to this function

async_execute(session, prepared, values, opaque \\ {:execute, make_ref()})

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

See: https://docs.rs/scylla/0.9.0/scylla/transport/session/struct.Session.html#method.execute

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.s_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} -> r
...>  after
...>    5_000 -> :timeout
...>  end
Link to this function

async_execute_paged(session, prepared, values, paging_state, opaque \\ {:execute_paged, make_ref()})

@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/0.9.0/scylla/transport/session/struct.Session.html#method.execute_paged

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.s_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.s_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} -> r
...>  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} -> r
...>  after
...>    5_000 -> :timeout
...>  end
Link to this function

async_fetch_schema_version(session, opaque \\ {:fetch_schema_version, make_ref()})

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

See: https://docs.rs/scylla/0.9.0/scylla/transport/session/struct.Session.html#method.fetch_schema_version

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} -> r
...>  after
...>    5_000 -> :timeout
...>  end
iex> true = is_binary(version)
Link to this function

async_prepare(session, query, opaque \\ {:prepare, make_ref()})

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

See: https://docs.rs/scylla/0.9.0/scylla/transport/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.s_doc WHERE a = ?;")
iex> {:ok, ps} = receive do
...>   {^opaque, r} -> r
...>  after
...>    5_000 -> :timeout
...>  end
iex> true = is_reference(ps)
Link to this function

async_query(session, query, values, opaque \\ {:query, make_ref()})

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

See: https://docs.rs/scylla/0.9.0/scylla/transport/session/struct.Session.html#method.query

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.s_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} -> r
...>  after
...>    5_000 -> :timeout
...>  end
Link to this function

async_query_paged(session, query, values, paging_state, opaque \\ {:query_paged, make_ref()})

@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/0.9.0/scylla/transport/session/struct.Session.html#method.query_paged

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.s_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.s_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} -> r
...>  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} -> r
...>  after
...>    5_000 -> :timeout
...>  end
Link to this function

async_refresh_metadata(session, opaque \\ {:refresh_metadata, make_ref()})

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

See: https://docs.rs/scylla/0.9.0/scylla/transport/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} -> r
...>  after
...>    5_000 -> :timeout
...>  end
Link to this function

async_use_keyspace(session, keyspace_name, case_sensitive, opaque \\ {:use_keyspace, make_ref()})

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

See: https://docs.rs/scylla/0.9.0/scylla/transport/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} -> r
...>  after
...>    5_000 -> :timeout
...>  end
Link to this function

await_schema_agreement(session, timeout_ms \\ 5000)

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

See: https://docs.rs/scylla/0.9.0/scylla/transport/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
Link to this function

await_timed_schema_agreement(session, timeout_ms, timeout_ms \\ 5000)

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

See: https://docs.rs/scylla/0.9.0/scylla/transport/session/struct.Session.html#method.await_timed_schema_agreement

Sync version of await_timed_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_timed_schema_agreement(session, 15_000)
{:ok, true}
Link to this function

batch(session, batch, values, timeout_ms \\ 5000)

See: https://docs.rs/scylla/0.9.0/scylla/transport/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.s_doc (a, b, c) VALUES (?, ?, ?)")
iex> values = [
...>   [{:text, "test"}, {:int, 2}, {:double, 1.0}]
...> ]
iex> {:ok, %QueryResult{}} = Session.batch(session, batch, values)
Link to this function

calculate_token(session, prepared, values)

See: https://docs.rs/scylla/0.9.0/scylla/transport/session/struct.Session.html#method.calculate_token

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.s_doc WHERE a = ?;")
iex> values = [{:text, "test"}]
iex> %Token{value: t} = Session.calculate_token(session, ps, values)
iex> true = is_integer(t)
Link to this function

check_schema_agreement(session, timeout_ms \\ 5000)

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

See: https://docs.rs/scylla/0.9.0/scylla/transport/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)
Link to this function

execute(session, prepared, values, timeout_ms \\ 5000)

See: https://docs.rs/scylla/0.9.0/scylla/transport/session/struct.Session.html#method.execute

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.s_doc (a, b, c) VALUES (?, ?, ?)")
iex> values = [{:text, "test"}, {:int, 2}, {:double, 1.0}]
iex> {:ok, %QueryResult{}} = Session.execute(session, ps, values)
Link to this function

execute_paged(session, prepared, values, paging_state, timeout_ms \\ 5000)

See: https://docs.rs/scylla/0.9.0/scylla/transport/session/struct.Session.html#method.execute_paged

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.s_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.s_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)
Link to this function

fetch_schema_version(session, timeout_ms \\ 5000)

@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/0.9.0/scylla/transport/session/struct.Session.html#method.fetch_schema_version

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)
Link to this function

prepare(session, query, timeout_ms \\ 5000)

See: https://docs.rs/scylla/0.9.0/scylla/transport/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.s_doc WHERE a = ?;")
iex> true = is_reference(ps)
Link to this function

query(session, query, values, timeout_ms \\ 5000)

See: https://docs.rs/scylla/0.9.0/scylla/transport/session/struct.Session.html#method.query

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.s_doc (a, b, c) VALUES (?, ?, ?)"
iex> values = [{:text, "test"}, {:int, 3}, {:double, 1.0}]
iex> {:ok, %QueryResult{}} = Session.query(session, query, values)
Link to this function

query_paged(session, query, values, paging_state, timeout_ms \\ 5000)

See: https://docs.rs/scylla/0.9.0/scylla/transport/session/struct.Session.html#method.query_paged

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.s_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.s_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)
Link to this function

refresh_metadata(session, timeout_ms \\ 5000)

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

See: https://docs.rs/scylla/0.9.0/scylla/transport/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)
Link to this function

use_keyspace(session, keyspace_name, case_sensitive, timeout_ms \\ 5000)

@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/0.9.0/scylla/transport/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)