Remove RawEventsQuery

scyllaconn/src/bincache.rs

@@ -7,7 +7,7 @@ use items_2::binsdim0::BinsDim0;
 use items_2::channelevents::ChannelEvents;
 use items_2::{empty_binned_dyn, empty_events_dyn};
 use netpod::log::*;
-use netpod::query::{CacheUsage, PlainEventsQuery, RawEventsQuery};
+use netpod::query::{CacheUsage, PlainEventsQuery};
 use netpod::timeunits::*;
 use netpod::{AggKind, ChannelTyped, ScalarType, Shape};
 use netpod::{PreBinnedPatchCoord, PreBinnedPatchIterator, PreBinnedPatchRange};
@@ -356,13 +356,20 @@ pub async fn fetch_uncached_binned_events(
     // We must produce some result with correct types even if upstream delivers nothing at all.
     let bin0 = empty_events_dyn(&chn.scalar_type, &chn.shape, &agg_kind);
     let mut time_binner = bin0.time_binner_new(edges.clone(), do_time_weight);
+    // TODO handle deadline better
     let deadline = Instant::now();
     let deadline = deadline
         .checked_add(Duration::from_millis(6000))
         .ok_or_else(|| Error::with_msg_no_trace(format!("deadline overflow")))?;
     let do_one_before_range = agg_kind.need_expand();
-    let _evq = RawEventsQuery::new(chn.channel.clone(), coord.patch_range(), agg_kind);
-    let evq = PlainEventsQuery::new(chn.channel.clone(), coord.patch_range(), 4096, None, true);
+    let evq = PlainEventsQuery::new(
+        chn.channel.clone(),
+        coord.patch_range(),
+        AggKind::TimeWeightedScalar,
+        Duration::from_millis(8000),
+        None,
+        true,
+    );
     let mut events_dyn = EventsStreamScylla::new(
         series,
         evq.range().clone(),

scyllaconn/src/events.rs

@@ -7,13 +7,12 @@ use items_2::eventsdim0::EventsDim0;
 use netpod::log::*;
 use netpod::query::{ChannelStateEventsQuery, PlainEventsQuery};
 use netpod::timeunits::*;
-use netpod::{Channel, NanoRange, ScalarType, Shape};
+use netpod::{NanoRange, ScalarType, Shape};
 use scylla::Session as ScySession;
 use std::collections::VecDeque;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{Context, Poll};
-use tokio_postgres::Client as PgClient;
 
 async fn find_ts_msp(series: i64, range: NanoRange, scy: Arc<ScySession>) -> Result<VecDeque<u64>, Error> {
     info!("find_ts_msp  series {}  {:?}", series, range);
@@ -559,43 +558,6 @@ impl Stream for EventsStreamScylla {
     }
 }
 
-pub async fn find_series(channel: &Channel, pgclient: Arc<PgClient>) -> Result<(u64, ScalarType, Shape), Error> {
-    info!("find_series  channel {:?}", channel);
-    let rows = if let Some(series) = channel.series() {
-        let q = "select series, facility, channel, scalar_type, shape_dims from series_by_channel where series = $1";
-        pgclient.query(q, &[&(series as i64)]).await.err_conv()?
-    } else {
-        let q = "select series, facility, channel, scalar_type, shape_dims from series_by_channel where facility = $1 and channel = $2";
-        pgclient
-            .query(q, &[&channel.backend(), &channel.name()])
-            .await
-            .err_conv()?
-    };
-    if rows.len() < 1 {
-        return Err(Error::with_public_msg_no_trace(format!(
-            "No series found for {channel:?}"
-        )));
-    }
-    if rows.len() > 1 {
-        error!("Multiple series found for {channel:?}");
-        return Err(Error::with_public_msg_no_trace(
-            "Multiple series found for channel, can not return data for ambiguous series",
-        ));
-    }
-    let row = rows
-        .into_iter()
-        .next()
-        .ok_or_else(|| Error::with_public_msg_no_trace(format!("can not find series for channel")))?;
-    let series = row.get::<_, i64>(0) as u64;
-    let _facility: String = row.get(1);
-    let _channel: String = row.get(2);
-    let a: i32 = row.get(3);
-    let scalar_type = ScalarType::from_scylla_i32(a)?;
-    let a: Vec<i32> = row.get(4);
-    let shape = Shape::from_scylla_shape_dims(&a)?;
-    Ok((series, scalar_type, shape))
-}
-
 pub async fn make_scylla_stream(
     evq: &PlainEventsQuery,
     do_one_before_range: bool,

scyllaconn/src/scyllaconn.rs

@@ -5,6 +5,7 @@ pub mod events;
 use err::Error;
 use errconv::ErrConv;
 use netpod::ScyllaConfig;
+use scylla::statement::Consistency;
 use scylla::Session as ScySession;
 use std::sync::Arc;
 
@@ -12,6 +13,7 @@ pub async fn create_scy_session(scyconf: &ScyllaConfig) -> Result<Arc<ScySession
     let scy = scylla::SessionBuilder::new()
         .known_nodes(&scyconf.hosts)
         .use_keyspace(&scyconf.keyspace, true)
+        .default_consistency(Consistency::LocalOne)
         .build()
         .await
         .err_conv()?;