1

     2

#include "evsql.h"

     3

#include "../lib/error.h"

     4

#include "../lib/misc.h"

     5

     6

#include <stdlib.h>

     7

#include <assert.h>

     8

     9

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

    10

    if (!res->error)

    11

        return "No error";

    12

    13

    switch (res->evsql->type) {

    14

        case EVSQL_EVPQ:

    15

            if (!res->result.pq)

    16

                return "unknown error (no result)";

    17

    18

            return PQresultErrorMessage(res->result.pq);

    19

    20

        default:

    21

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

    22

    }

    23

    24

}

    25

    26

size_t evsql_result_rows (const struct evsql_result *res) {

    27

    switch (res->evsql->type) {

    28

        case EVSQL_EVPQ:

    29

            return PQntuples(res->result.pq);

    30

    31

        default:

    32

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

    33

    }

    34

}

    35

    36

size_t evsql_result_cols (const struct evsql_result *res) {

    37

    switch (res->evsql->type) {

    38

        case EVSQL_EVPQ:

    39

            return PQnfields(res->result.pq);

    40

    41

        default:

    42

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

    43

    }

    44

}

    45

    46

size_t evsql_result_affected (const struct evsql_result *res) {

    47

    switch (res->evsql->type) {

    48

        case EVSQL_EVPQ:

    49

            // XXX: errors?

    50

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

    51

    52

        default:

    53

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

    54

    }

    55

}

    56

    57

    58

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

    59

    switch (res->evsql->type) {

    60

        case EVSQL_EVPQ:

    61

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

    62

    63

        default:

    64

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

    65

    }

    66

}

    67

    68

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

    69

    *ptr = NULL;

    70

    71

    switch (res->evsql->type) {

    72

        case EVSQL_EVPQ:

    73

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

    74

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

    75

    76

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

    77

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

    78

    79

            return 0;

    80

    81

        default:

    82

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

    83

    }

    84

    85

error:

    86

    return -1;

    87

}

    88

    89

err_t evsql_result_check (struct evsql_result *res) {

    90

    // so simple...

    91

    return res->error ? EIO : 0;

    92

}

    93

    94

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

    95

    struct evsql_item_info *col;

    96

    size_t cols = 0, nrows;

    97

    err_t err;

    98

    99

    // count info columns

   100

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

   101

        cols++;

   102

   103

    // number of rows returned/affected

   104

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

   105

   106

    // did the query fail outright?

   107

    if (res->error)

   108

        // dump error message

   109

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

   110

   111

/*

   112

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

   113

    if (nrows == 0)

   114

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

   115

*/

   116

   117

    // correct number of columns

   118

    if (evsql_result_cols(res) != cols)

   120

   121

    // assign

   122

    res->info = info;

   123

    res->row_offset = 0;

   124

   125

    // good

   126

    return 0;

   127

   128

error:

   129

    return err;

   130

   131

}

   132

   133

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

   134

    va_list vargs;

   135

    struct evsql_item_info *col;

   136

    size_t col_idx, row_idx = res->row_offset;

   137

    err_t err;

   138

   139

    // ensure that evsql_result_begin has been called

   140

    assert(res->info);

   141

   142

    // check if we're past the end

   143

    if (row_idx >= evsql_result_rows(res))

   144

        return 0;

   145

   146

    // varargs

   147

    va_start(vargs, res);

   148

   149

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

   150

        char *value = NULL;

   151

        size_t length = 0;

   152

   153

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

   154

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

   155

            if (!col->flags.null_ok)

   156

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

   157

   158

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

   159

            SERROR(err = EINVAL);

   160

   161

        }

   162

   163

        // read the arg

   164

        switch (col->type) {

   165

            case EVSQL_TYPE_BINARY: {

   166

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

   167

   168

                if (value) {

   169

                    item_ptr->ptr = value;

   170

                    item_ptr->len = length;

   171

                }

   172

            } break;

   173

   174

            case EVSQL_TYPE_STRING: {

   175

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

   176

   177

                if (value) {

   178

                    *str_ptr = value;

   179

                }

   180

   181

            } break;

   182

   183

            case EVSQL_TYPE_UINT16: {

   184

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

   185

   186

                if (!value) break;

   187

   188

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

   189

   190

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

   191

   192

                if (sval < 0) XERROR(err = ERANGE, "r%zu:c%zu: out of range for uint16_t: %hd", row_idx, col_idx, (signed short) sval);

   193

   194

                *uval_ptr = sval;

   195

            } break;

   196

   197

            case EVSQL_TYPE_UINT32: {

   198

                uint32_t *uval_ptr = va_arg(vargs, uint32_t *);

   199

   200

                if (!value) break;

   201

   202

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

   203

   204

                int32_t sval = ntohl(*((int32_t *) value));

   205

   206

                if (sval < 0) XERROR(err = ERANGE, "r%zu:c%zu: out of range for uint32_t: %ld", row_idx, col_idx, (signed long) sval);

   207

   208

                *uval_ptr = sval;

   209

            } break;

   210

   211

            case EVSQL_TYPE_UINT64: {

   212

                uint64_t *uval_ptr = va_arg(vargs, uint64_t *);

   213

   214

                if (!value) break;

   215

   216

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

   217

   218

                int64_t sval = ntohq(*((int64_t *) value));

   219

   220

                if (sval < 0) XERROR(err = ERANGE, "r%zu:c%zu: out of range for uint64_t: %lld", row_idx, col_idx, (signed long long) sval);

   221

   222

                *uval_ptr = sval;

   223

            } break;

   224

   225

            default:

   226

                XERROR(err = EINVAL, "r%zu:c%zu: invalid type: %d", row_idx, col_idx, col->type);

   227

        }

   228

    }

   229

   233

    // row handled succesfully

   234

    return 1;

   235

   236

error:

   237

    return -err;

   238

}

   239

   240

void evsql_result_end (struct evsql_result *res) {

   241

    // not much more to it...

   242

    evsql_result_free(res);

   243

}

   244

   245

void evsql_result_free (struct evsql_result *res) {

   246

    // note that the result itself might be NULL...

   247

    // in the case of internal-error results, these may be free'd multiple times!

   248

    switch (res->evsql->type) {

   249

        case EVSQL_EVPQ:

   250

            if (res->result.pq)

   251

                return PQclear(res->result.pq);

   252

   253

        default:

   254

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

   255

    }

   256

}

   257

   258