1

#include <assert.h>

     2

     3

#include "evsql.h"

     4

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

     5

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

     6

     7

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

     8

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

     9

    10

    assert(p->type == EVSQL_PARAM_STRING);

    11

    12

    p->data_raw = ptr;

    13

    p->length = 0;

    14

    15

    return 0;

    16

}

    17

    18

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

    19

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

    20

    21

    assert(p->type == EVSQL_PARAM_UINT32);

    22

    23

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

    24

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

    25

    p->length = sizeof(uval);

    26

    27

    return 0;

    28

}

    29

    30

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

    31

    if (!res->error)

    32

        return "No error";

    33

    34

    switch (res->evsql->type) {

    35

        case EVSQL_EVPQ:

    36

            if (!res->result.pq)

    37

                return "unknown error (no result)";

    38

    39

            return PQresultErrorMessage(res->result.pq);

    40

    41

        default:

    42

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

    43

    }

    44

    45

}

    46

    47

size_t evsql_result_rows (const struct evsql_result_info *res) {

    48

    switch (res->evsql->type) {

    49

        case EVSQL_EVPQ:

    50

            return PQntuples(res->result.pq);

    51

    52

        default:

    53

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

    54

    }

    55

}

    56

    57

size_t evsql_result_cols (const struct evsql_result_info *res) {

    58

    switch (res->evsql->type) {

    59

        case EVSQL_EVPQ:

    60

            return PQnfields(res->result.pq);

    61

    62

        default:

    63

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

    64

    }

    65

}

    66

    68

    *ptr = NULL;

    69

    70

    switch (res->evsql->type) {

    71

        case EVSQL_EVPQ:

    72

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

    73

                if (nullok)

    74

                    return 0;

    75

                else

    76

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

    77

            }

    78

    79

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

    80

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

    81

    84

    85

            return 0;

    86

    87

        default:

    88

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

    89

    }

    90

    91

error:

    92

    return -1;

    93

}

    94

   110

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

   111

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

   112

}

   113

   114

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

   115

    const char *data;

   116

    int16_t sval;

   117

   118

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

   119

        goto error;

   120

   121

    if (!data)

   122

        return 0;

   123

   124

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

   125

   126

    if (sval < 0)

   127

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

   128

   129

    *uval = sval;

   130

   131

    return 0;

   132

   133

error:

   134

    return nullok ? 0 : -1;

   135

}

   136

   137

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

   138

    const char *data;

   139

    int32_t sval;

   140

   141

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

   142

        goto error;

   143

   144

    if (!data)

   145

        return 0;

   146

   147

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

   148

   149

    if (sval < 0)

   150

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

   151

   152

    *uval = sval;

   153

   154

    return 0;

   155

   156

error:

   157

    return nullok ? 0 : -1;

   158

}

   159

   160

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

   161

    const char *data;

   162

    int64_t sval;

   163

   164

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

   165

        goto error;

   166

   167

    if (!data)

   168

        return 0;

   169

   170

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

   171

   172

    if (sval < 0)

   173

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

   174

   175

    *uval = sval;

   176

   177

    return 0;

   178

   179

error:

   180

    return nullok ? 0 : -1;

   181

}

   182

   183

void evsql_result_free (const struct evsql_result_info *res) {

   184

    switch (res->evsql->type) {

   185

        case EVSQL_EVPQ:

   186

            return PQclear(res->result.pq);

   187

   188

        default:

   189

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

   190

    }

   191

}

   192

   193

const char *evsql_conn_error (struct evsql_conn *conn) {

   194

    switch (conn->evsql->type) {

   195

        case EVSQL_EVPQ:

   196

            if (!conn->engine.evpq)

   197

                return "unknown error (no conn)";

   198

   199

            return evpq_error_message(conn->engine.evpq);

   200

   201

        default:

   202

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

   203

    }

   204

}

   205

   206

const char *evsql_trans_error (struct evsql_trans *trans) {

   207

    if (trans->conn == NULL)

   208

        return "unknown error (no trans conn)";

   209

   210

    return evsql_conn_error(trans->conn);

   211

}

   212