refactor

Author: xring

src/dds/create_table.rs

@@ -12,13 +12,13 @@ use nom::IResult;
 
 use base::column::{Column, ColumnSpecification};
 use base::table::Table;
-use common::{KeyPart, sql_identifier, statement_terminator, ws_sep_comma};
 use common::index_option::IndexOption;
 use common::table_option::TableOption;
 use common::{
     opt_index_name, CheckConstraintDefinition, FulltextOrSpatialType, IndexOrKeyType, IndexType,
     ReferenceDefinition,
 };
+use common::{sql_identifier, statement_terminator, ws_sep_comma, KeyPart};
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct CreateTableStatement {
@@ -178,15 +178,17 @@ fn create_as_query(i: &str) -> IResult<&str, CreateTableStatement, VerboseError<
             ))),
             multispace0,
             opt(tag_no_case("AS")),
-            multispace0,
+            multispace1,
+            tag_no_case("SELECT"),
+            multispace1,
             map(rest, |x| String::from(x)),
             statement_terminator,
         )),
         |(x)| {
             let table = x.0 .2;
             let if_not_exists = x.0 .1;
             let temporary = x.0 .0;
-            let create_type = CreateTableType::AsQuery(x.2, x.4, x.6, x.8, x.12);
+            let create_type = CreateTableType::AsQuery(x.2, x.4, x.6, x.8, x.14);
             CreateTableStatement {
                 table,
                 temporary,
@@ -420,7 +422,7 @@ fn primary_key(i: &str) -> IResult<&str, CreateDefinition, VerboseError<&str>> {
                 tag_no_case("KEY"),
             )), // PRIMARY KEY
             IndexType::opt_index_type,      // [index_type]
-            KeyPart::key_part_list,                 // (key_part,...)
+            KeyPart::key_part_list,         // (key_part,...)
             IndexOption::opt_index_option,  // [index_option]
         )),
         |(opt_symbol, _, opt_index_type, key_part, opt_index_option)| {
@@ -445,7 +447,7 @@ fn unique(i: &str) -> IResult<&str, CreateDefinition, VerboseError<&str>> {
             ), // UNIQUE [INDEX | KEY]
             opt_index_name,                 // [index_name]
             IndexType::opt_index_type,      // [index_type]
-            KeyPart::key_part_list,                 // (key_part,...)
+            KeyPart::key_part_list,         // (key_part,...)
             IndexOption::opt_index_option,  // [index_option]
         )),
         |(

src/dms/mod.rs

@@ -3,5 +3,3 @@ pub mod delete;
 pub mod insert;
 pub mod select;
 pub mod update;
-pub mod zz_create;
-mod zz_create_table_options;

src/dms/select.rs

@@ -12,7 +12,9 @@ use nom::sequence::{delimited, terminated, tuple};
 use base::column::Column;
 use base::FieldDefinitionExpression;
 use base::table::Table;
-use common::{JoinConstraint, JoinOperator, JoinRightSide, OrderClause, statement_terminator, unsigned_number};
+use common::{
+    JoinConstraint, JoinOperator, JoinRightSide, OrderClause, statement_terminator, unsigned_number,
+};
 use common::condition::ConditionExpression;
 
 #[derive(Clone, Debug, Default, Eq, Hash, PartialEq, Serialize, Deserialize)]
@@ -126,7 +128,7 @@ impl GroupByClause {
     pub fn parse(i: &str) -> IResult<&str, GroupByClause, VerboseError<&str>> {
         let (remaining_input, (_, _, _, columns, having)) = tuple((
             multispace0,
-            tag_no_case("group by"),
+            tag_no_case("GROUP BY"),
             multispace1,
             Column::field_list,
             opt(ConditionExpression::having_clause),
@@ -166,7 +168,7 @@ impl JoinClause {
     pub fn parse(i: &str) -> IResult<&str, JoinClause, VerboseError<&str>> {
         let (remaining_input, (_, _natural, operator, _, right, _, constraint)) = tuple((
             multispace0,
-            opt(terminated(tag_no_case("natural"), multispace1)),
+            opt(terminated(tag_no_case("NATURAL"), multispace1)),
             JoinOperator::parse,
             multispace1,
             JoinRightSide::parse,
@@ -204,15 +206,26 @@ impl LimitClause {
     pub fn parse(i: &str) -> IResult<&str, LimitClause, VerboseError<&str>> {
         let (remaining_input, (_, _, _, limit, opt_offset)) = tuple((
             multispace0,
-            tag_no_case("limit"),
+            tag_no_case("LIMIT"),
             multispace1,
             unsigned_number,
-            opt(offset),
+            opt(Self::offset),
         ))(i)?;
         let offset = opt_offset.unwrap_or_else(|| 0);
 
         Ok((remaining_input, LimitClause { limit, offset }))
     }
+
+    fn offset(i: &str) -> IResult<&str, u64, VerboseError<&str>> {
+        let (remaining_input, (_, _, _, val)) = tuple((
+            multispace0,
+            tag_no_case("OFFSET"),
+            multispace1,
+            unsigned_number,
+        ))(i)?;
+
+        Ok((remaining_input, val))
+    }
 }
 
 impl fmt::Display for LimitClause {
@@ -225,26 +238,15 @@ impl fmt::Display for LimitClause {
     }
 }
 
-fn offset(i: &str) -> IResult<&str, u64, VerboseError<&str>> {
-    let (remaining_input, (_, _, _, val)) = tuple((
-        multispace0,
-        tag_no_case("OFFSET"),
-        multispace1,
-        unsigned_number,
-    ))(i)?;
-
-    Ok((remaining_input, val))
-}
-
 #[cfg(test)]
 mod tests {
     use base::{FieldValueExpression, ItemPlaceholder, Operator};
     use base::column::{Column, FunctionArgument, FunctionArguments, FunctionExpression};
     use base::Literal;
     use base::table::Table;
     use common::{JoinConstraint, JoinOperator, JoinRightSide, OrderClause, OrderType};
-    use common::case::{CaseWhenExpression, ColumnOrLiteral};
     use common::arithmetic::{ArithmeticBase, ArithmeticExpression, ArithmeticOperator};
+    use common::case::{CaseWhenExpression, ColumnOrLiteral};
     use common::condition::{ConditionExpression, ConditionTree};
     use common::condition::ConditionBase;
     use common::condition::ConditionBase::LiteralList;