1

#ifndef EVSQL_INTERNAL_H

     2

#define EVSQL_INTERNAL_H

     3

     4

/*

     5

 * Internal interfaces

     6

 */

     7

     8

#include <sys/queue.h>

     9

    10

#include <event2/event.h>

    11

    13

#include "evpq.h"

    14

    15

/*

    16

 * The engine type

    17

 */

    18

enum evsql_type {

    19

    EVSQL_EVPQ,     // evpq

    20

};

    21

    22

/*

    23

 * Contains the type, engine configuration, list of connections and waiting query queue.

    24

 */

    25

struct evsql {

    26

    // what event_base to use

    27

    struct event_base *ev_base;

    28

    29

    // what engine we use

    30

    enum evsql_type type;

    31

    32

    // callbacks

    33

    evsql_error_cb error_fn;

    34

    void *cb_arg;

    35

    36

    // engine-specific connection configuration

    37

    union {

    38

        const char *evpq;

    39

    } engine_conf;

    40

    41

    // list of connections that are open

    42

    LIST_HEAD(evsql_conn_list, evsql_conn) conn_list;

    43

    44

    // list of queries running or waiting to run

    45

    TAILQ_HEAD(evsql_query_queue, evsql_query) query_queue;

    46

};

    47

    48

/*

    49

 * A single connection to the server.

    50

 *

    51

 * Contains the engine connection, may have a transaction associated, and may have a query associated.

    52

 */

    53

struct evsql_conn {

    54

    // evsql we belong to

    55

    struct evsql *evsql;

    56

    57

    // engine-specific connection info

    58

    union {

    59

        struct evpq_conn *evpq;

    60

    } engine;

    61

    62

    // our position in the conn list

    63

    LIST_ENTRY(evsql_conn) entry;

    64

    65

    // are we running a transaction?

    66

    struct evsql_trans *trans;

    67

    68

    // are we running a transactionless query?

    69

    struct evsql_query *query;

    70

};

    71

    72

/*

    73

 * A single transaction.

    74

 *

    75

 * Has a connection associated and possibly a query (which will also be associated with the connection)

    76

 */

    77

struct evsql_trans {

    78

    // our evsql_conn/evsql

    79

    struct evsql *evsql;

    80

    struct evsql_conn *conn;

    81

    82

    // callbacks

    83

    evsql_trans_error_cb error_fn;

    84

    evsql_trans_ready_cb ready_fn;

    85

    evsql_trans_done_cb done_fn;

    86

    void *cb_arg;

    87

    88

    // the transaction type

    89

    enum evsql_trans_type type;

    90

    91

    // has evsql_trans_commit be called?

    92

    int has_commit : 1;

    93

    94

    // our current query

    95

    struct evsql_query *query;

    96

    97

};

    98

    99

/*

   100

 * Backend result handle

   101

 */

   102

union evsql_result_handle {

   103

    PGresult *pq;

   104

};

   105

   106

/*

   107

 * A single query.

   108

 *

   109

 * Has the info needed to exec the query (as these may be queued), and the callback/result info.

   110

 */

   111

struct evsql_query {

   112

    // the actual SQL query, this may or may not be ours, see _evsql_query_exec

   113

    char *command;

   114

   115

    // possible query params

   116

    struct evsql_query_params_pq {

   117

        int count;

   118

   119

        Oid *types;

   120

        const char **values;

   121

        int *lengths;

   122

        int *formats;

   123

   124

        // storage for numeric values

   125

        union evsql_item_value *item_vals;

   126

   127

        int result_format;

   128

    } params;

   129

   130

    // our callback

   131

    evsql_query_cb cb_fn;

   132

    void *cb_arg;

   133

   134

    // the result we get

   135

    union evsql_result_handle result;

   136

   137

    // our position in the query list

   138

    TAILQ_ENTRY(evsql_query) entry;

   139

};

   140

   141

// the result

   142

struct evsql_result {

   143

    struct evsql *evsql;

   144

   145

    // possible error code

   146

    int error;

   147

   148

    // the actual result

   149

    union evsql_result_handle result;

   150

   151

    // result_* state

   152

    struct evsql_result_info *info;

   153

    size_t row_offset;

   154

};

   155

   156

   157

// maximum length for a 'BEGIN TRANSACTION ...' query

   158

#define EVSQL_QUERY_BEGIN_BUF 512

   159

   160

// the should the OID of some valid psql type... *ANY* valid psql type, doesn't matter, only used for NULLs

   161

// 16 = bool in 8.3

   162

#define EVSQL_PQ_ARBITRARY_TYPE_OID 16

   163

   164

/*

   165

 * Core query-submission interface.

   166

 *

   167

 * This performs some error-checking on the trans, allocates the evsql_query and does some basic initialization.

   168

 *

   169

 * This does not actually enqueue the query anywhere, no reference is stored anywhere.

   170

 *

   171

 * Returns the new evsql_query on success, NULL on failure.

   172

 */

   173

struct evsql_query *_evsql_query_new (struct evsql *evsql, struct evsql_trans *trans, evsql_query_cb query_fn, void *cb_arg);

   174

   175

/*

   176

 * Begin processing the given query, which should now be fully filled out.

   177

 *

   178

 * If trans is given, it MUST be idle, and the query will be executed. Otherwise, it will either be executed directly

   179

 * or enqueued for future execution.

   180

 *

   181

 * Returns zero on success, nonzero on failure.

   182

 */

   183

int _evsql_query_enqueue (struct evsql *evsql, struct evsql_trans *trans, struct evsql_query *query, const char *command);

   184

   185

/*

   186

 * Free the query and related resources, doesn't trigger any callbacks or remove from any queues.

   187

 *

   188

 * The command should already be taken care of (NULL).

   189

 */

   190

void _evsql_query_free (struct evsql_query *query);

   191

   192

#endif /* EVSQL_INTERNAL_H */