bool
DB::is_disc_present(const char* discname) throw(DBError)
{
const char* disc_presence_check = "SELECT DISTINCT disc FROM ddb WHERE disc LIKE ?";
int result;
bool disc_present = false;
std::string error_message = "Could not check disc presence";
// Prepare SQL statement
sqlite3_stmt* stmt;
result =
sqlite3_prepare_v2(db, disc_presence_check, -1, &stmt, NULL);
if(result != SQLITE_OK)
throw(DBError(error_message, DBError::PREPARE_STATEMENT));
// Execute SQL statement
result =
sqlite3_step(stmt);
// Check whether we have at least one disc in the database
if(result == SQLITE_ROW)
{
disc_present = true;
}
else if(result == SQLITE_DONE)
{
disc_present = false;
}
else
{
// We got an error
throw(DBError(error_message, DBError::EXECUTE_STATEMENT));
}
// Finalize SQL statement
result =
sqlite3_finalize(stmt);
if(result != SQLITE_OK)
throw(DBError(error_message, DBError::FINALIZE_STATEMENT));
// Return disc presence
return disc_present;
}
bool
DB::has_correct_format(void) throw(DBError)
{
const char* version_check = "SELECT COUNT(*) AS count, version FROM ddb_version";
std::string error_message = "Could not check database correctness";
int result;
bool format_is_correct = false;
// Prepare SQL statement
sqlite3_stmt* stmt;
result =
sqlite3_prepare_v2(db, version_check, -1, &stmt, NULL);
if(result != SQLITE_OK)
throw(DBError(error_message, DBError::PREPARE_STATEMENT));
// Execute SQL statement
result =
sqlite3_step(stmt);
if(result != SQLITE_ROW)
throw(DBError(error_message, DBError::EXECUTE_STATEMENT));
// Result should have only one row
if(sqlite3_column_int(stmt, 0) == 1)
{
// Version in database should be equal to the version of this class
format_is_correct = (sqlite3_column_int(stmt, 1) == version);
}
// Finalize SQL statement
result =
sqlite3_finalize(stmt);
if(result != SQLITE_OK)
throw(DBError(error_message, DBError::FINALIZE_STATEMENT));
if(!format_is_correct)
p->msg("Database has wrong format!", Print::INFO);
// Return correctness
return format_is_correct;
}
yasper::ptr<TupleIterator> Statement::begin() {
if(not stmt)
throw ValueError("The statement is null.");
if(sqlite3_reset(stmt) != SQLITE_OK)
throw DBError(db, "The statement cannot be reset (or initializated).");
return yasper::ptr<TupleIterator>(new TupleIterator(db, *stmt));
}
void
QtSqlCursorBackend::prepare(const String &sql)
{
clear();
stmt_.reset(new QSqlQuery(*conn_));
stmt_->setForwardOnly(true);
if (!stmt_->prepare(sql))
throw DBError(stmt_->lastError().text());
}
void
SQLiteConnectionBackend::begin_trans()
{
sqlite3_exec(conn_, "BEGIN TRANSACTION", NULL, 0, 0);
if (SQLITE_OK != sqlite3_errcode(conn_)) {
const char *err = sqlite3_errmsg(conn_);
throw DBError(WIDEN(err));
}
}
void
SQLiteCursorBackend::exec_direct(const String &sql)
{
int rs = sqlite3_exec(conn_, NARROW(sql).c_str(), 0, 0, 0);
if (SQLITE_OK != sqlite3_errcode(conn_)) {
const char *err = sqlite3_errmsg(conn_);
throw DBError(WIDEN(err));
}
}
void
SQLiteConnectionBackend::rollback()
{
sqlite3_exec(conn_, "ROLLBACK", NULL, 0, 0);
if (SQLITE_OK != sqlite3_errcode(conn_)) {
const char *err = sqlite3_errmsg(conn_);
throw DBError(WIDEN(err));
}
}
void
SQLiteConnectionBackend::commit()
{
sqlite3_exec(conn_, "COMMIT", NULL, 0, 0);
if (SQLITE_OK != sqlite3_errcode(conn_)) {
const char *err = sqlite3_errmsg(conn_);
throw DBError(WIDEN(err));
}
}
void
SQLiteCursorBackend::prepare(const String &sql)
{
close();
sqlite3_prepare_v2(conn_, NARROW(sql).c_str(), -1, &stmt_, 0);
if (SQLITE_OK != sqlite3_errcode(conn_) || !stmt_) {
const char *err = sqlite3_errmsg(conn_);
throw DBError(WIDEN(err));
}
}
SQLiteDB() {
db=NULL;
if (file.size()==0) {
throw DBError("Database file not set.");
}
int rc=sqlite3_open(file.c_str(),&db);
if (rc) {
DBError::busy_aware_throw(rc,sqlite3_errmsg(db));
}
}
void
SOCIConnectionBackend::begin_trans()
{
try {
conn_->begin();
}
catch (const soci::soci_error &e) {
throw DBError(WIDEN(e.what()));
}
}
void
SOCIConnectionBackend::rollback()
{
try {
conn_->rollback();
}
catch (const soci::soci_error &e) {
throw DBError(WIDEN(e.what()));
}
}
void
SOCICursorBackend::exec_direct(const String &sql)
{
try {
conn_->once << NARROW(sql);
}
catch (const soci::soci_error &e) {
throw DBError(WIDEN(e.what()));
}
}
void
SQLiteConnectionBackend::open(SqlDialect *dialect, const SqlSource &source)
{
close();
ScopedLock lock(drv_->conn_mux_);
own_handle_ = true;
sqlite3_open(NARROW(source.db()).c_str(), &conn_);
if (SQLITE_OK != sqlite3_errcode(conn_)) {
const char *err = sqlite3_errmsg(conn_);
throw DBError(WIDEN(err));
}
}
void
SOCICursorBackend::bind_params(const TypeCodes &types)
{
param_types_ = types;
if (in_params_.size())
throw DBError(_T("bind_params: already bound!"));
in_params_.resize(types.size());
in_flags_.resize(types.size());
for (size_t i = 0; i < types.size(); ++i) {
in_flags_[i] = soci::i_null;
switch (types[i]) {
case Value::INTEGER: {
if (in_params_[i].size() < sizeof(int))
in_params_[i].resize(sizeof(int));
int &x = *(int *)&(in_params_[i][0]);
x = 0;
stmt_->exchange(soci::use(x, in_flags_[i]));
break;
}
case Value::LONGINT: {
if (in_params_[i].size() < sizeof(LongInt))
in_params_[i].resize(sizeof(LongInt));
LongInt &x = *(LongInt *)&(in_params_[i][0]);
x = 0;
stmt_->exchange(soci::use(x, in_flags_[i]));
break;
}
case Value::FLOAT: {
if (in_params_[i].size() < sizeof(double))
in_params_[i].resize(sizeof(double));
double &x = *(double *)&(in_params_[i][0]);
x = 0;
stmt_->exchange(soci::use(x, in_flags_[i]));
break;
}
case Value::DATETIME: {
if (in_params_[i].size() < sizeof(std::tm))
in_params_[i].resize(sizeof(std::tm));
std::tm &x = *(std::tm *)&(in_params_[i][0]);
memset(&x, 0, sizeof(x));
stmt_->exchange(soci::use(x, in_flags_[i]));
break;
}
default: {
stmt_->exchange(soci::use(in_params_[i], in_flags_[i]));
}
}
}
if (is_select_)
stmt_->exchange(soci::into(row_));
stmt_->define_and_bind();
}
void
QtSqlConnectionBackend::open(SqlDialect *dialect, const SqlSource &source)
{
close();
ScopedLock lock(drv_->conn_mux_);
own_handle_ = true;
conn_name_ = dialect->get_name() + _T("_") + source.db()
+ _T("_") + to_string(drv_->seq_);
++drv_->seq_;
String driver = source.driver();
bool eat_slash = false;
if (driver == _T("QTSQL"))
{
if (dialect->get_name() == _T("MYSQL"))
driver = _T("QMYSQL");
else if (dialect->get_name() == _T("POSTGRES"))
driver = _T("QPSQL");
else if (dialect->get_name() == _T("ORACLE"))
driver = _T("QOCI");
else if (dialect->get_name() == _T("INTERBASE"))
driver = _T("QIBASE");
else if (dialect->get_name() == _T("SQLITE"))
driver = _T("QSQLITE");
if (dialect->native_driver_eats_slash()
&& !str_empty(source.db())
&& char_code(source.db()[0]) == '/')
eat_slash = true;
}
conn_ = new QSqlDatabase(QSqlDatabase::addDatabase(driver, conn_name_));
if (eat_slash)
conn_->setDatabaseName(str_substr(source.db(), 1));
else
conn_->setDatabaseName(source.db());
conn_->setUserName(source.user());
conn_->setPassword(source.passwd());
if (source.port() > 0)
conn_->setPort(source.port());
if (!str_empty(source.host()))
conn_->setHostName(source.host());
String options;
Strings keys = source.options();
for (size_t i = 0; i < keys.size(); ++i) {
if (!str_empty(options))
options += _T(";");
options += keys[i] + _T("=") + source[keys[i]];
}
if (!str_empty(options))
conn_->setConnectOptions(options);
if (!conn_->open())
throw DBError(conn_->lastError().text());
}
void SOCIConnectionBackend::close()
{
try {
if (own_handle_) {
if (conn_)
delete conn_;
own_handle_ = false;
}
conn_ = NULL;
}
catch (const soci::soci_error &e) {
throw DBError(WIDEN(e.what()));
}
}
void
SQLiteCursorBackend::exec(const Values ¶ms)
{
if (exec_count_)
sqlite3_reset(stmt_);
++exec_count_;
vector<string> str_params(params.size());
for (size_t i = 0; i < params.size(); ++i) {
if (params[i].get_type() == Value::INTEGER
|| params[i].get_type() == Value::LONGINT)
{
sqlite3_bind_int(stmt_, i + 1, params[i].as_integer());
if (SQLITE_OK != sqlite3_errcode(conn_)) {
const char *err = sqlite3_errmsg(conn_);
throw DBError(WIDEN(err));
}
} else if (params[i].is_null()) {
sqlite3_bind_null(stmt_, i + 1);
if (SQLITE_OK != sqlite3_errcode(conn_)) {
const char *err = sqlite3_errmsg(conn_);
throw DBError(WIDEN(err));
}
} else {
str_params[i] = NARROW(params[i].as_string());
sqlite3_bind_text(stmt_, i + 1,
str_params[i].c_str(), str_params[i].size(), SQLITE_STATIC);
if (SQLITE_OK != sqlite3_errcode(conn_)) {
const char *err = sqlite3_errmsg(conn_);
throw DBError(WIDEN(err));
}
}
}
last_code_ = sqlite3_step(stmt_);
if (last_code_ != SQLITE_DONE && last_code_ != SQLITE_ROW
&& last_code_ != SQLITE_OK)
throw DBError(WIDEN(sqlite3_errmsg(conn_)));
}
TupleIterator& TupleIterator::operator++() {
while(true) {
switch(sqlite3_step(&stmt)) {
case SQLITE_DONE:
done = true;
case SQLITE_ROW:
return *this;
case SQLITE_BUSY:
sleep(1);
break;
default:
throw DBError(db, "An error ocurred when executing the statement.");
}
}
}
void
DB::add_disc(const char* disc_name, const char* starting_path) throw(DBError)
{
const char* begin_transaction = "BEGIN";
const char* add_entry = "INSERT INTO ddb (directory, file, disc) VALUES (?, ?, ?)";
const char* end_transaction = "COMMIT";
std::string error_message = std::string("Could not add disc ") + disc_name;
int result;
// Declare disc root directory
fs::path disc_path(starting_path);
// Check, whether disc path is a directory
if(!fs::is_directory(disc_path))
throw(DBError(std::string("Path ") + starting_path + " is not a directory", DBError::FILE_ERROR));
// Container of file names
std::vector<std::pair<fs::path, bool> > filenames;
// Open directory and iterate through it recursively
fs::path current_path;
bool current_path_is_directory;
fs::recursive_directory_iterator end;
for(fs::recursive_directory_iterator dir(disc_path);
dir != end;
dir++)
{
current_path = dir->path();
current_path_is_directory = fs::is_directory(current_path);
// Put current file name into vector
filenames.push_back(std::make_pair(current_path, current_path_is_directory));
}
// Sort filenames
sort(filenames.begin(),filenames.end());
// Print file names, if verbosity is set high enough
if(p->get_verbosity() >= Print::VERBOSE_DEBUG)
{
std::pair<fs::path, bool> it;
foreach(it, filenames)
{
std::cout << (it.second ? "Directory" : "File") << " " << it.first << std::endl;
}
void
SOCICursorBackend::prepare(const String &sql)
{
close();
sql_ = NARROW(sql);
is_select_ = starts_with(
str_to_upper(trim_trailing_space(sql)), _T("SELECT"));
try {
stmt_ = new soci::statement(*conn_);
stmt_->alloc();
stmt_->prepare(sql_);
}
catch (const soci::soci_error &e) {
throw DBError(WIDEN(e.what()));
}
}
void
SOCICursorBackend::close()
{
try {
if (stmt_) {
delete stmt_;
stmt_ = NULL;
is_select_ = false;
bound_first_ = false;
executed_ = false;
sql_.empty();
}
}
catch (const soci::soci_error &e) {
throw DBError(WIDEN(e.what()));
}
}
void
DB::close(void) throw(DBError)
{
std::string error_message = "Could not close database";
int result;
p->msg("Closing database...", Print::VERBOSE);
// Close database
result =
sqlite3_close(db);
// If something went wrong, throw an exception
if(result != SQLITE_OK)
throw(DBError(error_message, DBError::FILE_ERROR));
p->msg("Done.", Print::DEBUG);
}
RowPtr SQLiteCursorBackend::fetch_row()
{
if (SQLITE_DONE == last_code_ || SQLITE_OK == last_code_)
return RowPtr();
if (SQLITE_ROW != last_code_)
throw DBError(WIDEN(sqlite3_errmsg(conn_)));
int col_count = sqlite3_column_count(stmt_);
RowPtr row(new Row(col_count));
for (int i = 0; i < col_count; ++i) {
String name = str_to_upper(WIDEN(sqlite3_column_name(stmt_, i)));
int type = sqlite3_column_type(stmt_, i);
(*row)[i].first = name;
if (SQLITE_NULL != type)
(*row)[i].second = Value(
WIDEN((const char *)sqlite3_column_text(stmt_, i)));
}
last_code_ = sqlite3_step(stmt_);
return row;
}
void
SOCIConnectionBackend::open(SqlDialect *dialect, const SqlSource &source)
{
close();
own_handle_ = true;
try {
String driver = source.driver();
std::string soci_backend = "odbc";
if (driver == _T("SOCI"))
soci_backend = soci_convert_dialect(dialect->get_name());
conn_ = new soci::session(soci_backend, NARROW(source.db()));
#ifdef YB_SOCI_DEBUG
conn_->set_log_stream(&cerr);
#endif
}
catch (const soci::soci_error &e) {
throw DBError(WIDEN(e.what()));
}
}
void
DB::open(const char* dbname, bool initialize) throw(DBError)
{
std::string error_message = std::string("Could not open file ") + dbname;
int result;
// Assume database is not open already
assert(db == NULL);
p->msg("Opening database...", Print::VERBOSE);
// Open database
result =
sqlite3_open_v2(dbname, &db, SQLITE_OPEN_READWRITE, NULL);
if(result != SQLITE_OK)
throw(DBError(error_message), DBError::FILE_ERROR);
p->msg("Done.", Print::DEBUG);
}
void
QtSqlCursorBackend::exec(const Values ¶ms)
{
if (bound_.empty())
for (unsigned i = 0; i < params.size(); ++i)
bound_.push_back(QVariant());
for (unsigned i = 0; i < params.size(); ++i) {
if (params[i].is_null())
bound_[i] = QVariant();
else if (params[i].get_type() == Value::DATETIME)
bound_[i] = QVariant(params[i].as_date_time());
else if (params[i].get_type() == Value::INTEGER)
bound_[i] = QVariant(params[i].as_integer());
else if (params[i].get_type() == Value::LONGINT)
bound_[i] = QVariant(params[i].as_longint());
else if (params[i].get_type() == Value::FLOAT)
bound_[i] = QVariant(params[i].as_float());
else
bound_[i] = QVariant(params[i].as_string());
stmt_->bindValue(i, bound_[i]);
}
if (!stmt_->exec())
throw DBError(stmt_->lastError().text());
}
void
QtSqlConnectionBackend::rollback()
{
if (!conn_->rollback())
throw DBError(conn_->lastError().text());
}
void
QtSqlConnectionBackend::commit()
{
if (!conn_->commit())
throw DBError(conn_->lastError().text());
}
void
QtSqlConnectionBackend::begin_trans()
{
if (!conn_->transaction())
throw DBError(conn_->lastError().text());
}
