1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105

use crate::*;

pub fn migrate(mut tester: impl tests::Tester) {
    let sql = r#"
CREATE TABLE Test (
    id INT,
    num INT,
    name TEXT
)"#;

    tester.run(sql).unwrap();

    let sqls = [
        "INSERT INTO Test (id, num, name) VALUES (1, 2, \"Hello\")",
        "INSERT INTO Test (id, num, name) VALUES (1, 9, \"World\")",
        "INSERT INTO Test (id, num, name) VALUES (3, 4, \"Great\")",
    ];

    sqls.iter().for_each(|sql| {
        tester.run(sql).unwrap();
    });

    let error_cases = vec![
        (
            RowError::UnsupportedAstValueType.into(),
            "INSERT INTO Test (id, num) VALUES (3 * 2, 1);",
        ),
        (
            RowError::MultiRowInsertNotSupported.into(),
            "INSERT INTO Test (id, num) VALUES (1, 1), (2, 1);",
        ),
        (
            ValueError::FailedToParseNumber.into(),
            "INSERT INTO Test (id, num) VALUES (1.1, 1);",
        ),
        (
            EvaluateError::UnsupportedCompoundIdentifier("Here.User.id".to_owned()).into(),
            "SELECT * FROM Test WHERE Here.User.id = 1",
        ),
        (
            JoinError::NaturalOnJoinNotSupported.into(),
            "SELECT * FROM Test NATURAL JOIN Test",
        ),
        (
            TableError::TableFactorNotSupported.into(),
            "SELECT * FROM (SELECT * FROM Test) as A;",
        ),
    ];

    error_cases.into_iter().for_each(|(error, sql)| {
        let error = Err(error);

        assert_eq!(error, tester.run(sql));
    });

    use Value::*;

    let found = tester
        .run("SELECT id, num, name FROM Test")
        .expect("select");
    let expected = select!(
        I64 I64 Str;
        1   2   "Hello".to_owned();
        1   9   "World".to_owned();
        3   4   "Great".to_owned()
    );
    assert_eq!(expected, found);

    let found = tester
        .run("SELECT id, num, name FROM Test WHERE id = 1")
        .expect("select");
    let expected = select!(
        I64 I64 Str;
        1   2   "Hello".to_owned();
        1   9   "World".to_owned()
    );
    assert_eq!(expected, found);

    tester.run_and_print("UPDATE Test SET id = 2");

    let found = tester
        .run("SELECT id, num, name FROM Test")
        .expect("select");
    let expected = select!(
        I64 I64 Str;
        2   2   "Hello".to_owned();
        2   9   "World".to_owned();
        2   4   "Great".to_owned()
    );
    assert_eq!(expected, found);

    let found = tester.run("SELECT id FROM Test").expect("select");
    let expected = select!(I64; 2; 2; 2);
    assert_eq!(expected, found);

    let found = tester.run("SELECT id, num FROM Test").expect("select");
    let expected = select!(I64 I64; 2 2; 2 9; 2 4);
    assert_eq!(expected, found);

    let found = tester
        .run("SELECT id, num FROM Test LIMIT 1 OFFSET 1")
        .expect("select");
    let expected = select!(I64 I64; 2 9);
    assert_eq!(expected, found);
}