1

     2

#include "evsql.h"

     3

#include "lib/log.h"

     4

#include "lib/signals.h"

     5

#include "lib/misc.h"

     6

     7

#include <event2/event.h>

     8

#include <event2/event_struct.h>

     9

#include <assert.h>

    10

    11

#define CONNINFO_DEFAULT "dbname=dbfs port=5433"

    12

    13

struct evsql_test_ctx {

    14

    struct evsql *db;

    15

    struct evsql_trans *trans;

    16

};

    17

    18

// forward-declare

    19

void query_send (struct evsql *db, struct evsql_trans *trans);

    20

    21

    22

void query_timer (int fd, short what, void *arg) {

    23

    struct evsql *db = arg;

    24

    25

    INFO("[evsql_test.timer] *tick*");

    26

    27

    query_send(db, NULL);

    28

}

    29

    30

void query_start (struct event_base *base, struct evsql *db) {

    31

    static struct event ev;

    32

    struct timeval tv = { 5, 0 };

    33

    34

//  XXX: disabled as evperiod_assign has gone missing

    35

//    evperiodic_assign(&ev, base, &tv, &query_timer, db);

    36

//    event_add(&ev, &tv);

    37

    38

    INFO("[evsql_test.timer_start] started timer");

    39

}

    40

    41

void query_results (struct evsql_result *result, void *arg) {

    42

    struct evsql *db = arg;

    43

    uint32_t val;

    44

    45

    (void) db;

    46

    47

    static struct evsql_result_info result_info = {

    48

        0, {

    49

            {   EVSQL_FMT_BINARY,   EVSQL_TYPE_UINT32   },

    50

            {   0,                  0                   }

    51

        }

    52

    };

    53

    54

    // begin

    55

    assert(evsql_result_begin(&result_info, result) == 0);

    56

    57

    // one row

    58

    assert(evsql_result_next(result, 

    59

        &val

    60

    ) > 0);

    61

    62

    // print

    63

    INFO("[evsql_test.results] got result: %p: val=%lu", result, (unsigned long) val);

    64

    65

    // done

    66

    evsql_result_end(result);

    67

}

    68

    69

void query_send (struct evsql *db, struct evsql_trans *trans) {

    70

    struct evsql_query *query = NULL;

    71

    static int query_id = 0;

    72

    73

    static struct evsql_query_info query_info = {

    74

        .sql    = "SELECT $1::int4 + 5",

    75

    76

        .params = {

    77

            {   EVSQL_FMT_BINARY,   EVSQL_TYPE_UINT32   },

    78

            {   0,                  0                   }

    79

        }

    80

    };

    81

    82

    // query

    83

    if ((query = evsql_query_exec(db, trans, &query_info, query_results, db,

    84

        (uint32_t) ++query_id

    85

    )) == NULL)

    86

        WARNING("evsql_query_exec failed");

    87

    88

    INFO("[evsql_test.query_send] enqueued query, trans=%p: %p: %d", trans, query, query_id);

    89

}

    90

    91

void trans_commit (struct evsql_test_ctx *ctx) {

    92

    if (evsql_trans_commit(ctx->trans))

    93

        FATAL("evsql_trans_commit failed");

    94

    95

    INFO("[evsql_test.trans_commit] commiting transaction");

    96

}

    97

    98

void trans_insert_result (struct evsql_result *res, void *arg) {

    99

    struct evsql_test_ctx *ctx = arg;

   100

    err_t err;

   101

   102

    // the result info

   103

    uint32_t id;

   104

    const char *str;

   105

   106

    static struct evsql_result_info result_info = {

   107

        0, {

   108

            {   EVSQL_FMT_BINARY,   EVSQL_TYPE_UINT32   },

   109

            {   EVSQL_FMT_BINARY,   EVSQL_TYPE_STRING   },

   110

            {   0,                  0                   }

   111

        }

   112

    };

   113

   114

    // begin

   115

    if ((err = evsql_result_begin(&result_info, res)))

   116

        EFATAL(err, "query failed%s", err == EIO ? evsql_result_error(res) : "");

   117

   118

    INFO("[evsql_test.insert] got %zu rows:", evsql_result_rows(res));

   119

   120

    // iterate over rows

   121

    while ((err = evsql_result_next(res, &id, &str)) > 0) {

   122

        INFO("\t%-4lu %s", (unsigned long) id, str);

   123

    }

   124

   125

    if (err)

   126

        EFATAL(err, "evsql_result_next failed");

   127

   128

    INFO("\t(done)");

   129

   130

    // done

   131

    evsql_result_end(res);

   132

   133

    // commit the transaction

   134

    trans_commit(ctx);

   135

}

   136

   137

