--- a/src/Connection.cpp Wed Dec 25 01:37:05 2019 +0100
+++ b/src/Connection.cpp Fri Jan 31 23:22:56 2020 +0100
@@ -24,32 +24,32 @@
namespace sql {
void Connection::begin() {
- sqlite3_exec(db, "BEGIN", nullptr, nullptr, nullptr);
+ sqlite3_exec((sqlite3*) db, "BEGIN", nullptr, nullptr, nullptr);
}
Connection::Connection(const char* filename) {
- int result = sqlite3_open(filename, &db);
+ int result = sqlite3_open(filename, (sqlite3**) & db);
if (result != SQLITE_OK) {
- sqlite3_close(db);
+ sqlite3_close((sqlite3*) db);
throw SqlException(L"Unable to open SQLite database.");
}
begin();
}
Connection::~Connection() {
- sqlite3_close(db);
+ sqlite3_close((sqlite3*) db);
}
PreparedStatement* Connection::prepareStatement(const char* sql) {
const char* remaining;
sqlite3_stmt *stmt;
- int result = sqlite3_prepare(db, sql, -1, &stmt, &remaining);
+ int result = sqlite3_prepare((sqlite3*) db, sql, -1, &stmt, &remaining);
if (result == SQLITE_OK) return new PreparedStatement(stmt);
else throw SqlException(L"Unable to prepare SQLite statement.");
}
bool Connection::getAutoCommit() {
- return sqlite3_get_autocommit(db);
+ return sqlite3_get_autocommit((sqlite3*) db);
}
void Connection::setAutoCommit(bool autoCommit) {
@@ -59,11 +59,11 @@
}
void Connection::commit() {
- sqlite3_exec(db, "COMMIT", nullptr, nullptr, nullptr);
+ sqlite3_exec((sqlite3*) db, "COMMIT", nullptr, nullptr, nullptr);
}
void Connection::rollback() {
- sqlite3_exec(db, "ROLLBACK", nullptr, nullptr, nullptr);
+ sqlite3_exec((sqlite3*) db, "ROLLBACK", nullptr, nullptr, nullptr);
}
}
--- a/src/Connection.h Wed Dec 25 01:37:05 2019 +0100
+++ b/src/Connection.h Fri Jan 31 23:22:56 2020 +0100
@@ -25,7 +25,7 @@
class Connection {
private:
- sqlite3* db;
+ void* db;
void begin();
public:
Connection(const char* filename); // TODO: add DriverManager class + support connecting using a DSN or a connectString
--- a/src/PreparedStatement.cpp Wed Dec 25 01:37:05 2019 +0100
+++ b/src/PreparedStatement.cpp Fri Jan 31 23:22:56 2020 +0100
@@ -25,57 +25,57 @@
namespace tr {
namespace sql {
-PreparedStatement::PreparedStatement(sqlite3_stmt* stmt) : stmt(stmt) {
+PreparedStatement::PreparedStatement(void* stmt) : stmt(stmt) {
}
PreparedStatement::~PreparedStatement() {
- sqlite3_finalize(stmt);
+ sqlite3_finalize((sqlite3_stmt*) stmt);
}
void PreparedStatement::setBoolean(int parameterIndex, relpipe::reader::boolean_t value) {
- int result = sqlite3_bind_int(stmt, parameterIndex, value);
+ int result = sqlite3_bind_int((sqlite3_stmt*) stmt, parameterIndex, value);
if (result != SQLITE_OK) throw SqlException(L"Unable to set SQLite parameter.");
}
void PreparedStatement::setInteger(int parameterIndex, relpipe::reader::integer_t value) {
- int result = sqlite3_bind_int64(stmt, parameterIndex, value);
+ int result = sqlite3_bind_int64((sqlite3_stmt*) stmt, parameterIndex, value);
if (result != SQLITE_OK) throw SqlException(L"Unable to set SQLite parameter.");
}
void PreparedStatement::setString(int parameterIndex, std::string value) {
- int result = sqlite3_bind_text(stmt, parameterIndex, value.c_str(), -1, SQLITE_TRANSIENT);
+ int result = sqlite3_bind_text((sqlite3_stmt*) stmt, parameterIndex, value.c_str(), -1, SQLITE_TRANSIENT);
if (result != SQLITE_OK) throw SqlException(L"Unable to set SQLite parameter.");
}
void PreparedStatement::setNull(int parameterIndex) {
- int result = sqlite3_bind_null(stmt, parameterIndex);
+ int result = sqlite3_bind_null((sqlite3_stmt*) stmt, parameterIndex);
if (result != SQLITE_OK) throw SqlException(L"Unable to set SQLite parameter.");
}
bool PreparedStatement::next() {
- int result = sqlite3_step(stmt);
+ int result = sqlite3_step((sqlite3_stmt*) stmt);
if (result == SQLITE_ROW) return true;
else if (result == SQLITE_DONE) return false;
else throw SqlException(L"Error while iterating over SQLite result.");
}
void PreparedStatement::reset() {
- int result = sqlite3_reset(stmt);
+ int result = sqlite3_reset((sqlite3_stmt*) stmt);
if (result != SQLITE_OK) throw SqlException(L"Unable to reset SQLite prepared statement.");
}
int PreparedStatement::getColumnCount() {
- return sqlite3_column_count(stmt);
+ return sqlite3_column_count((sqlite3_stmt*) stmt);
}
std::string PreparedStatement::getColumName(int columnIndex) {
- const char* name = sqlite3_column_name(stmt, columnIndex);
+ const char* name = sqlite3_column_name((sqlite3_stmt*) stmt, columnIndex);
if (name) return name;
else throw SqlException(L"Unable to get SQLite column name.");
}
relpipe::writer::TypeId PreparedStatement::getColumType(int columnIndex, relpipe::writer::TypeId defaultType) {
- const char* type = sqlite3_column_decltype(stmt, columnIndex);
+ const char* type = sqlite3_column_decltype((sqlite3_stmt*) stmt, columnIndex);
// TODO: sqlite3_column_decltype returns value only for columns of existing tables, not for dynamic expressions – SQLite uses dynamic types
// maybe we could write a function/module that returns result set metadata for given query (before executing it)
@@ -97,7 +97,7 @@
}
std::string PreparedStatement::getString(int columnIndex) {
- const char* value = (const char*) sqlite3_column_text(stmt, columnIndex);
+ const char* value = (const char*) sqlite3_column_text((sqlite3_stmt*) stmt, columnIndex);
return value ? value : ""; // TODO: support NULL values (when supported in relpipe format)
}
--- a/src/PreparedStatement.h Wed Dec 25 01:37:05 2019 +0100
+++ b/src/PreparedStatement.h Fri Jan 31 23:22:56 2020 +0100
@@ -27,9 +27,9 @@
class PreparedStatement {
private:
- sqlite3_stmt* stmt;
+ void* stmt;
public:
- PreparedStatement(sqlite3_stmt* stmt);
+ PreparedStatement(void* stmt);
virtual ~PreparedStatement();
void setBoolean(int parameterIndex, relpipe::reader::boolean_t value);
void setInteger(int parameterIndex, relpipe::reader::integer_t value);