1

     2

#include "evsql.h"

     3

     4

const char *evsql_result_error (const struct evsql_result *res) {

     5

    if (!res->error)

     6

        return "No error";

     7

     8

    switch (res->evsql->type) {

     9

        case EVSQL_EVPQ:

    10

            if (!res->result.pq)

    11

                return "unknown error (no result)";

    12

    13

            return PQresultErrorMessage(res->result.pq);

    14

    15

        default:

    16

            FATAL("res->evsql->type");

    17

    }

    18

    19

}

    20

    21

size_t evsql_result_rows (const struct evsql_result *res) {

    22

    switch (res->evsql->type) {

    23

        case EVSQL_EVPQ:

    24

            return PQntuples(res->result.pq);

    25

    26

        default:

    27

            FATAL("res->evsql->type");

    28

    }

    29

}

    30

    31

size_t evsql_result_cols (const struct evsql_result *res) {

    32

    switch (res->evsql->type) {

    33

        case EVSQL_EVPQ:

    34

            return PQnfields(res->result.pq);

    35

    36

        default:

    37

            FATAL("res->evsql->type");

    38

    }

    39

}

    40

    41

size_t evsql_result_affected (const struct evsql_result *res) {

    42

    switch (res->evsql->type) {

    43

        case EVSQL_EVPQ:

    44

            return strtol(PQcmdTuples(res->result.pq), NULL, 10);

    45

    46

        default:

    47

            FATAL("res->evsql->type");

    48

    }

    49

}

    50

    51

    52

int evsql_result_null (const struct evsql_result *res, size_t row, size_t col) {

    53

    switch (res->evsql->type) {

    54

        case EVSQL_EVPQ:

    55

            return PQgetisnull(res->result.pq, row, col);

    56

    57

        default:

    58

            FATAL("res->evsql->type");

    59

    }

    60

    61

error:

    62

    return -1;

    63

}

    64

    65

int evsql_result_field (const struct evsql_result *res, size_t row, size_t col, const char **ptr, size_t *size) {

    66

    *ptr = NULL;

    67

    68

    switch (res->evsql->type) {

    69

        case EVSQL_EVPQ:

    70

            if (PQfformat(res->result.pq, col) != 1)

    71

                ERROR("[%zu:%zu] PQfformat is not binary: %d", row, col, PQfformat(res->result.pq, col));

    72

    73

            *size = PQgetlength(res->result.pq, row, col);

    74

            *ptr  = PQgetvalue(res->result.pq, row, col);

    75

    76

            return 0;

    77

    78

        default:

    79

            FATAL("res->evsql->type");

    80

    }

    81

    82

error:

    83

    return -1;

    84

}

    85

    86

err_t evsql_result_begin (struct evsql_result_info *info, struct evsql_result *res) {

    87

    struct evsql_item_info *col;

    88

    size_t cols = 0, nrows;

    89

    err_t err;

    90

    91

    // count info columns

    92

    for (col = info->columns; col->type; col++)

    93

        cols++;

    94

    95

    // number of rows returned/affected

    96

    nrows = evsql_result_rows(res) || evsql_result_affected(res);

    97

    98

    // did the query fail outright?

    99

    if (res->error)

   100

        // dump error message

   101

        NXERROR(err = EIO, evsql_result_error(res));

   102

   103

/*

   104

    // SELECT/DELETE/UPDATE WHERE didn't match any rows -> ENOENT

   105

    if (nrows == 0)

   106

        XERROR(err = ENOENT, "no rows returned/affected");

   107

*/

   108

   109

    // correct number of columns

   110

    if (evsql_result_cols(res) != cols)

   111

        XERROR(err = EINVAL, "wrong number of columns: %zu -> %zu", cols, evsql_result_cols(res));

   112

   113

    // assign

   114

    res->info = info;

   115

    res->row_offset = 0;

   116

   117

    // good

   118

    return 0;

   119

   120

error:

   121

    return err;

   122

   123

}

   124

   125

int evsql_result_next (struct evsql_result *res, ...) {

   126

    va_list vargs;

   127

    struct evsql_item_info *col;

   128

    size_t col_idx, row_idx = res->row_offset;

   129

    int err;

   130

   131

    // check if we're past the end

   132

    if (row_idx >= evsql_result_rows(res))

   133

        return 0;

   134

   135

    // varargs

   136

    va_start(vargs);

   137

   138

    for (col = info->columns, col_idx = 0; col->type; col++, col_idx++) {

   139

        char *value = NULL;

   140

        size_t length = 0;

   141

   142

        // check for NULLs, then try and get the field value

   143

        if (evsql_result_null(res, row_idx, col_idx)) {

   144

            if (!col->flags.null_ok)

   145

                XERROR(err = EINVAL, "r%zu:c%zu: NULL", row_idx, col_idx);

   146

   147

        } else if (evsql_result_field(row_idx, col_idx, &value, &length)) {

   148

            EERROR(err = EINVAL);

   149

   150

        }

   151

   152

        // read the arg

   153

        switch (col->type) {

   154

            case EVSQL_TYPE_BINARY: {

   155

                struct evsql_item_binary *item_ptr = va_arg(vargs, struct evsql_item_binary *);

   156

   157

                if (value) {

   158

                    item_ptr->ptr = value;

   159

                    item_ptr->len = length;

   160

                }

   161

            } break;

   162

   163

            case EVSQL_TYPE_STRING: {

   164

                char **str_ptr = va_arg(vargs, char **);

   165

   166

                if (value) 

   167

                    *str_ptr = value;

   168

   169

            } break;

   170

   171

            case EVSQL_TYPE_UINT16: {

   172

                uint16_t *uval_ptr = va_arg(vars, uint16_t *);

   173

   174

                if (value) {

   175

                    if (length != sizeof(uint16_t))

   176

                        XERROR(err = EINVAL, "r%zu:c%zu: wrong size for uint16_t: %zu", row_idx, col_idx, length);

   177

   178

                    int16_t sval = ntohs(*((int16_t *) value));

   179

   180

                    if (sval < 0)

   181

                        XERROR(err = ERANGE, "r%zu:c%zu: out of range for uint16_t: %d", row_idx, col_idx, sval);

   182

   183

                    *uval_ptr = sval;

   184

                }

   185

            } break;

   186

        }

   187

    }

   188

   189

   190

}

   191

   192

void evsql_result_end (struct evsql_result *res) {

   193

    // not much more to it...

   194

    evsql_result_free(res);

   195

}

   196

   197

void evsql_result_free (struct evsql_result *res) {

   198

    switch (res->evsql->type) {

   199

        case EVSQL_EVPQ:

   200

            return PQclear(res->result.pq);

   201

   202

        default:

   203

            FATAL("res->evsql->type");

   204

    }

   205

}

   206

   207