1

     5

     6

#include <stdlib.h>

     7

#include <assert.h>

     8

     9

/*

    10

 * Initialize params->types/values/lengths/formats, params->count, params->result_format based on the given args

    11

 */

    12

static int _evsql_query_params_init_pq (struct evsql_query_params_pq *params, size_t param_count, enum evsql_item_format result_format) {

    13

    // set count

    14

    params->count = param_count;

    15

    16

    // allocate vertical storage for the parameters

    17

    if (0

    18

    19

        ||  !(params->types     = calloc(param_count, sizeof(Oid)))

    20

        ||  !(params->values    = calloc(param_count, sizeof(char *)))

    21

        ||  !(params->lengths   = calloc(param_count, sizeof(int)))

    22

        ||  !(params->formats   = calloc(param_count, sizeof(int)))

    23

        ||  !(params->item_vals = calloc(param_count, sizeof(union evsql_item_value)))

    24

    )

    25

        ERROR("calloc");

    26

    27

    // result format

    28

    switch (result_format) {

    29

        case EVSQL_FMT_TEXT:

    30

            params->result_format = 0; break;

    31

    32

        case EVSQL_FMT_BINARY:

    33

            params->result_format = 1; break;

    34

    35

        default:

    36

            FATAL("params.result_fmt: %d", result_format);

    37

    }

    38

    39

    // good

    40

    return 0;

    41

    42

error:

    43

    return -1;

    44

}

    45

    46

struct evsql_query *evsql_query (struct evsql *evsql, struct evsql_trans *trans, const char *command, evsql_query_cb query_fn, void *cb_arg) {

    47

    struct evsql_query *query = NULL;

    48

    49

    // alloc new query

    50

    if ((query = _evsql_query_new(evsql, trans, query_fn, cb_arg)) == NULL)

    51

        goto error;

    52

    53

    // just execute the command string directly

    54

    if (_evsql_query_enqueue(evsql, trans, query, command))

    55

        goto error;

    56

    57

    // ok

    58

    return query;

    59

    60

error:

    61

    _evsql_query_free(query);

    62

    63

    return NULL;

    64

}

    65

    66

struct evsql_query *evsql_query_params (struct evsql *evsql, struct evsql_trans *trans, 

    67

    const char *command, const struct evsql_query_params *params, 

    68

    evsql_query_cb query_fn, void *cb_arg

    69

) {

    70

    struct evsql_query *query = NULL;

    71

    const struct evsql_item *param;

    72

    size_t count = 0, idx;

    73

    74

    // alloc new query

    75

    if ((query = _evsql_query_new(evsql, trans, query_fn, cb_arg)) == NULL)

    76

        goto error;

    77

    78

    // count the params

    79

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

    80

        count++;

    81

    82

    // initialize params

    83

    _evsql_query_params_init_pq(&query->params, count, params->result_format);

    84

    85

    // transform

    86

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

    87

        // set for NULLs, otherwise not

    88

        query->params.types[idx] = (param->bytes || param->flags.has_value) ? 0 : EVSQL_PQ_ARBITRARY_TYPE_OID;

    89

    90

        // scalar values

    91

        query->params.item_vals[idx] = param->value;

    92

    93

        // values

    94

        // point this at the value stored in the item_vals union if flagged as such

    95

        query->params.values[idx] = param->flags.has_value ? (const char *) &query->params.item_vals[idx] : param->bytes;

    96

    97

        // lengths

    98

        query->params.lengths[idx] = param->length;

    99

   100

        // XXX: this assumes that format is FMT_BINARY...

   101

        query->params.formats[idx] = param->info.format;

   102

    }

   103

   104

    // execute it

   105

    if (_evsql_query_enqueue(evsql, trans, query, command))

   106

        goto error;

   107

   108

#ifdef DEBUG_ENABLED

   109

    // debug it?

   110

    DEBUG("evsql.%p: enqueued query=%p on trans=%p", evsql, query, trans);

   111

    evsql_query_debug(command, params);

   112

#endif /* DEBUG_ENABLED */

   113

   114

    // ok

   115

    return query;

   116

   117

error:

   118

    _evsql_query_free(query);

   119

   120

    return NULL;

   121

}

   122

   123