void trans_insert (struct evsql_test_ctx *ctx) {

   138

    struct evsql_query *query = NULL;

   139

   140

    // the query info

   141

    static struct evsql_query_info query_info = {

   142

        .sql    = "INSERT INTO evsql_test (str) VALUES ($1::varchar), ($2::varchar) RETURNING id, str",

   143

   144

        .params = {

   145

            {   EVSQL_FMT_BINARY,   EVSQL_TYPE_STRING   },

   146

            {   EVSQL_FMT_BINARY,   EVSQL_TYPE_STRING   },

   147

            {   0,                  0                   }

   148

        }

   149

    };

   150

   151

    // run the query

   152

    assert((query = evsql_query_exec(ctx->db, ctx->trans, &query_info, trans_insert_result, ctx,

   153

        (const char *) "row A",

   154

        (const char *) "row B"

   155

    )) != NULL);

   156

   157

    INFO("[evsql_test.insert] enqueued query: %p", query);

   158

}

   159

   160

void trans_create_result (struct evsql_result *res, void *arg) {

   161

    struct evsql_test_ctx *ctx = arg;

   162

   163

    // check

   164

    if (evsql_result_check(res))

   165

        FATAL("query failed: %s", evsql_result_error(res));

   166

   167

    INFO("[evsql_test.create_result] table created succesfully: %p", res);

   168

   169

    // free result

   170

    evsql_result_free(res);

   171

   172

    // insert

   173

    trans_insert(ctx);

   174

}

   175

   176

void trans_create_query (struct evsql_test_ctx *ctx) {

   177

    struct evsql_query *query = NULL;

   178

   179

    // the query info

   180

    static struct evsql_query_info query_info = {

   181

        .sql    = "CREATE TEMPORARY TABLE evsql_test ( id serial4, str varchar(32) DEFAULT 'foobar' ) ON COMMIT DROP",

   182

   183

        .params = {

   184

//            {   EVSQL_FMT_BINARY,   EVSQL_TYPE_STRING   },

   185

            {   0,                  0,                  }

   186

        }

   187

    };

   188

   189

    // run the query

   190

    assert((query = evsql_query_exec(ctx->db, ctx->trans, &query_info, trans_create_result, ctx

   191

//        (const char *) "foobar"

   192

    )) != NULL);

   193

   194

    INFO("[evsql_test.trans_create_query] enqueued query: %p", query);

   195

}

   196

   197

void trans_error (struct evsql_trans *trans, void *arg) {

   198

    struct evsql_test_ctx *ctx = arg;

   199

   200

    FATAL("[evsql_test.trans_error] failure: trans=%p: %s", ctx->trans, evsql_trans_error(trans));

   201

}

   202

   203

void trans_ready (struct evsql_trans *trans, void *arg) {

   204

    struct evsql_test_ctx *ctx = arg;

   205

   206

    INFO("[evsql_test.trans_ready] ready");

   207

   208

    trans_create_query(ctx);

   209

}

   210

   211

void trans_done (struct evsql_trans *trans, void *arg) {

   212

    struct evsql_test_ctx *ctx = arg;

   213

   214

    INFO("[evsql_test.trans_done] done: trans=%p", ctx->trans);

   215

}

   216

   217

void begin_transaction (struct evsql_test_ctx *ctx) {

   218

    assert((ctx->trans = evsql_trans(ctx->db, EVSQL_TRANS_DEFAULT, 

   219

        &trans_error, &trans_ready, &trans_done,

   220

        ctx

   221

    )) != NULL);

   222

   223

    INFO("[evsql_test.begin_trans] created transaction");

   224

 }

   225

   226

int main (int argc, char **argv) {

   227

    struct evsql_test_ctx ctx;

   228

    struct event_base *ev_base = NULL;

   229

    struct signals *signals = NULL;

   230

   231

    const char *db_conninfo;

   232

   233

    // parse args

   234

    db_conninfo = CONNINFO_DEFAULT;

   235

   236

    // init libevent

   237

    if ((ev_base = event_base_new()) == NULL)

   238

        ERROR("event_base_new");

   239

   240

    // setup signals

   241

    if ((signals = signals_default(ev_base)) == NULL)

   242

        ERROR("signals_default");

   243

   244

    // setup evsql

   245

    if ((ctx.db = evsql_new_pq(ev_base, db_conninfo, NULL, NULL)) == NULL)

   246

        ERROR("evsql_new_pq");

   247

   248

    // send query

   249

    query_send(ctx.db, NULL);

   250

   251

    // being transaction

   252

    begin_transaction(&ctx);

   253

   254

    // send query

   255

    query_send(ctx.db, NULL);

   256

   257

    // start query timer

   258

    query_start(ev_base, ctx.db);

   259

   260

    // run libevent

   261

    INFO("[evsql_test.main] running libevent loop");

   262

   263

    if (event_base_dispatch(ev_base))

   264

        PERROR("event_base_dispatch");

   265

   266

    // clean shutdown

   267

   268

error :

   269

    if (ctx.db) {

   270

        /* evsql_close(db); */

   271

    }

   272

   273

    if (signals)

   274

        signals_free(signals);

   275

   276

    if (ev_base)

   277

        event_base_free(ev_base);

   278

   279

    // XXX: err

   280

    return 0;    

   281

}

   282