#[derive(Debug, PartialEq)]
pub struct Select {
    pub fields: Vec<Field>,
    pub source: KIdentifier,
    pub where_clause: Option<Where>,
}

#[derive(Debug, PartialEq)]
pub enum Field {
    Named(String),
    Star,
}

#[derive(Debug, PartialEq)]
pub struct Where {
    pub predicates: Vec<Equals>,
}

impl Where {
    pub fn new(predicates: Vec<Equals>) -> Self {
        Self { predicates }
    }
}

#[derive(Debug, PartialEq)]
pub struct Equals {
    pub left: KIdentifier,
    pub right: KValue,
}

impl Equals {
    pub fn new(left: KIdentifier, right: KValue) -> Self {
        Self { left, right }
    }
}

#[derive(Debug, PartialEq)]
pub enum KValue {
    Identifier(KIdentifier),
    Number(KNumber),
    String(KString),
}

#[derive(Debug, PartialEq)]
pub struct KIdentifier {
    pub name: String,
}

#[derive(Debug, PartialEq)]
pub struct KNumber {
    pub value: f64,
}

#[derive(Debug, PartialEq)]
pub struct KString {
    pub value: String,
}

impl KIdentifier {
    pub fn new(name: &str) -> Self {
        Self {
            name: name.to_string(),
        }
    }
}

impl KNumber {
    pub fn new(value: f64) -> Self {
        Self { value }
    }
}

impl KString {
    pub fn new(value: &str) -> Self {
        Self {
            value: value.to_string(),
        }
    }
}