cql3_parser/
cassandra_statement.rs

1use crate::aggregate::Aggregate;
2use crate::alter_materialized_view::AlterMaterializedView;
3use crate::alter_table::AlterTable;
4use crate::alter_type::AlterType;
5use crate::cassandra_ast::{CassandraParser, ParsedStatement};
6use crate::common::{FQName, Identifier, Privilege};
7use crate::common_drop::CommonDrop;
8use crate::create_function::CreateFunction;
9use crate::create_index::CreateIndex;
10use crate::create_keyspace::CreateKeyspace;
11use crate::create_materialized_view::CreateMaterializedView;
12use crate::create_table::CreateTable;
13use crate::create_trigger::CreateTrigger;
14use crate::create_type::CreateType;
15use crate::create_user::CreateUser;
16use crate::delete::Delete;
17use crate::drop_trigger::DropTrigger;
18use crate::insert::Insert;
19use crate::list_role::ListRole;
20use crate::role_common::RoleCommon;
21use crate::select::Select;
22use crate::update::Update;
23use std::fmt::{Display, Formatter};
24use tree_sitter::{Node, Tree};
25
26/// The Supported Cassandra CQL3 statements
27/// Documentation for statements can be found at
28/// https://docs.datastax.com/en/cql-oss/3.3/cql/cql_reference/cqlCommandsTOC.html
29#[derive(PartialEq, Debug, Clone)]
30pub enum CassandraStatement {
31    AlterKeyspace(CreateKeyspace),
32    AlterMaterializedView(AlterMaterializedView),
33    AlterRole(RoleCommon),
34    AlterTable(AlterTable),
35    AlterType(AlterType),
36    AlterUser(CreateUser),
37    ApplyBatch,
38    CreateAggregate(Aggregate),
39    CreateFunction(CreateFunction),
40    CreateIndex(CreateIndex),
41    CreateKeyspace(CreateKeyspace),
42    CreateMaterializedView(CreateMaterializedView),
43    CreateRole(RoleCommon),
44    CreateTable(CreateTable),
45    CreateTrigger(CreateTrigger),
46    CreateType(CreateType),
47    CreateUser(CreateUser),
48    Delete(Delete),
49    DropAggregate(CommonDrop),
50    DropFunction(CommonDrop),
51    DropIndex(CommonDrop),
52    DropKeyspace(CommonDrop),
53    DropMaterializedView(CommonDrop),
54    DropRole(CommonDrop),
55    DropTable(CommonDrop),
56    DropTrigger(DropTrigger),
57    DropType(CommonDrop),
58    DropUser(CommonDrop),
59    Grant(Privilege),
60    Insert(Insert),
61    ListPermissions(Privilege),
62    ListRoles(ListRole),
63    Revoke(Privilege),
64    Select(Select),
65    Truncate(FQName),
66    Update(Update),
67    Use(Identifier),
68    Unknown(String),
69}
70
71impl CassandraStatement {
72    /// extract the cassandra statement from an AST tree.
73    /// the boolean return value is `true` if there is a parsing error in the statement tree.
74    pub fn from_tree(tree: &Tree, source: &str) -> Vec<ParsedStatement> {
75        let mut result = vec![];
76        let mut cursor = tree.root_node().walk();
77        let mut process = cursor.goto_first_child();
78        while process {
79            result.push(ParsedStatement::new(cursor.node(), source));
80            process = cursor.goto_next_sibling();
81            while process && cursor.node().kind().eq(";") {
82                process = cursor.goto_next_sibling();
83            }
84        }
85        result
86    }
87
88    /// extract the cassandra statement from an AST node.
89    pub fn from_node(node: &Node, source: &str) -> CassandraStatement {
90        match node.kind() {
91            "alter_keyspace" => CassandraStatement::AlterKeyspace(
92                CassandraParser::parse_keyspace_data(node, source),
93            ),
94            "alter_materialized_view" => CassandraStatement::AlterMaterializedView(
95                CassandraParser::parse_alter_materialized_view(node, source),
96            ),
97            "alter_role" => {
98                CassandraStatement::AlterRole(CassandraParser::parse_create_role(node, source))
99            }
100            "alter_table" => {
101                CassandraStatement::AlterTable(CassandraParser::parse_alter_table(node, source))
102            }
103            "alter_type" => {
104                CassandraStatement::AlterType(CassandraParser::parse_alter_type(node, source))
105            }
106            "alter_user" => {
107                CassandraStatement::AlterUser(CassandraParser::parse_create_user(node, source))
108            }
109            "apply_batch" => CassandraStatement::ApplyBatch,
110            "create_aggregate" => CassandraStatement::CreateAggregate(
111                CassandraParser::parse_create_aggregate(node, source),
112            ),
113            "create_function" => CassandraStatement::CreateFunction(
114                CassandraParser::parse_function_data(node, source),
115            ),
116            "create_index" => {
117                CassandraStatement::CreateIndex(CassandraParser::parse_index(node, source))
118            }
119            "create_keyspace" => CassandraStatement::CreateKeyspace(
120                CassandraParser::parse_keyspace_data(node, source),
121            ),
122            "create_materialized_view" => CassandraStatement::CreateMaterializedView(
123                CassandraParser::parse_create_materialized_vew(node, source),
124            ),
125            "create_role" => {
126                CassandraStatement::CreateRole(CassandraParser::parse_create_role(node, source))
127            }
128            "create_table" => {
129                CassandraStatement::CreateTable(CassandraParser::parse_create_table(node, source))
130            }
131            "create_trigger" => CassandraStatement::CreateTrigger(
132                CassandraParser::parse_create_trigger(node, source),
133            ),
134            "create_type" => {
135                CassandraStatement::CreateType(CassandraParser::parse_create_type(node, source))
136            }
137            "create_user" => {
138                CassandraStatement::CreateUser(CassandraParser::parse_create_user(node, source))
139            }
140            "delete_statement" => {
141                CassandraStatement::Delete(CassandraParser::parse_delete_statement(node, source))
142            }
143            "drop_aggregate" => CassandraStatement::DropAggregate(
144                CassandraParser::parse_standard_drop(node, source),
145            ),
146            "drop_function" => {
147                CassandraStatement::DropFunction(CassandraParser::parse_standard_drop(node, source))
148            }
149            "drop_index" => {
150                CassandraStatement::DropIndex(CassandraParser::parse_standard_drop(node, source))
151            }
152            "drop_keyspace" => {
153                CassandraStatement::DropKeyspace(CassandraParser::parse_standard_drop(node, source))
154            }
155            "drop_materialized_view" => CassandraStatement::DropMaterializedView(
156                CassandraParser::parse_standard_drop(node, source),
157            ),
158            "drop_role" => {
159                CassandraStatement::DropRole(CassandraParser::parse_standard_drop(node, source))
160            }
161            "drop_table" => {
162                CassandraStatement::DropTable(CassandraParser::parse_standard_drop(node, source))
163            }
164            "drop_trigger" => {
165                CassandraStatement::DropTrigger(CassandraParser::parse_drop_trigger(node, source))
166            }
167            "drop_type" => {
168                CassandraStatement::DropType(CassandraParser::parse_standard_drop(node, source))
169            }
170            "drop_user" => {
171                CassandraStatement::DropUser(CassandraParser::parse_standard_drop(node, source))
172            }
173            "grant" => CassandraStatement::Grant(CassandraParser::parse_privilege(node, source)),
174            "insert_statement" => {
175                CassandraStatement::Insert(CassandraParser::parse_insert(node, source))
176            }
177            "list_permissions" => {
178                CassandraStatement::ListPermissions(CassandraParser::parse_privilege(node, source))
179            }
180            "list_roles" => {
181                CassandraStatement::ListRoles(CassandraParser::parse_list_role_data(node, source))
182            }
183            "revoke" => CassandraStatement::Revoke(CassandraParser::parse_privilege(node, source)),
184            "select_statement" => {
185                CassandraStatement::Select(CassandraParser::parse_select(node, source))
186            }
187            "truncate" => {
188                CassandraStatement::Truncate(CassandraParser::parse_truncate(node, source))
189            }
190            "update" => CassandraStatement::Update(CassandraParser::parse_update(node, source)),
191            "use" => CassandraStatement::Use(CassandraParser::parse_use(node, source)),
192            _ => CassandraStatement::Unknown(source.to_string()),
193        }
194    }
195
196    pub fn get_keyspace<'a>(&'a self, default: &'a Identifier) -> &'a Identifier {
197        match self {
198            CassandraStatement::AlterKeyspace(x) => &x.name,
199            CassandraStatement::AlterMaterializedView(x) => {
200                x.name.keyspace.as_ref().unwrap_or(default)
201            }
202            CassandraStatement::AlterRole(_) => default,
203            CassandraStatement::AlterTable(x) => x.name.keyspace.as_ref().unwrap_or(default),
204            CassandraStatement::AlterType(x) => x.name.keyspace.as_ref().unwrap_or(default),
205            CassandraStatement::AlterUser(_) => default,
206            CassandraStatement::ApplyBatch => default,
207            CassandraStatement::CreateAggregate(x) => x.name.keyspace.as_ref().unwrap_or(default),
208            CassandraStatement::CreateFunction(x) => x.name.keyspace.as_ref().unwrap_or(default),
209            CassandraStatement::CreateIndex(x) => x.table.keyspace.as_ref().unwrap_or(default),
210            CassandraStatement::CreateKeyspace(x) => &x.name,
211            CassandraStatement::CreateMaterializedView(x) => {
212                x.name.keyspace.as_ref().unwrap_or(default)
213            }
214            CassandraStatement::CreateRole(_) => default,
215            CassandraStatement::CreateTable(x) => x.name.keyspace.as_ref().unwrap_or(default),
216            CassandraStatement::CreateTrigger(x) => x.name.keyspace.as_ref().unwrap_or(default),
217            CassandraStatement::CreateType(x) => x.name.keyspace.as_ref().unwrap_or(default),
218            CassandraStatement::CreateUser(_) => default,
219            CassandraStatement::Delete(x) => x.table_name.keyspace.as_ref().unwrap_or(default),
220            CassandraStatement::DropAggregate(x) => x.name.keyspace.as_ref().unwrap_or(default),
221            CassandraStatement::DropFunction(x) => x.name.keyspace.as_ref().unwrap_or(default),
222            CassandraStatement::DropIndex(x) => x.name.keyspace.as_ref().unwrap_or(default),
223            CassandraStatement::DropKeyspace(x) => &x.name.name,
224            CassandraStatement::DropMaterializedView(x) => {
225                x.name.keyspace.as_ref().unwrap_or(default)
226            }
227            CassandraStatement::DropRole(_) => default,
228            CassandraStatement::DropTable(x) => x.name.keyspace.as_ref().unwrap_or(default),
229            CassandraStatement::DropTrigger(x) => x.name.keyspace.as_ref().unwrap_or(default),
230            CassandraStatement::DropType(x) => x.name.keyspace.as_ref().unwrap_or(default),
231            CassandraStatement::DropUser(_) => default,
232            CassandraStatement::Grant(_) => default,
233            CassandraStatement::Insert(x) => x.table_name.keyspace.as_ref().unwrap_or(default),
234            CassandraStatement::ListPermissions(_) => default,
235            CassandraStatement::ListRoles(_) => default,
236            CassandraStatement::Revoke(_) => default,
237            CassandraStatement::Select(x) => x.table_name.keyspace.as_ref().unwrap_or(default),
238            CassandraStatement::Truncate(name) => name.keyspace.as_ref().unwrap_or(default),
239            CassandraStatement::Update(x) => x.table_name.keyspace.as_ref().unwrap_or(default),
240            CassandraStatement::Use(name) => name,
241            CassandraStatement::Unknown(_) => default,
242        }
243    }
244
245    pub fn short_name(&self) -> &'static str {
246        match self {
247            CassandraStatement::AlterKeyspace(_) => "ALTER KEYSPACE",
248            CassandraStatement::AlterMaterializedView(_) => "ALTER MATERIALIZED VIEW",
249            CassandraStatement::AlterRole(_) => "ALTER ROLE",
250            CassandraStatement::AlterTable(_) => "ALTER TABLE",
251            CassandraStatement::AlterType(_) => "ALTER TYPE",
252            CassandraStatement::AlterUser(_) => "ALTER USER",
253            CassandraStatement::ApplyBatch => "APPLY BATCH",
254            CassandraStatement::CreateAggregate(_) => "CREATE AGGREGATE",
255            CassandraStatement::CreateFunction(_) => "CREATE FUNCTION",
256            CassandraStatement::CreateIndex(_) => "CREATE INDEX",
257            CassandraStatement::CreateKeyspace(_) => "CREATE KEYSPACE",
258            CassandraStatement::CreateMaterializedView(_) => "CREATE MATERIALIZED VIEW",
259            CassandraStatement::CreateRole(_) => "CREATE ROLE",
260            CassandraStatement::CreateTable(_) => "CREATE TABLE",
261            CassandraStatement::CreateTrigger(_) => "CREATE TRIGGER",
262            CassandraStatement::CreateType(_) => "CREATE TYPE",
263            CassandraStatement::CreateUser(_) => "CREATE USER",
264            CassandraStatement::Delete(_) => "DELETE",
265            CassandraStatement::DropAggregate(_) => "DROP AGGREGATE",
266            CassandraStatement::DropFunction(_) => "DROP FUNCTION",
267            CassandraStatement::DropIndex(_) => "DROP INDEX",
268            CassandraStatement::DropKeyspace(_) => "DROP KEYSPACE",
269            CassandraStatement::DropMaterializedView(_) => "DROP MATERIALIZED VIEW",
270            CassandraStatement::DropRole(_) => "DROP ROLE",
271            CassandraStatement::DropTable(_) => "DROP TABLE",
272            CassandraStatement::DropTrigger(_) => "DROP TRIGGER",
273            CassandraStatement::DropType(_) => "DROP TYPE",
274            CassandraStatement::DropUser(_) => "DROP USER",
275            CassandraStatement::Grant(_) => "GRANT",
276            CassandraStatement::Insert(_) => "INSERT",
277            CassandraStatement::ListPermissions(_) => "LIST PERMISSIONS",
278            CassandraStatement::ListRoles(_) => "LIST ROLES",
279            CassandraStatement::Revoke(_) => "REVOKE",
280            CassandraStatement::Select(_) => "SELECT",
281            CassandraStatement::Truncate(_) => "TRUNCATE",
282            CassandraStatement::Update(_) => "UPDATE",
283            CassandraStatement::Use(_) => "USE",
284            CassandraStatement::Unknown(_) => "UNRECOGNIZED CQL",
285        }
286    }
287
288    /// returns the table name from the statement if there is one.
289    pub fn get_table_name(&self) -> Option<&FQName> {
290        match self {
291            CassandraStatement::AlterTable(t) => Some(&t.name),
292            CassandraStatement::CreateIndex(i) => Some(&i.table),
293            CassandraStatement::CreateMaterializedView(m) => Some(&m.table),
294            CassandraStatement::CreateTable(t) => Some(&t.name),
295            CassandraStatement::Delete(d) => Some(&d.table_name),
296            CassandraStatement::DropTable(t) => Some(&t.name),
297            CassandraStatement::DropTrigger(t) => Some(&t.table),
298            CassandraStatement::Insert(i) => Some(&i.table_name),
299            CassandraStatement::Select(s) => Some(&s.table_name),
300            CassandraStatement::Truncate(t) => Some(t),
301            CassandraStatement::Update(u) => Some(&u.table_name),
302            _ => None,
303        }
304    }
305}
306
307impl Display for CassandraStatement {
308    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
309        match self {
310            CassandraStatement::AlterKeyspace(keyspace_data) => {
311                write!(f, "ALTER {}", keyspace_data)
312            }
313            CassandraStatement::AlterMaterializedView(alter_data) => write!(f, "{}", alter_data),
314            CassandraStatement::AlterRole(role_data) => write!(f, "ALTER {}", role_data),
315            CassandraStatement::AlterTable(table_data) => {
316                write!(
317                    f,
318                    "ALTER TABLE {} {}",
319                    table_data.name, table_data.operation
320                )
321            }
322            CassandraStatement::AlterType(alter_type_data) => write!(f, "{}", alter_type_data),
323            CassandraStatement::AlterUser(user_data) => write!(f, "ALTER {}", user_data),
324            CassandraStatement::ApplyBatch => write!(f, "APPLY BATCH"),
325            CassandraStatement::CreateAggregate(aggregate_data) => write!(f, "{}", aggregate_data),
326            CassandraStatement::CreateFunction(function_data) => write!(f, "{}", function_data),
327            CassandraStatement::CreateIndex(index_data) => write!(f, "{}", index_data),
328            CassandraStatement::CreateKeyspace(keyspace_data) => {
329                write!(f, "CREATE {}", keyspace_data)
330            }
331            CassandraStatement::CreateMaterializedView(view_data) => write!(f, "{}", view_data),
332            CassandraStatement::CreateRole(role_data) => write!(f, "CREATE {}", role_data),
333            CassandraStatement::CreateTable(table_data) => write!(f, "CREATE TABLE {}", table_data),
334            CassandraStatement::CreateTrigger(trigger_data) => write!(f, "{}", trigger_data),
335            CassandraStatement::CreateType(type_data) => write!(f, "{}", type_data),
336            CassandraStatement::CreateUser(user_data) => write!(f, "CREATE {}", user_data),
337            CassandraStatement::Delete(statement_data) => write!(f, "{}", statement_data),
338            CassandraStatement::DropAggregate(drop_data) => {
339                write!(f, "{}", drop_data.get_text("AGGREGATE"))
340            }
341            CassandraStatement::DropFunction(drop_data) => {
342                write!(f, "{}", drop_data.get_text("FUNCTION"))
343            }
344            CassandraStatement::DropIndex(drop_data) => {
345                write!(f, "{}", drop_data.get_text("INDEX"))
346            }
347            CassandraStatement::DropKeyspace(drop_data) => {
348                write!(f, "{}", drop_data.get_text("KEYSPACE"))
349            }
350            CassandraStatement::DropMaterializedView(drop_data) => {
351                write!(f, "{}", drop_data.get_text("MATERIALIZED VIEW"))
352            }
353            CassandraStatement::DropRole(drop_data) => write!(f, "{}", drop_data.get_text("ROLE")),
354            CassandraStatement::DropTable(drop_data) => {
355                write!(f, "{}", drop_data.get_text("TABLE"))
356            }
357            CassandraStatement::DropTrigger(drop_trigger_data) => {
358                write!(f, "{}", drop_trigger_data)
359            }
360            CassandraStatement::DropType(drop_data) => write!(f, "{}", drop_data.get_text("TYPE")),
361            CassandraStatement::DropUser(drop_data) => write!(f, "{}", drop_data.get_text("USER")),
362            CassandraStatement::Grant(grant_data) => write!(
363                f,
364                "GRANT {} ON {} TO {}",
365                grant_data.privilege,
366                grant_data.resource.as_ref().unwrap(),
367                &grant_data.role.as_ref().unwrap()
368            ),
369            CassandraStatement::Insert(statement_data) => write!(f, "{}", statement_data),
370            CassandraStatement::ListPermissions(grant_data) => write!(
371                f,
372                "LIST {}{}{}",
373                grant_data.privilege,
374                grant_data
375                    .resource
376                    .as_ref()
377                    .map_or("".to_string(), |x| format!(" ON {}", x)),
378                grant_data
379                    .role
380                    .as_ref()
381                    .map_or("".to_string(), |x| format!(" OF {}", x))
382            ),
383            CassandraStatement::ListRoles(data) => write!(f, "{}", data),
384            CassandraStatement::Revoke(grant_data) => write!(
385                f,
386                "REVOKE {} ON {} FROM {}",
387                grant_data.privilege,
388                grant_data.resource.as_ref().unwrap(),
389                grant_data.role.as_ref().unwrap()
390            ),
391            CassandraStatement::Select(statement_data) => write!(f, "{}", statement_data),
392            CassandraStatement::Truncate(table) => write!(f, "TRUNCATE TABLE {}", table),
393            CassandraStatement::Update(statement_data) => write!(f, "{}", statement_data),
394            CassandraStatement::Use(keyspace) => write!(f, "USE {}", keyspace),
395            CassandraStatement::Unknown(query) => write!(f, "{}", query),
396        }
397    }
398}
399
400#[cfg(test)]
401mod tests {
402    use crate::{
403        cassandra_ast::CassandraAST,
404        cassandra_statement::CassandraStatement,
405        common::{FQName, Identifier},
406        common_drop::CommonDrop,
407        select::{Select, SelectElement},
408    };
409
410    // only tests single results
411    fn test_parsing(expected: &[&str], statements: &[&str]) {
412        for (statement, expected) in statements.iter().zip(expected) {
413            let ast = CassandraAST::new(statement);
414            assert!(
415                !ast.has_error(),
416                "AST has error\n{}\n{} ",
417                statement,
418                ast.tree.root_node().to_sexp()
419            );
420            let stmt = &ast.statements[0];
421            assert!(!stmt.has_error);
422            let stmt_str = stmt.statement.to_string();
423            assert_eq!(*expected, stmt_str);
424        }
425    }
426
427    fn assert_ast(query: &str, expected: &CassandraStatement) {
428        let ast = CassandraAST::new(query);
429        assert!(
430            !ast.has_error(),
431            "AST has error\n{}\n{} ",
432            query,
433            ast.tree.root_node().to_sexp()
434        );
435        assert_eq!(&ast.statements[0].statement, expected)
436    }
437
438    #[test]
439    fn test_ast() {
440        assert_ast(
441            "SELECT * FROM foo.table;",
442            &CassandraStatement::Select(Select {
443                distinct: false,
444                json: false,
445                table_name: FQName {
446                    keyspace: Some(Identifier::Unquoted("foo".into())),
447                    name: Identifier::Unquoted("table".into()),
448                },
449                columns: vec![SelectElement::Star],
450                where_clause: vec![],
451                order: None,
452                limit: None,
453                filtering: false,
454            }),
455        );
456        assert_ast(
457            "DROP TABLE keyspace.table;",
458            &CassandraStatement::DropTable(CommonDrop {
459                name: FQName {
460                    keyspace: Some(Identifier::Unquoted("keyspace".into())),
461                    name: Identifier::Unquoted("table".into()),
462                },
463                if_exists: false,
464            }),
465        );
466    }
467
468    #[test]
469    fn test_select_statements() {
470        let stmts = [
471            "SELECT DISTINCT JSON * FROM table",
472            "SELECT column FROM table",
473            "SELECT column AS column2 FROM table",
474            "SELECT func(*) FROM table",
475            "SELECT column AS column2, func(*) AS func2 FROM table;",
476            "SELECT column FROM table WHERE col < 5",
477            "SELECT column FROM table WHERE col <= 'hello'",
478            "SELECT column FROM table WHERE col = 5b6962dd-3f90-4c93-8f61-eabfa4a803e2;",
479            "SELECT column FROM table WHERE col <> -5",
480            "SELECT column FROM table WHERE col >= 3.5",
481            "SELECT column FROM table WHERE col = 0XFF",
482            "SELECT column FROM table WHERE col = 0Xef",
483            "SELECT column FROM table WHERE col = true",
484            "SELECT column FROM table WHERE col = false",
485            "SELECT column FROM table WHERE col = null",
486            "SELECT column FROM table WHERE col = null AND col2 = 'jinx'",
487            "SELECT column FROM table WHERE col = $$ a code's block $$",
488            "SELECT column FROM table WHERE func(*) < 5",
489            "SELECT column FROM table WHERE func(*) <= 'hello'",
490            "SELECT column FROM table WHERE func(*) = 5b6962dd-3f90-4c93-8f61-eabfa4a803e2;",
491            "SELECT column FROM table WHERE func(*) <> -5",
492            "SELECT column FROM table WHERE func(*) >= 3.5",
493            "SELECT column FROM table WHERE func(*) = 0XFF",
494            "SELECT column FROM table WHERE func(*) = 0Xff",
495            "SELECT column FROM table WHERE func(*) = true",
496            "SELECT column FROM table WHERE func(*) = false",
497            "SELECT column FROM table WHERE func(*) = func2(*)",
498            "SELECT column FROM table WHERE col IN ( 'literal', 5, func(*), true )",
499            "SELECT column FROM table WHERE (col1, col2) IN (( 5, 'stuff'), (6, 'other'));",
500            "SELECT column FROM table WHERE (col1, col2) >= (( 5, 'stuff'), (6, 'other'))",
501            "SELECT column FROM table WHERE col1 CONTAINS 'foo'",
502            "SELECT column FROM table WHERE col1 CONTAINS KEY 'foo'",
503            "SELECT column FROM table ORDER BY col1",
504            "SELECT column FROM table ORDER BY col1 ASC",
505            "SELECT column FROM table ORDER BY col1 DESC",
506            "SELECT column FROM table LIMIT 5",
507            "SELECT column FROM table ALLOW FILTERING",
508            "SELECT column from table where col=?",
509            r#"SELECT "col""umn" from "keyspace"."table" where col='cat''s claws'"#,
510        ];
511        let expected = [
512            "SELECT DISTINCT JSON * FROM table",
513            "SELECT column FROM table",
514            "SELECT column AS column2 FROM table",
515            "SELECT func(*) FROM table",
516            "SELECT column AS column2, func(*) AS func2 FROM table",
517            "SELECT column FROM table WHERE col < 5",
518            "SELECT column FROM table WHERE col <= 'hello'",
519            "SELECT column FROM table WHERE col = 5b6962dd-3f90-4c93-8f61-eabfa4a803e2",
520            "SELECT column FROM table WHERE col <> -5",
521            "SELECT column FROM table WHERE col >= 3.5",
522            "SELECT column FROM table WHERE col = 0XFF",
523            "SELECT column FROM table WHERE col = 0Xef",
524            "SELECT column FROM table WHERE col = true",
525            "SELECT column FROM table WHERE col = false",
526            "SELECT column FROM table WHERE col = NULL",
527            "SELECT column FROM table WHERE col = NULL AND col2 = 'jinx'",
528            "SELECT column FROM table WHERE col = $$ a code's block $$",
529            "SELECT column FROM table WHERE func(*) < 5",
530            "SELECT column FROM table WHERE func(*) <= 'hello'",
531            "SELECT column FROM table WHERE func(*) = 5b6962dd-3f90-4c93-8f61-eabfa4a803e2",
532            "SELECT column FROM table WHERE func(*) <> -5",
533            "SELECT column FROM table WHERE func(*) >= 3.5",
534            "SELECT column FROM table WHERE func(*) = 0XFF",
535            "SELECT column FROM table WHERE func(*) = 0Xff",
536            "SELECT column FROM table WHERE func(*) = true",
537            "SELECT column FROM table WHERE func(*) = false",
538            "SELECT column FROM table WHERE func(*) = func2(*)",
539            "SELECT column FROM table WHERE col IN ('literal', 5, func(*), true)",
540            "SELECT column FROM table WHERE (col1, col2) IN ((5, 'stuff'), (6, 'other'))",
541            "SELECT column FROM table WHERE (col1, col2) >= ((5, 'stuff'), (6, 'other'))",
542            "SELECT column FROM table WHERE col1 CONTAINS 'foo'",
543            "SELECT column FROM table WHERE col1 CONTAINS KEY 'foo'",
544            "SELECT column FROM table ORDER BY col1 ASC",
545            "SELECT column FROM table ORDER BY col1 ASC",
546            "SELECT column FROM table ORDER BY col1 DESC",
547            "SELECT column FROM table LIMIT 5",
548            "SELECT column FROM table ALLOW FILTERING",
549            "SELECT column FROM table WHERE col = ?",
550            r#"SELECT "col""umn" FROM "keyspace"."table" WHERE col = 'cat''s claws'"#,
551        ];
552        test_parsing(&expected, &stmts);
553    }
554
555    #[test]
556    fn test_insert_statements() {
557        let stmts = [
558            "BEGIN COUNTER BATCH USING TIMESTAMP 5 INSERT INTO keyspace.table (col1, col2) VALUES ('hello', 5);",
559            "INSERT INTO keyspace.table (col1, col2) VALUES ('hello', 5) IF NOT EXISTS",
560            "INSERT INTO keyspace.table (col1, col2) VALUES ('hello', 5) USING TIMESTAMP 3",
561            "INSERT INTO table (col1, col2) JSON $$ json code $$",
562            "INSERT INTO table (col1, col2) VALUES ({ 5 : 6 }, 'foo')",
563            "INSERT INTO table (col1, col2) VALUES ({ 5, 6 }, 'foo')",
564            "INSERT INTO table (col1, col2) VALUES ([ 5, 6 ], 'foo')",
565            "INSERT INTO table (col1, col2) VALUES (( 5, 6 ), 'foo')",
566            "INSERT INTO keyspace.table (col1, col2) VALUES ('hello', ?) IF NOT EXISTS",
567    ];
568        let expected = [
569            "BEGIN COUNTER BATCH USING TIMESTAMP 5 INSERT INTO keyspace.table (col1, col2) VALUES ('hello', 5)",
570            "INSERT INTO keyspace.table (col1, col2) VALUES ('hello', 5) IF NOT EXISTS",
571            "INSERT INTO keyspace.table (col1, col2) VALUES ('hello', 5) USING TIMESTAMP 3",
572            "INSERT INTO table (col1, col2) JSON $$ json code $$",
573            "INSERT INTO table (col1, col2) VALUES ({5:6}, 'foo')",
574            "INSERT INTO table (col1, col2) VALUES ({5, 6}, 'foo')",
575            "INSERT INTO table (col1, col2) VALUES ([5, 6], 'foo')",
576            "INSERT INTO table (col1, col2) VALUES ((5, 6), 'foo')",
577            "INSERT INTO keyspace.table (col1, col2) VALUES ('hello', ?) IF NOT EXISTS",
578    ];
579        test_parsing(&expected, &stmts);
580    }
581
582    #[test]
583    fn test_delete_statements() {
584        let stmts = [
585            "BEGIN LOGGED BATCH USING TIMESTAMP 5 DELETE column [ 'hello' ] from table WHERE column2 = 'foo' IF EXISTS",
586            "BEGIN UNLOGGED BATCH DELETE column [ 6 ] from keyspace.table USING TIMESTAMP 5 WHERE column2='foo' IF column3 = 'stuff'",
587            "BEGIN BATCH DELETE column [ 'hello' ] from keyspace.table WHERE column2='foo'",
588            "DELETE from table WHERE column2='foo'",
589            "DELETE column, column3 from keyspace.table WHERE column2='foo'",
590            "DELETE column, column3 from keyspace.table WHERE column2='foo' IF column4 = 'bar'",
591            "DELETE column, column3 from keyspace.table WHERE column2=?",
592            "DELETE column, column3 from keyspace.table WHERE column2='foo' IF column4 = ?",
593        ];
594        let expected  = [
595            "BEGIN BATCH USING TIMESTAMP 5 DELETE column['hello'] FROM table WHERE column2 = 'foo' IF EXISTS",
596            "BEGIN UNLOGGED BATCH DELETE column[6] FROM keyspace.table USING TIMESTAMP 5 WHERE column2 = 'foo' IF column3 = 'stuff'",
597            "BEGIN BATCH DELETE column['hello'] FROM keyspace.table WHERE column2 = 'foo'",
598            "DELETE FROM table WHERE column2 = 'foo'",
599            "DELETE column, column3 FROM keyspace.table WHERE column2 = 'foo'",
600            "DELETE column, column3 FROM keyspace.table WHERE column2 = 'foo' IF column4 = 'bar'",
601            "DELETE column, column3 FROM keyspace.table WHERE column2 = ?",
602            "DELETE column, column3 FROM keyspace.table WHERE column2 = 'foo' IF column4 = ?",
603        ];
604        test_parsing(&expected, &stmts);
605    }
606
607    #[test]
608    fn x() {
609        let qry = "DELETE column, column3 FROM keyspace.table WHERE column2 = 'foo' IF column4 = ?";
610        let ast = CassandraAST::new(qry);
611        let stmt = &ast.statements[0];
612        let stmt_str = stmt.statement.to_string();
613        assert_eq!(qry, stmt_str);
614    }
615
616    #[test]
617    fn test_has_error() {
618        let ast = CassandraAST::new("SELECT foo from bar.baz where fu='something'");
619        assert!(!ast.has_error());
620        let ast = CassandraAST::new("Not a valid statement");
621        assert!(ast.has_error());
622    }
623
624    #[test]
625    fn test_truncate() {
626        let stmts = [
627            "TRUNCATE foo",
628            "TRUNCATE TABLE foo",
629            "TRUNCATE keyspace.foo",
630            "TRUNCATE TABLE keyspace.foo",
631        ];
632        let expected = [
633            "TRUNCATE TABLE foo",
634            "TRUNCATE TABLE foo",
635            "TRUNCATE TABLE keyspace.foo",
636            "TRUNCATE TABLE keyspace.foo",
637        ];
638        test_parsing(&expected, &stmts);
639    }
640
641    #[test]
642    fn test_use() {
643        let stmts = ["USE keyspace"];
644        let expected = ["USE keyspace"];
645        test_parsing(&expected, &stmts);
646    }
647
648    #[test]
649    fn test_drop_aggregate() {
650        let stmts = [
651            "DROP AGGREGATE IF EXISTS aggregate;",
652            "DROP AGGREGATE aggregate;",
653            "DROP AGGREGATE IF EXISTS keyspace.aggregate;",
654            "DROP AGGREGATE keyspace.aggregate;",
655        ];
656        let expected = [
657            "DROP AGGREGATE IF EXISTS aggregate",
658            "DROP AGGREGATE aggregate",
659            "DROP AGGREGATE IF EXISTS keyspace.aggregate",
660            "DROP AGGREGATE keyspace.aggregate",
661        ];
662        test_parsing(&expected, &stmts);
663    }
664
665    #[test]
666    fn test_drop_function() {
667        let stmts = [
668            "DROP FUNCTION func;",
669            "DROP FUNCTION keyspace.func;",
670            "DROP FUNCTION IF EXISTS func;",
671            "DROP FUNCTION IF EXISTS keyspace.func;",
672        ];
673        let expected = [
674            "DROP FUNCTION func",
675            "DROP FUNCTION keyspace.func",
676            "DROP FUNCTION IF EXISTS func",
677            "DROP FUNCTION IF EXISTS keyspace.func",
678        ];
679        test_parsing(&expected, &stmts);
680    }
681
682    #[test]
683    fn test_drop_index() {
684        let stmts = [
685            "DROP INDEX idx;",
686            "DROP INDEX keyspace.idx;",
687            "DROP INDEX IF EXISTS idx;",
688            "DROP INDEX IF EXISTS keyspace.idx;",
689        ];
690        let expected = [
691            "DROP INDEX idx",
692            "DROP INDEX keyspace.idx",
693            "DROP INDEX IF EXISTS idx",
694            "DROP INDEX IF EXISTS keyspace.idx",
695        ];
696        test_parsing(&expected, &stmts);
697    }
698
699    #[test]
700    fn test_drop_keyspace() {
701        let stmts = [
702            "DROP KEYSPACE keyspace",
703            "DROP KEYSPACE IF EXISTS keyspace;",
704        ];
705        let expected = ["DROP KEYSPACE keyspace", "DROP KEYSPACE IF EXISTS keyspace"];
706        test_parsing(&expected, &stmts);
707    }
708
709    #[test]
710    fn test_drop_materialized_view() {
711        let stmts = [
712            "DROP MATERIALIZED VIEW view;",
713            "DROP MATERIALIZED VIEW IF EXISTS view;",
714            "DROP MATERIALIZED VIEW keyspace.view;",
715            "DROP MATERIALIZED VIEW IF EXISTS keyspace.view;",
716        ];
717        let expected = [
718            "DROP MATERIALIZED VIEW view",
719            "DROP MATERIALIZED VIEW IF EXISTS view",
720            "DROP MATERIALIZED VIEW keyspace.view",
721            "DROP MATERIALIZED VIEW IF EXISTS keyspace.view",
722        ];
723        test_parsing(&expected, &stmts);
724    }
725
726    #[test]
727    fn test_drop_role() {
728        let stmts = ["DROP ROLE role;", "DROP ROLE if exists role;"];
729        let expected = ["DROP ROLE role", "DROP ROLE IF EXISTS role"];
730        test_parsing(&expected, &stmts);
731    }
732
733    #[test]
734    fn test_drop_table() {
735        let stmts = [
736            "DROP TABLE table;",
737            "DROP TABLE IF EXISTS table;",
738            "DROP TABLE keyspace.table;",
739            "DROP TABLE IF EXISTS keyspace.table;",
740        ];
741        let expected = [
742            "DROP TABLE table",
743            "DROP TABLE IF EXISTS table",
744            "DROP TABLE keyspace.table",
745            "DROP TABLE IF EXISTS keyspace.table",
746        ];
747        test_parsing(&expected, &stmts);
748    }
749
750    #[test]
751    fn test_drop_type() {
752        let stmts = [
753            "DROP TYPE type;",
754            "DROP TYPE IF EXISTS type;",
755            "DROP TYPE keyspace.type;",
756            "DROP TYPE IF EXISTS keyspace.type;",
757        ];
758        let expected = [
759            "DROP TYPE type",
760            "DROP TYPE IF EXISTS type",
761            "DROP TYPE keyspace.type",
762            "DROP TYPE IF EXISTS keyspace.type",
763        ];
764        test_parsing(&expected, &stmts);
765    }
766
767    #[test]
768    fn test_drop_user() {
769        let stmts = ["DROP USER user;", "DROP USER IF EXISTS user;"];
770        let expected = ["DROP USER user", "DROP USER IF EXISTS user"];
771        test_parsing(&expected, &stmts);
772    }
773
774    #[test]
775    fn test_update_statements() {
776        let stmts = [
777            "BEGIN LOGGED BATCH USING TIMESTAMP 5 UPDATE keyspace.table SET col1 = 'foo' WHERE col2=5;",
778            "UPDATE keyspace.table USING TIMESTAMP 3 SET col1 = 'foo' WHERE col2=5;",
779            "UPDATE keyspace.table SET col1 = 'foo' WHERE col2=5 IF EXISTS;",
780            "UPDATE keyspace.table SET col1 = 'foo' WHERE col2=5 IF col3=7;",
781            "UPDATE keyspace.table SET col1 = { 5 : 'hello', 'world' : 5b6962dd-3f90-4c93-8f61-eabfa4a803e2 } WHERE col2=5 IF col3=7;",
782            "UPDATE keyspace.table SET col1 = {  'hello',  5b6962dd-3f90-4c93-8f61-eabfa4a803e2 } WHERE col2=5 IF col3=7;",
783            "UPDATE keyspace.table SET col1 = [  'hello',  5b6962dd-3f90-4c93-8f61-eabfa4a803e2 ] WHERE col2=5 IF col3=7;",
784            "UPDATE keyspace.table SET col1 = col2+5 WHERE col2=5 IF col3=7;",
785            "UPDATE keyspace.table SET col1 = col2+{ 5 : 'hello', 'world' : 5b6962dd-3f90-4c93-8f61-eabfa4a803e2 } WHERE col2=5 IF col3=7;",
786            "UPDATE keyspace.table SET col1 = { 5 : 'hello', 'world' : 5b6962dd-3f90-4c93-8f61-eabfa4a803e2 } - col2 WHERE col2=5 IF col3=7;",
787            "UPDATE keyspace.table SET col1 = col2 + {  'hello',  5b6962dd-3f90-4c93-8f61-eabfa4a803e2 }  WHERE col2=5 IF col3=7;",
788            "UPDATE keyspace.table SET col1 = {  'hello',  5b6962dd-3f90-4c93-8f61-eabfa4a803e2 } - col2 WHERE col2=5 IF col3=7;",
789            "UPDATE keyspace.table SET col1 = col2+[  'hello',  5b6962dd-3f90-4c93-8f61-eabfa4a803e2 ] WHERE col2=5 IF col3=7;",
790            "UPDATE keyspace.table SET col1 = [  'hello',  5b6962dd-3f90-4c93-8f61-eabfa4a803e2 ]+col2 WHERE col2=5 IF col3=7;",
791            "UPDATE keyspace.table SET col1[5] = 'hello' WHERE col2=5 IF col3=7;",
792            "UPDATE keyspace.table USING TIMESTAMP 3 SET col1 = 'foo' WHERE col2=5;",
793            "UPDATE foo SET c = 'yo', v = 123 WHERE z = 1",
794    ];
795        let expected = [
796            "BEGIN BATCH USING TIMESTAMP 5 UPDATE keyspace.table SET col1 = 'foo' WHERE col2 = 5",
797            "UPDATE keyspace.table USING TIMESTAMP 3 SET col1 = 'foo' WHERE col2 = 5",
798            "UPDATE keyspace.table SET col1 = 'foo' WHERE col2 = 5 IF EXISTS",
799            "UPDATE keyspace.table SET col1 = 'foo' WHERE col2 = 5 IF col3 = 7",
800            "UPDATE keyspace.table SET col1 = {5:'hello', 'world':5b6962dd-3f90-4c93-8f61-eabfa4a803e2} WHERE col2 = 5 IF col3 = 7",
801            "UPDATE keyspace.table SET col1 = {'hello', 5b6962dd-3f90-4c93-8f61-eabfa4a803e2} WHERE col2 = 5 IF col3 = 7",
802            "UPDATE keyspace.table SET col1 = ['hello', 5b6962dd-3f90-4c93-8f61-eabfa4a803e2] WHERE col2 = 5 IF col3 = 7",
803            "UPDATE keyspace.table SET col1 = col2 + 5 WHERE col2 = 5 IF col3 = 7",
804            "UPDATE keyspace.table SET col1 = col2 + {5:'hello', 'world':5b6962dd-3f90-4c93-8f61-eabfa4a803e2} WHERE col2 = 5 IF col3 = 7",
805            "UPDATE keyspace.table SET col1 = {5:'hello', 'world':5b6962dd-3f90-4c93-8f61-eabfa4a803e2} - col2 WHERE col2 = 5 IF col3 = 7",
806            "UPDATE keyspace.table SET col1 = col2 + {'hello', 5b6962dd-3f90-4c93-8f61-eabfa4a803e2} WHERE col2 = 5 IF col3 = 7",
807            "UPDATE keyspace.table SET col1 = {'hello', 5b6962dd-3f90-4c93-8f61-eabfa4a803e2} - col2 WHERE col2 = 5 IF col3 = 7",
808            "UPDATE keyspace.table SET col1 = col2 + ['hello', 5b6962dd-3f90-4c93-8f61-eabfa4a803e2] WHERE col2 = 5 IF col3 = 7",
809            "UPDATE keyspace.table SET col1 = ['hello', 5b6962dd-3f90-4c93-8f61-eabfa4a803e2] + col2 WHERE col2 = 5 IF col3 = 7",
810            "UPDATE keyspace.table SET col1[5] = 'hello' WHERE col2 = 5 IF col3 = 7",
811            "UPDATE keyspace.table USING TIMESTAMP 3 SET col1 = 'foo' WHERE col2 = 5",
812            "UPDATE foo SET c = 'yo', v = 123 WHERE z = 1",
813    ];
814        test_parsing(&expected, &stmts);
815    }
816
817    #[test]
818    fn test_create_role() {
819        let stmts = [
820            "CREATE ROLE if not exists role;",
821            "CREATE ROLE role",
822            "CREATE ROLE role WITH PASSWORD = 'password'",
823            "CREATE ROLE role WITH PASSWORD = 'password' AND LOGIN=false;",
824            "CREATE ROLE role WITH SUPERUSER=true;",
825            "CREATE ROLE role WITH OPTIONS={ 'foo' : 3.14, 'bar' : 'pi' }",
826        ];
827        let expected = [
828            "CREATE ROLE IF NOT EXISTS role",
829            "CREATE ROLE role",
830            "CREATE ROLE role WITH PASSWORD = 'password'",
831            "CREATE ROLE role WITH PASSWORD = 'password' AND LOGIN = FALSE",
832            "CREATE ROLE role WITH SUPERUSER = TRUE",
833            "CREATE ROLE role WITH OPTIONS = {'foo':3.14, 'bar':'pi'}",
834        ];
835        test_parsing(&expected, &stmts);
836    }
837
838    #[test]
839    fn test_alter_role() {
840        let stmts = [
841            r#"ALTER ROLE "role""#,
842            r#"ALTER ROLE "role" WITH PASSWORD = 'password';"#,
843            r#"ALTER ROLE "role" WITH PASSWORD = 'password' AND LOGIN=false;"#,
844            r#"ALTER ROLE "role" WITH SUPERUSER=true;"#,
845            r#"ALTER ROLE "role" WITH OPTIONS={ 'foo' : 3.14, 'bar' : 'pi' }"#,
846        ];
847        let expected = [
848            r#"ALTER ROLE "role""#,
849            r#"ALTER ROLE "role" WITH PASSWORD = 'password'"#,
850            r#"ALTER ROLE "role" WITH PASSWORD = 'password' AND LOGIN = FALSE"#,
851            r#"ALTER ROLE "role" WITH SUPERUSER = TRUE"#,
852            r#"ALTER ROLE "role" WITH OPTIONS = {'foo':3.14, 'bar':'pi'}"#,
853        ];
854        test_parsing(&expected, &stmts);
855    }
856
857    #[test]
858    fn test_create_user() {
859        let stmts = [
860            "CREATE USER if not exists username WITH PASSWORD 'password';",
861            "CREATE USER username WITH PASSWORD 'password' superuser;",
862            "CREATE USER username WITH PASSWORD 'password' nosuperuser;",
863        ];
864        let expected = [
865            "CREATE USER IF NOT EXISTS username WITH PASSWORD 'password'",
866            "CREATE USER username WITH PASSWORD 'password' SUPERUSER",
867            "CREATE USER username WITH PASSWORD 'password' NOSUPERUSER",
868        ];
869        test_parsing(&expected, &stmts);
870    }
871    #[test]
872    fn test_alter_user() {
873        let stmts = [
874            "ALTER USER username WITH PASSWORD 'password';",
875            "ALTER USER username WITH PASSWORD 'password' superuser;",
876            "ALTER USER username WITH PASSWORD 'password' nosuperuser;",
877        ];
878        let expected = [
879            "ALTER USER username WITH PASSWORD 'password'",
880            "ALTER USER username WITH PASSWORD 'password' SUPERUSER",
881            "ALTER USER username WITH PASSWORD 'password' NOSUPERUSER",
882        ];
883        test_parsing(&expected, &stmts);
884    }
885
886    #[test]
887    fn test_create_keyspace() {
888        let stmts = [
889        "CREATE KEYSPACE keyspace WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 1  };",
890        "CREATE KEYSPACE keyspace WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 1  } AND DURABLE_WRITES = false;",
891        "CREATE KEYSPACE if not exists keyspace WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 1  };",
892    ];
893        let expected = [
894        "CREATE KEYSPACE keyspace WITH REPLICATION = {'class':'SimpleStrategy', 'replication_factor':1}",
895        "CREATE KEYSPACE keyspace WITH REPLICATION = {'class':'SimpleStrategy', 'replication_factor':1} AND DURABLE_WRITES = FALSE",
896        "CREATE KEYSPACE IF NOT EXISTS keyspace WITH REPLICATION = {'class':'SimpleStrategy', 'replication_factor':1}",
897    ];
898        test_parsing(&expected, &stmts);
899    }
900    #[test]
901    fn test_alter_keyspace() {
902        let stmts = [
903            "ALTER KEYSPACE keyspace WITH REPLICATION = { 'foo' : 'bar', 'baz' : 5};",
904            "ALTER KEYSPACE keyspace WITH REPLICATION = { 'foo' : 5 } AND DURABLE_WRITES = true;",
905        ];
906        let expected = [
907            "ALTER KEYSPACE keyspace WITH REPLICATION = {'foo':'bar', 'baz':5}",
908            "ALTER KEYSPACE keyspace WITH REPLICATION = {'foo':5} AND DURABLE_WRITES = TRUE",
909        ];
910        test_parsing(&expected, &stmts);
911    }
912
913    #[test]
914    fn test_grant() {
915        let stmts = [
916            r#"GRANT ALL ON "keyspace".table TO role;"#,
917            r#"GRANT ALL PERMISSIONS ON "keyspace".table TO role;"#,
918            r#"GRANT ALTER ON "keyspace".table TO role;"#,
919            r#"GRANT AUTHORIZE ON "keyspace".table TO role;"#,
920            r#"GRANT DESCRIBE ON "keyspace".table TO role;"#,
921            r#"GRANT EXECUTE ON "keyspace".table TO role;"#,
922            r#"GRANT CREATE ON "keyspace".table TO role;"#,
923            r#"GRANT DROP ON "keyspace".table TO role;"#,
924            r#"GRANT MODIFY ON "keyspace".table TO role;"#,
925            r#"GRANT SELECT ON "keyspace".table TO role;"#,
926            "GRANT ALL ON ALL FUNCTIONS TO role;",
927            "GRANT ALL ON ALL FUNCTIONS IN KEYSPACE keyspace TO role;",
928            "GRANT ALL ON ALL KEYSPACES TO role;",
929            "GRANT ALL ON ALL ROLES TO role;",
930            r#"GRANT ALL ON FUNCTION "keyspace".function TO role;"#,
931            r#"GRANT ALL ON FUNCTION "function" TO role;"#,
932            r#"GRANT ALL ON KEYSPACE "keyspace" TO role;"#,
933            r#"GRANT ALL ON ROLE "role" TO role;"#,
934            r#"GRANT ALL ON TABLE "keyspace".table TO role;"#,
935            r#"GRANT ALL ON TABLE "table" TO role;"#,
936            r#"GRANT ALL ON "table" TO role;"#,
937        ];
938        let expected = [
939            r#"GRANT ALL PERMISSIONS ON TABLE "keyspace".table TO role"#,
940            r#"GRANT ALL PERMISSIONS ON TABLE "keyspace".table TO role"#,
941            r#"GRANT ALTER ON TABLE "keyspace".table TO role"#,
942            r#"GRANT AUTHORIZE ON TABLE "keyspace".table TO role"#,
943            r#"GRANT DESCRIBE ON TABLE "keyspace".table TO role"#,
944            r#"GRANT EXECUTE ON TABLE "keyspace".table TO role"#,
945            r#"GRANT CREATE ON TABLE "keyspace".table TO role"#,
946            r#"GRANT DROP ON TABLE "keyspace".table TO role"#,
947            r#"GRANT MODIFY ON TABLE "keyspace".table TO role"#,
948            r#"GRANT SELECT ON TABLE "keyspace".table TO role"#,
949            "GRANT ALL PERMISSIONS ON ALL FUNCTIONS TO role",
950            "GRANT ALL PERMISSIONS ON ALL FUNCTIONS IN KEYSPACE keyspace TO role",
951            "GRANT ALL PERMISSIONS ON ALL KEYSPACES TO role",
952            "GRANT ALL PERMISSIONS ON ALL ROLES TO role",
953            r#"GRANT ALL PERMISSIONS ON FUNCTION "keyspace".function TO role"#,
954            r#"GRANT ALL PERMISSIONS ON FUNCTION "function" TO role"#,
955            r#"GRANT ALL PERMISSIONS ON KEYSPACE "keyspace" TO role"#,
956            r#"GRANT ALL PERMISSIONS ON ROLE "role" TO role"#,
957            r#"GRANT ALL PERMISSIONS ON TABLE "keyspace".table TO role"#,
958            r#"GRANT ALL PERMISSIONS ON TABLE "table" TO role"#,
959            r#"GRANT ALL PERMISSIONS ON TABLE "table" TO role"#,
960        ];
961        test_parsing(&expected, &stmts);
962    }
963
964    #[test]
965    fn test_revoke() {
966        let stmts = [
967            r#"REVOKE ALL ON TABLE "keyspace".table FROM role;"#,
968            r#"REVOKE ALL PERMISSIONS ON  TABLE"keyspace".table FROM role;"#,
969            r#"REVOKE ALTER ON TABLE "keyspace".table FROM role;"#,
970            r#"REVOKE AUTHORIZE ON TABLE "keyspace".table FROM role;"#,
971            r#"REVOKE DESCRIBE ON TABLE "keyspace".table FROM role;"#,
972            r#"REVOKE EXECUTE ON TABLE "keyspace".table FROM role;"#,
973            r#"REVOKE CREATE ON TABLE "keyspace".table FROM role;"#,
974            r#"REVOKE DROP ON TABLE "keyspace".table FROM role;"#,
975            r#"REVOKE MODIFY ON TABLE "keyspace".table FROM role;"#,
976            r#"REVOKE SELECT ON TABLE "keyspace".table FROM role;"#,
977            "REVOKE ALL ON ALL FUNCTIONS FROM role;",
978            "REVOKE ALL ON ALL FUNCTIONS IN KEYSPACE keyspace FROM role;",
979            "REVOKE ALL ON ALL KEYSPACES FROM role;",
980            "REVOKE ALL ON ALL ROLES FROM role;",
981            r#"REVOKE ALL ON FUNCTION "keyspace".function FROM role;"#,
982            r#"REVOKE ALL ON FUNCTION "function" FROM role;"#,
983            r#"REVOKE ALL ON KEYSPACE "keyspace" FROM role;"#,
984            r#"REVOKE ALL ON ROLE "role" FROM role;"#,
985            r#"REVOKE ALL ON TABLE "keyspace".table FROM role;"#,
986            r#"REVOKE ALL ON TABLE "table" FROM role;"#,
987            r#"REVOKE ALL ON  TABLE"table" FROM role;"#,
988        ];
989        let expected = [
990            r#"REVOKE ALL PERMISSIONS ON TABLE "keyspace".table FROM role"#,
991            r#"REVOKE ALL PERMISSIONS ON TABLE "keyspace".table FROM role"#,
992            r#"REVOKE ALTER ON TABLE "keyspace".table FROM role"#,
993            r#"REVOKE AUTHORIZE ON TABLE "keyspace".table FROM role"#,
994            r#"REVOKE DESCRIBE ON TABLE "keyspace".table FROM role"#,
995            r#"REVOKE EXECUTE ON TABLE "keyspace".table FROM role"#,
996            r#"REVOKE CREATE ON TABLE "keyspace".table FROM role"#,
997            r#"REVOKE DROP ON TABLE "keyspace".table FROM role"#,
998            r#"REVOKE MODIFY ON TABLE "keyspace".table FROM role"#,
999            r#"REVOKE SELECT ON TABLE "keyspace".table FROM role"#,
1000            "REVOKE ALL PERMISSIONS ON ALL FUNCTIONS FROM role",
1001            "REVOKE ALL PERMISSIONS ON ALL FUNCTIONS IN KEYSPACE keyspace FROM role",
1002            "REVOKE ALL PERMISSIONS ON ALL KEYSPACES FROM role",
1003            "REVOKE ALL PERMISSIONS ON ALL ROLES FROM role",
1004            r#"REVOKE ALL PERMISSIONS ON FUNCTION "keyspace".function FROM role"#,
1005            r#"REVOKE ALL PERMISSIONS ON FUNCTION "function" FROM role"#,
1006            r#"REVOKE ALL PERMISSIONS ON KEYSPACE "keyspace" FROM role"#,
1007            r#"REVOKE ALL PERMISSIONS ON ROLE "role" FROM role"#,
1008            r#"REVOKE ALL PERMISSIONS ON TABLE "keyspace".table FROM role"#,
1009            r#"REVOKE ALL PERMISSIONS ON TABLE "table" FROM role"#,
1010            r#"REVOKE ALL PERMISSIONS ON TABLE "table" FROM role"#,
1011        ];
1012        test_parsing(&expected, &stmts);
1013    }
1014
1015    #[test]
1016    fn test_list_permissions() {
1017        let stmts = [
1018            "LIST ALL",
1019            r#"LIST ALL ON TABLE "keyspace".table OF role;"#,
1020            r#"LIST ALL PERMISSIONS ON  TABLE "keyspace".table OF role;"#,
1021            r#"LIST ALTER ON TABLE "keyspace".table OF role;"#,
1022            r#"LIST AUTHORIZE ON TABLE "keyspace".table OF role;"#,
1023            r#"LIST DESCRIBE ON TABLE "keyspace".table OF role;"#,
1024            r#"LIST EXECUTE ON TABLE "keyspace".table OF role;"#,
1025            r#"LIST CREATE ON TABLE "keyspace".table OF role;"#,
1026            r#"LIST DROP ON TABLE "keyspace".table OF role;"#,
1027            r#"LIST MODIFY ON TABLE "keyspace".table OF role;"#,
1028            r#"LIST SELECT ON TABLE "keyspace".table OF role;"#,
1029            "LIST ALL ON ALL FUNCTIONS OF role;",
1030            "LIST ALL ON ALL FUNCTIONS IN KEYSPACE keyspace OF role;",
1031            "LIST ALL ON ALL KEYSPACES OF role;",
1032            "LIST ALL ON ALL ROLES OF role;",
1033            r#"LIST ALL ON FUNCTION "keyspace".function OF role;"#,
1034            r#"LIST ALL ON FUNCTION "function" OF role;"#,
1035            r#"LIST ALL ON KEYSPACE "keyspace" OF role;"#,
1036            r#"LIST ALL ON ROLE "role" OF role;"#,
1037            r#"LIST ALL ON TABLE "keyspace".table OF role;"#,
1038            r#"LIST ALL ON TABLE "table" OF role;"#,
1039            r#"LIST ALL ON  TABLE "table" OF role;"#,
1040        ];
1041        let expected = [
1042            "LIST ALL PERMISSIONS",
1043            r#"LIST ALL PERMISSIONS ON TABLE "keyspace".table OF role"#,
1044            r#"LIST ALL PERMISSIONS ON TABLE "keyspace".table OF role"#,
1045            r#"LIST ALTER ON TABLE "keyspace".table OF role"#,
1046            r#"LIST AUTHORIZE ON TABLE "keyspace".table OF role"#,
1047            r#"LIST DESCRIBE ON TABLE "keyspace".table OF role"#,
1048            r#"LIST EXECUTE ON TABLE "keyspace".table OF role"#,
1049            r#"LIST CREATE ON TABLE "keyspace".table OF role"#,
1050            r#"LIST DROP ON TABLE "keyspace".table OF role"#,
1051            r#"LIST MODIFY ON TABLE "keyspace".table OF role"#,
1052            r#"LIST SELECT ON TABLE "keyspace".table OF role"#,
1053            "LIST ALL PERMISSIONS ON ALL FUNCTIONS OF role",
1054            "LIST ALL PERMISSIONS ON ALL FUNCTIONS IN KEYSPACE keyspace OF role",
1055            "LIST ALL PERMISSIONS ON ALL KEYSPACES OF role",
1056            "LIST ALL PERMISSIONS ON ALL ROLES OF role",
1057            r#"LIST ALL PERMISSIONS ON FUNCTION "keyspace".function OF role"#,
1058            r#"LIST ALL PERMISSIONS ON FUNCTION "function" OF role"#,
1059            r#"LIST ALL PERMISSIONS ON KEYSPACE "keyspace" OF role"#,
1060            r#"LIST ALL PERMISSIONS ON ROLE "role" OF role"#,
1061            r#"LIST ALL PERMISSIONS ON TABLE "keyspace".table OF role"#,
1062            r#"LIST ALL PERMISSIONS ON TABLE "table" OF role"#,
1063            r#"LIST ALL PERMISSIONS ON TABLE "table" OF role"#,
1064        ];
1065        test_parsing(&expected, &stmts);
1066    }
1067
1068    #[test]
1069    fn test_list_roles() {
1070        let stmts = [
1071            "LIST ROLES;",
1072            "LIST ROLES NORECURSIVE;",
1073            "LIST ROLES OF role_name;",
1074            "LIST ROLES OF role_name NORECURSIVE",
1075        ];
1076        let expected = [
1077            "LIST ROLES",
1078            "LIST ROLES NORECURSIVE",
1079            "LIST ROLES OF role_name",
1080            "LIST ROLES OF role_name NORECURSIVE",
1081        ];
1082        test_parsing(&expected, &stmts);
1083    }
1084
1085    #[test]
1086    fn test_apply_batch() {
1087        let stmts = ["Apply Batch;"];
1088        let expected = ["APPLY BATCH"];
1089        test_parsing(&expected, &stmts);
1090    }
1091
1092    #[test]
1093    fn test_create_index() {
1094        let stmts = [
1095            "CREATE INDEX index_name ON keyspace.table (column);",
1096            "CREATE INDEX index_name ON table (column);",
1097            "CREATE INDEX ON table (column);",
1098            "CREATE INDEX ON table (keys ( key ) );",
1099            "CREATE INDEX ON table (entries ( spec ) );",
1100            "CREATE INDEX ON table (full ( spec ) );",
1101        ];
1102        let expected = [
1103            "CREATE INDEX index_name ON keyspace.table( column )",
1104            "CREATE INDEX index_name ON table( column )",
1105            "CREATE INDEX ON table( column )",
1106            "CREATE INDEX ON table( KEYS( key ) )",
1107            "CREATE INDEX ON table( ENTRIES( spec ) )",
1108            "CREATE INDEX ON table( FULL( spec ) )",
1109        ];
1110        test_parsing(&expected, &stmts);
1111    }
1112
1113    #[test]
1114    fn test_create_table() {
1115        let stmts = [
1116        "CREATE TABLE IF NOT EXISTS keyspace.table (col1 text, col2 int, col3 FROZEN<col4>, PRIMARY KEY (col1, col2) );",
1117        "CREATE TABLE table (col1 text, col2 int, col3 FROZEN<col4>, PRIMARY KEY (col1, col2) ) WITH option = 'option' AND option2 = 3.5;",
1118        "CREATE TABLE table (col1 text, col2 int, col3 FROZEN<col4>, PRIMARY KEY (col1, col2) ) WITH caching = { 'keys' : 'ALL', 'rows_per_partition' : '100' } AND comment = 'Based on table';",
1119        "CREATE TABLE keyspace.table (col1 text, col2 int, col3 FROZEN<col4>, PRIMARY KEY (col1, col2) ) WITH CLUSTERING ORDER BY ( col2 )",
1120        "CREATE TABLE keyspace.table (col1 text, col2 int, col3 FROZEN<col4>, PRIMARY KEY (col1, col2) ) WITH option = 'option' AND option2 = 3.5 AND  CLUSTERING ORDER BY ( col2 )",
1121        "CREATE TABLE keyspace.table (col1 text, col2 int, PRIMARY KEY (col1) ) WITH option1='value' AND CLUSTERING ORDER BY ( col2 ) AND ID='someId' AND COMPACT STORAGE",
1122    ];
1123        let expected = [
1124        "CREATE TABLE IF NOT EXISTS keyspace.table (col1 TEXT, col2 INT, col3 FROZEN<col4>, PRIMARY KEY (col1, col2))",
1125        "CREATE TABLE table (col1 TEXT, col2 INT, col3 FROZEN<col4>, PRIMARY KEY (col1, col2)) WITH option = 'option' AND option2 = 3.5",
1126        "CREATE TABLE table (col1 TEXT, col2 INT, col3 FROZEN<col4>, PRIMARY KEY (col1, col2)) WITH caching = {'keys':'ALL', 'rows_per_partition':'100'} AND comment = 'Based on table'",
1127        "CREATE TABLE keyspace.table (col1 TEXT, col2 INT, col3 FROZEN<col4>, PRIMARY KEY (col1, col2)) WITH CLUSTERING ORDER BY (col2 ASC)",
1128        "CREATE TABLE keyspace.table (col1 TEXT, col2 INT, col3 FROZEN<col4>, PRIMARY KEY (col1, col2)) WITH option = 'option' AND option2 = 3.5 AND CLUSTERING ORDER BY (col2 ASC)",
1129        "CREATE TABLE keyspace.table (col1 TEXT, col2 INT, PRIMARY KEY (col1)) WITH option1 = 'value' AND CLUSTERING ORDER BY (col2 ASC) AND ID = 'someId' AND COMPACT STORAGE",
1130    ];
1131        test_parsing(&expected, &stmts);
1132    }
1133
1134    #[test]
1135    fn test_alter_table() {
1136        let stmts = [
1137            "ALTER TABLE keyspace.table ADD column1 UUID, column2 BIGINT;",
1138            "ALTER TABLE keyspace.table DROP column1, column2;",
1139            "ALTER TABLE keyspace.table DROP COMPACT STORAGE;",
1140            "ALTER TABLE keyspace.table RENAME column1 TO column2;",
1141            "ALTER TABLE keyspace.table WITH option1 = 'option' AND option2 = 3.5;",
1142        ];
1143        let expected = [
1144            "ALTER TABLE keyspace.table ADD column1 UUID, column2 BIGINT",
1145            "ALTER TABLE keyspace.table DROP column1, column2",
1146            "ALTER TABLE keyspace.table DROP COMPACT STORAGE",
1147            "ALTER TABLE keyspace.table RENAME column1 TO column2",
1148            "ALTER TABLE keyspace.table WITH option1 = 'option' AND option2 = 3.5",
1149        ];
1150        test_parsing(&expected, &stmts);
1151    }
1152
1153    #[test]
1154    fn test_drop_trigger() {
1155        let stmts = [
1156            "DROP TRIGGER trigger_name ON table_name;",
1157            "DROP TRIGGER trigger_name ON ks.table_name;",
1158            "DROP TRIGGER keyspace.trigger_name ON table_name;",
1159            "DROP TRIGGER keyspace.trigger_name ON ks.table_name;",
1160            "DROP TRIGGER if exists trigger_name ON table_name;",
1161            "DROP TRIGGER if exists trigger_name ON ks.table_name;",
1162            "DROP TRIGGER if exists keyspace.trigger_name ON table_name;",
1163            "DROP TRIGGER if exists keyspace.trigger_name ON ks.table_name;",
1164        ];
1165        let expected = [
1166            "DROP TRIGGER trigger_name ON table_name",
1167            "DROP TRIGGER trigger_name ON ks.table_name",
1168            "DROP TRIGGER keyspace.trigger_name ON table_name",
1169            "DROP TRIGGER keyspace.trigger_name ON ks.table_name",
1170            "DROP TRIGGER IF EXISTS trigger_name ON table_name",
1171            "DROP TRIGGER IF EXISTS trigger_name ON ks.table_name",
1172            "DROP TRIGGER IF EXISTS keyspace.trigger_name ON table_name",
1173            "DROP TRIGGER IF EXISTS keyspace.trigger_name ON ks.table_name",
1174        ];
1175        test_parsing(&expected, &stmts);
1176    }
1177
1178    #[test]
1179    fn test_create_trigger() {
1180        let stmts = [
1181            "CREATE TRIGGER trigger_name USING 'trigger_class'",
1182            "CREATE TRIGGER if not exists trigger_name USING 'trigger_class'",
1183            "CREATE TRIGGER if not exists keyspace.trigger_name USING 'trigger_class'",
1184        ];
1185        let expected = [
1186            "CREATE TRIGGER trigger_name USING 'trigger_class'",
1187            "CREATE TRIGGER IF NOT EXISTS trigger_name USING 'trigger_class'",
1188            "CREATE TRIGGER IF NOT EXISTS keyspace.trigger_name USING 'trigger_class'",
1189        ];
1190        test_parsing(&expected, &stmts);
1191    }
1192
1193    #[test]
1194    fn test_create_type() {
1195        let stmts = [
1196            r#"CREATE TYPE if not exists keyspace.type ( "col1" TIMESTAMP);"#,
1197            "CREATE TYPE if not exists keyspace.type ( col1 SET);",
1198            "CREATE TYPE keyspace.type ( col1 ASCII);",
1199            "CREATE TYPE keyspace.type ( col1 BIGINT);",
1200            "CREATE TYPE keyspace.type ( col1 BLOB);",
1201            "CREATE TYPE keyspace.type ( col1 BOOLEAN);",
1202            "CREATE TYPE keyspace.type ( col1 COUNTER);",
1203            "CREATE TYPE keyspace.type ( col1 DATE);",
1204            "CREATE TYPE keyspace.type ( col1 DECIMAL);",
1205            "CREATE TYPE keyspace.type ( col1 DOUBLE);",
1206            "CREATE TYPE keyspace.type ( col1 FLOAT);",
1207            "CREATE TYPE keyspace.type ( col1 FROZEN);",
1208            "CREATE TYPE keyspace.type ( col1 INET);",
1209            "CREATE TYPE keyspace.type ( col1 INT);",
1210            "CREATE TYPE keyspace.type ( col1 LIST);",
1211            "CREATE TYPE keyspace.type ( col1 MAP);",
1212            "CREATE TYPE keyspace.type ( col1 SMALLINT);",
1213            "CREATE TYPE keyspace.type ( col1 TEXT);",
1214            "CREATE TYPE type ( col1 TIME);",
1215            "CREATE TYPE type ( col1 TIMEUUID);",
1216            "CREATE TYPE type ( col1 TINYINT);",
1217            "CREATE TYPE type ( col1 TUPLE);",
1218            "CREATE TYPE type ( col1 VARCHAR);",
1219            "CREATE TYPE type ( col1 VARINT);",
1220            "CREATE TYPE type ( col1 TIMESTAMP);",
1221            "CREATE TYPE type ( col1 UUID);",
1222            r#"CREATE TYPE type ( col1 "foo");"#,
1223            r#"CREATE TYPE if not exists keyspace.type ( col1 "foo" < "subcol1", TIMESTAMP, BLOB > );"#,
1224            "CREATE TYPE type ( col1 UUID, Col2 int);",
1225        ];
1226        let expected = [
1227            r#"CREATE TYPE IF NOT EXISTS keyspace.type ("col1" TIMESTAMP)"#,
1228            "CREATE TYPE IF NOT EXISTS keyspace.type (col1 SET)",
1229            "CREATE TYPE keyspace.type (col1 ASCII)",
1230            "CREATE TYPE keyspace.type (col1 BIGINT)",
1231            "CREATE TYPE keyspace.type (col1 BLOB)",
1232            "CREATE TYPE keyspace.type (col1 BOOLEAN)",
1233            "CREATE TYPE keyspace.type (col1 COUNTER)",
1234            "CREATE TYPE keyspace.type (col1 DATE)",
1235            "CREATE TYPE keyspace.type (col1 DECIMAL)",
1236            "CREATE TYPE keyspace.type (col1 DOUBLE)",
1237            "CREATE TYPE keyspace.type (col1 FLOAT)",
1238            "CREATE TYPE keyspace.type (col1 FROZEN)",
1239            "CREATE TYPE keyspace.type (col1 INET)",
1240            "CREATE TYPE keyspace.type (col1 INT)",
1241            "CREATE TYPE keyspace.type (col1 LIST)",
1242            "CREATE TYPE keyspace.type (col1 MAP)",
1243            "CREATE TYPE keyspace.type (col1 SMALLINT)",
1244            "CREATE TYPE keyspace.type (col1 TEXT)",
1245            "CREATE TYPE type (col1 TIME)",
1246            "CREATE TYPE type (col1 TIMEUUID)",
1247            "CREATE TYPE type (col1 TINYINT)",
1248            "CREATE TYPE type (col1 TUPLE)",
1249            "CREATE TYPE type (col1 VARCHAR)",
1250            "CREATE TYPE type (col1 VARINT)",
1251            "CREATE TYPE type (col1 TIMESTAMP)",
1252            "CREATE TYPE type (col1 UUID)",
1253            r#"CREATE TYPE type (col1 "foo")"#,
1254            r#"CREATE TYPE IF NOT EXISTS keyspace.type (col1 "foo"<"subcol1", TIMESTAMP, BLOB>)"#,
1255            "CREATE TYPE type (col1 UUID, Col2 INT)",
1256        ];
1257        test_parsing(&expected, &stmts);
1258    }
1259
1260    #[test]
1261    fn test_alter_type() {
1262        let stmts = [
1263            "ALTER TYPE keyspace.type ALTER column TYPE UUID;",
1264            "ALTER TYPE keyspace.type ADD column2 UUID, column3 TIMESTAMP;",
1265            "ALTER TYPE keyspace.type RENAME column1 TO column2;",
1266            "ALTER TYPE type ALTER column TYPE UUID;",
1267            "ALTER TYPE type ADD column2 UUID, column3 TIMESTAMP;",
1268            "ALTER TYPE type RENAME column1 TO column2;",
1269            "ALTER TYPE type RENAME column1 TO column2 AND col3 TO col4;",
1270        ];
1271        let expected = [
1272            "ALTER TYPE keyspace.type ALTER column TYPE UUID",
1273            "ALTER TYPE keyspace.type ADD column2 UUID, column3 TIMESTAMP",
1274            "ALTER TYPE keyspace.type RENAME column1 TO column2",
1275            "ALTER TYPE type ALTER column TYPE UUID",
1276            "ALTER TYPE type ADD column2 UUID, column3 TIMESTAMP",
1277            "ALTER TYPE type RENAME column1 TO column2",
1278            "ALTER TYPE type RENAME column1 TO column2 AND col3 TO col4",
1279        ];
1280        test_parsing(&expected, &stmts);
1281    }
1282    #[test]
1283    fn test_create_function() {
1284        let stmts = [
1285            "CREATE OR REPLACE FUNCTION keyspace.func ( param1 int , param2 text) CALLED ON NULL INPUT RETURNS INT LANGUAGE javascript AS $$ return 5; $$;",
1286        "CREATE OR REPLACE FUNCTION keyspace.func ( param1 int , param2 text) RETURNS NULL ON NULL INPUT RETURNS text LANGUAGE javascript AS $$ return 'hello'; $$;",
1287        "CREATE FUNCTION IF NOT EXISTS func ( param1 int , param2 text) CALLED ON NULL INPUT RETURNS INT LANGUAGE javascript AS $$ return 5; $$;",
1288        ];
1289        let expected = [
1290            "CREATE OR REPLACE FUNCTION keyspace.func (param1 INT, param2 TEXT) CALLED ON NULL INPUT RETURNS INT LANGUAGE javascript AS $$ return 5; $$",
1291            "CREATE OR REPLACE FUNCTION keyspace.func (param1 INT, param2 TEXT) RETURNS NULL ON NULL INPUT RETURNS TEXT LANGUAGE javascript AS $$ return 'hello'; $$",
1292            "CREATE FUNCTION IF NOT EXISTS func (param1 INT, param2 TEXT) CALLED ON NULL INPUT RETURNS INT LANGUAGE javascript AS $$ return 5; $$",
1293        ];
1294        test_parsing(&expected, &stmts);
1295    }
1296
1297    #[test]
1298    fn test_create_aggregate() {
1299        let stmts = [
1300            "CREATE OR REPLACE AGGREGATE keyspace.aggregate ( UUID ) SFUNC sfunc STYPE TIMESTAMP FINALFUNC finalFunc INITCOND 5;",
1301        "CREATE AGGREGATE IF NOT EXISTS keyspace.aggregate  ( UUID ) SFUNC sfunc STYPE TIMESTAMP FINALFUNC finalFunc INITCOND 5;",
1302        "CREATE AGGREGATE keyspace.aggregate  ( ASCII ) SFUNC sfunc STYPE BIGINT FINALFUNC finalFunc INITCOND ( 5, 'text', 6.3);",
1303        "CREATE AGGREGATE keyspace.aggregate  ( ASCII ) SFUNC sfunc STYPE BIGINT FINALFUNC finalFunc INITCOND (( 5, 'text', 6.3),(4,'foo',3.14));",
1304        "CREATE AGGREGATE keyspace.aggregate  ( ASCII ) SFUNC sfunc STYPE BIGINT FINALFUNC finalFunc INITCOND ( key : (5,7,9));",
1305            "CREATE AGGREGATE keyspace.aggregate  ( ASCII ) SFUNC sfunc STYPE BIGINT FINALFUNC finalFunc INITCOND ( key1 : (5,7,9), key2 : (2,4,6));",
1306        ];
1307        let expected = [
1308            "CREATE OR REPLACE AGGREGATE keyspace.aggregate (UUID) SFUNC sfunc STYPE TIMESTAMP FINALFUNC finalFunc INITCOND 5",
1309            "CREATE AGGREGATE IF NOT EXISTS keyspace.aggregate (UUID) SFUNC sfunc STYPE TIMESTAMP FINALFUNC finalFunc INITCOND 5",
1310            "CREATE AGGREGATE keyspace.aggregate (ASCII) SFUNC sfunc STYPE BIGINT FINALFUNC finalFunc INITCOND (5, 'text', 6.3)",
1311            "CREATE AGGREGATE keyspace.aggregate (ASCII) SFUNC sfunc STYPE BIGINT FINALFUNC finalFunc INITCOND ((5, 'text', 6.3), (4, 'foo', 3.14))",
1312            "CREATE AGGREGATE keyspace.aggregate (ASCII) SFUNC sfunc STYPE BIGINT FINALFUNC finalFunc INITCOND (key:(5, 7, 9))",
1313            "CREATE AGGREGATE keyspace.aggregate (ASCII) SFUNC sfunc STYPE BIGINT FINALFUNC finalFunc INITCOND (key1:(5, 7, 9), key2:(2, 4, 6))",
1314        ];
1315        test_parsing(&expected, &stmts);
1316    }
1317
1318    #[test]
1319    fn test_create_materialized_view() {
1320        let stmts = [
1321            "CREATE MATERIALIZED VIEW view AS SELECT col1, col2 FROM tbl WHERE col3 IS NOT NULL PRIMARY KEY (col1);",
1322            "CREATE MATERIALIZED VIEW IF NOT EXISTS keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL AND col3 IS NOT NULL PRIMARY KEY (col1)",
1323        "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL AND col3 IS NOT NULL PRIMARY KEY (col1) WITH option1 = 'option';",
1324        "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL AND col3 IS NOT NULL PRIMARY KEY (col1) WITH option1 = 'option' AND CLUSTERING ORDER BY (col2 DESC);",
1325        "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL AND col4 IS NOT NULL AND col5 <> 'foo' PRIMARY KEY (col1) WITH option1 = 'option' AND option2 = 3.5 AND CLUSTERING ORDER BY (col2 DESC);",
1326        "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL AND col4 IS NOT NULL AND col5 <> 'foo' PRIMARY KEY (col1) WITH CLUSTERING ORDER BY (col2 DESC);",
1327        "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL AND col4 IS NOT NULL AND col5 <> 'foo' PRIMARY KEY (col1) WITH option1 = 'option' AND option2 = 3.5;",
1328        "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL AND col4 IS NOT NULL AND col5 <> 'foo' PRIMARY KEY (col1);",
1329        "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL PRIMARY KEY (col1,col2)",
1330        "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2, col3  FROM keyspace.table  WHERE col1 IS NOT NULL AND col4 IS NOT NULL PRIMARY KEY (col1, col4) WITH caching = { 'keys' : 'ALL', 'rows_per_partition' : '100' } AND comment = 'Based on table' ;",
1331        ];
1332        let expected = [
1333            "CREATE MATERIALIZED VIEW view AS SELECT col1, col2 FROM tbl WHERE col3 IS NOT NULL PRIMARY KEY (col1)",
1334            "CREATE MATERIALIZED VIEW IF NOT EXISTS keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL AND col3 IS NOT NULL PRIMARY KEY (col1)",
1335            "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL AND col3 IS NOT NULL PRIMARY KEY (col1) WITH option1 = 'option'",
1336            "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL AND col3 IS NOT NULL PRIMARY KEY (col1) WITH option1 = 'option' AND CLUSTERING ORDER BY (col2 DESC)",
1337            "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL AND col4 IS NOT NULL AND col5 <> 'foo' PRIMARY KEY (col1) WITH option1 = 'option' AND option2 = 3.5 AND CLUSTERING ORDER BY (col2 DESC)",
1338        "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL AND col4 IS NOT NULL AND col5 <> 'foo' PRIMARY KEY (col1) WITH CLUSTERING ORDER BY (col2 DESC)",
1339        "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL AND col4 IS NOT NULL AND col5 <> 'foo' PRIMARY KEY (col1) WITH option1 = 'option' AND option2 = 3.5",
1340        "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL AND col4 IS NOT NULL AND col5 <> 'foo' PRIMARY KEY (col1)",
1341        "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2 FROM ks_target.tbl_target WHERE col3 IS NOT NULL PRIMARY KEY (col1, col2)",
1342        "CREATE MATERIALIZED VIEW keyspace.view AS SELECT col1, col2, col3 FROM keyspace.table WHERE col1 IS NOT NULL AND col4 IS NOT NULL PRIMARY KEY (col1, col4) WITH caching = {'keys':'ALL', 'rows_per_partition':'100'} AND comment = 'Based on table'",
1343        ];
1344        test_parsing(&expected, &stmts);
1345    }
1346
1347    #[test]
1348    fn test_alter_materialized_view() {
1349        let stmts = [
1350            r#"ALTER MATERIALIZED VIEW "key""space".mview;"#,
1351            r#"ALTER MATERIALIZED VIEW "keyspace".mview;"#,
1352            "ALTER MATERIALIZED VIEW mview;",
1353            "ALTER MATERIALIZED VIEW keyspace.mview WITH option1 = 'option' AND option2 = 3.5;",
1354        ];
1355        let expected = [
1356            r#"ALTER MATERIALIZED VIEW "key""space".mview"#,
1357            r#"ALTER MATERIALIZED VIEW "keyspace".mview"#,
1358            "ALTER MATERIALIZED VIEW mview",
1359            "ALTER MATERIALIZED VIEW keyspace.mview WITH option1 = 'option' AND option2 = 3.5",
1360        ];
1361        test_parsing(&expected, &stmts);
1362    }
1363}
cql3_parser/cassandra_statement.rs

cql3_parser/
cassandra_statement.rs
