diesel_tests/tests/schema_inference.rs

extern crate chrono;

#[cfg(feature = "sqlite")]
mod sqlite {
    use super::chrono::*;
    use crate::schema::*;
    use diesel::*;

    #[derive(Queryable, PartialEq, Debug, Insertable)]
    #[table_name = "infer_all_the_ints"]
    struct InferredInts {
        col1: i32,
        col2: i32,
        col3: i32,
        col4: i32,
        col5: i16,
        col6: i16,
        col7: i16,
        col8: i64,
        col9: i64,
        col10: i64,
        col11: i16,
        col12: i32,
        col13: i64,
    }

    #[test]
    fn integers_infer_to_semantically_correct_types() {
        let conn = connection();
        let inferred_ints = InferredInts {
            col1: 1,
            col2: 2,
            col3: 3,
            col4: 4,
            col5: 5,
            col6: 6,
            col7: 7,
            col8: 8,
            col9: 9,
            col10: 10,
            col11: 11,
            col12: 12,
            col13: 13,
        };
        insert_into(infer_all_the_ints::table)
            .values(&inferred_ints)
            .execute(&conn)
            .unwrap();

        assert_eq!(
            Ok(vec![inferred_ints]),
            infer_all_the_ints::table.load(&conn)
        );
    }

    #[derive(Queryable, PartialEq, Debug, Insertable)]
    #[table_name = "infer_all_the_bools"]
    struct InferredBools {
        col1: bool,
        col2: bool,
        col3: bool,
        col4: bool,
    }

    #[test]
    fn bool_types_infer_to_bool() {
        let conn = connection();
        let inferred_bools = InferredBools {
            col1: true,
            col2: true,
            col3: false,
            col4: false,
        };
        insert_into(infer_all_the_bools::table)
            .values(&inferred_bools)
            .execute(&conn)
            .unwrap();

        assert_eq!(
            Ok(vec![inferred_bools]),
            infer_all_the_bools::table.load(&conn)
        );
    }

    #[derive(Queryable, PartialEq, Debug, Insertable)]
    #[table_name = "infer_all_the_strings"]
    struct InferredStrings {
        col1: String,
        col2: String,
        col3: String,
        col4: String,
        col5: String,
        col6: String,
        col7: String,
        col8: String,
        col9: Vec<u8>,
        col10: Vec<u8>,
    }

    #[test]
    fn strings_infer_to_semantically_correct_types() {
        let conn = connection();
        let inferred_strings = InferredStrings {
            col1: "Hello".into(),
            col2: "Hello".into(),
            col3: "Hello".into(),
            col4: "Hello".into(),
            col5: "Hello".into(),
            col6: "Hello".into(),
            col7: "Hello".into(),
            col8: "Hello".into(),
            col9: vec![1, 2, 3],
            col10: vec![1, 2, 3],
        };
        insert_into(infer_all_the_strings::table)
            .values(&inferred_strings)
            .execute(&conn)
            .unwrap();

        assert_eq!(
            Ok(vec![inferred_strings]),
            infer_all_the_strings::table.load(&conn)
        );
    }

    #[derive(Queryable, PartialEq, Debug, Insertable)]
    #[table_name = "infer_all_the_floats"]
    struct InferredFloats {
        col1: f32,
        col2: f32,
        col3: f64,
        col4: f64,
        col5: f64,
        col6: f64,
    }

    #[test]
    fn floats_infer_to_semantically_correct_types() {
        let conn = connection();
        let inferred_floats = InferredFloats {
            col1: 1.0,
            col2: 2.0,
            col3: 3.0,
            col4: 4.0,
            col5: 5.0,
            col6: 6.0,
        };
        insert_into(infer_all_the_floats::table)
            .values(&inferred_floats)
            .execute(&conn)
            .unwrap();

        assert_eq!(
            Ok(vec![inferred_floats]),
            infer_all_the_floats::table.load(&conn)
        );
    }

    #[derive(Queryable, PartialEq, Debug, Insertable)]
    #[table_name = "infer_all_the_datetime_types"]
    struct InferredDatetimeTypes {
        dt: NaiveDateTime,
        date: NaiveDate,
        time: NaiveTime,
        timestamp: NaiveDateTime,
    }