struct evsql_query *evsql_query_exec (struct evsql *evsql, struct evsql_trans *trans, 

   124

    const struct evsql_query_info *query_info,

   125

    evsql_query_cb query_fn, void *cb_arg,

   126

    ...

   127

) {

   128

    va_list vargs;

   129

    struct evsql_query *query = NULL;

   130

    const struct evsql_item_info *param;

   131

    size_t count = 0, idx;

   132

    err_t err = 1;

   133

   134

    // varargs

   135

    va_start(vargs, cb_arg);

   136

   137

    // alloc new query

   138

    if ((query = _evsql_query_new(evsql, trans, query_fn, cb_arg)) == NULL)

   139

        goto error;

   140

   141

    // count the params

   142

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

   143

        count++;

   144

   145

    // initialize params

   146

    _evsql_query_params_init_pq(&query->params, count, EVSQL_FMT_BINARY);

   147

   148

    // transform

   149

    for (param = query_info->params, idx = 0; param->type; param++, idx++) {

   150

        // default type to 0 (implicit)

   151

        query->params.types[idx] = 0;

   152

   153

        // default format to binary

   154

        query->params.formats[idx] = EVSQL_FMT_BINARY;

   155

   156

        // consume argument

   157

        switch (param->type) {

   158

            case EVSQL_TYPE_NULL_: {

   159

                // explicit type + text fmt

   160

                query->params.types[idx] = EVSQL_PQ_ARBITRARY_TYPE_OID;

   161

                query->params.values[idx] = NULL;

   162

                query->params.lengths[idx] = 0;

   163

                query->params.formats[idx] = EVSQL_FMT_TEXT;

   164

            } break;

   165

   166

            case EVSQL_TYPE_BINARY: {

   167

                struct evsql_item_binary item = va_arg(vargs, struct evsql_item_binary);

   168

   169

                // value + explicit len

   170

                query->params.values[idx] = item.ptr;

   171

                query->params.lengths[idx] = item.len;

   172

            } break;

   173

   174

            case EVSQL_TYPE_STRING: {

   175

                const char *str = va_arg(vargs, const char *);

   176

   177

                // value + automatic length, text format

   178

                query->params.values[idx] = str;

   179

                query->params.lengths[idx] = 0;

   180

                query->params.formats[idx] = EVSQL_FMT_TEXT;

   181

            } break;

   182

   183

            case EVSQL_TYPE_UINT16: {

   184

                // XXX: uint16_t is passed as `int'?

   185

                uint16_t uval = va_arg(vargs, int);

   186

   187

                if (uval != (int16_t) uval)

   188

                    ERROR("param $%zu: uint16 overflow: %d", idx + 1, uval);

   189

   190

                // network-byte-order value + explicit len

   191

                query->params.item_vals[idx].uint16 = htons(uval);

   192

                query->params.values[idx] = (const char *) &query->params.item_vals[idx];

   193

                query->params.lengths[idx] = sizeof(uint16_t);

   194

            } break;

   195

   196

            case EVSQL_TYPE_UINT32: {

   197

                uint32_t uval = va_arg(vargs, uint32_t);

   198

   199

                if (uval != (int32_t) uval)

   200

                    ERROR("param $%zu: uint32 overflow: %ld", idx + 1, (unsigned long) uval);

   201

   202

                // network-byte-order value + explicit len

   203

                query->params.item_vals[idx].uint32 = htonl(uval);

   204

                query->params.values[idx] = (const char *) &query->params.item_vals[idx];

   205

                query->params.lengths[idx] = sizeof(uint32_t);

   206

            } break;

   207

   208

            case EVSQL_TYPE_UINT64: {

   209

                uint64_t uval = va_arg(vargs, uint64_t);

   210

   211

                if (uval != (int64_t) uval)

   212

                    ERROR("param $%zu: uint16 overflow: %lld", idx + 1, (unsigned long long) uval);

   213

   214

                // network-byte-order value + explicit len

   215

                query->params.item_vals[idx].uint64 = htonq(uval);

   216

                query->params.values[idx] = (const char *) &query->params.item_vals[idx];

   217

                query->params.lengths[idx] = sizeof(uint64_t);

   218

            } break;

   219

   220

            default: 

   221

                FATAL("param $%zu: invalid type: %d", idx + 1, param->type);

   222

        }

   223

    }

   224

   225

    // execute it

   226

    if (_evsql_query_enqueue(evsql, trans, query, query_info->sql))

   227

        goto error;

   228

   229

    // no error, fallthrough for va_end

   230

    err = 0;

   231

   232

error:

   233

    // possible cleanup

   234

    if (err)

   235

        _evsql_query_free(query);

   236

   237

    // end varargs

   238

    va_end(vargs);

   239

   240

    // return 

   241

    return err ? NULL : query;

   242

}

   243

   244

   245

void evsql_query_abort (struct evsql_trans *trans, struct evsql_query *query) {

   246

    assert(query);

   247

   248

    if (trans) {

   249

        // must be the right query

   250

        assert(trans->query == query);

   251

    }

   252

   253

    // just strip the callback and wait for it to complete as normal

   254

    query->cb_fn = NULL;

   255

}

   256