1

#include <stdlib.h>

     2

#include <assert.h>

     3

     4

#include "evsql.h"

     5

#include "../lib/log.h"

     6

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

     7

     8

#define _PARAM_TYPE_CASE(typenam) case EVSQL_TYPE_ ## typenam: return #typenam

     9

    10

#define _PARAM_VAL_BUF_MAX 120

    11

#define _PARAM_VAL_CASE(typenam, ...) case EVSQL_TYPE_ ## typenam: if (item->bytes) ret = snprintf(buf, _PARAM_VAL_BUF_MAX, __VA_ARGS__); else return "(null)"; break

    12

    13

const char *evsql_item_type (const struct evsql_item_info *item_info) {

    14

    switch (item_info->type) {

    15

        _PARAM_TYPE_CASE (INVALID   );

    16

        _PARAM_TYPE_CASE (NULL_     );

    17

        _PARAM_TYPE_CASE (BINARY    );

    18

        _PARAM_TYPE_CASE (STRING    );

    19

        _PARAM_TYPE_CASE (UINT16    );

    20

        _PARAM_TYPE_CASE (UINT32    );

    21

        _PARAM_TYPE_CASE (UINT64    );

    22

        default: return "???";

    23

    }

    24

}

    25

    26

    27

static const char *evsql_item_val (const struct evsql_item *item) {

    28

    static char buf[_PARAM_VAL_BUF_MAX];

    29

    int ret;

    30

    31

    switch (item->info.type) {

    32

        _PARAM_VAL_CASE (INVALID,   "???"                               );

    33

        _PARAM_VAL_CASE (NULL_,     "(null)"                            );

    34

        _PARAM_VAL_CASE (BINARY,    "%zu:%s",   item->length, "... "    );

    35

        _PARAM_VAL_CASE (STRING,    "%s",       item->bytes             );

    36

        _PARAM_VAL_CASE (UINT16,    "%hu",      (unsigned short int)     ntohs(item->value.uint16)  );

    37

        _PARAM_VAL_CASE (UINT32,    "%lu",      (unsigned long int)      ntohl(item->value.uint32)  );

    38

        _PARAM_VAL_CASE (UINT64,    "%llu",     (unsigned long long int) ntohq(item->value.uint64)  );

    39

        default: return "???";

    40

    }

    41

    42

    return buf;

    43

}

    44

    45

int evsql_params_clear (struct evsql_query_params *params) {

    46

    struct evsql_item *param;

    47

    48

    for (param = params->list; param->info.type; param++) 

    49

        param->bytes = NULL;

    50

    51

    return 0;

    52

}

    53

    54

int evsql_param_null (struct evsql_query_params *params, size_t param) {

    55

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

    56

    57

    p->bytes = NULL;

    58

    p->flags.has_value = 0;

    59

    60

    return 0;

    61

}

    62

    63

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

    64

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

    65

    66

    assert(p->info.type == EVSQL_TYPE_BINARY);

    67

    68

    p->bytes = ptr;

    69

    p->length = len;

    70

    71

    return 0;

    72

}

    73

    74

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

    75

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

    76

    77

    assert(p->info.type == EVSQL_TYPE_STRING);

    81

    82

    p->bytes = ptr;

    83

    p->length = 0;

    84

    85

    return 0;

    86

}

    87

    88

int evsql_param_uint16 (struct evsql_query_params *params, size_t param, uint16_t uval) {

    89

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

    90

    91

    assert(p->info.type == EVSQL_TYPE_UINT16);

    92

    93

    p->value.uint16 = htons(uval);

    94

    p->length = sizeof(uval);

    95

    p->flags.has_value = 1;

    96

    97

    return 0;

    98

}

    99

   100

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

   101

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

   102

   103

    assert(p->info.type == EVSQL_TYPE_UINT32);

   104

   105

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

   106

    p->length = sizeof(uval);

   107

    p->flags.has_value = 1;

   108

   109

    return 0;

   110

}

   111

   112

