diff --git a/query-engine/connector-test-kit-rs/query-engine-tests/tests/raw/sql/typed_output.rs b/query-engine/connector-test-kit-rs/query-engine-tests/tests/raw/sql/typed_output.rs
index bc11be656f4d..e042ed240d5e 100644
--- a/query-engine/connector-test-kit-rs/query-engine-tests/tests/raw/sql/typed_output.rs
+++ b/query-engine/connector-test-kit-rs/query-engine-tests/tests/raw/sql/typed_output.rs
@@ -196,6 +196,64 @@ mod typed_output {
         Ok(())
     }
 
+    fn schema_native_types_pg() -> String {
+        let schema = indoc! {
+            r#"model TestModel {
+              #id(id, Int, @id)
+              oid Int? @test.Oid
+            }"#
+        };
+
+        schema.to_owned()
+    }
+
+    #[connector_test(schema(schema_native_types_pg), only(Postgres))]
+    async fn native_types_pg(runner: Runner) -> TestResult<()> {
+        create_row(
+            &runner,
+            r#"{
+              id: 1,
+              oid: 4294967295
+            }"#,
+        )
+        .await?;
+        create_row(&runner, r#"{ id: 2 }"#).await?;
+
+        insta::assert_snapshot!(
+          run_query_pretty!(&runner, fmt_query_raw(r#"SELECT * FROM "TestModel";"#, vec![])),
+          @r###"
+        {
+          "data": {
+            "queryRaw": [
+              {
+                "id": {
+                  "prisma__type": "int",
+                  "prisma__value": 1
+                },
+                "oid": {
+                  "prisma__type": "uint32",
+                  "prisma__value": 4294967295
+                }
+              },
+              {
+                "id": {
+                  "prisma__type": "int",
+                  "prisma__value": 2
+                },
+                "oid": {
+                  "prisma__type": "null",
+                  "prisma__value": null
+                }
+              }
+            ]
+          }
+        }
+        "###
+        );
+
+        Ok(())
+    }
+
     fn schema_mysql() -> String {
         let schema = indoc! {
             r#"model TestModel {
@@ -341,6 +399,53 @@ mod typed_output {
         Ok(())
     }
 
+    fn schema_uint() -> String {
+        let schema = indoc! {
+            r#"model TestModel {
+            #id(id, Int, @id)
+            uint Int @test.UnsignedInt
+          }"#
+        };
+
+        schema.to_owned()
+    }
+
+    #[connector_test(schema(schema_uint), only(MySql))]
+    async fn uint_as_int_mysql(runner: Runner) -> TestResult<()> {
+        create_row(
+            &runner,
+            r#"{
+            id: 1,
+            uint: 4294967295,
+          }"#,
+        )
+        .await?;
+
+        insta::assert_snapshot!(
+          run_query_pretty!(&runner, fmt_query_raw(r#"SELECT * FROM TestModel;"#, vec![])),
+          @r###"
+        {
+          "data": {
+            "queryRaw": [
+              {
+                "id": {
+                  "prisma__type": "int",
+                  "prisma__value": 1
+                },
+                "uint": {
+                  "prisma__type": "uint32",
+                  "prisma__value": 4294967295
+                }
+              }
+            ]
+          }
+        }
+        "###
+        );
+
+        Ok(())
+    }
+
     #[connector_test(schema(schema_mysql), only(MySql("mariadb")))]
     async fn all_scalars_mariadb(runner: Runner) -> TestResult<()> {
         create_row(
diff --git a/query-engine/connectors/sql-query-connector/src/value.rs b/query-engine/connectors/sql-query-connector/src/value.rs
index 7baaafd62859..f0e58f6c0228 100644
--- a/query-engine/connectors/sql-query-connector/src/value.rs
+++ b/query-engine/connectors/sql-query-connector/src/value.rs
@@ -8,6 +8,7 @@ pub fn to_prisma_value(quaint_value: Value<'_>) -> crate::Result<PrismaValue> {
     let val = match quaint_value {
         Value::Int32(i) => i.map(|i| PrismaValue::Int(i as i64)).unwrap_or(PrismaValue::Null),
         Value::Int64(i) => i.map(PrismaValue::Int).unwrap_or(PrismaValue::Null),
+        Value::UnsignedInt32(u) => u.map(|u| PrismaValue::Int(u as i64)).unwrap_or(PrismaValue::Null),
         Value::Float(Some(f)) => match f {
             f if f.is_nan() => {
                 return Err(ConversionFailure {
diff --git a/query-engine/connectors/sql-query-connector/src/value_ext.rs b/query-engine/connectors/sql-query-connector/src/value_ext.rs
index 1d9a82427592..331e1c33b6a1 100644
--- a/query-engine/connectors/sql-query-connector/src/value_ext.rs
+++ b/query-engine/connectors/sql-query-connector/src/value_ext.rs
@@ -14,6 +14,7 @@ impl<'a> IntoTypedJsonExtension for quaint::Value<'a> {
         let type_name = match self {
             quaint::Value::Int32(_) => "int",
             quaint::Value::Int64(_) => "bigint",
+            quaint::Value::UnsignedInt32(_) => "uint32",
             quaint::Value::Float(_) => "float",
             quaint::Value::Double(_) => "double",
             quaint::Value::Text(_) => "string",