-
Notifications
You must be signed in to change notification settings - Fork 5
/
bridge.c
138 lines (115 loc) · 11.1 KB
/
bridge.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
#include <sqlite3ext.h>
SQLITE_EXTENSION_INIT3
//- routine that work with sqlite3_context; see: https://sqlite.org/c3ref/context.html
//-----------------------------
void* _sqlite3_aggregate_context(sqlite3_context *ctx, int n){ return sqlite3_aggregate_context(ctx, n); }
sqlite3* _sqlite3_context_db_handle(sqlite3_context *ctx){ return sqlite3_context_db_handle(ctx); }
void* _sqlite3_user_data(sqlite3_context *ctx){ return sqlite3_user_data(ctx); }
void* _sqlite3_get_auxdata(sqlite3_context *ctx, int n){ return sqlite3_get_auxdata(ctx, n); }
void _sqlite3_set_auxdata(sqlite3_context *ctx, int n, void *val, void (*destructor)(void *)){ return sqlite3_set_auxdata(ctx, n, val, destructor); }
void _sqlite3_result_blob0(sqlite3_context *ctx, const void *val, int n, void (*destructor)(void *)){ sqlite3_result_blob(ctx, val, n, destructor); }
void _sqlite3_result_blob64(sqlite3_context *ctx, const void *val, sqlite3_uint64 n, void (*destructor)(void *)){ sqlite3_result_blob64(ctx, val, n, destructor); }
void _sqlite3_result_double(sqlite3_context *ctx, double val){ sqlite3_result_double(ctx, val); }
void _sqlite3_result_error(sqlite3_context *ctx, const char *msg, int n){ sqlite3_result_error(ctx, msg, n); }
void _sqlite3_result_error_code(sqlite3_context *ctx, int code){ sqlite3_result_error_code(ctx, code); }
void _sqlite3_result_error_nomem(sqlite3_context *ctx){ sqlite3_result_error_nomem(ctx); }
void _sqlite3_result_error_toobig(sqlite3_context *ctx){ sqlite3_result_error_toobig(ctx); }
void _sqlite3_result_int(sqlite3_context *ctx, int val){ sqlite3_result_int(ctx, val); }
void _sqlite3_result_int64(sqlite3_context *ctx, sqlite_int64 val){ sqlite3_result_int64(ctx, val); }
void _sqlite3_result_null(sqlite3_context *ctx){ sqlite3_result_null(ctx); }
void _sqlite3_result_text0(sqlite3_context *ctx, const char *val, int n, void (*destructor)(void *)){ sqlite3_result_text(ctx, val, n, destructor); }
void _sqlite3_result_value(sqlite3_context *ctx, sqlite3_value *val){ sqlite3_result_value(ctx, val); }
void _sqlite3_result_pointer(sqlite3_context *ctx, void *val, const char *name, void (*destructor)(void *)){ sqlite3_result_pointer(ctx, val, name, destructor); }
void _sqlite3_result_zeroblob(sqlite3_context *ctx, int sz){ return sqlite3_result_zeroblob(ctx, sz); }
int _sqlite3_result_zeroblob64(sqlite3_context *ctx, sqlite3_uint64 sz){ return sqlite3_result_zeroblob64(ctx, sz); }
void _sqlite3_result_subtype(sqlite3_context *ctx, unsigned int v){return sqlite3_result_subtype(ctx, v);}
// routines that work with sqlite_stmt; see: https://sqlite.org/c3ref/stmt.html
//-----------------------------
// constructor + destructor
int _sqlite3_prepare_v2(sqlite3 *db, const char *sql, int n, sqlite3_stmt **stmt, const char **tail){ return sqlite3_prepare_v2(db, sql, n, stmt, tail); }
int _sqlite3_finalize(sqlite3_stmt* stmt){ return sqlite3_finalize(stmt); }
// stepping / executing a prepared statement
int _sqlite3_step(sqlite3_stmt *stmt){ return sqlite3_step(stmt); }
int _sqlite3_reset(sqlite3_stmt *stmt){ return sqlite3_reset(stmt); }
int _sqlite3_clear_bindings(sqlite3_stmt *stmt){ return sqlite3_clear_bindings(stmt); }
int _sqlite3_data_count(sqlite3_stmt *stmt){ return sqlite3_data_count(stmt); }
int _sqlite3_column_count(sqlite3_stmt *stmt){ return sqlite3_column_count(stmt); }
sqlite3* _sqlite3_db_handle(sqlite3_stmt* stmt){ return sqlite3_db_handle(stmt); }
// binding values to prepared statement
int _sqlite3_bind_blob(sqlite3_stmt *stmt, int i, const void *val, int n, void (*destructor)(void *)){ return sqlite3_bind_blob(stmt, i, val, n, destructor); }
int _sqlite3_bind_double(sqlite3_stmt *stmt, int i, double val){ return sqlite3_bind_double(stmt, i, val); }
int _sqlite3_bind_int(sqlite3_stmt *stmt, int i, int val){ return sqlite3_bind_int(stmt, i, val); }
int _sqlite3_bind_int64(sqlite3_stmt *stmt, int i, sqlite_int64 val){ return sqlite3_bind_int64(stmt, i, val); }
int _sqlite3_bind_null(sqlite3_stmt *stmt, int i){ return sqlite3_bind_null(stmt, i); }
int _sqlite3_bind_text(sqlite3_stmt *stmt, int i, const char *val, int n, void (*destructor)(void *)){ return sqlite3_bind_text(stmt, i, val, n, destructor); }
int _sqlite3_bind_pointer(sqlite3_stmt *stmt, int i, void *val, const char *type, void (*destructor)(void *)){ return sqlite3_bind_pointer(stmt, i, val, type, destructor); }
int _sqlite3_bind_value(sqlite3_stmt *stmt, int i, const sqlite3_value *val){ return sqlite3_bind_value(stmt, i, val); }
int _sqlite3_bind_zeroblob(sqlite3_stmt *stmt, int i, int sz){ return sqlite3_bind_zeroblob(stmt, i, sz); }
int _sqlite3_bind_zeroblob64(sqlite3_stmt *stmt, int i, sqlite3_uint64 sz){ return sqlite3_bind_zeroblob64(stmt, i, sz); }
int _sqlite3_bind_parameter_count(sqlite3_stmt *stmt){ return sqlite3_bind_parameter_count(stmt); }
int _sqlite3_bind_parameter_index(sqlite3_stmt *stmt, const char *name){ return sqlite3_bind_parameter_index(stmt, name); }
const char* _sqlite3_bind_parameter_name(sqlite3_stmt *stmt, int n){ return sqlite3_bind_parameter_name(stmt, n); }
// reading result values from an sqlite3_stmt
const void* _sqlite3_column_blob(sqlite3_stmt* stmt, int i){ return sqlite3_column_blob(stmt, i); }
double _sqlite3_column_double(sqlite3_stmt* stmt, int i){ return sqlite3_column_double(stmt, i); }
int _sqlite3_column_int(sqlite3_stmt* stmt, int i){ return sqlite3_column_int(stmt, i); }
sqlite3_int64 _sqlite3_column_int64(sqlite3_stmt* stmt, int i){ return sqlite3_column_int64(stmt, i); }
const unsigned char* _sqlite3_column_text(sqlite3_stmt* stmt, int i){ return sqlite3_column_text(stmt, i); }
sqlite3_value* _sqlite3_column_value(sqlite3_stmt* stmt, int i){ return sqlite3_column_value(stmt, i); }
int _sqlite3_column_bytes(sqlite3_stmt* stmt, int i){ return sqlite3_column_bytes(stmt, i); }
// query sqlite3_stmt column information
const char* _sqlite3_column_name(sqlite3_stmt* stmt, int i){ return sqlite3_column_name(stmt, i); }
int _sqlite3_column_type(sqlite3_stmt* stmt, int i){ return sqlite3_column_type(stmt, i); }
const char* _sqlite3_column_database_name(sqlite3_stmt *stmt, int i){ return sqlite3_column_database_name(stmt, i); }
const char* _sqlite3_column_table_name(sqlite3_stmt *stmt, int i){ return sqlite3_column_table_name(stmt, i); }
const char* _sqlite3_column_origin_name(sqlite3_stmt *stmt, int i){ return sqlite3_column_origin_name(stmt, i); }
// meta-information about the statement itself
int _sqlite3_stmt_readonly(sqlite3_stmt* pStmt) { return sqlite3_stmt_readonly(pStmt); }
// routines to extract value from sqlite3_value type; see: https://sqlite.org/c3ref/value.html
//-----------------------------
const void* _sqlite3_value_blob(sqlite3_value *val){ return sqlite3_value_blob(val); }
double _sqlite3_value_double(sqlite3_value *val){ return sqlite3_value_double(val); }
int _sqlite3_value_int(sqlite3_value *val){ return sqlite3_value_int(val); }
sqlite_int64 _sqlite3_value_int64(sqlite3_value *val){ return sqlite3_value_int64(val); }
const unsigned char* _sqlite3_value_text(sqlite3_value *val){ return sqlite3_value_text(val); }
int _sqlite3_value_bytes(sqlite3_value *val){ return sqlite3_value_bytes(val); }
int _sqlite3_value_type(sqlite3_value *val){ return sqlite3_value_type(val); }
unsigned int _sqlite3_value_subtype(sqlite3_value *val){ return sqlite3_value_subtype(val); }
int _sqlite3_value_numeric_type(sqlite3_value *val){ return sqlite3_value_numeric_type(val); }
void* _sqlite3_value_pointer(sqlite3_value *val, const char *name){ return sqlite3_value_pointer(val, name); }
int _sqlite3_value_nochange(sqlite3_value *val){ return sqlite3_value_nochange(val); }
// routines to register application-defined sql functions
//-----------------------------
int _sqlite3_create_collation_v2(sqlite3 *db, const char *zName, int eTextRep, void *pUserData, int (*xCompare)(void *, int, const void *, int, const void *), void (*xDestroy)(void *)){ return sqlite3_create_collation_v2(db, zName, eTextRep, pUserData, xCompare, xDestroy); }
int _sqlite3_create_function_v2(sqlite3 *db, const char *zName, int nArgs, int eTextRep, void *pApp, void (*xFunc)(sqlite3_context *, int, sqlite3_value **), void (*xStep)(sqlite3_context *, int, sqlite3_value **), void (*xFinal)(sqlite3_context *), void (*xDestroy)(void *)){ return sqlite3_create_function_v2(db, zName, nArgs, eTextRep, pApp, xFunc, xStep, xFinal, xDestroy); }
int _sqlite3_create_window_function(sqlite3 *db, const char *zName, int nArgs, int eTextRep, void *pApp, void (*xStep)(sqlite3_context *, int, sqlite3_value **), void (*xFinal)(sqlite3_context *), void (*xValue)(sqlite3_context *), void (*xInverse)(sqlite3_context *, int, sqlite3_value **), void (*xDestroy)(void *)) { return sqlite3_create_window_function(db, zName, nArgs, eTextRep, pApp, xStep, xFinal, xValue, xInverse, xDestroy); }
// memory related operations
void* _sqlite3_malloc(int sz){ return sqlite3_malloc(sz); }
void* _sqlite3_realloc(void *p, int sz){ return sqlite3_realloc(p, sz); }
void _sqlite3_free(void *p){ sqlite3_free(p); }
// error details handler
int _sqlite3_errcode(sqlite3 *db){ return sqlite3_errcode(db); }
const char *_sqlite3_errmsg(sqlite3 *db){ return sqlite3_errmsg(db); }
// auth+tracing
int _sqlite3_set_authorizer(sqlite3 *db, int (*xAuth)(void *, int, const char *, const char *, const char *, const char *), void *pUserData){ return sqlite3_set_authorizer(db, xAuth, pUserData); }
int _sqlite3_trace_v2(sqlite3 *db, unsigned int uMask, int (*xCallback)(unsigned int, void *, void *, void *), void *pUserData){ return sqlite3_trace_v2(db, uMask, xCallback, pUserData); };
// hooks
void* _sqlite3_commit_hook(sqlite3 *db, int (*xCallback)(void *), void *pUserData){ return sqlite3_commit_hook(db, xCallback, pUserData); }
void* _sqlite3_rollback_hook(sqlite3 *db, void (*xCallback)(void *), void *pUserData){ return sqlite3_rollback_hook(db, xCallback, pUserData); }
void* _sqlite3_update_hook(sqlite3 *db, void (*xCallback)(void *, int, const char *, const char *, sqlite_int64), void *pUserData){ return sqlite3_update_hook(db, xCallback, pUserData); }
// version number information
sqlite_int64 _sqlite3_last_insert_rowid(sqlite3 *db){ return sqlite3_last_insert_rowid(db); }
const char* _sqlite3_libversion(void){ return sqlite3_libversion(); }
int _sqlite3_libversion_number(void) { return sqlite3_libversion_number(); }
// Virtual table routines
int _sqlite3_create_module_v2(sqlite3 *db, const char *name, const sqlite3_module *module, void *pApp, void (*destructor)(void *)){ return sqlite3_create_module_v2(db, name, module, pApp, destructor); }
int _sqlite3_declare_vtab(sqlite3 *db, const char *sql) { return sqlite3_declare_vtab(db, sql); }
const char* _sqlite3_vtab_collation(sqlite3_index_info* in, int i) { return sqlite3_vtab_collation(in, i); }
int _sqlite3_overload_function(sqlite3 *db, const char *name, int args) { return sqlite3_overload_function(db, name, args); }
int _sqlite3_vtab_nochange(sqlite3_context* ctx) { return sqlite3_vtab_nochange(ctx); }
// miscellaneous routines
int _sqlite3_get_autocommit(sqlite3 *db){ return sqlite3_get_autocommit(db); }
void _sqlite3_interrupt(sqlite3 *db){ sqlite3_interrupt(db); }
int _sqlite3_release_memory(int i){ return sqlite3_release_memory(i); }
int _sqlite3_threadsafe(void){ return sqlite3_threadsafe(); }
int _sqlite3_limit(sqlite3* db, int id, int val){ return sqlite3_limit(db, id, val); }