remove empty lines (#12)

Author: isnlan

src/error.rs

@@ -8,8 +8,8 @@ use sqlparser::parser::ParserError;
 /// and makes function signatures easier to read.
 pub type Result<T> = result::Result<T, SQLRiteError>;
 
-/// SQLRiteError is an enum with all the standardized errors available for returning 
-/// 
+/// SQLRiteError is an enum with all the standardized errors available for returning
+///
 #[derive(Error, Debug, PartialEq)]
 pub enum SQLRiteError {
     #[error("Not Implemented error: {0}")]

src/sql/db/database.rs

@@ -19,7 +19,7 @@ impl Database {
     ///
     /// ```
     /// let mut db = sql::db::database::Database::new("my_db".to_string());
-    /// ``` 
+    /// ```
     pub fn new(db_name: String) -> Self {
         Database {
             db_name,
@@ -33,7 +33,7 @@ impl Database {
         self.tables.contains_key(&table_name)
     }
 
-    /// Returns an immutable reference of `sql::db::table::Table` if the database contains a 
+    /// Returns an immutable reference of `sql::db::table::Table` if the database contains a
     /// table with the specified key as a table name.
     ///
     pub fn get_table(&self, table_name: String) -> Result<&Table> {
@@ -44,7 +44,7 @@ impl Database {
         }
     }
 
-    /// Returns an mutable reference of `sql::db::table::Table` if the database contains a 
+    /// Returns an mutable reference of `sql::db::table::Table` if the database contains a
     /// table with the specified key as a table name.
     ///
     pub fn get_table_mut(&mut self, table_name: String) -> Result<&mut Table> {
@@ -88,7 +88,7 @@ mod tests {
         }
         let query = ast.pop().unwrap();
 
-        let create_query = CreateQuery::new(&query).unwrap(); 
+        let create_query = CreateQuery::new(&query).unwrap();
         let table_name = &create_query.table_name;
         db.tables.insert(table_name.to_string(), Table::new(create_query));
 

src/sql/db/table.rs

@@ -298,12 +298,12 @@ impl Table {
                 } else{
                     if &self.primary_key == &column_names[i]{
                         continue
-                    } 
-                } 
+                    }
+                }
             }else{
                 if &self.primary_key == &column_names[i]{
                     continue
-                } 
+                }
             }
 
             // Getting the rows from the column name
@@ -348,11 +348,11 @@ impl Table {
     /// Print the table schema to standard output in a pretty formatted way
     ///
     /// # Example
-    /// 
+    ///
     /// ```
     /// let table = Table::new(payload);
     /// table.print_table_schema();
-    /// 
+    ///
     /// Prints to standard output:
     ///    +-------------+-----------+-------------+--------+----------+
     ///    | Column Name | Data Type | PRIMARY KEY | UNIQUE | NOT NULL |
@@ -380,11 +380,11 @@ impl Table {
     /// Print the table data to standard output in a pretty formatted way
     ///
     /// # Example
-    /// 
+    ///
     /// ```
     /// let db_table = db.get_table_mut(table_name.to_string()).unwrap();
     /// db_table.print_table_data();
-    /// 
+    ///
     /// Prints to standard output:
     ///     +----+---------+------------------------+
     ///     | id | name    | email                  |
@@ -429,8 +429,8 @@ impl Table {
                 if let Some(cell) = &columns.get(i){
                     print_table_rows[i].add_cell(PrintCell::new(cell));
                 }else{
-                    print_table_rows[i].add_cell(PrintCell::new("")); 
-                }                
+                    print_table_rows[i].add_cell(PrintCell::new(""));
+                }
             }
         }
 

src/sql/mod.rs

@@ -82,7 +82,7 @@ pub fn process_command(query: &str, db: &mut Database) -> Result<String> {
                 Err(err) => return Err(err),
             }
         }
-        Statement::Insert { .. } => { 
+        Statement::Insert { .. } => {
             let insert_query = InsertQuery::new(&query);
             match insert_query {
                 Ok(payload) => {
@@ -108,7 +108,6 @@ pub fn process_command(query: &str, db: &mut Database) -> Result<String> {
                                             Ok(()) => {
                                                 // No unique constraint violation, moving forward with inserting row
                                                 db_table.insert_row(&columns, &value);
-                                                
                                             }
                                             Err(err) => return Err(SQLRiteError::Internal(format!("Unique key constaint violation: {}",err))),
                                         }
@@ -126,7 +125,7 @@ pub fn process_command(query: &str, db: &mut Database) -> Result<String> {
                 Err(err) => return Err(err),
             }
 
-            message = String::from("INSERT Statement executed.") 
+            message = String::from("INSERT Statement executed.")
         }
         Statement::Query(_query) => message = String::from("SELECT Statement executed."),
         // Statement::Insert { .. } => message = String::from("INSERT Statement executed."),

src/sql/parser/create.rs

@@ -20,11 +20,11 @@ pub struct ParsedColumn {
 
 /// The following structure represents a CREATE TABLE query already parsed
 /// and broken down into name and a Vector of `ParsedColumn` metadata
-/// 
+///
 #[derive(Debug)]
 pub struct CreateQuery {
     /// name of table after parking and tokenizing of query
-    pub table_name: String,      
+    pub table_name: String,
     /// Vector of `ParsedColumn` type with column metadata information
     pub columns: Vec<ParsedColumn>,
 }
@@ -55,7 +55,7 @@ impl CreateQuery {
                     if parsed_columns.iter().any(|col| col.name == name){
                         return Err(SQLRiteError::Internal(format!("Duplicate column name: {}", &name)))
                     }
-                    
+
                     // Parsing each column for it data type
                     // For now only accepting basic data types
                     let datatype = match &col.data_type {
@@ -112,7 +112,7 @@ impl CreateQuery {
                         not_null,
                         is_unique,
                     });
-                    
+
                 }
                 // TODO: Handle constraints,
                 // Default value and others.
@@ -164,6 +164,6 @@ mod tests {
                 }
             },
             _ => ()
-        };          
+        };
     }
 }

src/sql/parser/insert.rs

@@ -4,7 +4,7 @@ use crate::error::{Result, SQLRiteError};
 
 /// The following structure represents a INSERT query already parsed
 /// and broken down into `table_name` a `Vec<String>` representing the `Columns`
-/// and `Vec<Vec<String>>` representing the list of `Rows` to be inserted 
+/// and `Vec<Vec<String>>` representing the list of `Rows` to be inserted
 #[derive(Debug)]
 pub struct InsertQuery {
     pub table_name: String,