forks/erlang-sqlite3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixed compilation errors under CL

Browse Source
This commit is contained in:
Alexey Romanov
2010-12-11 21:02:22 +03:00
parent c2b8f29395
commit aacdf8c3f6
1 changed files with 58 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
c_src/sqlite3_drv.c
View File

@@ -37,14 +37,26 @@ DRIVER_INIT(basic_driver) {
static inline ptr_list *add_to_ptr_list(ptr_list *list, void *value_ptr);
static inline void free_ptr_list(ptr_list *list, void(* free_head)(void *));
#ifndef max // macro in Windows
static inline int max(int a, int b);
#endif
static inline int sql_is_insert(const char *sql);
// required because driver_free(_binary) are macros in Windows
void driver_free_fun(void *ptr) {
driver_free(ptr);
}
void driver_free_binary_fun(void *ptr) {
driver_free_binary((ErlDrvBinary *) ptr);
}
// Driver Start
static ErlDrvData start(ErlDrvPort port, char* cmd) {
sqlite3_drv_t* retval = (sqlite3_drv_t*) driver_alloc(sizeof(sqlite3_drv_t));
struct sqlite3 *db = NULL;
int status = 0;
char *db_name;
retval->log = fopen(LOG_PATH, "a+");
if (!retval->log) {
@@ -54,7 +66,7 @@ static ErlDrvData start(ErlDrvPort port, char* cmd) {
fprintf(retval->log,
"--- Start erlang-sqlite3 driver\nCommand line: [%s]\n", cmd);
const char *db_name = strstr(cmd, " ");
db_name = strstr(cmd, " ");
if (!db_name) {
fprintf(retval->log,
"ERROR: DB name should be passed at command line\n");
@@ -286,13 +298,13 @@ static inline int decode_and_bind_param(
// include space for null separator
char_buf_val = driver_alloc((*p_size + 1) * sizeof(char));
ei_decode_string(buffer, p_index, char_buf_val);
result = sqlite3_bind_text(statement, param_index, char_buf_val, *p_size, &driver_free);
result = sqlite3_bind_text(statement, param_index, char_buf_val, *p_size, &driver_free_fun);
break;
case ERL_BINARY_EXT:
char_buf_val = driver_alloc(*p_size * sizeof(char));
ei_decode_binary(buffer, p_index, char_buf_val, &bin_size);
// assert(bin_size == *p_size)
result = sqlite3_bind_text(statement, param_index, char_buf_val, *p_size, &driver_free);
result = sqlite3_bind_text(statement, param_index, char_buf_val, *p_size, &driver_free_fun);
break;
case ERL_SMALL_TUPLE_EXT:
// assume this is {blob, Blob}
@@ -305,7 +317,7 @@ static inline int decode_and_bind_param(
char_buf_val = driver_alloc(*p_size * sizeof(char));
ei_decode_binary(buffer, p_index, char_buf_val, &bin_size);
// assert(bin_size == *p_size)
result = sqlite3_bind_blob(statement, param_index, char_buf_val, *p_size, &driver_free);
result = sqlite3_bind_blob(statement, param_index, char_buf_val, *p_size, &driver_free_fun);
break;
default:
output_error(drv, SQLITE_MISUSE, "bad parameter type");
@@ -433,6 +445,7 @@ static int sql_bind_and_exec(sqlite3_drv_t *drv, char *buffer, int buffer_size)
char *rest = NULL;
sqlite3_stmt *statement;
long bin_size;
char *command;
#ifdef DEBUG
fprintf(drv->log, "Preexec: %.*s\n", buffer_size, buffer);
@@ -454,7 +467,7 @@ static int sql_bind_and_exec(sqlite3_drv_t *drv, char *buffer, int buffer_size)
"SQL should be sent as an Erlang binary");
}
char *command = driver_alloc(size * sizeof(char));
command = driver_alloc(size * sizeof(char));
ei_decode_binary(buffer, &index, command, &bin_size);
// assert(bin_size == size)
result = sqlite3_prepare_v2(drv->db, command, size, &statement,
@@ -480,10 +493,9 @@ static void sql_free_async(void *_async_command) {
async_command->driver_data->async_handle = 0;
free_ptr_list(async_command->ptrs, &driver_free);
free_ptr_list(async_command->ptrs, &driver_free_fun);
free_ptr_list(async_command->binaries,
(void (*)(void *)) &driver_free_binary);
free_ptr_list(async_command->binaries, &driver_free_binary_fun);
if (async_command->finalize_statement_on_free && async_command->statement) {
sqlite3_finalize(async_command->statement);
@@ -495,8 +507,7 @@ static void sql_free_async(void *_async_command) {
static void sql_exec_async(void *_async_command) {
async_sqlite3_command *async_command =
(async_sqlite3_command *) _async_command;
int term_count = 0;
int term_allocated = 0;
int term_count = 0, base_term_count, term_allocated = 0;
ErlDrvTermData *dataset = NULL;
int row_count = 0;
sqlite3_drv_t *drv = async_command->driver_data;
@@ -526,7 +537,7 @@ static void sql_exec_async(void *_async_command) {
}
dataset[term_count - 2] = ERL_DRV_ATOM;
dataset[term_count - 1] = drv->atom_columns;
int base_term_count = term_count;
base_term_count = term_count;
get_columns(
drv, statement, column_count, base_term_count, &term_count, &term_allocated, &dataset);
term_count += 4;
@@ -907,6 +918,7 @@ static int prepare(sqlite3_drv_t *drv, char *command, int command_size) {
int result;
char *rest = NULL;
sqlite3_stmt *statement;
ErlDrvTermData spec[6];
#ifdef DEBUG
fprintf(drv->log, "Preparing statement: %.*s\n", command_size, command);
@@ -928,18 +940,21 @@ static int prepare(sqlite3_drv_t *drv, char *command, int command_size) {
drv->prepared_stmts[drv->prepared_count] = statement;
drv->prepared_count++;
ErlDrvTermData spec[] = {
ERL_DRV_PORT, driver_mk_port(drv->port),
ERL_DRV_UINT, drv->prepared_count - 1,
ERL_DRV_TUPLE, 2
};
spec[0] = ERL_DRV_PORT;
spec[1] = driver_mk_port(drv->port);
spec[2] = ERL_DRV_UINT;
spec[3] = drv->prepared_count - 1;
spec[4] = ERL_DRV_TUPLE;
spec[5] = 2;
return driver_output_term(drv->port, spec, sizeof(spec) / sizeof(spec[0]));
}
static int prepared_bind(sqlite3_drv_t *drv, char *buffer, int buffer_size) {
int result;
unsigned int prepared_index;
long long_prepared_index;
int index = 0, type, size;
sqlite3_stmt *statement;
#ifdef DEBUG
fprintf(drv->log, "Finalizing prepared statement: %.*s\n", buffer_size, buffer);
@@ -950,14 +965,14 @@ static int prepared_bind(sqlite3_drv_t *drv, char *buffer, int buffer_size) {
ei_decode_tuple_header(buffer, &index, &size);
// assert(size == 2);
ei_decode_long(buffer, &index, &long_prepared_index);
unsigned int prepared_index = (unsigned int) long_prepared_index;
prepared_index = (unsigned int) long_prepared_index;
if (prepared_index >= drv->prepared_count) {
return output_error(drv, SQLITE_MISUSE,
"Trying to bind non-existent prepared statement");
}
sqlite3_stmt *statement = drv->prepared_stmts[prepared_index];
statement = drv->prepared_stmts[prepared_index];
result =
bind_parameters(drv, buffer, buffer_size, &index, statement, &type, &size);
if (result == SQLITE_OK) {
@@ -968,8 +983,11 @@ static int prepared_bind(sqlite3_drv_t *drv, char *buffer, int buffer_size) {
}
static int prepared_columns(sqlite3_drv_t *drv, char *buffer, int buffer_size) {
unsigned int prepared_index;
long long_prepared_index;
int index = 0, term_count = 0, term_allocated = 0;
int index = 0, term_count = 0, term_allocated = 0, column_count;
sqlite3_stmt *statement;
ErlDrvTermData *dataset = NULL;
#ifdef DEBUG
fprintf(drv->log, "Finalizing prepared statement: %.*s\n", buffer_size, buffer);
@@ -978,15 +996,14 @@ static int prepared_columns(sqlite3_drv_t *drv, char *buffer, int buffer_size) {
ei_decode_version(buffer, &index, NULL);
ei_decode_long(buffer, &index, &long_prepared_index);
unsigned int prepared_index = (unsigned int) long_prepared_index;
prepared_index = (unsigned int) long_prepared_index;
if (prepared_index >= drv->prepared_count) {
return output_error(drv, SQLITE_MISUSE,
"Trying to reset non-existent prepared statement");
}
sqlite3_stmt *statement = drv->prepared_stmts[prepared_index];
ErlDrvTermData *dataset = NULL;
statement = drv->prepared_stmts[prepared_index];
term_count += 2;
if (term_count > term_allocated) {
@@ -996,7 +1013,7 @@ static int prepared_columns(sqlite3_drv_t *drv, char *buffer, int buffer_size) {
dataset[term_count - 2] = ERL_DRV_PORT;
dataset[term_count - 1] = driver_mk_port(drv->port);
int column_count = sqlite3_column_count(statement);
column_count = sqlite3_column_count(statement);
get_columns(
drv, statement, column_count, 2, &term_count, &term_allocated, &dataset);
@@ -1009,9 +1026,12 @@ static int prepared_columns(sqlite3_drv_t *drv, char *buffer, int buffer_size) {
static int prepared_step(sqlite3_drv_t *drv, char *buffer, int buffer_size) {
int result;
unsigned int prepared_index;
long long_prepared_index;
int index = 0;
char *rest = NULL;
sqlite3_stmt *statement;
async_sqlite3_command *async_command;
#ifdef DEBUG
fprintf(drv->log, "Evaluating prepared statement: %.*s\n", command_size, command);
@@ -1020,15 +1040,15 @@ static int prepared_step(sqlite3_drv_t *drv, char *buffer, int buffer_size) {
ei_decode_version(buffer, &index, NULL);
ei_decode_long(buffer, &index, &long_prepared_index);
unsigned int prepared_index = (unsigned int) long_prepared_index;
prepared_index = (unsigned int) long_prepared_index;
if (prepared_index >= drv->prepared_count) {
return output_error(drv, SQLITE_MISUSE,
"Trying to evaluate non-existent prepared statement");
}
sqlite3_stmt *statement = drv->prepared_stmts[prepared_index];
async_sqlite3_command *async_command = make_async_command(drv, statement);
statement = drv->prepared_stmts[prepared_index];
async_command = make_async_command(drv, statement);
if (sqlite3_threadsafe()) {
drv->async_handle = driver_async(drv->port, &drv->key, sql_step_async,
@@ -1041,8 +1061,10 @@ static int prepared_step(sqlite3_drv_t *drv, char *buffer, int buffer_size) {
}
static int prepared_reset(sqlite3_drv_t *drv, char *buffer, int buffer_size) {
unsigned int prepared_index;
long long_prepared_index;
int index = 0;
sqlite3_stmt *statement;
#ifdef DEBUG
fprintf(drv->log, "Finalizing prepared statement: %.*s\n", command_size, command);
@@ -1051,7 +1073,7 @@ static int prepared_reset(sqlite3_drv_t *drv, char *buffer, int buffer_size) {
ei_decode_version(buffer, &index, NULL);
ei_decode_long(buffer, &index, &long_prepared_index);
unsigned int prepared_index = (unsigned int) long_prepared_index;
prepared_index = (unsigned int) long_prepared_index;
if (prepared_index >= drv->prepared_count) {
return output_error(drv, SQLITE_MISUSE,
@@ -1059,14 +1081,16 @@ static int prepared_reset(sqlite3_drv_t *drv, char *buffer, int buffer_size) {
}
// don't bother about error code, any errors should already be shown by step
sqlite3_stmt *statement = drv->prepared_stmts[prepared_index];
statement = drv->prepared_stmts[prepared_index];
sqlite3_reset(statement);
return output_ok(drv);
}
static int prepared_clear_bindings(sqlite3_drv_t *drv, char *buffer, int buffer_size) {
unsigned int prepared_index;
long long_prepared_index;
int index = 0;
sqlite3_stmt *statement;
#ifdef DEBUG
fprintf(drv->log, "Finalizing prepared statement: %.*s\n", command_size, command);
@@ -1075,19 +1099,20 @@ static int prepared_clear_bindings(sqlite3_drv_t *drv, char *buffer, int buffer_
ei_decode_version(buffer, &index, NULL);
ei_decode_long(buffer, &index, &long_prepared_index);
unsigned int prepared_index = (unsigned int) long_prepared_index;
prepared_index = (unsigned int) long_prepared_index;
if (prepared_index >= drv->prepared_count) {
return output_error(drv, SQLITE_MISUSE,
"Trying to clear bindings of non-existent prepared statement");
}
sqlite3_stmt *statement = drv->prepared_stmts[prepared_index];
statement = drv->prepared_stmts[prepared_index];
sqlite3_clear_bindings(statement);
return output_ok(drv);
}
static int prepared_finalize(sqlite3_drv_t *drv, char *buffer, int buffer_size) {
unsigned int prepared_index;
long long_prepared_index;
int index = 0;
@@ -1098,7 +1123,7 @@ static int prepared_finalize(sqlite3_drv_t *drv, char *buffer, int buffer_size)
ei_decode_version(buffer, &index, NULL);
ei_decode_long(buffer, &index, &long_prepared_index);
unsigned int prepared_index = (unsigned int) long_prepared_index;
prepared_index = (unsigned int) long_prepared_index;
if (prepared_index >= drv->prepared_count) {
return output_error(drv, SQLITE_MISUSE,
@@ -1152,9 +1177,11 @@ static inline void free_ptr_list(ptr_list *list, void(* free_head)(void *)) {
}
}
#ifndef max // macro in Windows
static inline int max(int a, int b) {
return a >= b ? a : b;
}
#endif
static inline int sql_is_insert(const char *sql) {
// neither strcasestr nor strnicmp are portable, so have to do this