Function test_interpret

src/expr/tests/test_runner.rs:121–164

(s: &str)

    }

    fn test_interpret(s: &str) -> Result<Vec<String>, String> {
        let mut input_stream = tokenize(s)?.into_iter();
        let mut ctx = MirScalarExprDeserializeContext::default();
        let types: Vec<SqlColumnType> =
            deserialize(&mut input_stream, "Vec<SqlColumnType>", &mut ctx)?;
        let values: Vec<Vec<MirScalarExpr>> =
            deserialize(&mut input_stream, "Vec<Vec<MirScalarExpr>>", &mut ctx)?;
        let expr: MirScalarExpr = deserialize(&mut input_stream, "MirScalarExpr", &mut ctx)?;
        let tests: Vec<MirScalarExpr> =
            deserialize(&mut input_stream, "Vec<MirScalarExpr>", &mut ctx)?;

        let arena = RowArena::new();
        let relation = ReprRelationType::new(types.iter().map(ReprColumnType::from).collect());
        let mut interpreter = ColumnSpecs::new(&relation, &arena);

        let specs: Vec<_> = values
            .into_iter()
            .map(|col_exprs| {
                col_exprs
                    .into_iter()
                    .map(|expr| interpreter.expr(&expr).range)
                    .reduce(|a, b| a.union(b))
                    .expect("at least one literal")
            })
            .collect();

        for (id, spec) in specs.into_iter().enumerate() {
            interpreter.push_column(id, spec);
        }
        let output = interpreter.expr(&expr);

        let mut may_contain: Vec<_> = tests
            .iter()
            .map(|t| t.eval(&[], &arena).expect("literal datum"))
            .filter(|d| output.range.may_contain(*d))
            .map(|d| d.to_string())
            .collect();

        if output.range.may_fail() {
            may_contain.push("<err>".into())
        }

        Ok(may_contain)
    }

    #[mz_ore::test]
    #[cfg_attr(miri, ignore)] // error: unsupported operation: can't call foreign function `decContextDefault` on OS `linux`