Skip to content

Commit d3cbf9d

Browse files
sylwiaszunejkosylwiaszunejko
committed
Move bind markers and value list tests to statement.rs
Extra cases and some small fixes added.
1 parent d9af125 commit d3cbf9d

File tree

2 files changed

+154
-119
lines changed

2 files changed

+154
-119
lines changed

‎scylla/tests/integration/session.rs

Lines changed: 1 addition & 119 deletions
Original file line numberDiff line numberDiff line change
@@ -25,11 +25,9 @@ use scylla::routing::partitioner::{calculate_token_for_partition_key, Partitione
2525
use scylla::statement::Consistency;
2626
use scylla_cql::frame::request::query::{PagingState, PagingStateResponse};
2727
use scylla_cql::serialize::row::{SerializeRow, SerializedValues};
28-
use scylla_cql::serialize::value::SerializeValue;
2928
use scylla_cql::value::Row;
3029
use std::collections::BTreeSet;
31-
use std::collections::{BTreeMap, HashMap};
32-
use std::collections::HashSet;
30+
use std::collections::HashMap;
3331
use std::sync::atomic::{AtomicBool, Ordering};
3432
use std::sync::Arc;
3533
use tokio::net::TcpListener;
@@ -1514,62 +1512,6 @@ async fn test_turning_off_schema_fetching() {
15141512
assert_eq!(keyspace.user_defined_types.len(), 0);
15151513
}
15161514

1517-
#[tokio::test]
1518-
async fn test_named_bind_markers() {
1519-
let session = create_new_session_builder().build().await.unwrap();
1520-
let ks = unique_keyspace_name();
1521-
1522-
session
1523-
.ddl(format!("CREATE KEYSPACE {} WITH REPLICATION = {{'class' : 'NetworkTopologyStrategy', 'replication_factor' : 1}}", ks))
1524-
.await
1525-
.unwrap();
1526-
1527-
session
1528-
.query_unpaged(format!("USE {}", ks), &[])
1529-
.await
1530-
.unwrap();
1531-
1532-
session
1533-
.ddl("CREATE TABLE t (pk int, ck int, v int, PRIMARY KEY (pk, ck, v))")
1534-
.await
1535-
.unwrap();
1536-
1537-
session.await_schema_agreement().await.unwrap();
1538-
1539-
let prepared = session
1540-
.prepare("INSERT INTO t (pk, ck, v) VALUES (:pk, :ck, :v)")
1541-
.await
1542-
.unwrap();
1543-
let hashmap: HashMap<&str, i32> = HashMap::from([("pk", 7), ("v", 42), ("ck", 13)]);
1544-
session.execute_unpaged(&prepared, &hashmap).await.unwrap();
1545-
1546-
let btreemap: BTreeMap<&str, i32> = BTreeMap::from([("ck", 113), ("v", 142), ("pk", 17)]);
1547-
session.execute_unpaged(&prepared, &btreemap).await.unwrap();
1548-
1549-
let rows: Vec<(i32, i32, i32)> = session
1550-
.query_unpaged("SELECT pk, ck, v FROM t", &[])
1551-
.await
1552-
.unwrap()
1553-
.into_rows_result()
1554-
.unwrap()
1555-
.rows::<(i32, i32, i32)>()
1556-
.unwrap()
1557-
.map(|res| res.unwrap())
1558-
.collect();
1559-
1560-
assert_eq!(rows, vec![(7, 13, 42), (17, 113, 142)]);
1561-
1562-
let wrongmaps: Vec<HashMap<&str, i32>> = vec![
1563-
HashMap::from([("pk", 7), ("fefe", 42), ("ck", 13)]),
1564-
HashMap::from([("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", 7)]),
1565-
HashMap::new(),
1566-
HashMap::from([("ck", 9)]),
1567-
];
1568-
for wrongmap in wrongmaps {
1569-
assert!(session.execute_unpaged(&prepared, &wrongmap).await.is_err());
1570-
}
1571-
}
1572-
15731515
#[tokio::test]
15741516
async fn test_prepared_partitioner() {
15751517
let session = create_new_session_builder().build().await.unwrap();
@@ -1707,66 +1649,6 @@ async fn test_unprepared_reprepare_in_execute() {
17071649
assert_eq!(all_rows, vec![(1, 2, 3), (1, 3, 2)]);
17081650
}
17091651

1710-
#[tokio::test]
1711-
async fn test_unusual_valuelists() {
1712-
let _ = tracing_subscriber::fmt::try_init();
1713-
1714-
let session = create_new_session_builder().build().await.unwrap();
1715-
let ks = unique_keyspace_name();
1716-
1717-
session.ddl(format!("CREATE KEYSPACE IF NOT EXISTS {} WITH REPLICATION = {{'class' : 'NetworkTopologyStrategy', 'replication_factor' : 1}}", ks)).await.unwrap();
1718-
session.use_keyspace(ks, false).await.unwrap();
1719-
1720-
session
1721-
.ddl("CREATE TABLE IF NOT EXISTS tab (a int, b int, c varchar, primary key (a, b, c))")
1722-
.await
1723-
.unwrap();
1724-
1725-
let insert_a_b_c = session
1726-
.prepare("INSERT INTO tab (a, b, c) VALUES (?, ?, ?)")
1727-
.await
1728-
.unwrap();
1729-
1730-
let values_dyn: Vec<&dyn SerializeValue> = vec![
1731-
&1 as &dyn SerializeValue,
1732-
&2 as &dyn SerializeValue,
1733-
&"&dyn" as &dyn SerializeValue,
1734-
];
1735-
session
1736-
.execute_unpaged(&insert_a_b_c, values_dyn)
1737-
.await
1738-
.unwrap();
1739-
1740-
let values_box_dyn: Vec<Box<dyn SerializeValue>> = vec![
1741-
Box::new(1) as Box<dyn SerializeValue>,
1742-
Box::new(3) as Box<dyn SerializeValue>,
1743-
Box::new("Box dyn") as Box<dyn SerializeValue>,
1744-
];
1745-
session
1746-
.execute_unpaged(&insert_a_b_c, values_box_dyn)
1747-
.await
1748-
.unwrap();
1749-
1750-
let mut all_rows: Vec<(i32, i32, String)> = session
1751-
.query_unpaged("SELECT a, b, c FROM tab", ())
1752-
.await
1753-
.unwrap()
1754-
.into_rows_result()
1755-
.unwrap()
1756-
.rows::<(i32, i32, String)>()
1757-
.unwrap()
1758-
.map(|r| r.unwrap())
1759-
.collect();
1760-
all_rows.sort();
1761-
assert_eq!(
1762-
all_rows,
1763-
vec![
1764-
(1i32, 2i32, "&dyn".to_owned()),
1765-
(1, 3, "Box dyn".to_owned())
1766-
]
1767-
);
1768-
}
1769-
17701652
// A tests which checks that Session::batch automatically reprepares PreparedStatemtns if they become unprepared.
17711653
// Doing an ALTER TABLE statement clears prepared statement cache and all prepared statements need
17721654
// to be prepared again.

‎scylla/tests/integration/statement.rs

Lines changed: 153 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,18 @@
11
use crate::utils::{create_new_session_builder, setup_tracing, unique_keyspace_name, PerformDDL};
2+
use assert_matches::assert_matches;
3+
use scylla::errors::BadQuery;
4+
use scylla::errors::ExecutionError;
5+
use scylla::serialize::value::SerializeValue;
26
use scylla::{
37
batch::{Batch, BatchType},
48
query::Query,
59
response::PagingState,
10+
serialize,
611
statement::SerialConsistency,
712
};
813
use scylla_cql::Consistency;
14+
use std::collections::BTreeMap;
15+
use std::collections::HashMap;
916
use std::collections::HashSet;
1017
use std::sync::{Arc, Mutex};
1118

@@ -306,3 +313,149 @@ async fn test_timestamp_generator() {
306313
.map(|row_result| row_result.unwrap())
307314
.all(|(_a, _b, writetime)| timestamps_locked.contains(&writetime)));
308315
}
316+
317+
#[tokio::test]
318+
async fn test_named_bind_markers() {
319+
let session = create_new_session_builder().build().await.unwrap();
320+
let ks = unique_keyspace_name();
321+
322+
session
323+
.ddl(format!("CREATE KEYSPACE {} WITH REPLICATION = {{'class' : 'NetworkTopologyStrategy', 'replication_factor' : 1}}", ks))
324+
.await
325+
.unwrap();
326+
327+
session.use_keyspace(ks, false).await.unwrap();
328+
329+
session
330+
.ddl("CREATE TABLE t (pk int, ck int, v int, PRIMARY KEY (pk, ck, v))")
331+
.await
332+
.unwrap();
333+
334+
let prepared = session
335+
.prepare("INSERT INTO t (pk, ck, v) VALUES (:pk, :ck, :v)")
336+
.await
337+
.unwrap();
338+
let hashmap: HashMap<&str, i32> = HashMap::from([("pk", 7), ("v", 42), ("ck", 13)]);
339+
session.execute_unpaged(&prepared, &hashmap).await.unwrap();
340+
341+
let btreemap: BTreeMap<&str, i32> = BTreeMap::from([("ck", 113), ("v", 142), ("pk", 17)]);
342+
session.execute_unpaged(&prepared, &btreemap).await.unwrap();
343+
344+
let rows: Vec<(i32, i32, i32)> = session
345+
.query_unpaged("SELECT pk, ck, v FROM t", &[])
346+
.await
347+
.unwrap()
348+
.into_rows_result()
349+
.unwrap()
350+
.rows::<(i32, i32, i32)>()
351+
.unwrap()
352+
.collect::<Result<_, _>>()
353+
.unwrap();
354+
355+
assert_eq!(rows, vec![(7, 13, 42), (17, 113, 142)]);
356+
357+
let wrongmaps = [
358+
HashMap::from([("v", 7), ("fefe", 42), ("ck", 13)]),
359+
HashMap::from([("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", 7)]),
360+
HashMap::new(),
361+
HashMap::from([("ck", 9)]),
362+
];
363+
for wrongmap in wrongmaps {
364+
let result = session.execute_unpaged(&prepared, &wrongmap).await;
365+
let Err(ExecutionError::BadQuery(BadQuery::SerializationError(e))) = result else {
366+
panic!("Expected ValueMissingForColumn error");
367+
};
368+
assert_matches!(&e
369+
.downcast_ref::<serialize::row::BuiltinTypeCheckError>()
370+
.unwrap()
371+
.kind,
372+
serialize::row::BuiltinTypeCheckErrorKind::ValueMissingForColumn { name }
373+
if name == "pk");
374+
}
375+
}
376+
377+
#[tokio::test]
378+
async fn test_unusual_valuelists() {
379+
setup_tracing();
380+
381+
let session = create_new_session_builder().build().await.unwrap();
382+
let ks = unique_keyspace_name();
383+
384+
session.ddl(format!("CREATE KEYSPACE IF NOT EXISTS {} WITH REPLICATION = {{'class' : 'NetworkTopologyStrategy', 'replication_factor' : 1}}", ks)).await.unwrap();
385+
session.use_keyspace(ks, false).await.unwrap();
386+
387+
session
388+
.ddl("CREATE TABLE IF NOT EXISTS tab (a int, b int, c varchar, primary key (a, b, c))")
389+
.await
390+
.unwrap();
391+
392+
let insert_a_b_c = session
393+
.prepare("INSERT INTO tab (a, b, c) VALUES (?, ?, ?)")
394+
.await
395+
.unwrap();
396+
397+
let values_dyn: Vec<&dyn SerializeValue> = vec![
398+
&1 as &dyn SerializeValue,
399+
&2 as &dyn SerializeValue,
400+
&"&dyn" as &dyn SerializeValue,
401+
];
402+
session
403+
.execute_unpaged(&insert_a_b_c, values_dyn)
404+
.await
405+
.unwrap();
406+
407+
let values_box_dyn: Vec<Box<dyn SerializeValue>> = vec![
408+
Box::new(1) as Box<dyn SerializeValue>,
409+
Box::new(3) as Box<dyn SerializeValue>,
410+
Box::new("Box dyn") as Box<dyn SerializeValue>,
411+
];
412+
session
413+
.execute_unpaged(&insert_a_b_c, values_box_dyn)
414+
.await
415+
.unwrap();
416+
417+
session
418+
.execute_unpaged(
419+
&insert_a_b_c,
420+
(
421+
Box::new(1) as Box<dyn SerializeValue>,
422+
&2 as &dyn SerializeValue,
423+
&"Box,&dyn" as &dyn SerializeValue,
424+
),
425+
)
426+
.await
427+
.unwrap();
428+
429+
session
430+
.execute_unpaged(
431+
&insert_a_b_c,
432+
(
433+
&2 as &dyn SerializeValue,
434+
Box::new(1) as Box<dyn SerializeValue>,
435+
&"&dyn,Box" as &dyn SerializeValue,
436+
),
437+
)
438+
.await
439+
.unwrap();
440+
441+
let mut all_rows: Vec<(i32, i32, String)> = session
442+
.query_unpaged("SELECT a, b, c FROM tab", ())
443+
.await
444+
.unwrap()
445+
.into_rows_result()
446+
.unwrap()
447+
.rows::<(i32, i32, String)>()
448+
.unwrap()
449+
.map(|r| r.unwrap())
450+
.collect();
451+
all_rows.sort_unstable();
452+
assert_eq!(
453+
all_rows,
454+
vec![
455+
(1i32, 2i32, "&dyn".to_owned()),
456+
(1, 2i32, "Box,&dyn".to_owned()),
457+
(1, 3, "Box dyn".to_owned()),
458+
(2i32, 1, "&dyn,Box".to_owned())
459+
]
460+
);
461+
}

0 commit comments

Comments
 (0)