verify column in option is the same as provided input

[skyzh]

 query II rowsort
 select sum(v1), v2 + 1 as a, count(*) from t group by a
 ----
 3 2 2
 7 3 2
 5 4 1

We should give an error in this case, where we only specify II, but provide 3 column input.

[xxchan]

We need to refactor DB interface? Currently it only returns String. At least it should be Vec<String>. Or maybe Vec<(char, String)> for the type?

Another proposal is use Result as an associated type for DB #16, but I think it might be hard to Runner to handle it? 🤔

[xxchan]

I'm thinking about how should we handle the type.

• duckdb's slt do not check the type, but only the number of columns.
• cockroach's slt has more type chars than sqlite's

Currently in runner we don't check the type-string. In parser, I prototyped something like this:

#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[non_exhaustive]
pub enum ColumnType {
    Text,
    Integer,
    FloatingPoint,
    /// Do not check the type of the column.
    Any,
    Unknown(char),
}

impl Display for ColumnType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ColumnType::Text => write!(f, "T"),
            ColumnType::Integer => write!(f, "I"),
            ColumnType::FloatingPoint => write!(f, "R"),
            ColumnType::Any => write!(f, "?"),
            ColumnType::Unknown(c) => write!(f, "{}", c),
        }
    }
}

impl TryFrom<char> for ColumnType {
    type Error = ParseErrorKind;

    fn try_from(c: char) -> Result<Self, Self::Error> {
        match c {
            'T' => Ok(Self::Text),
            'I' => Ok(Self::Integer),
            'R' => Ok(Self::FloatingPoint),
            '?' => Ok(Self::Any),
            // FIXME:
            // _ => Err(ParseErrorKind::InvalidType(c)),
            _ => Ok(Self::Unknown(c)),
        }
    }
}

[xxchan]

I'm wondering whether slt is a good place to check types. One problem is that different dbs may have different type system.

[xxchan]

After #111, it would be easy to implement column type checking, but we need to decide the exact policy.

It's trivial to check number of columns though.

[xxchan]

One solution may be providing a customizable type checker fn(&ColumnType, &ColumnType) -> bool in runner. Just like Validator 🤪

[melgenek]

Hi!
I was working on implementing column type checks for Datafusion, and needed to let sqllogictest-rs validate columns.

I see two ways:

1. creating a standard way for column validation, as well as defining a set of column types.
2. making column type and validation strategies customizable.

The first approach seems to be quite complicated to achieve, as different users of this library could have different needs. Column types also depend on SQL dialects that library users support.

Approach 2 seems a bit more flexible to me, allowing downstream projects to use sqllogictest-rs without a need to coordinate with each other.

I went ahead and implemented a way to define column types and a custom column validator in this pr #160. I would appreciate your feedback.