rqb 0.1.7

sqlx-first typed Postgres query builder.
Documentation 
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use crate::common::{self, order_items, organizations, products};
use uuid::Uuid;

#[tokio::test]
#[ignore = "requires Postgres 18 and RQB_TEST_DATABASE_URL"]
async fn postgres_version_is_18() {
    let pool = common::pool().await;
    common::assert_postgres_18(&pool).await;
}

#[tokio::test]
#[ignore = "requires Postgres 18 and RQB_TEST_DATABASE_URL"]
async fn fetch_one_maps_no_rows_to_not_found() {
    let pool = common::pool().await;

    let err = rqb::select(products::table())
        .column(products::ID)
        .filter(products::ID.eq(Uuid::new_v4()))
        .fetch_one_scalar::<Uuid>(&pool)
        .await
        .unwrap_err();

    assert!(matches!(err, rqb::Error::NotFound));
}

#[tokio::test]
#[ignore = "requires Postgres 18 and RQB_TEST_DATABASE_URL"]
async fn unique_violation_maps_constraint_name() {
    let pool = common::pool().await;

    let err = rqb::insert(products::table())
        .set_many((
            products::ID.set(Uuid::new_v4()),
            products::SKU.set("CAM-001".to_owned()),
            products::NAME.set("Duplicate Camera".to_owned()),
            products::PRICE_CENTS.set(100_i64),
        ))
        .execute(&pool)
        .await
        .unwrap_err();

    assert!(matches!(err, rqb::Error::UniqueViolation(_)));
    assert_eq!(err.code(), Some("23505"));
    assert_eq!(err.constraint_name(), Some("products_sku_key"));
    assert!(!err.is_retryable());
}

#[tokio::test]
#[ignore = "requires Postgres 18 and RQB_TEST_DATABASE_URL"]
async fn pk_violation_maps_to_unique_violation() {
    let pool = common::pool().await;

    let err = rqb::insert(products::table())
        .set_many((
            products::ID.set(common::uuid("20000000-0000-0000-0000-000000000001")),
            products::SKU.set(common::unique_text("pk")),
            products::NAME.set("Duplicate primary key".to_owned()),
            products::PRICE_CENTS.set(100_i64),
        ))
        .execute(&pool)
        .await
        .unwrap_err();

    assert!(matches!(err, rqb::Error::UniqueViolation(_)));
    assert_eq!(err.constraint_name(), Some("products_pkey"));
}

#[tokio::test]
#[ignore = "requires Postgres 18 and RQB_TEST_DATABASE_URL"]
async fn foreign_key_violation_maps_constraint_name() {
    let pool = common::pool().await;

    let err = rqb::insert(order_items::table())
        .set_many((
            order_items::ID.set(Uuid::new_v4()),
            order_items::ORDER_ID.set(Uuid::new_v4()),
            order_items::PRODUCT_ID.set(common::uuid("20000000-0000-0000-0000-000000000001")),
            order_items::QUANTITY.set(1_i32),
            order_items::UNIT_PRICE_CENTS.set(100_i64),
        ))
        .execute(&pool)
        .await
        .unwrap_err();

    assert!(matches!(err, rqb::Error::ForeignKeyViolation(_)));
    assert_eq!(err.code(), Some("23503"));
    assert_eq!(err.constraint_name(), Some("order_items_order_id_fkey"));
}

#[tokio::test]
#[ignore = "requires Postgres 18 and RQB_TEST_DATABASE_URL"]
async fn not_null_violation_maps_column_name() {
    let pool = common::pool().await;

    let err = rqb::insert(products::table())
        .set_many((
            products::ID.set(Uuid::new_v4()),
            products::SKU.set(common::unique_text("not-null")),
            products::PRICE_CENTS.set(100_i64),
        ))
        .execute(&pool)
        .await
        .unwrap_err();

    assert!(matches!(err, rqb::Error::NotNullViolation(_)));
    assert_eq!(err.code(), Some("23502"));
    assert_eq!(err.column_name(), Some("name"));
}

#[tokio::test]
#[ignore = "requires Postgres 18 and RQB_TEST_DATABASE_URL"]
async fn check_violation_maps_constraint_name() {
    let pool = common::pool().await;

    let err = rqb::insert(products::table())
        .set_many((
            products::ID.set(Uuid::new_v4()),
            products::SKU.set(common::unique_text("check")),
            products::NAME.set("Invalid price".to_owned()),
            products::PRICE_CENTS.set(-1_i64),
        ))
        .execute(&pool)
        .await
        .unwrap_err();

    assert!(matches!(err, rqb::Error::CheckViolation(_)));
    assert_eq!(err.code(), Some("23514"));
    assert_eq!(
        err.constraint_name(),
        Some("products_price_cents_non_negative")
    );
}

#[tokio::test]
#[ignore = "requires Postgres 18 and RQB_TEST_DATABASE_URL"]
async fn referenced_parent_delete_reports_foreign_key_violation() {
    let pool = common::pool().await;

    let err = rqb::delete_from(organizations::table())
        .filter(organizations::ID.eq(common::uuid("00000000-0000-0000-0000-000000000001")))
        .execute(&pool)
        .await
        .unwrap_err();

    assert!(matches!(err, rqb::Error::ForeignKeyViolation(_)));
    assert_eq!(err.code(), Some("23503"));
    assert_eq!(
        err.constraint_name(),
        Some("app_users_organization_id_fkey")
    );
}