4007820649

Build # 4007820649

Build Type

github

Committed by GitHub

Commit Message

Merge b71e66da1 into 6c0ac2b2c

Pull Request Pull Request #734: Bump ahash from 0.8.2 to 0.8.3

Run Details

23507 of 35166 relevant lines covered (66.85%)

40241.5 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.21

/dozer-sql/src/pipeline/expression/scalar/tests/cast.rs

use dozer_types::types::SourceDefinition;
use dozer_types::{
    chrono::{DateTime, NaiveDate, TimeZone, Utc},
    ordered_float::OrderedFloat,
    rust_decimal::Decimal,
    types::{Field, FieldDefinition, FieldType, Schema},
};

use crate::pipeline::expression::scalar::tests::scalar_common::run_scalar_fct;

// #[test]
// fn test_uint() {
//     let f = run_scalar_fct(
//         "SELECT CAST(field AS UINT) FROM users",
//         Schema::empty()
//             .field(
//                 FieldDefinition::new(String::from("field"), FieldType::Int, false),
//                 false,
//             )
//             .clone(),
//         vec![Field::Int(42)],
//     );
//     assert_eq!(f, Field::UInt(42));

//     let f = run_scalar_fct(
//         "SELECT CAST(field AS UINT) FROM users",
//         Schema::empty()
//             .field(
//                 FieldDefinition::new(String::from("field"), FieldType::String, false),
//                 false,
//             )
//             .clone(),
//         vec![Field::String("42".to_string())],
//     );
//     assert_eq!(f, Field::UInt(42));

//     let f = run_scalar_fct(
//         "SELECT CAST(field AS UINT) FROM users",
//         Schema::empty()
//             .field(
//                 FieldDefinition::new(String::from("field"), FieldType::UInt, false),
//                 false,
//             )
//             .clone(),
//         vec![Field::UInt(42)],
//     );
//     assert_eq!(f, Field::UInt(42));
// }

#[test]
fn test_int() {
    let f = run_scalar_fct(
        "SELECT CAST(field AS INT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Int,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Int(42)],
    );
    assert_eq!(f, Field::Int(42));

    let f = run_scalar_fct(
        "SELECT CAST(field AS INT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::String,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::String("42".to_string())],
    );
    assert_eq!(f, Field::Int(42));

    let f = run_scalar_fct(
        "SELECT CAST(field AS INT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::UInt,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::UInt(42)],
    );
    assert_eq!(f, Field::Int(42));
}

#[test]
fn test_float() {
    let f = run_scalar_fct(
        "SELECT CAST(field AS FLOAT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Decimal,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Decimal(Decimal::new(42, 1))],
    );
    assert_eq!(
        f,
        Field::Float(dozer_types::ordered_float::OrderedFloat(4.2))
    );

    let f = run_scalar_fct(
        "SELECT CAST(field AS FLOAT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Float,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Float(OrderedFloat(4.2))],
    );
    assert_eq!(f, Field::Float(OrderedFloat(4.2)));

    let f = run_scalar_fct(
        "SELECT CAST(field AS FLOAT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Int,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Int(4)],
    );
    assert_eq!(f, Field::Float(OrderedFloat(4.0)));

    let f = run_scalar_fct(
        "SELECT CAST(field AS FLOAT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::String,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::String("4.2".to_string())],
    );
    assert_eq!(f, Field::Float(OrderedFloat(4.2)));

    let f = run_scalar_fct(
        "SELECT CAST(field AS FLOAT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::UInt,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::UInt(4)],
    );
    assert_eq!(f, Field::Float(OrderedFloat(4.0)));
}

