1

#include <assert.h>

     2

     3

#include "evsql.h"

     4

#include "evsql_internal.h"

     6

#include "lib/error.h"

     7

#include "lib/misc.h"

     8

     9

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

    10

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

    11

    12

    assert(p->type == EVSQL_PARAM_STRING);

    13

    14

    p->data_raw = ptr;

    15

    p->length = 0;

    16

    17

    return 0;

    18

}

    19

    20

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

    21

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

    22

    23

    assert(p->type == EVSQL_PARAM_UINT32);

    24

    25

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

    26

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

    27

    p->length = sizeof(uval);

    28

    29

    return 0;

    30

}

    31

    32

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

    33

    if (!res->error)

    34

        return "No error";

    35

    36

    switch (res->evsql->type) {

    37

        case EVSQL_EVPQ:

    38

            if (!res->result.pq)

    39

                return "unknown error (no result)";

    40

    41

            return PQresultErrorMessage(res->result.pq);

    42

    43

        default:

    44

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

    45

    }

    46

    47

}

    48

    49

size_t evsql_result_rows (const struct evsql_result_info *res) {

    50

    switch (res->evsql->type) {

    51

        case EVSQL_EVPQ:

    52

            return PQntuples(res->result.pq);

    53

    54

        default:

    55

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

    56

    }

    57

}

    58

    59

size_t evsql_result_cols (const struct evsql_result_info *res) {

    60

    switch (res->evsql->type) {

    61

        case EVSQL_EVPQ:

    62

            return PQnfields(res->result.pq);

    63

    64

        default:

    65

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

    66

    }

    67

}

    68

    69

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

    70

    *ptr = NULL;

    71

    72

    switch (res->evsql->type) {

    73

        case EVSQL_EVPQ:

    74

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

    75

                if (nullok)

    76

                    return 0;

    77

                else

    78

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

    79

            }

    80

    81

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

    82

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

    83

    84

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

    85

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

    86

    87

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

    88

    89

            return 0;

    90

    91

        default:

    92

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

    93

    }

    94

    95

error:

    96

    return -1;

    97

}

    98

    99

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

   100

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

   101

}

   102

   103

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

   104

    const char *data;

   105

    int16_t sval;

   106

   107

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

   108

        goto error;

   109

   110

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

   111

   112

    if (sval < 0)

   113

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

   114

   115

    *uval = sval;

   116

   117

    return 0;

   118

   119

error:

   120

    return nullok ? 0 : -1;

   121

}

   122

   123

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

   124

    const char *data;

   125

    int32_t sval;

   126

   127

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

   128

        goto error;

   129

   130

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

   131

   132

    if (sval < 0)

   133

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

   134

   135

    *uval = sval;

   136

   137

    return 0;

   138

   139

error:

   140

    return nullok ? 0 : -1;

   141

}

   142

   143

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

   144

    const char *data;

   145

    int64_t sval;

   146

   147

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

   148

        goto error;

   149

   150

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

   151

   152

    if (sval < 0)

   153

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

   154

   155

    *uval = sval;

   156

   157

    return 0;

   158

   159

error:

   160

    return nullok ? 0 : -1;

   161

}

   162

   163

void evsql_result_free (const struct evsql_result_info *res) {

   164

    switch (res->evsql->type) {

   165

        case EVSQL_EVPQ:

   166

            return PQclear(res->result.pq);

   167

   168

        default:

   169

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

   170

    }

   171

}