elif-orm 0.7.1

Production-ready ORM with migrations, database services, connection pooling, and 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

use serde_json::Value as JsonValue;

/// Convert a PostgreSQL row to JSON Value (standalone function)
pub fn convert_row_to_json(row: &sqlx::postgres::PgRow) -> Result<JsonValue, String> {
    use sqlx::{Column, Row};
    let mut map = serde_json::Map::new();

    for (i, column) in row.columns().iter().enumerate() {
        let column_name = column.name();

        // Try to get the value as different PostgreSQL types
        let json_value = if let Ok(value) = row.try_get::<Option<String>, _>(i) {
            value.map_or(JsonValue::Null, JsonValue::String)
        } else if let Ok(value) = row.try_get::<Option<i64>, _>(i) {
            value.map_or(JsonValue::Null, |v| {
                JsonValue::Number(serde_json::Number::from(v))
            })
        } else if let Ok(value) = row.try_get::<Option<i32>, _>(i) {
            value.map_or(JsonValue::Null, |v| {
                JsonValue::Number(serde_json::Number::from(v))
            })
        } else if let Ok(value) = row.try_get::<Option<f64>, _>(i) {
            value.map_or(JsonValue::Null, |v| {
                JsonValue::Number(
                    serde_json::Number::from_f64(v).unwrap_or(serde_json::Number::from(0)),
                )
            })
        } else if let Ok(value) = row.try_get::<Option<f32>, _>(i) {
            value.map_or(JsonValue::Null, |v| {
                JsonValue::Number(
                    serde_json::Number::from_f64(v as f64).unwrap_or(serde_json::Number::from(0)),
                )
            })
        } else if let Ok(value) = row.try_get::<Option<bool>, _>(i) {
            value.map_or(JsonValue::Null, JsonValue::Bool)
        } else if let Ok(value) = row.try_get::<Option<chrono::DateTime<chrono::Utc>>, _>(i) {
            value.map_or(JsonValue::Null, |v| JsonValue::String(v.to_rfc3339()))
        } else if let Ok(value) = row.try_get::<Option<uuid::Uuid>, _>(i) {
            value.map_or(JsonValue::Null, |v| JsonValue::String(v.to_string()))
        } else if let Ok(value) = row.try_get::<Option<serde_json::Value>, _>(i) {
            value.unwrap_or(JsonValue::Null)
        } else {
            // Fallback: try to get as string or return null
            if let Ok(value) = row.try_get::<Option<String>, _>(i) {
                value.map_or(JsonValue::Null, JsonValue::String)
            } else {
                JsonValue::Null
            }
        };

        map.insert(column_name.to_string(), json_value);
    }

    Ok(JsonValue::Object(map))
}

/// Row to JSON conversion functionality
impl super::BatchLoader {
    /// Convert a PostgreSQL row to JSON Value
    pub(super) fn row_to_json(&self, row: &sqlx::postgres::PgRow) -> Result<JsonValue, String> {
        use sqlx::{Column, Row};
        let mut map = serde_json::Map::new();

        for (i, column) in row.columns().iter().enumerate() {
            let column_name = column.name();

            // Try to get the value as different PostgreSQL types
            let json_value = if let Ok(value) = row.try_get::<Option<String>, _>(i) {
                value.map_or(JsonValue::Null, JsonValue::String)
            } else if let Ok(value) = row.try_get::<Option<i64>, _>(i) {
                value.map_or(JsonValue::Null, |v| {
                    JsonValue::Number(serde_json::Number::from(v))
                })
            } else if let Ok(value) = row.try_get::<Option<i32>, _>(i) {
                value.map_or(JsonValue::Null, |v| {
                    JsonValue::Number(serde_json::Number::from(v))
                })
            } else if let Ok(value) = row.try_get::<Option<f64>, _>(i) {
                value.map_or(JsonValue::Null, |v| {
                    JsonValue::Number(
                        serde_json::Number::from_f64(v).unwrap_or(serde_json::Number::from(0)),
                    )
                })
            } else if let Ok(value) = row.try_get::<Option<f32>, _>(i) {
                value.map_or(JsonValue::Null, |v| {
                    JsonValue::Number(
                        serde_json::Number::from_f64(v as f64)
                            .unwrap_or(serde_json::Number::from(0)),
                    )
                })
            } else if let Ok(value) = row.try_get::<Option<bool>, _>(i) {
                value.map_or(JsonValue::Null, JsonValue::Bool)
            } else if let Ok(value) = row.try_get::<Option<chrono::DateTime<chrono::Utc>>, _>(i) {
                value.map_or(JsonValue::Null, |v| JsonValue::String(v.to_rfc3339()))
            } else if let Ok(value) = row.try_get::<Option<uuid::Uuid>, _>(i) {
                value.map_or(JsonValue::Null, |v| JsonValue::String(v.to_string()))
            } else if let Ok(value) = row.try_get::<Option<serde_json::Value>, _>(i) {
                value.unwrap_or(JsonValue::Null)
            } else {
                // Fallback: try to get as string or return null
                if let Ok(value) = row.try_get::<Option<String>, _>(i) {
                    value.map_or(JsonValue::Null, JsonValue::String)
                } else {
                    JsonValue::Null
                }
            };

            map.insert(column_name.to_string(), json_value);
        }

        Ok(JsonValue::Object(map))
    }
}