Merge pull request #51 from nickolay/rust-2018

Rust 2018 and clippy fixes

Author: andygrove

Cargo.toml

@@ -12,6 +12,7 @@ include = [
     "src/**/*.rs",
     "Cargo.toml",
 ]
+edition = "2018"
 
 [lib]
 name = "sqlparser"
@@ -24,3 +25,4 @@ uuid = "0.7.1"
 
 [dev-dependencies]
 simple_logger = "1.0.1"
+matches = "0.1"

examples/cli.rs

@@ -1,5 +1,7 @@
-extern crate simple_logger;
-extern crate sqlparser;
+#![warn(clippy::all)]
+
+use simple_logger;
+
 ///! A small command-line app to run the parser.
 /// Run with `cargo run --example cli`
 use std::fs;
@@ -14,8 +16,8 @@ fn main() {
         .nth(1)
         .expect("No arguments provided!\n\nUsage: cargo run --example cli FILENAME.sql");
 
-    let contents =
-        fs::read_to_string(&filename).expect(&format!("Unable to read the file {}", &filename));
+    let contents = fs::read_to_string(&filename)
+        .unwrap_or_else(|_| panic!("Unable to read the file {}", &filename));
     let without_bom = if contents.chars().nth(0).unwrap() as u64 != 0xfeff {
         contents.as_str()
     } else {
@@ -31,7 +33,7 @@ fn main() {
                 "Round-trip:\n'{}'",
                 statements
                     .iter()
-                    .map(|s| s.to_string())
+                    .map(std::string::ToString::to_string)
                     .collect::<Vec<_>>()
                     .join("\n")
             );

examples/parse_select.rs

@@ -1,4 +1,4 @@
-extern crate sqlparser;
+#![warn(clippy::all)]
 
 use sqlparser::dialect::GenericSqlDialect;
 use sqlparser::sqlparser::*;

src/dialect/ansi_sql.rs

@@ -1,4 +1,4 @@
-use dialect::Dialect;
+use crate::dialect::Dialect;
 
 pub struct AnsiSqlDialect {}
 

src/dialect/generic_sql.rs

@@ -1,4 +1,4 @@
-use dialect::Dialect;
+use crate::dialect::Dialect;
 pub struct GenericSqlDialect {}
 
 impl Dialect for GenericSqlDialect {

src/dialect/keywords.rs

@@ -365,9 +365,9 @@ keyword!(
 );
 
 /// special case of keyword where the it is an invalid identifier
-pub const END_EXEC: &'static str = "END-EXEC";
+pub const END_EXEC: &str = "END-EXEC";
 
-pub const ALL_KEYWORDS: &'static [&'static str] = &[
+pub const ALL_KEYWORDS: &[&str] = &[
     ABS,
     ADD,
     ASC,
@@ -716,7 +716,7 @@ pub const ALL_KEYWORDS: &'static [&'static str] = &[
 
 /// These keywords can't be used as a table alias, so that `FROM table_name alias`
 /// can be parsed unambiguously without looking ahead.
-pub const RESERVED_FOR_TABLE_ALIAS: &'static [&'static str] = &[
+pub const RESERVED_FOR_TABLE_ALIAS: &[&str] = &[
     // Reserved as both a table and a column alias:
     WITH, SELECT, WHERE, GROUP, ORDER, UNION, EXCEPT, INTERSECT,
     // Reserved only as a table alias in the `FROM`/`JOIN` clauses:
@@ -725,7 +725,7 @@ pub const RESERVED_FOR_TABLE_ALIAS: &'static [&'static str] = &[
 
 /// Can't be used as a column alias, so that `SELECT <expr> alias`
 /// can be parsed unambiguously without looking ahead.
-pub const RESERVED_FOR_COLUMN_ALIAS: &'static [&'static str] = &[
+pub const RESERVED_FOR_COLUMN_ALIAS: &[&str] = &[
     // Reserved as both a table and a column alias:
     WITH, SELECT, WHERE, GROUP, ORDER, UNION, EXCEPT, INTERSECT,
     // Reserved only as a column alias in the `SELECT` clause:

src/dialect/postgresql.rs

@@ -1,4 +1,4 @@
-use dialect::Dialect;
+use crate::dialect::Dialect;
 
 pub struct PostgreSqlDialect {}
 

src/lib.rs

@@ -34,11 +34,7 @@
 //!
 //! println!("AST: {:?}", ast);
 //! ```
-
-#[macro_use]
-extern crate log;
-extern crate chrono;
-extern crate uuid;
+#![warn(clippy::all)]
 
 pub mod dialect;
 pub mod sqlast;

src/sqlast/mod.rs

@@ -202,7 +202,7 @@ impl ToString for ASTNode {
 #[derive(Debug, Clone, PartialEq)]
 pub enum SQLStatement {
     /// SELECT
-    SQLSelect(SQLQuery),
+    SQLQuery(Box<SQLQuery>),
     /// INSERT
     SQLInsert {
         /// TABLE
@@ -240,7 +240,7 @@ pub enum SQLStatement {
     SQLCreateView {
         /// View name
         name: SQLObjectName,
-        query: SQLQuery,
+        query: Box<SQLQuery>,
         materialized: bool,
     },
     /// CREATE TABLE
@@ -264,17 +264,17 @@ pub enum SQLStatement {
 impl ToString for SQLStatement {
     fn to_string(&self) -> String {
         match self {
-            SQLStatement::SQLSelect(s) => s.to_string(),
+            SQLStatement::SQLQuery(s) => s.to_string(),
             SQLStatement::SQLInsert {
                 table_name,
                 columns,
                 values,
             } => {
                 let mut s = format!("INSERT INTO {}", table_name.to_string());
-                if columns.len() > 0 {
+                if !columns.is_empty() {
                     s += &format!(" ({})", columns.join(", "));
                 }
-                if values.len() > 0 {
+                if !values.is_empty() {
                     s += &format!(
                         " VALUES({})",
                         values
@@ -307,12 +307,12 @@ impl ToString for SQLStatement {
                     );
                 }
                 s += " FROM stdin; ";
-                if values.len() > 0 {
+                if !values.is_empty() {
                     s += &format!(
                         "\n{}",
                         values
                             .iter()
-                            .map(|v| v.clone().unwrap_or("\\N".to_string()))
+                            .map(|v| v.clone().unwrap_or_else(|| "\\N".to_string()))
                             .collect::<Vec<String>>()
                             .join("\t")
                     );
@@ -381,13 +381,7 @@ impl ToString for SQLStatement {
                 file_format.as_ref().map(|f| f.to_string()).unwrap(),
                 location.as_ref().unwrap()
             ),
-            SQLStatement::SQLCreateTable {
-                name,
-                columns,
-                external: _,
-                file_format: _,
-                location: _,
-            } => format!(
+            SQLStatement::SQLCreateTable { name, columns, .. } => format!(
                 "CREATE TABLE {} ({})",
                 name.to_string(),
                 columns
@@ -483,7 +477,7 @@ impl ToString for FileFormat {
     }
 }
 
-use sqlparser::ParserError;
+use crate::sqlparser::ParserError;
 use std::str::FromStr;
 impl FromStr for FileFormat {
     type Err = ParserError;

src/sqlast/query.rs

@@ -50,7 +50,7 @@ impl ToString for SQLQuery {
 #[derive(Debug, Clone, PartialEq)]
 pub enum SQLSetExpr {
     /// Restricted SELECT .. FROM .. HAVING (no ORDER BY or set operations)
-    Select(SQLSelect),
+    Select(Box<SQLSelect>),
     /// Parenthesized SELECT subquery, which may include more set operations
     /// in its body and an optional ORDER BY / LIMIT.
     Query(Box<SQLQuery>),

src/sqlast/sqltype.rs

@@ -19,14 +19,14 @@ pub enum SQLType {
     Blob(usize),
     /// Decimal type with optional precision and scale e.g. DECIMAL(10,2)
     Decimal(Option<usize>, Option<usize>),
+    /// Floating point with optional precision e.g. FLOAT(8)
+    Float(Option<usize>),
     /// Small integer
     SmallInt,
     /// Integer
     Int,
     /// Big integer
     BigInt,
-    /// Floating point with optional precision e.g. FLOAT(8)
-    Float(Option<usize>),
     /// Floating point e.g. REAL
     Real,
     /// Double e.g. DOUBLE PRECISION
@@ -54,20 +54,8 @@ pub enum SQLType {
 impl ToString for SQLType {
     fn to_string(&self) -> String {
         match self {
-            SQLType::Char(size) => {
-                if let Some(size) = size {
-                    format!("char({})", size)
-                } else {
-                    "char".to_string()
-                }
-            }
-            SQLType::Varchar(size) => {
-                if let Some(size) = size {
-                    format!("character varying({})", size)
-                } else {
-                    "character varying".to_string()
-                }
-            }
+            SQLType::Char(size) => format_type_with_optional_length("char", size),
+            SQLType::Varchar(size) => format_type_with_optional_length("character varying", size),
             SQLType::Uuid => "uuid".to_string(),
             SQLType::Clob(size) => format!("clob({})", size),
             SQLType::Binary(size) => format!("binary({})", size),
@@ -76,22 +64,14 @@ impl ToString for SQLType {
             SQLType::Decimal(precision, scale) => {
                 if let Some(scale) = scale {
                     format!("numeric({},{})", precision.unwrap(), scale)
-                } else if let Some(precision) = precision {
-                    format!("numeric({})", precision)
                 } else {
-                    format!("numeric")
+                    format_type_with_optional_length("numeric", precision)
                 }
             }
+            SQLType::Float(size) => format_type_with_optional_length("float", size),
             SQLType::SmallInt => "smallint".to_string(),
             SQLType::Int => "int".to_string(),
             SQLType::BigInt => "bigint".to_string(),
-            SQLType::Float(size) => {
-                if let Some(size) = size {
-                    format!("float({})", size)
-                } else {
-                    "float".to_string()
-                }
-            }
             SQLType::Real => "real".to_string(),
             SQLType::Double => "double".to_string(),
             SQLType::Boolean => "boolean".to_string(),
@@ -106,3 +86,11 @@ impl ToString for SQLType {
         }
     }
 }
+
+fn format_type_with_optional_length(sql_type: &str, len: &Option<usize>) -> String {
+    let mut s = sql_type.to_string();
+    if let Some(len) = len {
+        s += &format!("({})", len);
+    }
+    s
+}