Currently, the SQL type BIT is only partially supported--it's in sea_query::ColumnType, but it doesn't get generated properly by sea-orm-cli and it doesn't get serialized with into_json.

For a table with a field like this:

  `field` bit(1) NOT NULL,

sea just generates a "custom" field:

    #[sea_orm(column_type = "custom(\"BIT(1)\")")]
    pub field: String,

Retrieving data with this model fails with the following error:

Query(SqlxError(ColumnDecode { index: "\"field\"", source: "mismatched types; Rust type `core::option::Option<alloc::string::String>` (as SQL type `VARCHAR`) is not compatible with SQL type `BIT`" }))'

Changing the rust type to bool (if BIT(1)) or u32 or u64 (for larger numbers of bits) works fine for the model, but silently fails to be converted to serde_json::Value using into_json-- the resulting Objects are simply missing the fields.

An example repo to show the problem: https://github.com/e-rhodes/sea-orm-test/tree/bit

What should be done in this case?

Ideally, in my opinion, it would choose between bool or u{x} for the Rust type as appropriate for the number of bits (so BIT(1) -> bool, BIT(2-8) => u8, BIT(9-16) -> u16, etc.). Even just bool or u64 would be helpful, since BIT(1) is likely the most common. Automatically generating u64 but allowing retrieval to a bool after changing it manually would also be acceptable (similar to the current behavior with TINYINT).

The maximum value for the number of bits is 64 in MySQL (source), which means it could always go into a u64, but it doesn't look like there's a limit in postgres, which complicates things (source).

If there isn't a limit for Postgres, then maybe it would have to be Vec<bool>. For BIT as opposed to BIT VARYING, it would be really cool to generate a fixed array (i.e. BIT(m) -> [bool; m]). That way you can just destructure the array without having to check the length in the Rust code when you know it's guaranteed by the database. This might actually be a nicer interface to use than u64.

It doesn't seem like the column_type attribute really has an effect. Using the correct sea_query::ColumnType::Bit doesn't change the output, only changing the Rust type fixes the error:

    #[sea_orm(column_type = "Bit(Some(1))")]
    pub field: bool,

So it seems like it should be left off entirely, but maybe it's helpful? I'm not familiar enough with the inner workings to know.

As for into_json, the current behavior of silently failing, even when the model would deserialize correctly, is definitely not ideal lol. I think at the very least it should produce an error when it fails to match a type (just simply adding a return Err() at then end of all the try_get_type!s in impl FromQueryResult for JsonValue). Ideally, it would go to Value::Bool or Value::Number as appropriate (or Value::Array(Vec<Value::Bool>).