void evsql_query_debug (const char *sql, const struct evsql_query_params *params) {

   113

    const struct evsql_item *param;

   114

    size_t param_count = 0, idx = 0;

   115

   116

    // count the params

   117

    for (param = params->list; param->info.type; param++) 

   118

        param_count++;

   119

   120

    DEBUG("sql:     %s", sql);

   121

    DEBUG("params:  %zu", param_count);

   122

   123

    for (param = params->list; param->info.type; param++) {

   124

        DEBUG("\t%2zu : %8s = %s", ++idx, evsql_item_type(&param->info), evsql_item_val(param));

   125

    }

   126

}

   127

   128

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

   129

    *ptr = NULL;

   130

   131

    switch (res->evsql->type) {

   132

        case EVSQL_EVPQ:

   133

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

   134

                if (nullok)

   135

                    return 0;

   136

                else

   137

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

   138

            }

   139

   140

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

   141

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

   142

   143

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

   144

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

   145

   146

            return 0;

   147

   148

        default:

   149

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

   150

    }

   151

   152

error:

   153

    return -1;

   154

}

   155

   156

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

   157

    size_t real_size = 0;

   158

   159

    if (evsql_result_binary(res, row, col, ptr, &real_size, nullok))

   160

        goto error;

   161

   162

    if (*ptr == NULL) {

   163

        assert(nullok);

   164

        return 0;

   165

    }

   166

   167

    if (size && real_size != size)

   168

        ERROR("[%zu:%zu] field size mismatch: %zu -> %zu", row, col, size, real_size);

   169

   170

    return 0;

   171

   172

error:

   173

    return -1;

   174

}

   175

   176

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

   177

    size_t real_size;

   178

   179

    if (evsql_result_binary(res, row, col, ptr, &real_size, nullok))

   180

        goto error;

   181

   182

    assert(real_size == strlen(*ptr));

   183

   184

    return 0;

   185

   186

error:

   187

    return -1;

   188

}

   189

   190

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

   191

    const char *data;

   192

    int16_t sval;

   193

   194

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

   195

        goto error;

   196

   197

    if (!data)

   198

        return 0;

   199

   200

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

   201

   202

    if (sval < 0)

   203

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

   204

   205

    *uval = sval;

   206

   207

    return 0;

   208

   209

error:

   210

    return nullok ? 0 : -1;

   211

}

   212

   213

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

   214

    const char *data;

   215

    int32_t sval;

   216

   217

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

   218

        goto error;

   219

   220

    if (!data)

   221

        return 0;

   222

   223

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

   224

   225

    if (sval < 0)

   226

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

   227

   228

    *uval = sval;

   229

   230

    return 0;

   231

   232

error:

   233

    return nullok ? 0 : -1;

   234

}

   235

   236

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

   237

    const char *data;

   238

    int64_t sval;

   239

   240

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

   241

        goto error;

   242

   243

    if (!data)

   244

        return 0;

   245

   246

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

   247

   248

    if (sval < 0)

   249

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

   250

   251

    *uval = sval;

   252

   253

    return 0;

   254

   255

error:

   256

    return nullok ? 0 : -1;

   257

}

   258

   259

const char *evsql_conn_error (struct evsql_conn *conn) {

   260

    switch (conn->evsql->type) {

   261

        case EVSQL_EVPQ:

   262

            if (!conn->engine.evpq)

   263

                return "unknown error (no conn)";

   264

   265

            return evpq_error_message(conn->engine.evpq);

   266

   267

        default:

   268

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

   269

    }

   270

}

   271

   272

const char *evsql_trans_error (struct evsql_trans *trans) {

   273

    if (trans->conn == NULL)

   274

        return "unknown error (no trans conn)";

   275

   276

    return evsql_conn_error(trans->conn);

   277

}

   278