1

#include <assert.h>

     2

     3

#include "evsql.h"

     4

#include "evsql_internal.h"

     5

#include "lib/error.h"

     6

#include "lib/misc.h"

     7

     8

int evsql_param_string (struct evsql_query_params *params, size_t param, const char *ptr) {

     9

    struct evsql_query_param *p = &params->list[param];

    10

    11

    assert(p->type == EVSQL_PARAM_STRING);

    12

    13

    p->data_raw = ptr;

    14

    p->length = 0;

    15

    16

    return 0;

    17

}

    18

    19

int evsql_param_uint32 (struct evsql_query_params *params, size_t param, uint32_t uval) {

    20

    struct evsql_query_param *p = &params->list[param];

    21

    22

    assert(p->type == EVSQL_PARAM_UINT32);

    23

    24

    p->data.uint32 = htonl(uval);

    25

    p->data_raw = (const char *) &p->data.uint32;

    26

    p->length = sizeof(uval);

    27

    28

    return 0;

    29

}

    30

    31

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

    32

    if (!res->error)

    33

        return "No error";

    34

    35

    switch (res->evsql->type) {

    36

        case EVSQL_EVPQ:

    37

            if (!res->result.pq)

    38

                return "unknown error (no result)";

    39

    40

            return PQresultErrorMessage(res->result.pq);

    41

    42

        default:

    43

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

    44

    }

    45

    46

}

    47

    48

size_t evsql_result_rows (const struct evsql_result_info *res) {

    49

    switch (res->evsql->type) {

    50

        case EVSQL_EVPQ:

    51

            return PQntuples(res->result.pq);

    52

    53

        default:

    54

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

    55

    }

    56

}

    57

    58

size_t evsql_result_cols (const struct evsql_result_info *res) {

    59

    switch (res->evsql->type) {

    60

        case EVSQL_EVPQ:

    61

            return PQnfields(res->result.pq);

    62

    63

        default:

    64

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

    65

    }

    66

}

    67

    68

int evsql_result_binary (const struct evsql_result_info *res, size_t row, size_t col, const char **ptr, size_t size, int nullok) {

    69

    *ptr = NULL;

    70

    71

    switch (res->evsql->type) {

    72

        case EVSQL_EVPQ:

    73

            if (PQgetisnull(res->result.pq, row, col)) {

    74

                if (nullok)

    75

                    return 0;

    76

                else

    77

                    ERROR("[%zu:%zu] field is null", row, col);

    78

            }

    79

    80

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

    81

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

    82

    83

            if (size && PQgetlength(res->result.pq, row, col) != size)

    84

                ERROR("[%zu:%zu] field size mismatch: %zu -> %d", row, col, size, PQgetlength(res->result.pq, row, col));

    85

    86

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

    87

    88

            return 0;

    89

    90

        default:

    91

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

    92

    }

    93

    94

error:

    95

    return -1;

    96

}

    97

    98

int evsql_result_string (const struct evsql_result_info *res, size_t row, size_t col, const char **ptr, int nullok) {

    99

    return evsql_result_binary(res, row, col, ptr, 0, nullok);

   100

}

   101

   102

int evsql_result_uint16 (const struct evsql_result_info *res, size_t row, size_t col, uint16_t *uval, int nullok) {

   103

    const char *data;

   104

    int16_t sval;

   105

   106

    if (evsql_result_binary(res, row, col, &data, sizeof(*uval), nullok))

   107

        goto error;

   108

   109

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

   110

   111

    if (sval < 0)

   112

        ERROR("negative value for unsigned: %d", sval);

   113

   114

    *uval = sval;

   115

   116

    return 0;

   117

   118

error:

   119

    return nullok ? 0 : -1;

   120

}

   121

   122

int evsql_result_uint32 (const struct evsql_result_info *res, size_t row, size_t col, uint32_t *uval, int nullok) {

   123

    const char *data;

   124

    int32_t sval;

   125

   126

    if (evsql_result_binary(res, row, col, &data, sizeof(*uval), nullok))

   127

        goto error;

   128

   129

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

   130

   131

    if (sval < 0)

   132

        ERROR("negative value for unsigned: %d", sval);

   133

   134

    *uval = sval;

   135

   136

    return 0;

   137

   138

error:

   139

    return nullok ? 0 : -1;

   140

}

   141

   142

int evsql_result_uint64 (const struct evsql_result_info *res, size_t row, size_t col, uint64_t *uval, int nullok) {

   143

    const char *data;

   144

    int64_t sval;

   145

   146

    if (evsql_result_binary(res, row, col, &data, sizeof(*uval), nullok))

   147

        goto error;

   148

   149

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

   150

   151

    if (sval < 0)

   152

        ERROR("negative value for unsigned: %ld", sval);

   153

   154

    *uval = sval;

   155

   156

    return 0;

   157

   158

error:

   159

    return nullok ? 0 : -1;

   160

}

   161

   162

void evsql_result_free (const struct evsql_result_info *res) {

   163

    switch (res->evsql->type) {

   164

        case EVSQL_EVPQ:

   165

            return PQclear(res->result.pq);

   166

   167

        default:

   168

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

   169

    }

   170

}