defmodule Xandra.Prepared do
@moduledoc """
A data structure used to internally represent prepared queries.
See [`%Xandra.Prepared{}`](`__struct__/0`) for information about which fields are
public. All other fields are documented in `t:t/0` to avoid Dialyzer warnings,
but are not meant to be used by users.
"""
@doc """
A struct that represents a prepared query.
These are the publicly-accessible fields of this struct:
* `:tracing_id` - the tracing ID (as a UUID binary) if tracing was enabled,
or `nil` if no tracing was enabled. See the "Tracing" section in `Xandra.execute/4`.
* `:response_custom_payload` - the *custom payload* sent by the server, if present.
If the server doesn't send a custom payload, this field is `nil`. Otherwise,
it's of type `t:Xandra.custom_payload/0`. See the "Custom payloads" section
in the documentation for the `Xandra` module.
"""
alias Xandra.Frame
defstruct [
:statement,
:values,
:id,
:bound_columns,
:result_columns,
:default_consistency,
:protocol_module,
:compressor,
:tracing_id,
:request_custom_payload,
:response_custom_payload,
:keyspace,
:result_metadata_id
]
@typedoc """
The type for a prepared query.
The only public fields here are `:tracing_id` and `:response_custom_payload`.
See [`%Xandra.Prepared{}`](`__struct__/0`).
"""
@type t :: %__MODULE__{
statement: Xandra.statement(),
values: Xandra.values() | nil,
id: binary | nil,
bound_columns: [Xandra.Page.column()] | nil,
result_columns: list | nil,
default_consistency: atom | nil,
protocol_module: module | nil,
compressor: module | nil,
tracing_id: binary | nil,
request_custom_payload: Xandra.custom_payload() | nil,
response_custom_payload: Xandra.custom_payload() | nil,
keyspace: binary | nil,
result_metadata_id: binary | nil
}
@doc false
def rewrite_named_params_to_positional(%__MODULE__{} = prepared, params) when is_map(params) do
Enum.map(prepared.bound_columns, fn {_keyspace, _table, name, _type} ->
case Map.fetch(params, name) do
{:ok, value} ->
value
:error ->
raise ArgumentError,
"missing named parameter #{inspect(name)} for prepared query, " <>
"got: #{inspect(params)}"
end
end)
end
@doc false
@spec encode(t(), Xandra.values(), keyword()) :: iodata()
def encode(prepared, values, options)
def encode(prepared, values, options) when is_map(values) do
encode(prepared, rewrite_named_params_to_positional(prepared, values), options)
end
def encode(%__MODULE__{} = prepared, values, options) when is_list(values) do
Frame.new(:execute,
tracing: options[:tracing],
compressor: prepared.compressor,
custom_payload: prepared.request_custom_payload,
stream_id: Keyword.get(options, :stream_id, 0)
)
|> prepared.protocol_module.encode_request(%{prepared | values: values}, options)
|> Frame.encode(prepared.protocol_module)
end
defimpl Inspect do
import Inspect.Algebra
def inspect(prepared, options) do
properties = [
statement: prepared.statement,
tracing_id: prepared.tracing_id
]
concat(["#Xandra.Prepared<", to_doc(properties, options), ">"])
end
end
end