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_PARAM_ ## typenam: return #typenam

     9

    10

#define _PARAM_VAL_BUF_MAX 120

    11

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

    12

    13

const char *evsql_param_type (const struct evsql_query_param *param) {

    14

    switch (param->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_param_val (const struct evsql_query_param *param) {

    28

    static char buf[_PARAM_VAL_BUF_MAX];

    29

    int ret;

    30

    31

    switch (param->type) {

    32

        _PARAM_VAL_CASE (INVALID,   "???"                               );

    33

        _PARAM_VAL_CASE (NULL_,     "(null)"                            );

    34

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

    35

        _PARAM_VAL_CASE (STRING,    "%s",       param->data_raw         );

    36

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

    37

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

    38

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

    39

        default: return "???";

    40

    }

    41

    42

    return buf;

    43

}

    44

    45

int evsql_params_clear (struct evsql_query_params *params) {

    46

    struct evsql_query_param *param;

    47

    48

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

    49

        param->data_raw = NULL;

    50

    51

    return 0;

    52

}

    53

    54

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

    55

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

    56

    57

    p->data_raw = NULL;

    58

    59

    return 0;

    60

}

    61

    62

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

    63

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

    64

    65

    assert(p->type == EVSQL_PARAM_BINARY);

    66

    67

    p->data_raw = ptr;

    68

    p->length = len;

    69

    70

    return 0;

    71

}

    72

    73

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

    74

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

    75

    76

    assert(p->type == EVSQL_PARAM_STRING);

    77

    78

    p->data_raw = ptr;

    79

    p->length = 0;

    80

    81

    return 0;

    82

}

    83

    84

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

    85

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

    86

    87

    assert(p->type == EVSQL_PARAM_UINT16);

    88

    89

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

    90

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

    91

    p->length = sizeof(uval);

    92

    93

    return 0;

    94

}

    95

    96

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

    97

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

    98

    99

    assert(p->type == EVSQL_PARAM_UINT32);

   100

   101

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

   102

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

   103

    p->length = sizeof(uval);

   104

   105

    return 0;

   106

}

   107

   108

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

   109

    const struct evsql_query_param *param;

   110

    size_t param_count = 0, idx = 0;

   111

   112

    // count the params

   113

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

   114

        param_count++;

   115

   116

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

   117

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

   118

   119

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

   120

        DEBUG("\t%2zu : %8s = %s", ++idx, evsql_param_type(param), evsql_param_val(param));

   121

    }

   122

}

   123

   125

    *ptr = NULL;

   126

   127

    switch (res->evsql->type) {

   128

        case EVSQL_EVPQ:

   129

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

   130

                if (nullok)

   131

                    return 0;

   132

                else

   133

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

   134

            }

   135

   136

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

   137

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

   138

   139

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

   140

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

   141

   142

            return 0;

   143

   144

        default:

   145

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

   146

    }

   147

   148

error:

   149

    return -1;

   150

}

   151

   153

    size_t real_size = 0;

   154

   155

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

   156

        goto error;

   157

   158

    if (*ptr == NULL) {

   159

        assert(nullok);

   160

        return 0;

   161

    }

   162

   163

    if (size && real_size != size)

   164

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

   165

   166

    return 0;

   167

   168

error:

   169

    return -1;

   170

}

   171

   173

    size_t real_size;

   174

   175

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

   176

        goto error;

   177

   178

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

   179

   180

    return 0;

   181

   182

error:

   183

    return -1;

   184

}

   185

   187

    const char *data;

   188

    int16_t sval;

   189

   190

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

   191

        goto error;

   192

   193

    if (!data)

   194

        return 0;

   195

   196

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

   197

   198

    if (sval < 0)

   199

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

   200

   201

    *uval = sval;

   202

   203

    return 0;

   204

   205

error:

   206

    return nullok ? 0 : -1;

   207

}

   208

   210

    const char *data;

   211

    int32_t sval;

   212

   213

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

   214

        goto error;

   215

   216

    if (!data)

   217

        return 0;

   218

   219

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

   220

   221

    if (sval < 0)

   222

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

   223

   224

    *uval = sval;

   225

   226

    return 0;

   227

   228

error:

   229

    return nullok ? 0 : -1;

   230

}

   231

   233

    const char *data;

   234

    int64_t sval;

   235

   236

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

   237

        goto error;

   238

   239

    if (!data)

   240

        return 0;

   241

   242

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

   243

   244

    if (sval < 0)

   245

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

   246

   247

    *uval = sval;

   248

   249

    return 0;

   250

   251

error:

   252

    return nullok ? 0 : -1;

   253

}

   254

   255

const char *evsql_conn_error (struct evsql_conn *conn) {

   256

    switch (conn->evsql->type) {

   257

        case EVSQL_EVPQ:

   258

            if (!conn->engine.evpq)

   259

                return "unknown error (no conn)";

   260

   261

            return evpq_error_message(conn->engine.evpq);

   262

   263

        default:

   264

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

   265

    }

   266

}

   267

   268

const char *evsql_trans_error (struct evsql_trans *trans) {

   269

    if (trans->conn == NULL)

   270

        return "unknown error (no trans conn)";

   271

   272

    return evsql_conn_error(trans->conn);

   273

}

   274