omedusyo/minisql
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix errors in parsing crate

Browse source
This commit is contained in:
Yuriy Dupyn 2024-02-01 14:45:29 +01:00
parent 339686f5c5
commit fbd7bf1f72
2 changed files with 34 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files

28
parser/src/parsing/literal.rs
View file

@ -1,4 +1,4 @@
use minisql::type_system::{IndexableValue, Value}; use minisql::type_system::Value;
use nom::{ use nom::{
branch::alt, branch::alt,
character::complete::{char, digit1, none_of, u64}, character::complete::{char, digit1, none_of, u64},
@ -34,13 +34,13 @@ pub fn parse_number(input: &str) -> IResult<&str, Value> {
let value = format!("{}{}", sign.unwrap_or('+'), digits) let value = format!("{}{}", sign.unwrap_or('+'), digits)
.parse::<u64>() .parse::<u64>()
.map_err(|_| nom::Err::Failure(make_error(input, nom::error::ErrorKind::Fail)))?; .map_err(|_| nom::Err::Failure(make_error(input, nom::error::ErrorKind::Fail)))?;
Ok((input, Value::Indexable(IndexableValue::Int(value)))) Ok((input, Value::Int(value)))
} }
} }
} }
pub fn parse_int(input: &str) -> IResult<&str, Value> { pub fn parse_int(input: &str) -> IResult<&str, Value> {
u64(input).map(|(input, v)| (input, Value::Indexable(IndexableValue::Int(v)))) u64(input).map(|(input, v)| (input, Value::Int(v)))
} }
fn escape_tab(input: &str) -> IResult<&str, char> { fn escape_tab(input: &str) -> IResult<&str, char> {
@ -85,19 +85,19 @@ pub fn parse_string(input: &str) -> IResult<&str, Value> {
// Combine the characters into a string // Combine the characters into a string
let value: String = content.into_iter().collect(); let value: String = content.into_iter().collect();
Ok((input, Value::Indexable(IndexableValue::String(value)))) Ok((input, Value::String(value)))
} }
pub fn parse_uuid(input: &str) -> IResult<&str, Value> { pub fn parse_uuid(input: &str) -> IResult<&str, Value> {
let (input, value) = pair(char('u'), u64)(input) let (input, value) = pair(char('u'), u64)(input)
.map(|(input, (_, v))| (input, Value::Indexable(IndexableValue::Uuid(v))))?; .map(|(input, (_, v))| (input, Value::Uuid(v)))?;
Ok((input, value)) Ok((input, value))
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::parsing::literal::{parse_db_value, parse_string, parse_uuid}; use crate::parsing::literal::{parse_db_value, parse_string, parse_uuid};
use minisql::type_system::{IndexableValue, Value}; use minisql::type_system::Value;
#[test] #[test]
fn test_string_parser() { fn test_string_parser() {
@ -105,21 +105,21 @@ mod tests {
parse_string(r#""simple""#), parse_string(r#""simple""#),
Ok(( Ok((
"", "",
Value::Indexable(IndexableValue::String(String::from("simple"))) Value::String(String::from("simple"))
)) ))
); );
assert_eq!( assert_eq!(
parse_string(r#""\"\t\r\n\\""#), parse_string(r#""\"\t\r\n\\""#),
Ok(( Ok((
"", "",
Value::Indexable(IndexableValue::String(String::from("\"\t\r\n\\"))) Value::String(String::from("\"\t\r\n\\"))
)) ))
); );
assert_eq!( assert_eq!(
parse_string(r#""name is \"John\".""#), parse_string(r#""name is \"John\".""#),
Ok(( Ok((
"", "",
Value::Indexable(IndexableValue::String(String::from("name is \"John\"."))) Value::String(String::from("name is \"John\"."))
)) ))
); );
} }
@ -128,7 +128,7 @@ mod tests {
fn test_parse_db_value() { fn test_parse_db_value() {
let (input, value) = parse_db_value("5").expect("should parse"); let (input, value) = parse_db_value("5").expect("should parse");
assert_eq!(input, ""); assert_eq!(input, "");
assert_eq!(value, Value::Indexable(IndexableValue::Int(5))); assert_eq!(value, Value::Int(5));
let (input, value) = parse_db_value("5.5").expect("should parse"); let (input, value) = parse_db_value("5.5").expect("should parse");
assert_eq!(input, ""); assert_eq!(input, "");
@ -140,9 +140,9 @@ mod tests {
assert_eq!(input, ""); assert_eq!(input, "");
assert_eq!( assert_eq!(
value, value,
Value::Indexable(IndexableValue::String( Value::String(
"abcdefghkjklmnopqrstuvwxyz!@#$%^&*()_+ ".to_string() "abcdefghkjklmnopqrstuvwxyz!@#$%^&*()_+ ".to_string()
)) )
); );
} }
@ -183,7 +183,7 @@ mod tests {
fn test_parse_int() { fn test_parse_int() {
assert_eq!( assert_eq!(
parse_db_value("5134616"), parse_db_value("5134616"),
Ok(("", Value::Indexable(IndexableValue::Int(5134616)))) Ok(("", Value::Int(5134616)))
); );
} }
@ -191,7 +191,7 @@ mod tests {
fn test_parse_uuid() { fn test_parse_uuid() {
assert_eq!( assert_eq!(
parse_uuid("u131515"), parse_uuid("u131515"),
Ok(("", Value::Indexable(IndexableValue::Uuid(131515)))) Ok(("", Value::Uuid(131515)))
) )
} }
} }

42
parser/src/validation.rs
View file

@ -105,7 +105,7 @@ fn validate_table_schema(raw_table_schema: RawTableSchema) -> Result<TableSchema
} in raw_table_schema.columns } in raw_table_schema.columns
{ {
if is_primary { if is_primary {
primary_keys.push((column_name.clone(), type_)) primary_keys.push((column_name.clone(), type_.clone()))
} }
columns.push(column_name); columns.push(column_name);
types.push(type_); types.push(type_);
@ -355,9 +355,7 @@ mod tests {
use minisql::type_system::{IndexableValue, Value}; use minisql::type_system::{IndexableValue, Value};
use Condition::*; use Condition::*;
use IndexableValue::*;
use RawQuerySyntax::*; use RawQuerySyntax::*;
use Value::*;
fn users_schema() -> TableSchema { fn users_schema() -> TableSchema {
TableSchema::new( TableSchema::new(
@ -567,7 +565,7 @@ mod tests {
let syntax: RawQuerySyntax = Select( let syntax: RawQuerySyntax = Select(
"users".to_string(), "users".to_string(),
ColumnSelection::All, ColumnSelection::All,
Some(Eq("age".to_string(), Indexable(Int(25)))), Some(Eq("age".to_string(), Value::Int(25))),
); );
let result = validate_operation(syntax, &db_schema); let result = validate_operation(syntax, &db_schema);
assert!(matches!(result, Ok(Operation::Select(_, _, _)))); assert!(matches!(result, Ok(Operation::Select(_, _, _))));
@ -579,7 +577,7 @@ mod tests {
assert!(table_position == users_position); assert!(table_position == users_position);
assert!(column_selection == vec![id, name, age]); assert!(column_selection == vec![id, name, age]);
assert!(condition == Some(operation::Condition::Eq(age, Indexable(Int(25))))); assert!(condition == Some(operation::Condition::Eq(age, Value::Int(25))));
} }
#[test] #[test]
@ -634,7 +632,7 @@ mod tests {
let syntax: RawQuerySyntax = Select( let syntax: RawQuerySyntax = Select(
"users".to_string(), "users".to_string(),
ColumnSelection::All, ColumnSelection::All,
Some(Eq("does_not_exist".to_string(), Indexable(Int(25)))), Some(Eq("does_not_exist".to_string(), Value::Int(25))),
); );
let result = validate_operation(syntax, &db_schema); let result = validate_operation(syntax, &db_schema);
assert!(matches!(result, Err(ValidationError::ColumnsDoNotExist(_)))); assert!(matches!(result, Err(ValidationError::ColumnsDoNotExist(_))));
@ -648,7 +646,7 @@ mod tests {
let syntax: RawQuerySyntax = Select( let syntax: RawQuerySyntax = Select(
"users".to_string(), "users".to_string(),
ColumnSelection::All, ColumnSelection::All,
Some(Eq("age".to_string(), Indexable(String("25".to_string())))), Some(Eq("age".to_string(), Value::String("25".to_string()))),
); );
let result = validate_operation(syntax, &db_schema); let result = validate_operation(syntax, &db_schema);
assert!(matches!(result, Err(ValidationError::TypeMismatch { .. }))); assert!(matches!(result, Err(ValidationError::TypeMismatch { .. })));
@ -665,9 +663,9 @@ mod tests {
let syntax: RawQuerySyntax = Insert( let syntax: RawQuerySyntax = Insert(
"users".to_string(), "users".to_string(),
vec![ vec![
("name".to_string(), Indexable(String("Alice".to_string()))), ("name".to_string(), Value::String("Alice".to_string())),
("id".to_string(), Indexable(Uuid(0))), ("id".to_string(), Value::Uuid(0)),
("age".to_string(), Indexable(Int(25))), ("age".to_string(), Value::Int(25)),
], ],
); );
let result = validate_operation(syntax, &db_schema); let result = validate_operation(syntax, &db_schema);
@ -685,9 +683,9 @@ mod tests {
assert!( assert!(
values values
== vec![ == vec![
Indexable(Uuid(0)), Value::Uuid(0),
Indexable(String("Alice".to_string())), Value::String("Alice".to_string()),
Indexable(Int(25)) Value::Int(25)
] ]
); );
} }
@ -700,10 +698,10 @@ mod tests {
let syntax: RawQuerySyntax = Insert( let syntax: RawQuerySyntax = Insert(
"users".to_string(), "users".to_string(),
vec![ vec![
("name".to_string(), Indexable(String("Alice".to_string()))), ("name".to_string(), Value::String("Alice".to_string())),
("id".to_string(), Indexable(Uuid(0))), ("id".to_string(), Value::Uuid(0)),
("age".to_string(), Indexable(Int(25))), ("age".to_string(), Value::Int(25)),
("does_not_exist".to_string(), Indexable(Int(25))), ("does_not_exist".to_string(), Value::Int(25)),
], ],
); );
let result = validate_operation(syntax, &db_schema); let result = validate_operation(syntax, &db_schema);
@ -718,9 +716,9 @@ mod tests {
let syntax: RawQuerySyntax = Insert( let syntax: RawQuerySyntax = Insert(
"users".to_string(), "users".to_string(),
vec![ vec![
("name".to_string(), Indexable(String("Alice".to_string()))), ("name".to_string(), Value::String("Alice".to_string())),
("id".to_string(), Indexable(Uuid(0))), ("id".to_string(), Value::Uuid(0)),
("age".to_string(), Number(25.0)), ("age".to_string(), Value::Number(25.0)),
], ],
); );
let result = validate_operation(syntax, &db_schema); let result = validate_operation(syntax, &db_schema);
@ -756,7 +754,7 @@ mod tests {
let syntax: RawQuerySyntax = Delete( let syntax: RawQuerySyntax = Delete(
"users".to_string(), "users".to_string(),
Some(Eq("age".to_string(), Indexable(Int(25)))), Some(Eq("age".to_string(), Value::Int(25))),
); );
let result = validate_operation(syntax, &db_schema); let result = validate_operation(syntax, &db_schema);
assert!(matches!( assert!(matches!(
@ -772,7 +770,7 @@ mod tests {
assert!(table_position == users_position); assert!(table_position == users_position);
assert!(column == age); assert!(column == age);
assert!(value == Indexable(Int(25))); assert!(value == Value::Int(25));
} }
// ====CreateIndex==== // ====CreateIndex====