PR Re ENTREGA TP

README.md

@@ -0,0 +1,37 @@
+# Ejercicio individual | (75.42) Taller de programación I 
+
+## Alumno: Testa Santiago Tomas ( 108301 ) 
+
+### Detalles de entrega
+
+Pendientes:
+
+1. Testing (mas test unitarios e integración)
+
+2. Documentación de funciones
+
+3. Refactor de funciones para que tengan menos de 30 lineas. Por una cuestión de tiempos se deja para el final. 
+
+6. Terminar trabajo sobre el parseo ( TODOs & funcion para imprimir errores ). Se decide para poder avanzar con las funcionalidades implementar las mismas tal que, en caso de haber un error, simplemente no ejecutarán nada.  
+
+Funcionalidades probadas OK
+
+1. SELECT 
+
+2. INSERT INTO
+
+3. UPDATE 
+
+4. DELETE FROM 
+
+### Detalles de implementación
+
+Para la logica del programa se decidio dividir en dos etapas: parseo y ejecucción. El punto del parseo es que se encuentre cualquier error previo a ejecucción del query, tal que no sea posible dañar la base de datos por error humano. De encontrarse un error se debe imprimir   
+
+Logica booleana: Se implemento por medio de un vector de vectores. Por cada OR se pushea un nuevo vector, donde en este vector se pushearán las expresiones simples y las negaciones ( los ANDs no son pusheados, ya que sería redundante ).
+
+Esta implementación tiene como problema que un query con el condicional WHERE A AND AND AND {...} B resulta en WHERE A AND B. Como solución simple se planteó un chequeo en parseo que si se encuentra un condicional AND, se chequeará que el largo sea tal que el condicional sea válido, y que el proximo elemento no sea AND u OR.
+
+Para la lógica booleana tambien se considero un arbol binario de expresiones booleanas (https://en.wikipedia.org/wiki/Binary_expression_tree). No se logró implementar debido a problemas con el manejo de memoria en Rust, aunque en mi opinión creo que es la mejor implementación posible.  
+
+Para en ORDER BY no cargar las tablas completas en memoria se eligió "Full external sort" (https://cs186berkeley.net/notes/note8/)

src/condition.rs

@@ -0,0 +1,106 @@
+pub mod condition_type;
+// pub mod complex_condition;
+// use condition_type::BooleanOperator;
+// use crate::libs::error;
+
+use condition_type::ConditionOperator;
+
+pub struct Condition {
+    pub condition: ConditionOperator,
+    pub column: Option<usize>,
+    pub value: Option<String>,
+}
+
+/// Constructor for not condition
+pub fn build_not_condition() -> Condition {
+    Condition {
+        condition: ConditionOperator::Equal,
+        column: None,
+        value: None,
+    }
+}
+
+/// Constructor for general condition (simple expression, non boolean)
+pub fn build_condition(column: usize, value: String, cond: ConditionOperator) -> Condition {
+    Condition {
+        condition: cond,
+        column: Some(column),
+        value: Some(value),
+    }
+}
+
+/// Returns string (or int if it's parseable as int) comparison
+///
+/// Pre:  Strings and operator
+/// Post: True if condition applies
+pub fn operate_condition(v1: &String, v2: &String, operator: &ConditionOperator) -> bool {
+    if let Ok(x1) = v1.parse::<i32>() {
+        if let Ok(x2) = v2.parse::<i32>() {
+            match operator {
+                ConditionOperator::Minor => return x1 < x2,
+                ConditionOperator::MinorEqual => return x1 <= x2,
+                ConditionOperator::Equal => return x1 == x2,
+                ConditionOperator::Higher => return x1 > x2,
+                ConditionOperator::HigherEqual => return x1 >= x2,
+            }
+        };
+    };
+
+    match operator {
+        ConditionOperator::Minor => v1 < v2,
+        ConditionOperator::MinorEqual => v1 <= v2,
+        ConditionOperator::Equal => v1.eq(v2),
+        ConditionOperator::Higher => v1 > v2,
+        ConditionOperator::HigherEqual => v1 >= v2,
+    }
+}
+
+/// Returns the result of applying the condition to the lineW
+///
+/// Pre:  Line to vec and condition (bool vector).
+/// Post: Bool if condition applies or not
+pub fn operate_full_condition(elements: &[String], condition: &[Vec<Condition>]) -> bool {
+    let mut or_valid = false;
+    let mut or_counter = 0;
+
+    let mut and_valid;
+    let mut and_counter;
+    let mut not_detected;
+
+    while or_counter < condition.len() && !or_valid {
+        and_valid = true;
+        and_counter = 0;
+        not_detected = false;
+        while and_counter < condition[or_counter].len() && and_valid {
+            match &condition[or_counter][and_counter].column {
+                None => not_detected = !not_detected,
+                Some(column) => match &condition[or_counter][and_counter].value {
+                    None => return false,
+                    Some(value) => {
+                        if not_detected {
+                            and_valid = !operate_condition(
+                                &elements[*column],
+                                value,
+                                &condition[or_counter][and_counter].condition,
+                            )
+                        } else {
+                            and_valid = operate_condition(
+                                &elements[*column],
+                                value,
+                                &condition[or_counter][and_counter].condition,
+                            );
+                        }
+                    }
+                },
+            }
+
+            and_counter += 1;
+        }
+
+        or_valid = and_valid;
+
+        or_counter += 1;
+    }
+
+    or_valid
+}

src/condition/complex_condition.rs

@@ -0,0 +1,133 @@
+use std::borrow::BorrowMut;
+
+use crate::{libs::error::WHERE_MAL_FORMATEADO, query::Query};
+use super::{condition_type::{self, ConditionOperator}, BooleanOperator, Condition};
+
+pub struct ComplexCondition {
+    // Tree of complex conditions 
+    pub operator:       BooleanOperator,
+    pub left_cond:      Option<Box<ComplexCondition>>,   // Oldest condition ( first to be found )
+    pub left_simple:    Option<Condition>,
+    pub right_cond:     Option<Box<ComplexCondition>>,   // Newest condition ( last to be found )
+    pub right_simple:   Option<Condition>,
+}
+
+pub fn build_simple_condition(left: Option<Condition>) -> ComplexCondition {
+    ComplexCondition {
+        operator:       BooleanOperator::I,
+        left_simple:    left,
+
+        left_cond:      None,
+        right_simple:   None,
+        right_cond:     None,
+    }
+}
+
+pub fn build_complex_condition(op: BooleanOperator, left: Option<Box<ComplexCondition>>, right: Option<Box<ComplexCondition>>) -> ComplexCondition {
+    ComplexCondition {
+        operator:       op,
+        left_cond:      left,
+        right_cond:     right,
+
+        left_simple:    None,
+        right_simple:   None
+    }
+} 
+
+pub fn tree_check(root: &ComplexCondition) -> bool {
+    // In Order valid check ( no None leafs )
+    match &root.operator {
+        BooleanOperator::OR     => tree_check_or_and(&root),
+        BooleanOperator::AND    => tree_check_or_and(&root),
+        BooleanOperator::NOT    => tree_check_not_i(&root),
+        BooleanOperator::I      => tree_check_not_i(&root)
+    }
+}
+
+fn tree_check_or_and(root: &ComplexCondition) -> bool {
+    match &root.left_cond {
+        Some(left) => {
+            match &root.right_cond {
+                Some(right) => return tree_check(&*left) && tree_check(&*right),
+                None => return false
+            }
+        },
+        None => return false
+    }
+}
+
+fn tree_check_not_i(root: &ComplexCondition) -> bool {
+    match &root.left_cond {
+        Some(left) => {
+            match root.right_cond {
+                Some(_) => return false,
+                None => return tree_check(&*left)
+            }
+        },
+        None => return false
+    }
+}
+
+pub fn add_node_to_tree(mut new_node: ComplexCondition, root: &mut ComplexCondition) -> Result<ComplexCondition,u32> {
+    // Pre:  Previous root and new node
+    // Post: If success new root, else Error
+    if check_precedence(&new_node.operator, &root.operator) {           // IM new root
+        new_node.left_cond =  Some(Box::new(*root));
+        Ok(new_node)
+    } else if root.left_cond.is_none() {             // IM RIGHT SON 
+        Err(WHERE_MAL_FORMATEADO)
+    } else {
+        match root.right_cond.as_deref() {
+            Some(mut x) => add_node_to_tree(new_node, x.borrow_mut()),
+            None => {
+                root.right_cond = Some(Box::new(new_node));
+                return Ok(*root)
+            }
+        }
+    }
+}
+
+fn check_valid_args_for_basic_condition(args: &Vec<String>, start_position: usize) -> bool {
+    if start_position + 3 > args.len() {
+        false
+    } else {
+        let first = &args[start_position];
+        let second = &args[start_position + 1];
+        let third = &args[start_position + 2];
+
+        if first.eq("AND") || first.eq("OR") || first.eq("NOT") {
+            false
+        } else if second.eq("AND") || second.eq("OR") || second.eq("NOT") {
+            false 
+        } else if ! ( second.eq(">") || second.eq(">=") || second.eq("=") || second.eq("<") || second.eq("<=") ) {
+            false
+        } else if third.eq("AND") || third.eq("OR") || third.eq("NOT") {
+            false
+        } else {
+            true 
+        }
+    }  
+}
+
+pub fn check_precedence(op1: &BooleanOperator, op2: &BooleanOperator) -> bool {
+    // Pre:  Operators
+    // Post: True if it's higher on the tree, false if not 
+    match op1 {
+        BooleanOperator::OR => true,
+        BooleanOperator::AND => {
+            if *op2 == BooleanOperator::OR {
+                false
+            } else {
+                true
+            }
+        },
+        BooleanOperator::NOT => {
+            if *op2 == BooleanOperator::OR || *op2 == BooleanOperator::AND {
+                false
+            } else {
+                true
+            }
+        },
+        BooleanOperator::I => false,
+    }
+}

src/condition/condition_type.rs

@@ -0,0 +1,23 @@
+pub enum ConditionOperator {
+    Minor,
+    MinorEqual,
+    Equal,
+    Higher,
+    HigherEqual,
+}
+
+pub enum BooleanOperator {
+    AND,
+    OR,
+    NOT, // NOT.         Left child
+    I,   // identity.
+}
+
+/*
+impl PartialEq for BooleanOperator {
+    fn eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
+impl Eq for BooleanOperator {}
+*/

src/libs.rs

@@ -0,0 +1,4 @@
+// Dumb file for organize everything into libs
+pub mod error;
+pub mod exec;
+pub mod parsing;