1 

     2 #include "evsql.h"

     3 

     4 /*

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

     6  */

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

     8     // set count

     9     params->count = param_count;

    10 

    11     // allocate vertical storage for the parameters

    12     if (0

    13         

    14         ||  !(query->params.types    = calloc(query->params.count, sizeof(Oid)))

    15         ||  !(query->params.values   = calloc(query->params.count, sizeof(char *)))

    16         ||  !(query->params.lengths  = calloc(query->params.count, sizeof(int)))

    17         ||  !(query->params.formats  = calloc(query->params.count, sizeof(int)))

    18     )

    19         ERROR("calloc");

    20 

    21     // result format

    22     switch (result_format) {

    23         case EVSQL_FMT_TEXT:

    24             params.result_format = 0; break;

    25 

    26         case EVSQL_FMT_BINARY:

    27             params.result_format = 1; break;

    28 

    29         default:

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

    31     }

    32     

    33     // good

    34     return 0;

    35 

    36 error:

    37     return -1;

    38 }

    39 

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

    41     struct evsql_query *query = NULL;

    42     

    43     // alloc new query

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

    45         goto error;

    46     

    47     // just execute the command string directly

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

    49         goto error;

    50 

    51     // ok

    52     return query;

    53 

    54 error:

    55     _evsql_query_free(query);

    56 

    57     return NULL;

    58 }

    59 

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

    61     const char *command, const struct evsql_query_params *params, 

    62     evsql_query_cb query_fn, void *cb_arg

    63 ) {

    64     struct evsql_query *query = NULL;

    65     const struct evsql_item *param;

    66     size_t count = 0, idx;

    67     

    68     // alloc new query

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

    70         goto error;

    71 

    72     // count the params

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

    74         count++;

    75     

    76     // initialize params

    77     evsql_query_params_init_pq(&query->params, count, params->result_format);

    78 

    79     // transform

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

    81         // `set for NULLs, otherwise not

    82         query->params.types[idx] = param->bytes ? 0 : EVSQL_PQ_ARBITRARY_TYPE_OID;

    83         

    84         // values

    85         query->params.values[idx] = param->bytes;

    86 

    87         // lengths

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

    89 

    90         // formats, binary if length is nonzero, but text for NULLs

    91         query->params.formats[idx] = param->length && param->bytes ? 1 : 0;

    92     }

    93 

    94     // execute it

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

    96         goto error;

    97 

    98 #ifdef DEBUG_ENABLED

    99     // debug it?

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

   101     evsql_query_debug(command, params);

   102 #endif /* DEBUG_ENABLED */

   103 

   104     // ok

   105     return query;

   106 

   107 error:

   108     _evsql_query_free(query);

   109     

   110     return NULL;

   111 }

   112 

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

   114     const struct evsql_query_info *query_info,

   115     evsql_query_cb query_fn, void *cb_arg,

   116     ...

   117 ) {

   118     va_list vargs;

   119     struct evsql_query *query = NULL;

   120     const struct evsql_item_info *param;

   121     size_t count = 0, idx;

   122     err_t err = 1;

   123 

   124     // varargs

   125     va_start(vargs, cb_arg);

   126     

   127     // alloc new query

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

   129         goto error;

   130 

   131     // count the params

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

   133         count++;

   134     

   135     // initialize params

   136     evsql_query_params_init_pq(&query->params, count, EVSQL_FMT_BINARY);

   137 

   138     // transform

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

   140         // default type to 0 (implicit)

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

   142 

   143         // default format to binary

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

   145 

   146         // consume argument

   147         switch (param->info.type) {

   148             case EVSQL_TYPE_NULL_: {

   149                 // explicit type + text fmt

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

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

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

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

   154             } break;

   155 

   156             case EVSQL_TYPE_BINARY: {

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

   158                 

   159                 // value + explicit len

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

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

   162             } break;

   163 

   164             case EVSQL_TYPE_STRING: {

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

   166 

   167                 // value + automatic length, text format

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

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

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

   171             } break;

   172             

   173             case EVSQL_TYPE_UINT16: {

   174                 uint16_t uval = va_arg(vargs, uint16_t);

   175 

   176                 if (uval != (int16_t) uval)

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

   178                 

   179                 // network-byte-order value + explicit len

   180                 query->params.values[idx] = htons(uval);

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

   182             } break;

   183             

   184             case EVSQL_TYPE_UINT32: {

   185                 uint32_t uval = va_arg(vargs, uint32_t);

   186 

   187                 if (uval != (int32_t) uval)

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

   189                 

   190                 // network-byte-order value + explicit len

   191                 query->params.values[idx] = htonl(uval);

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

   193             } break;

   194 

   195             case EVSQL_TYPE_UINT64: {

   196                 uint64_t uval = va_arg(vargs, uint64_t);

   197 

   198                 if (uval != (int64_t) uval)

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

   200                 

   201                 // network-byte-order value + explicit len

   202                 query->params.values[idx] = htonq(uval);

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

   204             } break;

   205             

   206             default: 

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

   208         }

   209     }

   210 

   211     // execute it

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

   213         goto error;

   214     

   215     // no error, fallthrough for va_end

   216     err = 0;

   217 

   218 error:

   219     // possible cleanup

   220     if (err)

   221         _evsql_query_free(query);

   222     

   223     // end varargs

   224     va_end(vargs);

   225     

   226     // return 

   227     return err ? NULL : query;

   228 }

   229 

   230 

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

   232     assert(query);

   233 

   234     if (trans) {

   235         // must be the right query

   236         assert(trans->query == query);

   237     }

   238 

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

   240     query->cb_fn = NULL;

   241 }

   242