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

    49

        param->bytes = NULL;

    52

    53

    return 0;

    54

}

    55

    56

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

    57

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

    58

    59

    p->bytes = NULL;

    60

    p->flags.has_value = 0;

    61

    62

    return 0;

    63

}

    64

    65

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

    66

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

    67

    68

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

    69

    70

    p->bytes = ptr;

    71

    p->length = len;

    72

    73

    return 0;

    74

}

    75

    76

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

    77

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

    78

    79

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

    80

    81

    // XXX: hmm...

    82

    p->info.format = EVSQL_FMT_TEXT;

    83

    84

    p->bytes = ptr;

    85

    p->length = 0;

    86

    87

    return 0;

    88

}

    89

    90

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

    91

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

    92

    93

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

    94

    95

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

    96

    p->length = sizeof(uval);

    97

    p->flags.has_value = 1;

    98

    99

    return 0;

   100

}

   101

   102

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

   103

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

   104

   105

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

   106

   107

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

   108

    p->length = sizeof(uval);

   109

    p->flags.has_value = 1;

   110

   111

    return 0;

   112

}

   113

   114

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

   115

    const struct evsql_item *param;

   116

    size_t param_count = 0, idx = 0;

   117

   118

    // count the params

   119

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

   120

        param_count++;

   121

   122

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

   123

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

   124

   125

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

   126

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

   127

    }

   128

}

   129

   130

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

   131

    *ptr = NULL;

   132

   133

    switch (res->evsql->type) {

   134

        case EVSQL_EVPQ:

   135

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

   136

                if (nullok)

   137

                    return 0;

   138

                else

   139

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

   140

            }

   141

   142

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

   143

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

   144

   145

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

   146

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

   147

   148

            return 0;

   149

   150

        default:

   151

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

   152

    }

   153

   154

error:

   155

    return -1;

   156

}

   157

   158

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

   159

    size_t real_size = 0;

   160

   161

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

   162

        goto error;

   163

   164

    if (*ptr == NULL) {

   165

        assert(nullok);

   166

        return 0;

   167

    }

   168

   169

    if (size && real_size != size)

   170

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

   171

   172

    return 0;

   173

   174

error:

   175

    return -1;

   176

}

   177

   178

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

   179

    size_t real_size;

   180

   181

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

   182

        goto error;

   183

   184

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

   185

   186

    return 0;

   187

   188

error:

   189

    return -1;

   190

}

   191

   192

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

   193

    const char *data;

   194

    int16_t sval;

   195

   196

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

   197

        goto error;

   198

   199

    if (!data)

   200

        return 0;

   201

   202

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

   203

   204

    if (sval < 0)

   205

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

   206

   207

    *uval = sval;

   208

   209

    return 0;

   210

   211

error:

   212

    return nullok ? 0 : -1;

   213

}

   214

   215

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

   216

    const char *data;

   217

    int32_t sval;

   218

   219

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

   220

        goto error;

   221

   222

    if (!data)

   223

        return 0;

   224

   225

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

   226

   227

    if (sval < 0)

   228

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

   229

   230

    *uval = sval;

   231

   232

    return 0;

   233

   234

error:

   235

    return nullok ? 0 : -1;

   236

}

   237

   238

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

   239

    const char *data;

   240

    int64_t sval;

   241

   242

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

   243

        goto error;

   244

   245

    if (!data)

   246

        return 0;

   247

   248

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

   249

   250

    if (sval < 0)

   251

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

   252

   253

    *uval = sval;

   254

   255

    return 0;

   256

   257

error:

   258

    return nullok ? 0 : -1;

   259

}

   260

   261

const char *evsql_conn_error (struct evsql_conn *conn) {

   262

    switch (conn->evsql->type) {

   263

        case EVSQL_EVPQ:

   264

            if (!conn->engine.evpq)

   265

                return "unknown error (no conn)";

   266

   267

            return evpq_error_message(conn->engine.evpq);

   268

   269

        default:

   270

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

   271

    }

   272

}

   273

   274

const char *evsql_trans_error (struct evsql_trans *trans) {

   275

    if (trans->conn == NULL)

   276

        return "unknown error (no trans conn)";

   277

   278

    return evsql_conn_error(trans->conn);

   279

}

   280