#[test]
fn test_boolean() {
    let f = run_scalar_fct(
        "SELECT CAST(field AS BOOLEAN) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Boolean,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Boolean(true)],
    );
    assert_eq!(f, Field::Boolean(true));

    let f = run_scalar_fct(
        "SELECT CAST(field AS BOOLEAN) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Decimal,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Decimal(Decimal::new(0, 0))],
    );
    assert_eq!(f, Field::Boolean(false));

    let f = run_scalar_fct(
        "SELECT CAST(field AS BOOLEAN) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Decimal,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Decimal(Decimal::new(1, 0))],
    );
    assert_eq!(f, Field::Boolean(true));

    let f = run_scalar_fct(
        "SELECT CAST(field AS BOOLEAN) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Float,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Float(OrderedFloat(1.0))],
    );
    assert_eq!(f, Field::Boolean(true));

    let f = run_scalar_fct(
        "SELECT CAST(field AS BOOLEAN) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Int,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Int(0)],
    );
    assert_eq!(f, Field::Boolean(false));

    let f = run_scalar_fct(
        "SELECT CAST(field AS BOOLEAN) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::UInt,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::UInt(1)],
    );
    assert_eq!(f, Field::Boolean(true));
}

#[test]
fn test_string() {
    // let f = run_scalar_fct(
    //     "SELECT CAST(field AS STRING) FROM users",
    //     Schema::empty()
    //         .field(
    //             FieldDefinition::new(String::from("field"), FieldType::Binary, false),
    //             false,
    //         )
    //         .clone(),
    //     vec![Field::Binary(vec![])],
    // );
    // assert_eq!(f, Field::String("".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS STRING) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Boolean,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Boolean(true)],
    );
    assert_eq!(f, Field::String("TRUE".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS STRING) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Date,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Date(NaiveDate::from_ymd(2022, 1, 1))],
    );
    assert_eq!(f, Field::String("2022-01-01".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS STRING) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Decimal,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Decimal(Decimal::new(42, 1))],
    );
    assert_eq!(f, Field::String("4.2".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS STRING) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Float,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Float(OrderedFloat(4.2))],
    );
    assert_eq!(f, Field::String("4.2".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS STRING) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Int,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Int(-42)],
    );
    assert_eq!(f, Field::String("-42".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS STRING) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::String,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::String("Hello".to_string())],
    );
    assert_eq!(f, Field::String("Hello".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS STRING) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Text,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Text("Hello".to_string())],
    );
    assert_eq!(f, Field::String("Hello".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS STRING) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Timestamp,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Timestamp(DateTime::from(
            Utc.timestamp_millis(42_000_000),
        ))],
    );
    assert_eq!(f, Field::String("1970-01-01T11:40:00+00:00".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS STRING) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::UInt,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::UInt(42)],
    );
    assert_eq!(f, Field::String("42".to_string()));
}

#[test]
fn test_text() {
    // let f = run_scalar_fct(
    //     "SELECT CAST(field AS STRING) FROM users",
    //     Schema::empty()
    //         .field(
    //             FieldDefinition::new(String::from("field"), FieldType::Binary, false),
    //             false,
    //         )
    //         .clone(),
    //     vec![Field::Binary(vec![])],
    // );
    // assert_eq!(f, Field::String("".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS TEXT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Boolean,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Boolean(true)],
    );
    assert_eq!(f, Field::Text("TRUE".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS TEXT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Date,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Date(NaiveDate::from_ymd(2022, 1, 1))],
    );
    assert_eq!(f, Field::Text("2022-01-01".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS TEXT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Decimal,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Decimal(Decimal::new(42, 1))],
    );
    assert_eq!(f, Field::Text("4.2".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS TEXT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Float,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Float(OrderedFloat(4.2))],
    );
    assert_eq!(f, Field::Text("4.2".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS TEXT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Int,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Int(-42)],
    );
    assert_eq!(f, Field::Text("-42".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS TEXT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::String,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::String("Hello".to_string())],
    );
    assert_eq!(f, Field::Text("Hello".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS TEXT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Text,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Text("Hello".to_string())],
    );
    assert_eq!(f, Field::Text("Hello".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS TEXT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::Timestamp,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::Timestamp(DateTime::from(
            Utc.timestamp_millis(42_000_000),
        ))],
    );
    assert_eq!(f, Field::Text("1970-01-01T11:40:00+00:00".to_string()));

    let f = run_scalar_fct(
        "SELECT CAST(field AS TEXT) FROM users",
        Schema::empty()
            .field(
                FieldDefinition::new(
                    String::from("field"),
                    FieldType::UInt,
                    false,
                    SourceDefinition::Dynamic,
                ),
                false,
            )
            .clone(),
        vec![Field::UInt(42)],
    );
    assert_eq!(f, Field::Text("42".to_string()));
}

