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_binary (struct evsql_query_params *params, size_t param, const char *ptr, size_t len) {

    55

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

    56

    57

    assert(p->type == EVSQL_PARAM_BINARY);

    58

    59

    p->data_raw = ptr;

    60

    p->length = len;

    61

    62

    return 0;

    63

}

    64

    65

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

    66

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

    67

    68

    assert(p->type == EVSQL_PARAM_STRING);

    69

    70

    p->data_raw = ptr;

    71

    p->length = 0;

    72

    73

    return 0;

    74

}

    75

    76

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

    77

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

    78

    79

    assert(p->type == EVSQL_PARAM_UINT16);

    80

    81

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

    82

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

    83

    p->length = sizeof(uval);

    84

    85

    return 0;

    86

}

    87

    88

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

    89

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

    90

    91

    assert(p->type == EVSQL_PARAM_UINT32);

    92

    93

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

    94

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

    95

    p->length = sizeof(uval);

    96

    97

    return 0;

    98

}

    99

   100

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

   101

    const struct evsql_query_param *param;

   102

    size_t param_count = 0, idx = 0;

   103

   104

    // count the params

   105

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

   106

        param_count++;

   107

   108

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

   109

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

   110

   111

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

   112

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

   113

    }

   114

}

   115

   116

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

   117

    if (!res->error)

   118

        return "No error";

   119

   120

    switch (res->evsql->type) {

   121

        case EVSQL_EVPQ:

   122

            if (!res->result.pq)

   123

                return "unknown error (no result)";

   124

   125

            return PQresultErrorMessage(res->result.pq);

   126

   127

        default:

   128

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

   129

    }

   130

   131

}

   132

   133

size_t evsql_result_rows (const struct evsql_result_info *res) {

   134

    switch (res->evsql->type) {

   135

        case EVSQL_EVPQ:

   136

            return PQntuples(res->result.pq);

   137

   138

        default:

   139

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

   140

    }

   141

}

   142

   143

size_t evsql_result_cols (const struct evsql_result_info *res) {

   144

    switch (res->evsql->type) {

   145

        case EVSQL_EVPQ:

   146

            return PQnfields(res->result.pq);

   147

   148

        default:

   149

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

   150

    }

   151

}

   152

   163

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

   164

    *ptr = NULL;

   165

   166

    switch (res->evsql->type) {

   167

        case EVSQL_EVPQ:

   168

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

   169

                if (nullok)

   170

                    return 0;

   171

                else

   172

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

   173

            }

   174

   175

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

   176

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

   177

   178

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

   179

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

   180

   181

            return 0;

   182

   183

        default:

   184

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

   185

    }

   186

   187

error:

   188

    return -1;

   189

}

   190

   191

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

   192

    size_t real_size = 0;

   193

   194

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

   195

        goto error;

   196

   197

    if (*ptr == NULL) {

   198

        assert(nullok);

   199

        return 0;

   200

    }

   201

   202

    if (size && real_size != size)

   203

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

   204

   205

    return 0;

   206

   207

error:

   208

    return -1;

   209

}

   210

   211

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

   212

    size_t real_size;

   213

   214

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

   215

        goto error;

   216

   217

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

   218

   219

    return 0;

   220

   221

error:

   222

    return -1;

   223

}

   224

   225

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

   226

    const char *data;

   227

    int16_t sval;

   228

   229

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

   230

        goto error;

   231

   232

    if (!data)

   233

        return 0;

   234

   235

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

   236

   237

    if (sval < 0)

   238

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

   239

   240

    *uval = sval;

   241

   242

    return 0;

   243

   244

error:

   245

    return nullok ? 0 : -1;

   246

}

   247

   248

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

   249

    const char *data;

   250

    int32_t sval;

   251

   252

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

   253

        goto error;

   254

   255

    if (!data)

   256

        return 0;

   257

   258

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

   259

   260

    if (sval < 0)

   261

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

   262

   263

    *uval = sval;

   264

   265

    return 0;

   266

   267

error:

   268

    return nullok ? 0 : -1;

   269

}

   270

   271

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

   272

    const char *data;

   273

    int64_t sval;

   274

   275

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

   276

        goto error;

   277

   278

    if (!data)

   279

        return 0;

   280

   281

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

   282

   283

    if (sval < 0)

   284

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

   285

   286

    *uval = sval;

   287

   288

    return 0;

   289

   290

error:

   291

    return nullok ? 0 : -1;

   292

}

   293

   294

void evsql_result_free (const struct evsql_result_info *res) {

   295

    switch (res->evsql->type) {

   296

        case EVSQL_EVPQ:

   297

            return PQclear(res->result.pq);

   298

   299

        default:

   300

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

   301

    }

   302

}

   303

   304

const char *evsql_conn_error (struct evsql_conn *conn) {

   305

    switch (conn->evsql->type) {

   306

        case EVSQL_EVPQ:

   307

            if (!conn->engine.evpq)

   308

                return "unknown error (no conn)";

   309

   310

            return evpq_error_message(conn->engine.evpq);

   311

   312

        default:

   313

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

   314

    }

   315

}

   316

   317

const char *evsql_trans_error (struct evsql_trans *trans) {

   318

    if (trans->conn == NULL)

   319

        return "unknown error (no trans conn)";

   320

   321

    return evsql_conn_error(trans->conn);

   322

}

   323