231 lines
8.2 KiB
Rust
231 lines
8.2 KiB
Rust
use crate::config::ScyllaIngestConfig;
|
|
use crate::session::create_session;
|
|
use err::thiserror;
|
|
use err::ThisError;
|
|
use netpod::ttl::RetentionTime;
|
|
use scylla::prepared_statement::PreparedStatement;
|
|
use scylla::transport::errors::NewSessionError;
|
|
use scylla::transport::errors::QueryError;
|
|
use scylla::Session as ScySession;
|
|
use std::sync::Arc;
|
|
|
|
#[derive(Debug, ThisError)]
|
|
#[cstm(name = "ScyllaStore")]
|
|
pub enum Error {
|
|
NewSessionError(#[from] NewSessionError),
|
|
QueryError(#[from] QueryError),
|
|
NewSession,
|
|
}
|
|
|
|
pub struct DataStore {
|
|
pub rett: RetentionTime,
|
|
pub scy: Arc<ScySession>,
|
|
pub qu_insert_ts_msp: Arc<PreparedStatement>,
|
|
pub qu_insert_scalar_u8: Arc<PreparedStatement>,
|
|
pub qu_insert_scalar_u16: Arc<PreparedStatement>,
|
|
pub qu_insert_scalar_u32: Arc<PreparedStatement>,
|
|
pub qu_insert_scalar_u64: Arc<PreparedStatement>,
|
|
pub qu_insert_scalar_i8: Arc<PreparedStatement>,
|
|
pub qu_insert_scalar_i16: Arc<PreparedStatement>,
|
|
pub qu_insert_scalar_i32: Arc<PreparedStatement>,
|
|
pub qu_insert_scalar_i64: Arc<PreparedStatement>,
|
|
pub qu_insert_scalar_f32: Arc<PreparedStatement>,
|
|
pub qu_insert_scalar_f64: Arc<PreparedStatement>,
|
|
pub qu_insert_scalar_bool: Arc<PreparedStatement>,
|
|
pub qu_insert_scalar_string: Arc<PreparedStatement>,
|
|
pub qu_insert_scalar_enum: Arc<PreparedStatement>,
|
|
pub qu_insert_array_u8: Arc<PreparedStatement>,
|
|
pub qu_insert_array_u16: Arc<PreparedStatement>,
|
|
pub qu_insert_array_u32: Arc<PreparedStatement>,
|
|
pub qu_insert_array_u64: Arc<PreparedStatement>,
|
|
pub qu_insert_array_i8: Arc<PreparedStatement>,
|
|
pub qu_insert_array_i16: Arc<PreparedStatement>,
|
|
pub qu_insert_array_i32: Arc<PreparedStatement>,
|
|
pub qu_insert_array_i64: Arc<PreparedStatement>,
|
|
pub qu_insert_array_f32: Arc<PreparedStatement>,
|
|
pub qu_insert_array_f64: Arc<PreparedStatement>,
|
|
pub qu_insert_array_bool: Arc<PreparedStatement>,
|
|
pub qu_insert_binned_scalar_f32_v01: Arc<PreparedStatement>,
|
|
pub qu_insert_binned_scalar_f32_v02: Arc<PreparedStatement>,
|
|
pub qu_account_00: Arc<PreparedStatement>,
|
|
pub qu_account_recv_00: Arc<PreparedStatement>,
|
|
pub qu_dummy: Arc<PreparedStatement>,
|
|
}
|
|
|
|
macro_rules! prep_qu_ins_a {
|
|
($id1:expr, $rett:expr, $scy:expr) => {{
|
|
let cql = format!(
|
|
concat!(
|
|
"insert into {}{} (series, ts_msp, ts_lsp, value)",
|
|
" values (?, ?, ?, ?)"
|
|
),
|
|
$rett.table_prefix(),
|
|
$id1
|
|
);
|
|
let q = $scy.prepare(cql).await?;
|
|
Arc::new(q)
|
|
}};
|
|
}
|
|
|
|
macro_rules! prep_qu_ins_b {
|
|
($id1:expr, $rett:expr, $scy:expr) => {{
|
|
let cql = format!(
|
|
concat!(
|
|
"insert into {}{} (series, ts_msp, ts_lsp, valueblob)",
|
|
" values (?, ?, ?, ?)"
|
|
),
|
|
$rett.table_prefix(),
|
|
$id1
|
|
);
|
|
let q = $scy.prepare(cql).await?;
|
|
Arc::new(q)
|
|
}};
|
|
}
|
|
|
|
macro_rules! prep_qu_ins_enum {
|
|
($id1:expr, $rett:expr, $scy:expr) => {{
|
|
let cql = format!(
|
|
concat!(
|
|
"insert into {}{} (series, ts_msp, ts_lsp, value, valuestr)",
|
|
" values (?, ?, ?, ?, ?)"
|
|
),
|
|
$rett.table_prefix(),
|
|
$id1
|
|
);
|
|
let q = $scy.prepare(cql).await?;
|
|
Arc::new(q)
|
|
}};
|
|
}
|
|
|
|
macro_rules! prep_qu_ins_c {
|
|
($id1:expr, $fields:expr, $values:expr, $rett:expr, $scy:expr) => {{
|
|
let cql = format!(
|
|
concat!("insert into {}{} ({})", " values ({})"),
|
|
$rett.table_prefix(),
|
|
$id1,
|
|
$fields,
|
|
$values,
|
|
);
|
|
let q = $scy.prepare(cql).await?;
|
|
Arc::new(q)
|
|
}};
|
|
}
|
|
|
|
impl DataStore {
|
|
pub async fn new(scyconf: &ScyllaIngestConfig, rett: RetentionTime) -> Result<Self, Error> {
|
|
let scy = create_session(scyconf).await.map_err(|_| Error::NewSession)?;
|
|
|
|
let q = scy
|
|
.prepare(format!(
|
|
concat!("insert into {}{} (series, ts_msp) values (?, ?)"),
|
|
rett.table_prefix(),
|
|
"ts_msp"
|
|
))
|
|
.await?;
|
|
let qu_insert_ts_msp = Arc::new(q);
|
|
|
|
let qu_insert_scalar_u8 = prep_qu_ins_a!("events_scalar_u8", rett, scy);
|
|
let qu_insert_scalar_u16 = prep_qu_ins_a!("events_scalar_u16", rett, scy);
|
|
let qu_insert_scalar_u32 = prep_qu_ins_a!("events_scalar_u32", rett, scy);
|
|
let qu_insert_scalar_u64 = prep_qu_ins_a!("events_scalar_u64", rett, scy);
|
|
let qu_insert_scalar_i8 = prep_qu_ins_a!("events_scalar_i8", rett, scy);
|
|
let qu_insert_scalar_i16 = prep_qu_ins_a!("events_scalar_i16", rett, scy);
|
|
let qu_insert_scalar_i32 = prep_qu_ins_a!("events_scalar_i32", rett, scy);
|
|
let qu_insert_scalar_i64 = prep_qu_ins_a!("events_scalar_i64", rett, scy);
|
|
let qu_insert_scalar_f32 = prep_qu_ins_a!("events_scalar_f32", rett, scy);
|
|
let qu_insert_scalar_f64 = prep_qu_ins_a!("events_scalar_f64", rett, scy);
|
|
let qu_insert_scalar_bool = prep_qu_ins_a!("events_scalar_bool", rett, scy);
|
|
let qu_insert_scalar_string = prep_qu_ins_a!("events_scalar_string", rett, scy);
|
|
let qu_insert_scalar_enum = prep_qu_ins_enum!("events_scalar_enum", rett, scy);
|
|
|
|
let qu_insert_array_u8 = prep_qu_ins_b!("events_array_u8", rett, scy);
|
|
let qu_insert_array_u16 = prep_qu_ins_b!("events_array_u16", rett, scy);
|
|
let qu_insert_array_u32 = prep_qu_ins_b!("events_array_u32", rett, scy);
|
|
let qu_insert_array_u64 = prep_qu_ins_b!("events_array_u64", rett, scy);
|
|
let qu_insert_array_i8 = prep_qu_ins_b!("events_array_i8", rett, scy);
|
|
let qu_insert_array_i16 = prep_qu_ins_b!("events_array_i16", rett, scy);
|
|
let qu_insert_array_i32 = prep_qu_ins_b!("events_array_i32", rett, scy);
|
|
let qu_insert_array_i64 = prep_qu_ins_b!("events_array_i64", rett, scy);
|
|
let qu_insert_array_f32 = prep_qu_ins_b!("events_array_f32", rett, scy);
|
|
let qu_insert_array_f64 = prep_qu_ins_b!("events_array_f64", rett, scy);
|
|
let qu_insert_array_bool = prep_qu_ins_b!("events_array_bool", rett, scy);
|
|
|
|
let qu_insert_binned_scalar_f32_v01 = prep_qu_ins_c!(
|
|
"binned_scalar_f32_v01",
|
|
"series, bin_len_ms, ts_msp, off, count, min, max, avg",
|
|
"?, ?, ?, ?, ?, ?, ?, ?",
|
|
rett,
|
|
scy
|
|
);
|
|
|
|
let qu_insert_binned_scalar_f32_v02 = prep_qu_ins_c!(
|
|
"binned_scalar_f32",
|
|
"series, bin_len_ms, ts_msp, off, count, min, max, avg",
|
|
"?, ?, ?, ?, ?, ?, ?, ?",
|
|
rett,
|
|
scy
|
|
);
|
|
|
|
let qu_account_00 = prep_qu_ins_c!(
|
|
"account_00",
|
|
"part, ts, series, count, bytes",
|
|
"?, ?, ?, ?, ?",
|
|
rett,
|
|
scy
|
|
);
|
|
|
|
let qu_account_recv_00 = prep_qu_ins_c!(
|
|
"account_recv_00",
|
|
"part, ts, series, count, bytes",
|
|
"?, ?, ?, ?, ?",
|
|
rett,
|
|
scy
|
|
);
|
|
|
|
let q = scy
|
|
.prepare(format!(
|
|
concat!("select * from {}{} limit 1"),
|
|
rett.table_prefix(),
|
|
"ts_msp"
|
|
))
|
|
.await?;
|
|
let qu_dummy = Arc::new(q);
|
|
|
|
let ret = Self {
|
|
rett,
|
|
scy,
|
|
qu_insert_ts_msp,
|
|
qu_insert_scalar_u8,
|
|
qu_insert_scalar_u16,
|
|
qu_insert_scalar_u32,
|
|
qu_insert_scalar_u64,
|
|
qu_insert_scalar_i8,
|
|
qu_insert_scalar_i16,
|
|
qu_insert_scalar_i32,
|
|
qu_insert_scalar_i64,
|
|
qu_insert_scalar_f32,
|
|
qu_insert_scalar_f64,
|
|
qu_insert_scalar_bool,
|
|
qu_insert_scalar_string,
|
|
qu_insert_scalar_enum,
|
|
qu_insert_array_u8,
|
|
qu_insert_array_u16,
|
|
qu_insert_array_u32,
|
|
qu_insert_array_u64,
|
|
qu_insert_array_i8,
|
|
qu_insert_array_i16,
|
|
qu_insert_array_i32,
|
|
qu_insert_array_i64,
|
|
qu_insert_array_f32,
|
|
qu_insert_array_f64,
|
|
qu_insert_array_bool,
|
|
qu_insert_binned_scalar_f32_v01,
|
|
qu_insert_binned_scalar_f32_v02,
|
|
qu_account_00,
|
|
qu_account_recv_00,
|
|
qu_dummy,
|
|
};
|
|
Ok(ret)
|
|
}
|
|
}
|