Skip to content

Commit 0a66a1b

Browse files
lovasoalovasoa
committed
refactor(odbc): fix tests
This commit refactors the OdbcValueVec enum to include nullable variants for BigInt and Double types, enhancing the handling of null values. Additionally, the instantiation of ColumnData within tests is updated to utilize OdbcBatch, improving memory efficiency and reducing cloning overhead. The changes streamline the management of column data across various ODBC types.
1 parent 65829db commit 0a66a1b

File tree

10 files changed

+218
-59
lines changed

10 files changed

+218
-59
lines changed

‎sqlx-core/src/odbc/mod.rs‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -25,8 +25,9 @@
2525
//!
2626
//! You can configure buffer settings for performance tuning:
2727
//!
28-
//! ```rust
29-
//! use sqlx::odbc::{OdbcConnectOptions, OdbcBufferSettings};
28+
//! ```rust,no_run
29+
//! use std::str::FromStr;
30+
//! use sqlx_core_oldapi::odbc::{OdbcConnectOptions, OdbcBufferSettings};
3031
//!
3132
//! let mut opts = OdbcConnectOptions::from_str("DSN=MyDataSource")?;
3233
//!

‎sqlx-core/src/odbc/options/mod.rs‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -69,15 +69,16 @@ impl OdbcConnectOptions {
6969
/// when fetching data from ODBC data sources.
7070
///
7171
/// # Example
72-
/// ```rust
73-
/// use sqlx::odbc::{OdbcConnectOptions, OdbcBufferSettings};
72+
/// ```rust,no_run
73+
/// use std::str::FromStr;
74+
/// use sqlx_core_oldapi::odbc::{OdbcConnectOptions, OdbcBufferSettings};
7475
///
7576
/// let mut opts = OdbcConnectOptions::from_str("DSN=MyDataSource")?;
7677
/// opts.buffer_settings(OdbcBufferSettings {
7778
/// batch_size: 256,
7879
/// max_column_size: 2048,
7980
/// });
80-
/// # Ok::<(), sqlx::Error>(())
81+
/// # Ok::<(), sqlx_core_oldapi::error::Error>(())
8182
/// ```
8283
pub fn buffer_settings(&mut self, settings: OdbcBufferSettings) -> &mut Self {
8384
self.buffer_settings = settings;

‎sqlx-core/src/odbc/row.rs‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -88,7 +88,7 @@ mod tests {
8888
use std::sync::Arc;
8989

9090
fn create_test_row() -> OdbcRow {
91-
let columns = vec![
91+
let columns = Arc::new([
9292
OdbcColumn {
9393
name: "lowercase_col".to_string(),
9494
type_info: OdbcTypeInfo::new(DataType::Integer),
@@ -104,24 +104,24 @@ mod tests {
104104
type_info: OdbcTypeInfo::new(DataType::Double),
105105
ordinal: 2,
106106
},
107-
];
107+
]);
108108

109109
let column_data = vec![
110-
ColumnData {
111-
values: OdbcValueVec::NullableBigInt(vec![Some(42)]),
110+
Arc::new(ColumnData {
111+
values: OdbcValueVec::BigInt(vec![42]),
112112
type_info: OdbcTypeInfo::new(DataType::Integer),
113113
nulls: vec![false],
114-
},
115-
ColumnData {
114+
}),
115+
Arc::new(ColumnData {
116116
values: OdbcValueVec::Text(vec![Some("test".to_string())]),
117117
type_info: OdbcTypeInfo::new(DataType::Varchar { length: None }),
118118
nulls: vec![false],
119-
},
120-
ColumnData {
121-
values: OdbcValueVec::NullableDouble(vec![Some(std::f64::consts::PI)]),
119+
}),
120+
Arc::new(ColumnData {
121+
values: OdbcValueVec::Double(vec![std::f64::consts::PI]),
122122
type_info: OdbcTypeInfo::new(DataType::Double),
123123
nulls: vec![false],
124-
},
124+
}),
125125
];
126126

127127
OdbcRow {

‎sqlx-core/src/odbc/types/bool.rs‎

Lines changed: 28 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -90,29 +90,40 @@ impl<'r> Decode<'r, Odbc> for bool {
9090
#[cfg(test)]
9191
mod tests {
9292
use super::*;
93-
use crate::odbc::{ColumnData, OdbcTypeInfo, OdbcValueVec};
93+
use crate::odbc::{ColumnData, OdbcBatch, OdbcColumn, OdbcTypeInfo, OdbcValueVec};
9494
use crate::type_info::TypeInfo;
9595
use odbc_api::DataType;
96+
use std::sync::Arc;
9697

9798
fn make_ref(value_vec: OdbcValueVec, data_type: DataType) -> OdbcValueRef<'static> {
9899
let column = ColumnData {
99100
values: value_vec,
100101
type_info: OdbcTypeInfo::new(data_type),
102+
nulls: vec![false],
101103
};
102-
let ptr = Box::leak(Box::new(column));
103-
OdbcValueRef::new(ptr, 0)
104+
let column_data = vec![Arc::new(column)];
105+
let batch = OdbcBatch {
106+
columns: Arc::new([OdbcColumn {
107+
name: "test".to_string(),
108+
type_info: OdbcTypeInfo::new(data_type),
109+
ordinal: 0,
110+
}]),
111+
column_data,
112+
};
113+
let batch_ptr = Box::leak(Box::new(batch));
114+
OdbcValueRef::new(batch_ptr, 0, 0)
104115
}
105116

106117
fn create_test_value_text(text: &'static str, data_type: DataType) -> OdbcValueRef<'static> {
107118
make_ref(OdbcValueVec::Text(vec![Some(text.to_string())]), data_type)
108119
}
109120

110121
fn create_test_value_int(value: i64, data_type: DataType) -> OdbcValueRef<'static> {
111-
make_ref(OdbcValueVec::NullableBigInt(vec![Some(value)]), data_type)
122+
make_ref(OdbcValueVec::BigInt(vec![value]), data_type)
112123
}
113124

114125
fn create_test_value_float(value: f64, data_type: DataType) -> OdbcValueRef<'static> {
115-
make_ref(OdbcValueVec::NullableDouble(vec![Some(value)]), data_type)
126+
make_ref(OdbcValueVec::Double(vec![value]), data_type)
116127
}
117128

118129
#[test]
@@ -307,9 +318,19 @@ mod tests {
307318
let column = ColumnData {
308319
values: OdbcValueVec::Text(vec![Some("not_a_bool".to_string())]),
309320
type_info: OdbcTypeInfo::BIT,
321+
nulls: vec![false],
322+
};
323+
let column_data = vec![Arc::new(column)];
324+
let batch = OdbcBatch {
325+
columns: Arc::new([OdbcColumn {
326+
name: "test".to_string(),
327+
type_info: OdbcTypeInfo::BIT,
328+
ordinal: 0,
329+
}]),
330+
column_data,
310331
};
311-
let ptr = Box::leak(Box::new(column));
312-
let value = OdbcValueRef::new(ptr, 0);
332+
let batch_ptr = Box::leak(Box::new(batch));
333+
let value = OdbcValueRef::new(batch_ptr, 0, 0);
313334

314335
let result = <bool as Decode<Odbc>>::decode(value);
315336
assert!(result.is_err());

‎sqlx-core/src/odbc/types/bytes.rs‎

Lines changed: 26 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -71,17 +71,28 @@ impl Type<Odbc> for [u8] {
7171
#[cfg(test)]
7272
mod tests {
7373
use super::*;
74-
use crate::odbc::{ColumnData, OdbcTypeInfo, OdbcValueVec};
74+
use crate::odbc::{ColumnData, OdbcBatch, OdbcColumn, OdbcTypeInfo, OdbcValueVec};
7575
use crate::type_info::TypeInfo;
7676
use odbc_api::DataType;
77+
use std::sync::Arc;
7778

7879
fn make_ref(value_vec: OdbcValueVec, data_type: DataType) -> OdbcValueRef<'static> {
7980
let column = ColumnData {
8081
values: value_vec,
8182
type_info: OdbcTypeInfo::new(data_type),
83+
nulls: vec![false],
8284
};
83-
let ptr = Box::leak(Box::new(column));
84-
OdbcValueRef::new(ptr, 0)
85+
let column_data = vec![Arc::new(column)];
86+
let batch = OdbcBatch {
87+
columns: Arc::new([OdbcColumn {
88+
name: "test".to_string(),
89+
type_info: OdbcTypeInfo::new(data_type),
90+
ordinal: 0,
91+
}]),
92+
column_data,
93+
};
94+
let batch_ptr = Box::leak(Box::new(batch));
95+
OdbcValueRef::new(batch_ptr, 0, 0)
8596
}
8697

8798
fn create_test_value_text(text: &'static str, data_type: DataType) -> OdbcValueRef<'static> {
@@ -187,9 +198,19 @@ mod tests {
187198
let column = ColumnData {
188199
values: OdbcValueVec::Text(vec![Some("not_bytes".to_string())]),
189200
type_info: OdbcTypeInfo::varbinary(None),
201+
nulls: vec![false],
202+
};
203+
let column_data = vec![Arc::new(column)];
204+
let batch = OdbcBatch {
205+
columns: Arc::new([OdbcColumn {
206+
name: "test".to_string(),
207+
type_info: OdbcTypeInfo::varbinary(None),
208+
ordinal: 0,
209+
}]),
210+
column_data,
190211
};
191-
let ptr = Box::leak(Box::new(column));
192-
let value = OdbcValueRef::new(ptr, 0);
212+
let batch_ptr = Box::leak(Box::new(batch));
213+
let value = OdbcValueRef::new(batch_ptr, 0, 0);
193214
// Vec<u8> can decode text as bytes, so this should succeed
194215
let result = <Vec<u8> as Decode<'_, Odbc>>::decode(value);
195216
assert!(result.is_ok());

‎sqlx-core/src/odbc/types/chrono.rs‎

Lines changed: 30 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -461,30 +461,43 @@ impl<'r> Decode<'r, Odbc> for DateTime<Local> {
461461
#[cfg(test)]
462462
mod tests {
463463
use super::*;
464-
use crate::odbc::{ColumnData, OdbcTypeInfo, OdbcValueRef, OdbcValueVec};
464+
use crate::odbc::{
465+
ColumnData, OdbcBatch, OdbcColumn, OdbcTypeInfo, OdbcValueRef, OdbcValueVec,
466+
};
465467
use crate::type_info::TypeInfo;
466468
use chrono::{DateTime, NaiveDate, NaiveDateTime, NaiveTime, Utc};
467469
use odbc_api::DataType;
470+
use std::sync::Arc;
468471

469472
fn make_ref(value_vec: OdbcValueVec, data_type: DataType) -> OdbcValueRef<'static> {
470473
let column = ColumnData {
471474
values: value_vec,
472475
type_info: OdbcTypeInfo::new(data_type),
476+
nulls: vec![false],
473477
};
474-
let ptr = Box::leak(Box::new(column));
475-
OdbcValueRef::new(ptr, 0)
478+
let column_data = vec![Arc::new(column)];
479+
let batch = OdbcBatch {
480+
columns: Arc::new([OdbcColumn {
481+
name: "test".to_string(),
482+
type_info: OdbcTypeInfo::new(data_type),
483+
ordinal: 0,
484+
}]),
485+
column_data,
486+
};
487+
let batch_ptr = Box::leak(Box::new(batch));
488+
OdbcValueRef::new(batch_ptr, 0, 0)
476489
}
477490

478491
fn create_test_value_text(text: &'static str, data_type: DataType) -> OdbcValueRef<'static> {
479492
make_ref(OdbcValueVec::Text(vec![Some(text.to_string())]), data_type)
480493
}
481494

482495
fn create_test_value_int(value: i64, data_type: DataType) -> OdbcValueRef<'static> {
483-
make_ref(OdbcValueVec::NullableBigInt(vec![Some(value)]), data_type)
496+
make_ref(OdbcValueVec::BigInt(vec![value]), data_type)
484497
}
485498

486499
fn create_test_value_float(value: f64, data_type: DataType) -> OdbcValueRef<'static> {
487-
make_ref(OdbcValueVec::NullableDouble(vec![Some(value)]), data_type)
500+
make_ref(OdbcValueVec::Double(vec![value]), data_type)
488501
}
489502

490503
fn create_test_value_blob(data: &'static [u8], data_type: DataType) -> OdbcValueRef<'static> {
@@ -625,9 +638,19 @@ mod tests {
625638
let column = ColumnData {
626639
values: OdbcValueVec::Text(vec![None]),
627640
type_info: OdbcTypeInfo::new(DataType::Date),
641+
nulls: vec![true],
642+
};
643+
let column_data = vec![Arc::new(column)];
644+
let batch = OdbcBatch {
645+
columns: Arc::new([OdbcColumn {
646+
name: "test".to_string(),
647+
type_info: OdbcTypeInfo::new(DataType::Date),
648+
ordinal: 0,
649+
}]),
650+
column_data,
628651
};
629-
let ptr = Box::leak(Box::new(column));
630-
let value = OdbcValueRef::new(ptr, 0);
652+
let batch_ptr = Box::leak(Box::new(batch));
653+
let value = OdbcValueRef::new(batch_ptr, 0, 0);
631654
assert_eq!(get_text_from_value(&value)?, None);
632655

633656
Ok(())

‎sqlx-core/src/odbc/types/decimal.rs‎

Lines changed: 30 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -73,18 +73,31 @@ impl<'r> Decode<'r, Odbc> for Decimal {
7373
#[cfg(test)]
7474
mod tests {
7575
use super::*;
76-
use crate::odbc::{ColumnData, OdbcTypeInfo, OdbcValueRef, OdbcValueVec};
76+
use crate::odbc::{
77+
ColumnData, OdbcBatch, OdbcColumn, OdbcTypeInfo, OdbcValueRef, OdbcValueVec,
78+
};
7779
use crate::type_info::TypeInfo;
7880
use odbc_api::DataType;
7981
use std::str::FromStr;
82+
use std::sync::Arc;
8083

8184
fn make_ref(value_vec: OdbcValueVec, data_type: DataType) -> OdbcValueRef<'static> {
8285
let column = ColumnData {
8386
values: value_vec,
8487
type_info: OdbcTypeInfo::new(data_type),
88+
nulls: vec![false],
8589
};
86-
let ptr = Box::leak(Box::new(column));
87-
OdbcValueRef::new(ptr, 0)
90+
let column_data = vec![Arc::new(column)];
91+
let batch = OdbcBatch {
92+
columns: Arc::new([OdbcColumn {
93+
name: "test".to_string(),
94+
type_info: OdbcTypeInfo::new(data_type),
95+
ordinal: 0,
96+
}]),
97+
column_data,
98+
};
99+
let batch_ptr = Box::leak(Box::new(batch));
100+
OdbcValueRef::new(batch_ptr, 0, 0)
88101
}
89102

90103
fn create_test_value_text(text: &'static str, data_type: DataType) -> OdbcValueRef<'static> {
@@ -96,11 +109,11 @@ mod tests {
96109
}
97110

98111
fn create_test_value_int(value: i64, data_type: DataType) -> OdbcValueRef<'static> {
99-
make_ref(OdbcValueVec::NullableBigInt(vec![Some(value)]), data_type)
112+
make_ref(OdbcValueVec::BigInt(vec![value]), data_type)
100113
}
101114

102115
fn create_test_value_float(value: f64, data_type: DataType) -> OdbcValueRef<'static> {
103-
make_ref(OdbcValueVec::NullableDouble(vec![Some(value)]), data_type)
116+
make_ref(OdbcValueVec::Double(vec![value]), data_type)
104117
}
105118

106119
#[test]
@@ -255,9 +268,19 @@ mod tests {
255268
let column = ColumnData {
256269
values: OdbcValueVec::Text(vec![Some("not_a_number".to_string())]),
257270
type_info: OdbcTypeInfo::decimal(10, 2),
271+
nulls: vec![false],
272+
};
273+
let column_data = vec![Arc::new(column)];
274+
let batch = OdbcBatch {
275+
columns: Arc::new([OdbcColumn {
276+
name: "test".to_string(),
277+
type_info: OdbcTypeInfo::decimal(10, 2),
278+
ordinal: 0,
279+
}]),
280+
column_data,
258281
};
259-
let ptr = Box::leak(Box::new(column));
260-
let value = OdbcValueRef::new(ptr, 0);
282+
let batch_ptr = Box::leak(Box::new(batch));
283+
let value = OdbcValueRef::new(batch_ptr, 0, 0);
261284

262285
let result = <Decimal as Decode<Odbc>>::decode(value);
263286
assert!(result.is_err());

0 commit comments

Comments
 (0)