1	use dozer_types::types::SourceDefinition;
2	use dozer_types::{
3	chrono::{DateTime, NaiveDate, TimeZone, Utc},
4	ordered_float::OrderedFloat,
5	rust_decimal::Decimal,
6	types::{Field, FieldDefinition, FieldType, Schema},
7	};
8
9	use crate::pipeline::expression::scalar::tests::scalar_common::run_scalar_fct;
10
11	// #[test]
12	// fn test_uint() {
13	// let f = run_scalar_fct(
14	// "SELECT CAST(field AS UINT) FROM users",
15	// Schema::empty()
16	// .field(
17	// FieldDefinition::new(String::from("field"), FieldType::Int, false),
18	// false,
19	// )
20	// .clone(),
21	// vec![Field::Int(42)],
22	// );
23	// assert_eq!(f, Field::UInt(42));
24
25	// let f = run_scalar_fct(
26	// "SELECT CAST(field AS UINT) FROM users",
27	// Schema::empty()
28	// .field(
29	// FieldDefinition::new(String::from("field"), FieldType::String, false),
30	// false,
31	// )
32	// .clone(),
33	// vec![Field::String("42".to_string())],
34	// );
35	// assert_eq!(f, Field::UInt(42));
36
37	// let f = run_scalar_fct(
38	// "SELECT CAST(field AS UINT) FROM users",
39	// Schema::empty()
40	// .field(
41	// FieldDefinition::new(String::from("field"), FieldType::UInt, false),
42	// false,
43	// )
44	// .clone(),
45	// vec![Field::UInt(42)],
46	// );
47	// assert_eq!(f, Field::UInt(42));
48	// }
49		×
50	#[test]	1✔
51	fn test_int() {	1✔
52	let f = run_scalar_fct(	1✔
53	"SELECT CAST(field AS INT) FROM users",	1✔
54	Schema::empty()	1✔
55	.field(	1✔
56	FieldDefinition::new(	1✔
57	String::from("field"),	1✔
58	FieldType::Int,	1✔
59	false,	1✔
60	SourceDefinition::Dynamic,	1✔
61	),	1✔
62	false,	1✔
63	)	1✔
64	.clone(),	1✔
65	vec![Field::Int(42)],	1✔
66	);	1✔
67	assert_eq!(f, Field::Int(42));	1✔
68		×
69	let f = run_scalar_fct(	1✔
70	"SELECT CAST(field AS INT) FROM users",	1✔
71	Schema::empty()	1✔
72	.field(	1✔
73	FieldDefinition::new(	1✔
74	String::from("field"),	1✔
75	FieldType::String,	1✔
76	false,	1✔
77	SourceDefinition::Dynamic,	1✔
78	),	1✔
79	false,	1✔
80	)	1✔
81	.clone(),	1✔
82	vec![Field::String("42".to_string())],	1✔
83	);	1✔
84	assert_eq!(f, Field::Int(42));	1✔
85		×
86	let f = run_scalar_fct(	1✔
87	"SELECT CAST(field AS INT) FROM users",	1✔
88	Schema::empty()	1✔
89	.field(	1✔
90	FieldDefinition::new(	1✔
91	String::from("field"),	1✔
92	FieldType::UInt,	1✔
93	false,	1✔
94	SourceDefinition::Dynamic,	1✔
95	),	1✔
96	false,	1✔
97	)	1✔
98	.clone(),	1✔
99	vec![Field::UInt(42)],	1✔
100	);	1✔
101	assert_eq!(f, Field::Int(42));	1✔
102	}	1✔
103		×
104	#[test]	1✔
105	fn test_float() {	1✔
106	let f = run_scalar_fct(	1✔
107	"SELECT CAST(field AS FLOAT) FROM users",	1✔
108	Schema::empty()	1✔
109	.field(	1✔
110	FieldDefinition::new(	1✔
111	String::from("field"),	1✔
112	FieldType::Decimal,	1✔
113	false,	1✔
114	SourceDefinition::Dynamic,	1✔
115	),	1✔
116	false,	1✔
117	)	1✔
118	.clone(),	1✔
119	vec![Field::Decimal(Decimal::new(42, 1))],	1✔
120	);	1✔
121	assert_eq!(	1✔
122	f,	1✔
123	Field::Float(dozer_types::ordered_float::OrderedFloat(4.2))	1✔
124	);	1✔
125		×
126	let f = run_scalar_fct(	1✔
127	"SELECT CAST(field AS FLOAT) FROM users",	1✔
128	Schema::empty()	1✔
129	.field(	1✔
130	FieldDefinition::new(	1✔
131	String::from("field"),	1✔
132	FieldType::Float,	1✔
133	false,	1✔
134	SourceDefinition::Dynamic,	1✔
135	),	1✔
136	false,	1✔
137	)	1✔
138	.clone(),	1✔
139	vec![Field::Float(OrderedFloat(4.2))],	1✔
140	);	1✔
141	assert_eq!(f, Field::Float(OrderedFloat(4.2)));	1✔
142		×
143	let f = run_scalar_fct(	1✔
144	"SELECT CAST(field AS FLOAT) FROM users",	1✔
145	Schema::empty()	1✔
146	.field(	1✔
147	FieldDefinition::new(	1✔
148	String::from("field"),	1✔
149	FieldType::Int,	1✔
150	false,	1✔
151	SourceDefinition::Dynamic,	1✔
152	),	1✔
153	false,	1✔
154	)	1✔
155	.clone(),	1✔
156	vec![Field::Int(4)],	1✔
157	);	1✔
158	assert_eq!(f, Field::Float(OrderedFloat(4.0)));	1✔
159		×
160	let f = run_scalar_fct(	1✔
161	"SELECT CAST(field AS FLOAT) FROM users",	1✔
162	Schema::empty()	1✔
163	.field(	1✔
164	FieldDefinition::new(	1✔
165	String::from("field"),	1✔
166	FieldType::String,	1✔
167	false,	1✔
168	SourceDefinition::Dynamic,	1✔
169	),	1✔
170	false,	1✔
171	)	1✔
172	.clone(),	1✔
173	vec![Field::String("4.2".to_string())],	1✔
174	);	1✔
175	assert_eq!(f, Field::Float(OrderedFloat(4.2)));	1✔
176		×
177	let f = run_scalar_fct(	1✔
178	"SELECT CAST(field AS FLOAT) FROM users",	1✔
179	Schema::empty()	1✔
180	.field(	1✔
181	FieldDefinition::new(	1✔
182	String::from("field"),	1✔
183	FieldType::UInt,	1✔
184	false,	1✔
185	SourceDefinition::Dynamic,	1✔
186	),	1✔
187	false,	1✔
188	)	1✔
189	.clone(),	1✔
190	vec![Field::UInt(4)],	1✔
191	);	1✔
192	assert_eq!(f, Field::Float(OrderedFloat(4.0)));	1✔
193	}	1✔
194		×
195	#[test]	1✔
196	fn test_boolean() {	1✔
197	let f = run_scalar_fct(	1✔
198	"SELECT CAST(field AS BOOLEAN) FROM users",	1✔
199	Schema::empty()	1✔
200	.field(	1✔
201	FieldDefinition::new(	1✔
202	String::from("field"),	1✔
203	FieldType::Boolean,	1✔
204	false,	1✔
205	SourceDefinition::Dynamic,	1✔
206	),	1✔
207	false,	1✔
208	)	1✔
209	.clone(),	1✔
210	vec![Field::Boolean(true)],	1✔
211	);	1✔
212	assert_eq!(f, Field::Boolean(true));	1✔
213		×
214	let f = run_scalar_fct(	1✔
215	"SELECT CAST(field AS BOOLEAN) FROM users",	1✔
216	Schema::empty()	1✔
217	.field(	1✔
218	FieldDefinition::new(	1✔
219	String::from("field"),	1✔
220	FieldType::Decimal,	1✔
221	false,	1✔
222	SourceDefinition::Dynamic,	1✔
223	),	1✔
224	false,	1✔
225	)	1✔
226	.clone(),	1✔
227	vec![Field::Decimal(Decimal::new(0, 0))],	1✔
228	);	1✔
229	assert_eq!(f, Field::Boolean(false));	1✔
230		×
231	let f = run_scalar_fct(	1✔
232	"SELECT CAST(field AS BOOLEAN) FROM users",	1✔
233	Schema::empty()	1✔
234	.field(	1✔
235	FieldDefinition::new(	1✔
236	String::from("field"),	1✔
237	FieldType::Decimal,	1✔
238	false,	1✔
239	SourceDefinition::Dynamic,	1✔
240	),	1✔
241	false,	1✔
242	)	1✔
243	.clone(),	1✔
244	vec![Field::Decimal(Decimal::new(1, 0))],	1✔
245	);	1✔
246	assert_eq!(f, Field::Boolean(true));	1✔
247		×
248	let f = run_scalar_fct(	1✔
249	"SELECT CAST(field AS BOOLEAN) FROM users",	1✔
250	Schema::empty()	1✔
251	.field(	1✔
252	FieldDefinition::new(	1✔
253	String::from("field"),	1✔
254	FieldType::Float,	1✔
255	false,	1✔
256	SourceDefinition::Dynamic,	1✔
257	),	1✔
258	false,	1✔
259	)	1✔
260	.clone(),	1✔
261	vec![Field::Float(OrderedFloat(1.0))],	1✔
262	);	1✔
263	assert_eq!(f, Field::Boolean(true));	1✔
264		×
265	let f = run_scalar_fct(	1✔
266	"SELECT CAST(field AS BOOLEAN) FROM users",	1✔
267	Schema::empty()	1✔
268	.field(	1✔
269	FieldDefinition::new(	1✔
270	String::from("field"),	1✔
271	FieldType::Int,	1✔
272	false,	1✔
273	SourceDefinition::Dynamic,	1✔
274	),	1✔
275	false,	1✔
276	)	1✔
277	.clone(),	1✔
278	vec![Field::Int(0)],	1✔
279	);	1✔
280	assert_eq!(f, Field::Boolean(false));	1✔
281		×
282	let f = run_scalar_fct(	1✔
283	"SELECT CAST(field AS BOOLEAN) FROM users",	1✔
284	Schema::empty()	1✔
285	.field(	1✔
286	FieldDefinition::new(	1✔
287	String::from("field"),	1✔
288	FieldType::UInt,	1✔
289	false,	1✔
290	SourceDefinition::Dynamic,	1✔
291	),	1✔
292	false,	1✔
293	)	1✔
294	.clone(),	1✔
295	vec![Field::UInt(1)],	1✔
296	);	1✔
297	assert_eq!(f, Field::Boolean(true));	1✔
298	}	1✔
299		×
300	#[test]	1✔
301	fn test_string() {	1✔
302	// let f = run_scalar_fct(	1✔
303	// "SELECT CAST(field AS STRING) FROM users",	1✔
304	// Schema::empty()	1✔
305	// .field(	1✔
306	// FieldDefinition::new(String::from("field"), FieldType::Binary, false),	1✔
307	// false,	1✔
308	// )	1✔
309	// .clone(),	1✔
310	// vec![Field::Binary(vec![])],	1✔
311	// );	1✔
312	// assert_eq!(f, Field::String("".to_string()));	1✔
313		1✔
314	let f = run_scalar_fct(	1✔
315	"SELECT CAST(field AS STRING) FROM users",	1✔
316	Schema::empty()	1✔
317	.field(	1✔
318	FieldDefinition::new(	1✔
319	String::from("field"),	1✔
320	FieldType::Boolean,	1✔
321	false,	1✔
322	SourceDefinition::Dynamic,	1✔
323	),	1✔
324	false,	1✔
325	)	1✔
326	.clone(),	1✔
327	vec![Field::Boolean(true)],	1✔
328	);	1✔
329	assert_eq!(f, Field::String("TRUE".to_string()));	1✔
330		×
331	let f = run_scalar_fct(	1✔
332	"SELECT CAST(field AS STRING) FROM users",	1✔
333	Schema::empty()	1✔
334	.field(	1✔
335	FieldDefinition::new(	1✔
336	String::from("field"),	1✔
337	FieldType::Date,	1✔
338	false,	1✔
339	SourceDefinition::Dynamic,	1✔
340	),	1✔
341	false,	1✔
342	)	1✔
343	.clone(),	1✔
344	vec![Field::Date(NaiveDate::from_ymd(2022, 1, 1))],	1✔
345	);	1✔
346	assert_eq!(f, Field::String("2022-01-01".to_string()));	1✔
347		×
348	let f = run_scalar_fct(	1✔
349	"SELECT CAST(field AS STRING) FROM users",	1✔
350	Schema::empty()	1✔
351	.field(	1✔
352	FieldDefinition::new(	1✔
353	String::from("field"),	1✔
354	FieldType::Decimal,	1✔
355	false,	1✔
356	SourceDefinition::Dynamic,	1✔
357	),	1✔
358	false,	1✔
359	)	1✔
360	.clone(),	1✔
361	vec![Field::Decimal(Decimal::new(42, 1))],	1✔
362	);	1✔
363	assert_eq!(f, Field::String("4.2".to_string()));	1✔
364		×
365	let f = run_scalar_fct(	1✔
366	"SELECT CAST(field AS STRING) FROM users",	1✔
367	Schema::empty()	1✔
368	.field(	1✔
369	FieldDefinition::new(	1✔
370	String::from("field"),	1✔
371	FieldType::Float,	1✔
372	false,	1✔
373	SourceDefinition::Dynamic,	1✔
374	),	1✔
375	false,	1✔
376	)	1✔
377	.clone(),	1✔
378	vec![Field::Float(OrderedFloat(4.2))],	1✔
379	);	1✔
380	assert_eq!(f, Field::String("4.2".to_string()));	1✔
381		×
382	let f = run_scalar_fct(	1✔
383	"SELECT CAST(field AS STRING) FROM users",	1✔
384	Schema::empty()	1✔
385	.field(	1✔
386	FieldDefinition::new(	1✔
387	String::from("field"),	1✔
388	FieldType::Int,	1✔
389	false,	1✔
390	SourceDefinition::Dynamic,	1✔
391	),	1✔
392	false,	1✔
393	)	1✔
394	.clone(),	1✔
395	vec![Field::Int(-42)],	1✔
396	);	1✔
397	assert_eq!(f, Field::String("-42".to_string()));	1✔
398		×
399	let f = run_scalar_fct(	1✔
400	"SELECT CAST(field AS STRING) FROM users",	1✔
401	Schema::empty()	1✔
402	.field(	1✔
403	FieldDefinition::new(	1✔
404	String::from("field"),	1✔
405	FieldType::String,	1✔
406	false,	1✔
407	SourceDefinition::Dynamic,	1✔
408	),	1✔
409	false,	1✔
410	)	1✔
411	.clone(),	1✔
412	vec![Field::String("Hello".to_string())],	1✔
413	);	1✔
414	assert_eq!(f, Field::String("Hello".to_string()));	1✔
415
416	let f = run_scalar_fct(	1✔
417	"SELECT CAST(field AS STRING) FROM users",	1✔
418	Schema::empty()	1✔
419	.field(	1✔
420	FieldDefinition::new(	1✔
421	String::from("field"),	1✔
422	FieldType::Text,	1✔
423	false,	1✔
424	SourceDefinition::Dynamic,	1✔
425	),	1✔
426	false,	1✔
427	)	1✔
428	.clone(),	1✔
429	vec![Field::Text("Hello".to_string())],	1✔
430	);	1✔
431	assert_eq!(f, Field::String("Hello".to_string()));	1✔
432		×
433	let f = run_scalar_fct(	1✔
434	"SELECT CAST(field AS STRING) FROM users",	1✔
435	Schema::empty()	1✔
436	.field(	1✔
437	FieldDefinition::new(	1✔
438	String::from("field"),	1✔
439	FieldType::Timestamp,	1✔
440	false,	1✔
441	SourceDefinition::Dynamic,	1✔
442	),	1✔
443	false,	1✔
444	)	1✔
445	.clone(),	1✔
446	vec![Field::Timestamp(DateTime::from(	1✔
447	Utc.timestamp_millis(42_000_000),	1✔
448	))],	1✔
449	);	1✔
450	assert_eq!(f, Field::String("1970-01-01T11:40:00+00:00".to_string()));	1✔
451
452	let f = run_scalar_fct(	1✔
453	"SELECT CAST(field AS STRING) FROM users",	1✔
454	Schema::empty()	1✔
455	.field(	1✔
456	FieldDefinition::new(	1✔
457	String::from("field"),	1✔
458	FieldType::UInt,	1✔
459	false,	1✔
460	SourceDefinition::Dynamic,	1✔
461	),	1✔
462	false,	1✔
463	)	1✔
464	.clone(),	1✔
465	vec![Field::UInt(42)],	1✔
466	);	1✔
467	assert_eq!(f, Field::String("42".to_string()));	1✔
468	}	1✔
469		×
470	#[test]	1✔
471	fn test_text() {	1✔
472	// let f = run_scalar_fct(	1✔
473	// "SELECT CAST(field AS STRING) FROM users",	1✔
474	// Schema::empty()	1✔
475	// .field(	1✔
476	// FieldDefinition::new(String::from("field"), FieldType::Binary, false),	1✔
477	// false,	1✔
478	// )	1✔
479	// .clone(),	1✔
480	// vec![Field::Binary(vec![])],	1✔
481	// );	1✔
482	// assert_eq!(f, Field::String("".to_string()));	1✔
483		1✔
484	let f = run_scalar_fct(	1✔
485	"SELECT CAST(field AS TEXT) FROM users",	1✔
486	Schema::empty()	1✔
487	.field(	1✔
488	FieldDefinition::new(	1✔
489	String::from("field"),	1✔
490	FieldType::Boolean,	1✔
491	false,	1✔
492	SourceDefinition::Dynamic,	1✔
493	),	1✔
494	false,	1✔
495	)	1✔
496	.clone(),	1✔
497	vec![Field::Boolean(true)],	1✔
498	);	1✔
499	assert_eq!(f, Field::Text("TRUE".to_string()));	1✔
500
501	let f = run_scalar_fct(	1✔
502	"SELECT CAST(field AS TEXT) FROM users",	1✔
503	Schema::empty()	1✔
504	.field(	1✔
505	FieldDefinition::new(	1✔
506	String::from("field"),	1✔
507	FieldType::Date,	1✔
508	false,	1✔
509	SourceDefinition::Dynamic,	1✔
510	),	1✔
511	false,	1✔
512	)	1✔
513	.clone(),	1✔
514	vec![Field::Date(NaiveDate::from_ymd(2022, 1, 1))],	1✔
515	);	1✔
516	assert_eq!(f, Field::Text("2022-01-01".to_string()));	1✔
517
518	let f = run_scalar_fct(	1✔
519	"SELECT CAST(field AS TEXT) FROM users",	1✔
520	Schema::empty()	1✔
521	.field(	1✔
522	FieldDefinition::new(	1✔
523	String::from("field"),	1✔
524	FieldType::Decimal,	1✔
525	false,	1✔
526	SourceDefinition::Dynamic,	1✔
527	),	1✔
528	false,	1✔
529	)	1✔
530	.clone(),	1✔
531	vec![Field::Decimal(Decimal::new(42, 1))],	1✔
532	);	1✔
533	assert_eq!(f, Field::Text("4.2".to_string()));	1✔
534
535	let f = run_scalar_fct(	1✔
536	"SELECT CAST(field AS TEXT) FROM users",	1✔
537	Schema::empty()	1✔
538	.field(	1✔
539	FieldDefinition::new(	1✔
540	String::from("field"),	1✔
541	FieldType::Float,	1✔
542	false,	1✔
543	SourceDefinition::Dynamic,	1✔
544	),	1✔
545	false,	1✔
546	)	1✔
547	.clone(),	1✔
548	vec![Field::Float(OrderedFloat(4.2))],	1✔
549	);	1✔
550	assert_eq!(f, Field::Text("4.2".to_string()));	1✔
551
552	let f = run_scalar_fct(	1✔
553	"SELECT CAST(field AS TEXT) FROM users",	1✔
554	Schema::empty()	1✔
555	.field(	1✔
556	FieldDefinition::new(	1✔
557	String::from("field"),	1✔
558	FieldType::Int,	1✔
559	false,	1✔
560	SourceDefinition::Dynamic,	1✔
561	),	1✔
562	false,	1✔
563	)	1✔
564	.clone(),	1✔
565	vec![Field::Int(-42)],	1✔
566	);	1✔
567	assert_eq!(f, Field::Text("-42".to_string()));	1✔
568
569	let f = run_scalar_fct(	1✔
570	"SELECT CAST(field AS TEXT) FROM users",	1✔
571	Schema::empty()	1✔
572	.field(	1✔
573	FieldDefinition::new(	1✔
574	String::from("field"),	1✔
575	FieldType::String,	1✔
576	false,	1✔
577	SourceDefinition::Dynamic,	1✔
578	),	1✔
579	false,	1✔
580	)	1✔
581	.clone(),	1✔
582	vec![Field::String("Hello".to_string())],	1✔
583	);	1✔
584	assert_eq!(f, Field::Text("Hello".to_string()));	1✔
585
586	let f = run_scalar_fct(	1✔
587	"SELECT CAST(field AS TEXT) FROM users",	1✔
588	Schema::empty()	1✔
589	.field(	1✔
590	FieldDefinition::new(	1✔
591	String::from("field"),	1✔
592	FieldType::Text,	1✔
593	false,	1✔
594	SourceDefinition::Dynamic,	1✔
595	),	1✔
596	false,	1✔
597	)	1✔
598	.clone(),	1✔
599	vec![Field::Text("Hello".to_string())],	1✔
600	);	1✔
601	assert_eq!(f, Field::Text("Hello".to_string()));	1✔
602
603	let f = run_scalar_fct(	1✔
604	"SELECT CAST(field AS TEXT) FROM users",	1✔
605	Schema::empty()	1✔
606	.field(	1✔
607	FieldDefinition::new(	1✔
608	String::from("field"),	1✔
609	FieldType::Timestamp,	1✔
610	false,	1✔
611	SourceDefinition::Dynamic,	1✔
612	),	1✔
613	false,	1✔
614	)	1✔
615	.clone(),	1✔
616	vec![Field::Timestamp(DateTime::from(	1✔
617	Utc.timestamp_millis(42_000_000),	1✔
618	))],	1✔
619	);	1✔
620	assert_eq!(f, Field::Text("1970-01-01T11:40:00+00:00".to_string()));	1✔
621
622	let f = run_scalar_fct(	1✔
623	"SELECT CAST(field AS TEXT) FROM users",	1✔
624	Schema::empty()	1✔
625	.field(	1✔
626	FieldDefinition::new(	1✔
627	String::from("field"),	1✔
628	FieldType::UInt,	1✔
629	false,	1✔
630	SourceDefinition::Dynamic,	1✔
631	),	1✔
632	false,	1✔
633	)	1✔
634	.clone(),	1✔
635	vec![Field::UInt(42)],	1✔
636	);	1✔
637	assert_eq!(f, Field::Text("42".to_string()));	1✔
638	}	1✔

getdozer / dozer / 4007820649

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous