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
Types
opaque()
@type opaque() :: any()
Functions
async_await_schema_agreement(session, opaque \\ {:await_schema_agreement, make_ref()})
@spec async_await_schema_agreement( ExScylla.Types.session(), opaque() ) :: {:ok, opaque()} | {:error, any()}
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
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()}
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}
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
async_check_schema_agreement(session, opaque \\ {:check_schema_agreement, make_ref()})
@spec async_check_schema_agreement( ExScylla.Types.session(), opaque() ) :: {:ok, opaque()} | {:error, any()}
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
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
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
async_fetch_schema_version(session, opaque \\ {:fetch_schema_version, make_ref()})
@spec async_fetch_schema_version( ExScylla.Types.session(), opaque() ) :: {:ok, opaque()} | {:error, any()}
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)
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)
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
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
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
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
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}
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
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}
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}
batch(session, batch, values, timeout_ms \\ 5000)
@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/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)
calculate_token(session, prepared, values)
@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/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)
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}
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)
execute(session, prepared, values, timeout_ms \\ 5000)
@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/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)
execute_paged(session, prepared, values, paging_state, timeout_ms \\ 5000)
@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/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)
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}
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)
prepare(session, query, timeout_ms \\ 5000)
@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/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)
query(session, query, values, timeout_ms \\ 5000)
@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/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)
query_paged(session, query, values, paging_state, timeout_ms \\ 5000)
@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/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)
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)
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)