    #[test]
    fn datetime_types_are_correctly_inferred() {
        let conn = connection();

        let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms(9, 10, 11);
        let inferred_datetime_types = InferredDatetimeTypes {
            dt: dt,
            date: dt.date(),
            time: dt.time(),
            timestamp: dt,
        };

        insert_into(infer_all_the_datetime_types::table)
            .values(&inferred_datetime_types)
            .execute(&conn)
            .unwrap();

        assert_eq!(
            Ok(vec![inferred_datetime_types]),
            infer_all_the_datetime_types::table.load(&conn)
        );
    }
}

#[cfg(feature = "postgres")]
mod postgres {
    use super::chrono::*;
    use crate::schema::*;
    use diesel::data_types::PgNumeric;
    use diesel::*;
    use std::collections::Bound;

    #[derive(Queryable, PartialEq, Debug, Insertable)]
    #[table_name = "all_the_ranges"]
    struct InferredRanges {
        int4: (Bound<i32>, Bound<i32>),
        int8: (Bound<i64>, Bound<i64>),
        num: (Bound<PgNumeric>, Bound<PgNumeric>),
        ts: (Bound<NaiveDateTime>, Bound<NaiveDateTime>),
        tstz: (Bound<DateTime<Utc>>, Bound<DateTime<Utc>>),
        date: (Bound<NaiveDate>, Bound<NaiveDate>),
    }

    #[test]
    fn ranges_are_correctly_inferred() {
        let conn = connection();
        let numeric = PgNumeric::Positive {
            weight: 1,
            scale: 1,
            digits: vec![1],
        };
        let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms(9, 10, 11);

        let inferred_ranges = InferredRanges {
            int4: (Bound::Included(5), Bound::Excluded(12)),
            int8: (Bound::Included(5), Bound::Excluded(13)),
            num: (Bound::Included(numeric), Bound::Unbounded),
            ts: (Bound::Included(dt), Bound::Unbounded),
            tstz: (
                Bound::Unbounded,
                Bound::Excluded(DateTime::<Utc>::from_utc(dt, Utc)),
            ),
            date: (Bound::Included(dt.date()), Bound::Unbounded),
        };

        insert_into(all_the_ranges::table)
            .values(&inferred_ranges)
            .execute(&conn)
            .unwrap();

        assert_eq!(Ok(vec![inferred_ranges]), all_the_ranges::table.load(&conn));
    }
}

#[cfg(feature = "mysql")]
mod mysql {
    use crate::schema::*;
    use diesel::*;

    #[derive(Insertable)]
    #[table_name = "all_the_blobs"]
    struct InferredBlobs<'a> {
        id: i32,
        tiny: &'a [u8],
        normal: &'a [u8],
        medium: &'a [u8],
        big: &'a [u8],
    }

    #[derive(Queryable, Debug, PartialEq)]
    struct Blobs {
        id: i32,
        tiny: Vec<u8>,
        normal: Vec<u8>,
        medium: Vec<u8>,
        big: Vec<u8>,
    }

    #[test]
    fn blobs_are_correctly_inferred() {
        let conn = connection();
        let inferred_blobs = InferredBlobs {
            id: 0,
            tiny: &[0x01],
            normal: &[0x02],
            medium: &[0x03],
            big: &[0x04],
        };

        let blobs = Blobs {
            id: 0,
            tiny: vec![0x01],
            normal: vec![0x02],
            medium: vec![0x03],
            big: vec![0x04],
        };

        insert_into(all_the_blobs::table)
            .values(&inferred_blobs)
            .execute(&conn)
            .unwrap();
        assert_eq!(Ok(vec![blobs]), all_the_blobs::table.load(&conn));
    }
}

#[test]
fn columns_named_as_reserved_keywords_are_renamed() {
    use crate::schema::*;
    use diesel::*;

    #[derive(Queryable, Insertable, Debug, PartialEq)]
    #[table_name = "with_keywords"]
    struct WithKeywords {
        fn_: i32,
        let_: i32,
        extern_: i32,
    }

    let value = WithKeywords {
        fn_: 1,
        let_: 42,
        extern_: 51,
    };

    let conn = connection();
    insert_into(with_keywords::table)
        .values(&value)
        .execute(&conn)
        .unwrap();
    assert_eq!(Ok(vec![value]), with_keywords::table.load(&conn));
}