Refactoring

Author: andygrove

examples/acme_parser.rs

@@ -0,0 +1,20 @@
+use std::sync::{Arc, Mutex};
+
+extern crate datafusion_sql;
+
+use datafusion_sql::ansi::tokenizer::ANSISQLTokenizer;
+use datafusion_sql::ansi::parser::ANSISQLParser;
+use datafusion_sql::tokenizer::*;
+use datafusion_sql::parser::*;
+
+
+fn main() {
+
+    let sql = "SELECT 1 + 1";
+
+    // Create parsers
+    match ANSISQLParser::parse(sql).unwrap() {
+        Some(ast) => println!("{:?}", ast),
+        _ => {}
+    }
+}

examples/parse_sql.rs

@@ -1,30 +1,56 @@
 use std::cmp::PartialEq;
 use std::fmt::Debug;
-//use std::iter::Peekable;
-//use std::str::Chars;
-
-use std::sync::{Arc, Mutex};
+//use std::rc::Rc;
+//use std::sync::{Arc, Mutex};
 
+use super::tokenizer::ANSISQLTokenizer;
 use super::super::tokenizer::*;
 use super::super::parser::*;
 
-pub struct ANSISQLParser<TokenType> {
-    tokenizer: Arc<Mutex<SQLTokenizer<TokenType>>>
+pub struct ANSISQLParser {
+    tokenizer: Box<SQLTokenizer>
 }
 
-impl<TokenType> ANSISQLParser<TokenType> where TokenType: Debug + PartialEq {
+impl ANSISQLParser where {
 
-    pub fn new(tokenizer: Arc<Mutex<SQLTokenizer<TokenType>>>) -> Self {
-        ANSISQLParser { tokenizer: tokenizer.clone() }
+    pub fn parse(sql: &str) -> Result<Option<Box<SQLExpr>>, ParserError> {
+        let mut parser = ANSISQLParser { tokenizer: Box::new(ANSISQLTokenizer::new(sql)) };
+        parser.parse_expr()
     }
 }
 
-impl<TokenType, ExprType> SQLParser<TokenType, ExprType> for ANSISQLParser<TokenType>
-    where TokenType: Debug + PartialEq, ExprType: Debug {
+impl SQLParser for ANSISQLParser {
+
+    fn parse_expr(&mut self) -> Result<Option<Box<SQLExpr>>, ParserError> {
+
+        let precedence: usize = 0;
+
+        let mut e = self.parse_prefix()?;
+
+        match e {
+            Some(mut expr) => {
+                while let Some(token) = self.tokenizer.peek_token()? {
+                    let next_precedence = self.tokenizer.precedence(&token);
+
+                    if precedence >= next_precedence {
+                        break;
+                    }
+
+                    expr = self.parse_infix(&expr, next_precedence)?.unwrap(); //TODO: fix me
+                }
+
+                Ok(Some(expr))
+            }
+            _ => {
+                Ok(None)
+            }
+        }
+
+    }
 
-    fn parse_prefix(&mut self, chars: &mut CharSeq) -> Result<Option<Box<SQLExpr<ExprType>>>, ParserError<TokenType>> {
+    fn parse_prefix(&mut self) -> Result<Option<Box<SQLExpr>>, ParserError> {
 
-        match self.tokenizer.lock().unwrap().next_token(chars)? {
+        match self.tokenizer.next_token()? {
             Some(SQLToken::Keyword(ref k)) => match k.to_uppercase().as_ref() {
                 "INSERT" => unimplemented!(),
                 "UPDATE" => unimplemented!(),
@@ -37,7 +63,7 @@ impl<TokenType, ExprType> SQLParser<TokenType, ExprType> for ANSISQLParser<Token
         }
     }
 
-    fn parse_infix(&mut self, _chars: &mut CharSeq, _left: &SQLExpr<ExprType>, _precedence: usize) -> Result<Option<Box<SQLExpr<ExprType>>>, ParserError<TokenType>> {
+    fn parse_infix(&mut self, _left: &SQLExpr, _precedence: usize) -> Result<Option<Box<SQLExpr>>, ParserError> {
         unimplemented!()
     }
 }

src/ansi/parser.rs

@@ -4,26 +4,37 @@ use std::fmt::Debug;
 use super::super::tokenizer::*;
 
 pub struct ANSISQLTokenizer {
+    chars: CharSeq
 }
 
-impl<TokenType> SQLTokenizer<TokenType> for ANSISQLTokenizer
-    where TokenType: Debug + PartialEq {
+impl ANSISQLTokenizer {
+    pub fn new(sql: &str) -> Self {
+        ANSISQLTokenizer { chars: CharSeq::new(sql) }
+    }
+}
 
-    fn precedence(&self, _token: &SQLToken<TokenType>) -> usize {
+impl SQLTokenizer for ANSISQLTokenizer {
+
+    fn precedence(&self, _token: &SQLToken) -> usize {
         unimplemented!()
     }
 
-    fn next_token(&mut self, chars: &mut CharSeq) -> Result<Option<SQLToken<TokenType>>, TokenizerError> {
-        match chars.next() {
+    fn peek_token(&mut self) -> Result<Option<SQLToken>, TokenizerError> {
+        unimplemented!()
+    }
+
+
+    fn next_token(&mut self) -> Result<Option<SQLToken>, TokenizerError> {
+        match self.chars.next() {
             Some(ch) => match ch {
                 ' ' | '\t' | '\n' => Ok(Some(SQLToken::Whitespace(ch))),
                 '0' ... '9' => {
                     let mut s = String::new();
                     s.push(ch);
-                    while let Some(&ch) = chars.peek() {
+                    while let Some(&ch) = self.chars.peek() {
                         match ch {
                             '0' ... '9' => {
-                                chars.next(); // consume
+                                self.chars.next(); // consume
                                 s.push(ch);
                             },
                             _ => break