Skip to content

Commit 12b9f5a

Browse files
nickolaynickolay
committed
Merge branches 'strings' and 'remove-duplicate-tests'
2 parents 078eb67 + 70c799e commit 12b9f5a

File tree

2 files changed

+116
-634
lines changed

2 files changed

+116
-634
lines changed

‎tests/sqlparser_generic.rs

Lines changed: 108 additions & 63 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
extern crate log;
22
extern crate sqlparser;
33

4-
use sqlparser::dialect::GenericSqlDialect;
4+
use sqlparser::dialect::*;
55
use sqlparser::sqlast::*;
66
use sqlparser::sqlparser::*;
77
use sqlparser::sqltokenizer::*;
@@ -10,7 +10,7 @@ use sqlparser::sqltokenizer::*;
1010
fn parse_delete_statement() {
1111
let sql: &str = "DELETE FROM 'table'";
1212

13-
match parse_sql(&sql) {
13+
match verified(&sql) {
1414
ASTNode::SQLDelete { relation, .. } => {
1515
assert_eq!(
1616
Some(Box::new(ASTNode::SQLValue(Value::SingleQuotedString(
@@ -31,7 +31,7 @@ fn parse_where_delete_statement() {
3131
use self::ASTNode::*;
3232
use self::SQLOperator::*;
3333

34-
match parse_sql(&sql) {
34+
match verified(&sql) {
3535
ASTNode::SQLDelete {
3636
relation,
3737
selection,
@@ -61,8 +61,7 @@ fn parse_where_delete_statement() {
6161
#[test]
6262
fn parse_simple_select() {
6363
let sql = String::from("SELECT id, fname, lname FROM customer WHERE id = 1 LIMIT 5");
64-
let ast = parse_sql(&sql);
65-
match ast {
64+
match verified(&sql) {
6665
ASTNode::SQLSelect {
6766
projection, limit, ..
6867
} => {
@@ -76,8 +75,7 @@ fn parse_simple_select() {
7675
#[test]
7776
fn parse_select_wildcard() {
7877
let sql = String::from("SELECT * FROM customer");
79-
let ast = parse_sql(&sql);
80-
match ast {
78+
match verified(&sql) {
8179
ASTNode::SQLSelect { projection, .. } => {
8280
assert_eq!(1, projection.len());
8381
assert_eq!(ASTNode::SQLWildcard, projection[0]);
@@ -89,8 +87,7 @@ fn parse_select_wildcard() {
8987
#[test]
9088
fn parse_select_count_wildcard() {
9189
let sql = String::from("SELECT COUNT(*) FROM customer");
92-
let ast = parse_sql(&sql);
93-
match ast {
90+
match verified(&sql) {
9491
ASTNode::SQLSelect { projection, .. } => {
9592
assert_eq!(1, projection.len());
9693
assert_eq!(
@@ -111,7 +108,7 @@ fn parse_not() {
111108
"SELECT id FROM customer \
112109
WHERE NOT salary = ''",
113110
);
114-
let _ast = parse_sql(&sql);
111+
let _ast = verified(&sql);
115112
//TODO: add assertions
116113
}
117114

@@ -121,14 +118,14 @@ fn parse_select_string_predicate() {
121118
"SELECT id, fname, lname FROM customer \
122119
WHERE salary != 'Not Provided' AND salary != ''",
123120
);
124-
let _ast = parse_sql(&sql);
121+
let _ast = verified(&sql);
125122
//TODO: add assertions
126123
}
127124

128125
#[test]
129126
fn parse_projection_nested_type() {
130127
let sql = String::from("SELECT customer.address.state FROM foo");
131-
let _ast = parse_sql(&sql);
128+
let _ast = verified(&sql);
132129
//TODO: add assertions
133130
}
134131

@@ -137,7 +134,6 @@ fn parse_compound_expr_1() {
137134
use self::ASTNode::*;
138135
use self::SQLOperator::*;
139136
let sql = String::from("a + b * c");
140-
let ast = parse_sql(&sql);
141137
assert_eq!(
142138
SQLBinaryExpr {
143139
left: Box::new(SQLIdentifier("a".to_string())),
@@ -148,7 +144,7 @@ fn parse_compound_expr_1() {
148144
right: Box::new(SQLIdentifier("c".to_string()))
149145
})
150146
},
151-
ast
147+
verified(&sql)
152148
);
153149
}
154150

@@ -157,7 +153,6 @@ fn parse_compound_expr_2() {
157153
use self::ASTNode::*;
158154
use self::SQLOperator::*;
159155
let sql = String::from("a * b + c");
160-
let ast = parse_sql(&sql);
161156
assert_eq!(
162157
SQLBinaryExpr {
163158
left: Box::new(SQLBinaryExpr {
@@ -168,33 +163,76 @@ fn parse_compound_expr_2() {
168163
op: Plus,
169164
right: Box::new(SQLIdentifier("c".to_string()))
170165
},
171-
ast
166+
verified(&sql)
172167
);
173168
}
174169

175170
#[test]
176171
fn parse_is_null() {
177172
use self::ASTNode::*;
178173
let sql = String::from("a IS NULL");
179-
let ast = parse_sql(&sql);
180-
assert_eq!(SQLIsNull(Box::new(SQLIdentifier("a".to_string()))), ast);
174+
assert_eq!(
175+
SQLIsNull(Box::new(SQLIdentifier("a".to_string()))),
176+
verified(&sql)
177+
);
181178
}
182179

183180
#[test]
184181
fn parse_is_not_null() {
185182
use self::ASTNode::*;
186183
let sql = String::from("a IS NOT NULL");
187-
let ast = parse_sql(&sql);
188-
assert_eq!(SQLIsNotNull(Box::new(SQLIdentifier("a".to_string()))), ast);
184+
assert_eq!(
185+
SQLIsNotNull(Box::new(SQLIdentifier("a".to_string()))),
186+
verified(&sql)
187+
);
188+
}
189+
190+
#[test]
191+
fn parse_like() {
192+
let sql = String::from("SELECT * FROM customers WHERE name LIKE '%a'");
193+
match verified(&sql) {
194+
ASTNode::SQLSelect { selection, .. } => {
195+
assert_eq!(
196+
ASTNode::SQLBinaryExpr {
197+
left: Box::new(ASTNode::SQLIdentifier("name".to_string())),
198+
op: SQLOperator::Like,
199+
right: Box::new(ASTNode::SQLValue(Value::SingleQuotedString(
200+
"%a".to_string()
201+
))),
202+
},
203+
*selection.unwrap()
204+
);
205+
}
206+
_ => assert!(false),
207+
}
208+
}
209+
210+
#[test]
211+
fn parse_not_like() {
212+
let sql = String::from("SELECT * FROM customers WHERE name NOT LIKE '%a'");
213+
match verified(&sql) {
214+
ASTNode::SQLSelect { selection, .. } => {
215+
assert_eq!(
216+
ASTNode::SQLBinaryExpr {
217+
left: Box::new(ASTNode::SQLIdentifier("name".to_string())),
218+
op: SQLOperator::NotLike,
219+
right: Box::new(ASTNode::SQLValue(Value::SingleQuotedString(
220+
"%a".to_string()
221+
))),
222+
},
223+
*selection.unwrap()
224+
);
225+
}
226+
_ => assert!(false),
227+
}
189228
}
190229

191230
#[test]
192231
fn parse_select_order_by() {
193232
let sql = String::from(
194233
"SELECT id, fname, lname FROM customer WHERE id < 5 ORDER BY lname ASC, fname DESC",
195234
);
196-
let ast = parse_sql(&sql);
197-
match ast {
235+
match verified(&sql) {
198236
ASTNode::SQLSelect { order_by, .. } => {
199237
assert_eq!(
200238
Some(vec![
@@ -246,8 +284,7 @@ fn parse_select_order_by_limit() {
246284
#[test]
247285
fn parse_select_group_by() {
248286
let sql = String::from("SELECT id, fname, lname FROM customer GROUP BY lname, fname");
249-
let ast = parse_sql(&sql);
250-
match ast {
287+
match verified(&sql) {
251288
ASTNode::SQLSelect { group_by, .. } => {
252289
assert_eq!(
253290
Some(vec![
@@ -263,24 +300,16 @@ fn parse_select_group_by() {
263300

264301
#[test]
265302
fn parse_limit_accepts_all() {
266-
let sql = String::from("SELECT id, fname, lname FROM customer WHERE id = 1 LIMIT ALL");
267-
let ast = parse_sql(&sql);
268-
match ast {
269-
ASTNode::SQLSelect {
270-
projection, limit, ..
271-
} => {
272-
assert_eq!(3, projection.len());
273-
assert_eq!(None, limit);
274-
}
275-
_ => assert!(false),
276-
}
303+
parses_to(
304+
"SELECT id, fname, lname FROM customer WHERE id = 1 LIMIT ALL",
305+
"SELECT id, fname, lname FROM customer WHERE id = 1",
306+
);
277307
}
278308

279309
#[test]
280310
fn parse_cast() {
281-
let sql = String::from("SELECT CAST(id AS BIGINT) FROM customer");
282-
let ast = parse_sql(&sql);
283-
match ast {
311+
let sql = String::from("SELECT CAST(id AS bigint) FROM customer");
312+
match verified(&sql) {
284313
ASTNode::SQLSelect { projection, .. } => {
285314
assert_eq!(1, projection.len());
286315
assert_eq!(
@@ -293,6 +322,10 @@ fn parse_cast() {
293322
}
294323
_ => assert!(false),
295324
}
325+
parses_to(
326+
"SELECT CAST(id AS BIGINT) FROM customer",
327+
"SELECT CAST(id AS bigint) FROM customer",
328+
);
296329
}
297330

298331
#[test]
@@ -303,8 +336,14 @@ fn parse_create_table() {
303336
lat DOUBLE NULL,\
304337
lng DOUBLE NULL)",
305338
);
306-
let ast = parse_sql(&sql);
307-
match ast {
339+
parses_to(
340+
&sql,
341+
"CREATE TABLE uk_cities (\
342+
name character varying(100) NOT NULL, \
343+
lat double, \
344+
lng double)",
345+
);
346+
match parse_sql(&sql) {
308347
ASTNode::SQLCreateTable { name, columns } => {
309348
assert_eq!("uk_cities", name);
310349
assert_eq!(3, columns.len());
@@ -331,31 +370,31 @@ fn parse_create_table() {
331370
#[test]
332371
fn parse_scalar_function_in_projection() {
333372
let sql = String::from("SELECT sqrt(id) FROM foo");
334-
let ast = parse_sql(&sql);
335-
if let ASTNode::SQLSelect { projection, .. } = ast {
336-
assert_eq!(
337-
vec![ASTNode::SQLFunction {
338-
id: String::from("sqrt"),
339-
args: vec![ASTNode::SQLIdentifier(String::from("id"))],
340-
}],
341-
projection
342-
);
343-
} else {
344-
assert!(false);
373+
match verified(&sql) {
374+
ASTNode::SQLSelect { projection, .. } => {
375+
assert_eq!(
376+
vec![ASTNode::SQLFunction {
377+
id: String::from("sqrt"),
378+
args: vec![ASTNode::SQLIdentifier(String::from("id"))],
379+
}],
380+
projection
381+
);
382+
}
383+
_ => assert!(false),
345384
}
346385
}
347386

348387
#[test]
349388
fn parse_aggregate_with_group_by() {
350389
let sql = String::from("SELECT a, COUNT(1), MIN(b), MAX(b) FROM foo GROUP BY a");
351-
let _ast = parse_sql(&sql);
390+
let _ast = verified(&sql);
352391
//TODO: assertions
353392
}
354393

355394
#[test]
356395
fn parse_literal_string() {
357396
let sql = "SELECT 'one'";
358-
match parse_sql(&sql) {
397+
match verified(&sql) {
359398
ASTNode::SQLSelect { ref projection, .. } => {
360399
assert_eq!(
361400
projection[0],
@@ -381,7 +420,7 @@ fn parse_simple_math_expr_minus() {
381420
#[test]
382421
fn parse_select_version() {
383422
let sql = "SELECT @@version";
384-
match parse_sql(&sql) {
423+
match verified(&sql) {
385424
ASTNode::SQLSelect { ref projection, .. } => {
386425
assert_eq!(
387426
projection[0],
@@ -488,9 +527,9 @@ fn parse_delete_with_semi_colon() {
488527

489528
#[test]
490529
fn parse_implicit_join() {
491-
let sql = "SELECT * FROM t1,t2";
530+
let sql = "SELECT * FROM t1, t2";
492531

493-
match parse_sql(sql) {
532+
match verified(sql) {
494533
ASTNode::SQLSelect { joins, .. } => {
495534
assert_eq!(joins.len(), 1);
496535
assert_eq!(
@@ -509,7 +548,7 @@ fn parse_implicit_join() {
509548
fn parse_cross_join() {
510549
let sql = "SELECT * FROM t1 CROSS JOIN t2";
511550

512-
match parse_sql(sql) {
551+
match verified(sql) {
513552
ASTNode::SQLSelect { joins, .. } => {
514553
assert_eq!(joins.len(), 1);
515554
assert_eq!(
@@ -595,10 +634,6 @@ fn parse_complex_join() {
595634

596635
#[test]
597636
fn parse_join_syntax_variants() {
598-
fn parses_to(from: &str, to: &str) {
599-
assert_eq!(to, &parse_sql(from).to_string())
600-
}
601-
602637
parses_to(
603638
"SELECT c1 FROM t1 INNER JOIN t2 USING(c1)",
604639
"SELECT c1 FROM t1 JOIN t2 USING(c1)",
@@ -623,6 +658,10 @@ fn verified(query: &str) -> ASTNode {
623658
ast
624659
}
625660

661+
fn parses_to(from: &str, to: &str) {
662+
assert_eq!(to, &parse_sql(from).to_string())
663+
}
664+
626665
fn joins_from(ast: ASTNode) -> Vec<Join> {
627666
match ast {
628667
ASTNode::SQLSelect { joins, .. } => joins,
@@ -631,8 +670,14 @@ fn joins_from(ast: ASTNode) -> Vec<Join> {
631670
}
632671

633672
fn parse_sql(sql: &str) -> ASTNode {
634-
let dialect = GenericSqlDialect {};
635-
let mut tokenizer = Tokenizer::new(&dialect, &sql);
673+
let generic_ast = parse_sql_with(sql, &GenericSqlDialect {});
674+
let pg_ast = parse_sql_with(sql, &PostgreSqlDialect {});
675+
assert_eq!(generic_ast, pg_ast);
676+
generic_ast
677+
}
678+
679+
fn parse_sql_with(sql: &str, dialect: &Dialect) -> ASTNode {
680+
let mut tokenizer = Tokenizer::new(dialect, &sql);
636681
let tokens = tokenizer.tokenize().unwrap();
637682
let mut parser = Parser::new(tokens);
638683
let ast = parser.parse().unwrap();

0 commit comments

Comments
 (0)