Modularized into separate files

Add ToString implementation on the components

Author: ivanceras

src/sqlast.rs

@@ -25,6 +25,20 @@ use chrono::{NaiveDate,
             };
 
 use uuid::Uuid;
+pub use self::value::Value;
+pub use self::sqltype::SQLType;
+pub use self::table_key::{
+    AlterOperation,
+    TableKey,
+    Key
+};
+
+pub use self::sql_operator::SQLOperator;
+
+mod value;
+mod sqltype;
+mod table_key;
+mod sql_operator;
 
 /// SQL Abstract Syntax Tree (AST)
 #[derive(Debug, Clone, PartialEq)]
@@ -36,7 +50,7 @@ pub enum ASTNode {
     /// Multi part identifier e.g. `myschema.dbo.mytable`
     SQLCompoundIdentifier(Vec<String>),
     /// Assigment e.g. `name = 'Fred'` in an UPDATE statement
-    SQLAssignment(String, Box<ASTNode>),
+    SQLAssignment(SQLAssignment),
     /// `IS NULL` expression
     SQLIsNull(Box<ASTNode>),
     /// `IS NOT NULL` expression
@@ -102,7 +116,7 @@ pub enum ASTNode {
         /// TABLE
         table_name: String,
         /// Column assignments
-        assignemnts: Vec<SQLAssigment>,
+        assignments: Vec<SQLAssignment>,
         /// WHERE
         selection: Option<Box<ASTNode>>,
     },
@@ -112,9 +126,6 @@ pub enum ASTNode {
         relation: Option<Box<ASTNode>>,
         /// WHERE
         selection: Option<Box<ASTNode>>,
-        /// ORDER BY
-        order_by: Option<Vec<SQLOrderByExpr>>,
-        limit: Option<Box<ASTNode>>,
     },
     /// CREATE TABLE
     SQLCreateTable {
@@ -131,41 +142,134 @@ pub enum ASTNode {
     }
 }
 
-/// SQL values such as int, double, string timestamp
-#[derive(Debug, Clone, PartialEq)]
-pub enum Value{
-    /// Literal signed long
-    Long(i64),
-    /// Literal floating point value
-    Double(f64),
-    /// Unquoted string
-    String(String),
-    Uuid(Uuid),
-    /// 'string value'
-    SingleQuotedString(String),
-    /// "string value"
-    DoubleQuotedString(String),
-    /// Boolean value true or false,
-    Boolean(bool),
-    /// Date value
-    Date(NaiveDate),
-    // Time
-    Time(NaiveTime),
-    /// Date and time
-    DateTime(NaiveDateTime),
-    /// Timstamp with time zone
-    Timestamp(DateTime<FixedOffset>),
-    /// NULL value in insert statements,
-    Null,
+
+impl ToString for ASTNode{
+
+    fn to_string(&self) -> String {
+        match self{
+            ASTNode::SQLIdentifier(s) => s.to_string(),
+            ASTNode::SQLWildcard => "*".to_string(),
+            ASTNode::SQLCompoundIdentifier(s) => s.join("."),
+            ASTNode::SQLAssignment(ass) => ass.to_string(),
+            ASTNode::SQLIsNull(ast) => format!("{} IS NULL",ast.as_ref().to_string()),
+            ASTNode::SQLIsNotNull(ast) => format!("{} IS NOT NULL", ast.as_ref().to_string()),
+            ASTNode::SQLBinaryExpr{left, op, right} => {
+                format!("{} {} {}", left.as_ref().to_string(), op.to_string(), right.as_ref().to_string())
+            }
+            ASTNode::SQLCast{expr, data_type} => {
+                format!("CAST({} AS {})", expr.as_ref().to_string(), data_type.to_string())
+            }
+            ASTNode::SQLNested(ast) => format!("({})", ast.as_ref().to_string()),
+            ASTNode::SQLUnary {operator, rex } => {
+                format!("{} {}", operator.to_string(), rex.as_ref().to_string())
+            }
+            ASTNode::SQLValue(v) => v.to_string(),
+            ASTNode::SQLFunction{id, args} => format!("{}({})", id, args.iter().map(|a|a.to_string()).collect::<Vec<String>>().join(", ")),
+            ASTNode::SQLSelect{
+                projection,
+                relation,
+                selection,
+                order_by,
+                group_by,
+                having,
+                limit,
+            } => {
+                let mut s = format!("SELECT {}", projection.iter().map(|p|p.to_string()).collect::<Vec<String>>().join(", "));
+                if let Some(relation) = relation{
+                    s += &format!(" FROM {}", relation.as_ref().to_string());
+                }
+                if let Some(selection) = selection{
+                    s += &format!(" WHERE {}", selection.as_ref().to_string());
+                }
+                if let Some(group_by) = group_by {
+                    s += &format!(" GROUP BY {}", group_by.iter().map(|g|g.to_string()).collect::<Vec<String>>().join(", "));
+                }
+                if let Some(having) = having{
+                    s += &format!(" HAVING {}", having.as_ref().to_string());
+                }
+                if let Some(order_by) = order_by{
+                    s += &format!(" ORDER BY {}", order_by.iter().map(|o|o.to_string()).collect::<Vec<String>>().join(", "));
+                }
+                if let Some(limit) = limit {
+                    s += &format!(" LIMIT {}", limit.as_ref().to_string());
+                }
+                s
+            }
+            ASTNode::SQLInsert{ table_name, columns, values } => {
+                let mut s = format!("INSERT INTO {}", table_name);
+                if columns.len() > 0 {
+                    s += &format!(" ({})", columns.join(", "));
+                }
+                if values.len() > 0 {
+                    s += &format!(" VALUES({})", 
+                                 values.iter()
+                                    .map(|row|row.iter().map(|c|c.to_string())
+                                            .collect::<Vec<String>>().join(", ")
+                                        ).collect::<Vec<String>>().join(", ")
+                                );
+                }
+                s
+            }
+            ASTNode::SQLCopy{table_name, columns, values} => {
+                let mut s = format!("COPY {}", table_name);
+                if columns.len() > 0 {
+                    s += &format!(" ({})", columns.iter().map(|c|c.to_string()).collect::<Vec<String>>().join(", "));
+                }
+                s += " FROM stdin; ";
+                if values.len() > 0 {
+                    s += &format!("\n{}",
+                                 values.iter()
+                                    .map(|v|v.to_string())
+                                        .collect::<Vec<String>>().join("\t")
+                                );
+                }
+                s
+            }
+            ASTNode::SQLUpdate{table_name, assignments, selection} => {
+                let mut s = format!("UPDATE {}", table_name);
+                if assignments.len() > 0 {
+                    s += &format!("{}", assignments.iter().map(|ass|ass.to_string()).collect::<Vec<String>>().join(", "));
+                }
+                if let Some(selection) = selection{
+                    s += &format!(" WHERE {}", selection.as_ref().to_string());
+                }
+                s
+            }
+            ASTNode::SQLDelete{relation, selection} => {
+                let mut s = String::from("DELETE");
+                if let Some(relation) = relation{
+                    s += &format!(" FROM {}", relation.as_ref().to_string());
+                }
+                if let Some(selection) = selection{
+                    s += &format!(" WHERE {}", selection.as_ref().to_string());
+                }
+                s
+            }
+            ASTNode::SQLCreateTable{name, columns} => {
+                format!("CREATE TABLE {} ({})", name, columns.iter().map(|c|c.to_string()).collect::<Vec<String>>().join(", "))
+            }
+            ASTNode::SQLAlterTable{name, operation} => {
+                format!("ALTER TABLE {} {}", name, operation.to_string())
+            }
+        }
+    }
 }
 
 /// SQL assignment `foo = expr` as used in SQLUpdate
+/// TODO: unify this with the ASTNode SQLAssignment
 #[derive(Debug, Clone, PartialEq)]
-pub struct SQLAssigment {
+pub struct SQLAssignment {
     id: String,
     value: Box<ASTNode>,
 }
 
+impl ToString for SQLAssignment{
+    
+    fn to_string(&self) -> String {
+        format!("SET {} = {}", self.id, self.value.as_ref().to_string())
+    }
+}
+
 /// SQL ORDER BY expression
 #[derive(Debug, Clone, PartialEq)]
 pub struct SQLOrderByExpr {
@@ -179,109 +283,45 @@ impl SQLOrderByExpr {
     }
 }
 
+impl ToString for SQLOrderByExpr{
+    fn to_string(&self) -> String {
+        if self.asc{
+            format!("{} ASC", self.expr.as_ref().to_string())
+        }else{
+            format!("{} DESC", self.expr.as_ref().to_string())
+        }
+    }
+}
+
 /// SQL column definition
 #[derive(Debug, Clone, PartialEq)]
 pub struct SQLColumnDef {
     pub name: String,
     pub data_type: SQLType,
-    pub allow_null: bool,
     pub is_primary: bool,
     pub is_unique: bool,
     pub default: Option<Box<ASTNode>>,
+    pub allow_null: bool,
 }
 
-/// SQL datatypes for literals in SQL statements
-#[derive(Debug, Clone, PartialEq)]
-pub enum SQLType {
-    /// Fixed-length character type e.g. CHAR(10)
-    Char(Option<usize>),
-    /// Variable-length character type e.g. VARCHAR(10)
-    Varchar(Option<usize>),
-    /// Uuid value
-    Uuid,
-    /// Large character object e.g. CLOB(1000)
-    Clob(usize),
-    /// Fixed-length binary type e.g. BINARY(10)
-    Binary(usize),
-    /// Variable-length binary type e.g. VARBINARY(10)
-    Varbinary(usize),
-    /// Large binary object e.g. BLOB(1000)
-    Blob(usize),
-    /// Decimal type with precision and optional scale e.g. DECIMAL(10,2)
-    Decimal(usize, 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
-    Double,
-    /// Boolean
-    Boolean,
-    /// Date
-    Date,
-    /// Time
-    Time,
-    /// Timestamp
-    Timestamp,
-    /// Regclass used in postgresql serial
-    Regclass,
-    /// Text
-    Text,
-    /// Bytea
-    Bytea,
-    /// Custom type such as enums
-    Custom(String),
-    /// Arrays
-    Array(Box<SQLType>),
-}
 
-/// SQL Operator
-#[derive(Debug, PartialEq, Clone)]
-pub enum SQLOperator {
-    Plus,
-    Minus,
-    Multiply,
-    Divide,
-    Modulus,
-    Gt,
-    Lt,
-    GtEq,
-    LtEq,
-    Eq,
-    NotEq,
-    And,
-    Or,
-}
+impl ToString for SQLColumnDef{
 
-#[derive(Debug, PartialEq, Clone)]
-pub enum AlterOperation{
-    AddConstraint(TableKey),
-    RemoveConstraint{
-        name: String,
+    fn to_string(&self) -> String {
+        let mut s = format!("{} {}", self.name, self.data_type.to_string());
+        if self.is_primary{
+            s += " PRIMARY KEY";
+        }
+        if self.is_unique{
+            s += " UNIQUE";
+        }
+        if let Some(ref default) = self.default{
+            s += &format!(" DEFAULT {}", default.as_ref().to_string());
+        }
+        if !self.allow_null{
+            s += " NOT NULL";
+        }
+        s
     }
 }
 
-
-#[derive(Debug, PartialEq, Clone)]
-pub struct Key{
-    pub name: Option<String>,
-    pub columns: Vec<String>,
-}
-
-#[derive(Debug, PartialEq, Clone)]
-pub enum TableKey{
-    PrimaryKey(Key),
-    UniqueKey(Key),
-    Key(Key),
-    ForeignKey {
-        key: Key,
-        foreign_table: String,
-        referred_columns: Vec<String>,
-    }
-}

src/sqlast/sql_operator.rs

@@ -0,0 +1,40 @@
+
+/// SQL Operator
+#[derive(Debug, PartialEq, Clone)]
+pub enum SQLOperator {
+    Plus,
+    Minus,
+    Multiply,
+    Divide,
+    Modulus,
+    Gt,
+    Lt,
+    GtEq,
+    LtEq,
+    Eq,
+    NotEq,
+    And,
+    Or,
+}
+
+impl ToString for SQLOperator{
+
+    fn to_string(&self) -> String {
+        match self{
+            SQLOperator::Plus => "+".to_string(),
+            SQLOperator::Minus => "-".to_string(),
+            SQLOperator::Multiply => "*".to_string(),
+            SQLOperator::Divide => "/".to_string(),
+            SQLOperator::Modulus => "%".to_string(),
+            SQLOperator::Gt => ">".to_string(),
+            SQLOperator::Lt => "<".to_string(),
+            SQLOperator::GtEq => ">=".to_string(),
+            SQLOperator::LtEq => "<=".to_string(),
+            SQLOperator::Eq => "=".to_string(),
+            SQLOperator::NotEq => "!=".to_string(),
+            SQLOperator::And => "AND".to_string(),
+            SQLOperator::Or => "OR".to_string(),
+        }
+    }
+}
+