Skip to content

D
dlib
Commit 94ff8e83 authored by Davis King's avatar Davis King
Browse files
Options

Just removed the sqlite namespace and unindended everything.

parent 8d1cf196
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 254 additions and 260 deletions
dlib/sqlite/sqlite.h
View file @ 94ff8e83
This diff is collapsed.
dlib/sqlite/sqlite_abstract.h
View file @ 94ff8e83
This diff is collapsed.
dlib/sqlite/sqlite_tools.h
View file @ 94ff8e83
......@@ -11,181 +11,178 @@
namespace dlib
{
namespace sqlite
{
class transaction : noncopyable
class transaction : noncopyable
{
public:
transaction (
database& db_
) :
db(db_),
committed(false)
{
public:
transaction (
database& db_
) :
db(db_),
committed(false)
{
db.exec("begin transaction");
}
db.exec("begin transaction");
}
void commit ()
void commit ()
{
if (!committed)
{
if (!committed)
{
committed = true;
db.exec("commit");
}
committed = true;
db.exec("commit");
}
}
~transaction()
{
if (!committed)
db.exec("rollback");
}
~transaction()
{
if (!committed)
db.exec("rollback");
}
private:
database& db;
bool committed;
private:
database& db;
bool committed;
};
};
// ------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
template <
typename T
>
void query_object (
database& db,
const std::string& query,
T& item
)
template <
typename T
>
void query_object (
database& db,
const std::string& query,
T& item
)
{
statement st(db, query);
st.exec();
if (st.move_next() && st.get_num_columns() == 1)
{
statement st(db, query);
st.exec();
if (st.move_next() && st.get_num_columns() == 1)
{
st.get_column_as_object(0,item);
if (st.move_next())
throw sqlite_error("query doesn't result in exactly 1 element");
}
else
{
st.get_column_as_object(0,item);
if (st.move_next())
throw sqlite_error("query doesn't result in exactly 1 element");
}
}
else
{
throw sqlite_error("query doesn't result in exactly 1 element");
}
}
// ------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
inline std::string query_text (
database& db,
const std::string& query
)
inline std::string query_text (
database& db,
const std::string& query
)
{
statement st(db, query);
st.exec();
if (st.move_next() && st.get_num_columns() == 1)
{
statement st(db, query);
st.exec();
if (st.move_next() && st.get_num_columns() == 1)
{
const std::string& temp = st.get_column_as_text(0);
if (st.move_next())
throw sqlite_error("query doesn't result in exactly 1 element");
return temp;
}
else
{
const std::string& temp = st.get_column_as_text(0);
if (st.move_next())
throw sqlite_error("query doesn't result in exactly 1 element");
}
return temp;
}
else
{
throw sqlite_error("query doesn't result in exactly 1 element");
}
}
// ------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
inline double query_double (
database& db,
const std::string& query
)
inline double query_double (
database& db,
const std::string& query
)
{
statement st(db, query);
st.exec();
if (st.move_next() && st.get_num_columns() == 1)
{
statement st(db, query);
st.exec();
if (st.move_next() && st.get_num_columns() == 1)
{
double temp = st.get_column_as_double(0);
if (st.move_next())
throw sqlite_error("query doesn't result in exactly 1 element");
return temp;
}
else
{
double temp = st.get_column_as_double(0);
if (st.move_next())
throw sqlite_error("query doesn't result in exactly 1 element");
}
return temp;
}
else
{
throw sqlite_error("query doesn't result in exactly 1 element");
}
}
// ------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
inline int query_int (
database& db,
const std::string& query
)
inline int query_int (
database& db,
const std::string& query
)
{
statement st(db, query);
st.exec();
if (st.move_next() && st.get_num_columns() == 1)
{
statement st(db, query);
st.exec();
if (st.move_next() && st.get_num_columns() == 1)
{
int temp = st.get_column_as_int(0);
if (st.move_next())
throw sqlite_error("query doesn't result in exactly 1 element");
return temp;
}
else
{
int temp = st.get_column_as_int(0);
if (st.move_next())
throw sqlite_error("query doesn't result in exactly 1 element");
}
return temp;
}
else
{
throw sqlite_error("query doesn't result in exactly 1 element");
}
}
// ------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
inline int64 query_int64 (
database& db,
const std::string& query
)
inline int64 query_int64 (
database& db,
const std::string& query
)
{
statement st(db, query);
st.exec();
if (st.move_next() && st.get_num_columns() == 1)
{
statement st(db, query);
st.exec();
if (st.move_next() && st.get_num_columns() == 1)
{
int64 temp = st.get_column_as_int64(0);
if (st.move_next())
throw sqlite_error("query doesn't result in exactly 1 element");
return temp;
}
else
{
int64 temp = st.get_column_as_int64(0);
if (st.move_next())
throw sqlite_error("query doesn't result in exactly 1 element");
}
return temp;
}
else
{
throw sqlite_error("query doesn't result in exactly 1 element");
}
}
// ------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
inline const std::vector<char> query_blob (
database& db,
const std::string& query
)
inline const std::vector<char> query_blob (
database& db,
const std::string& query
)
{
statement st(db, query);
st.exec();
if (st.move_next() && st.get_num_columns() == 1)
{
statement st(db, query);
st.exec();
if (st.move_next() && st.get_num_columns() == 1)
{
const std::vector<char>& temp = st.get_column_as_blob(0);
if (st.move_next())
throw sqlite_error("query doesn't result in exactly 1 element");
return temp;
}
else
{
const std::vector<char>& temp = st.get_column_as_blob(0);
if (st.move_next())
throw sqlite_error("query doesn't result in exactly 1 element");
}
return temp;
}
else
{
throw sqlite_error("query doesn't result in exactly 1 element");
}
}
// ------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
}
}
#endif // DLIB_SQLiTE_TOOLS_H_
......
dlib/sqlite/sqlite_tools_abstract.h
View file @ 94ff8e83
......@@ -10,156 +10,153 @@
namespace dlib
{
namespace sqlite
{
class transaction : noncopyable
{
/*!
WHAT THIS OBJECT REPRESENTS
This object is a tool for creating exception safe
database transactions.
!*/
public:
transaction (
database& db
);
/*!
ensures
- Begins a database transaction which will be rolled back
if commit() isn't called eventually.
- In particular, performs: db.exec("begin transaction");
!*/
void commit (
);
/*!
ensures
- if (commit() hasn't already been called) then
- Commits all changes made during this database transaction.
- In particular, performs: db.exec("commit");
- else
- does nothing
!*/
~transaction(
);
/*!
ensures
- if (commit() was never called) then
- rolls back any changes made to the database during this transaction.
- In particular, performs: db.exec("rollback");
- else
- does nothing
!*/
};
// ------------------------------------------------------------------------------------
template <
typename T
>
void query_object (
database& db,
const std::string& query,
T& item
);
class transaction : noncopyable
{
/*!
ensures
- executes the given SQL query against db. If the query results in a
single row and column being returned then the data in the column is
interpreted as a binary BLOB and deserialized into item.
throws
- sqlite_error or serialization_error if an error occurs which prevents
this operation from succeeding.
WHAT THIS OBJECT REPRESENTS
This object is a tool for creating exception safe
database transactions.
!*/
// ------------------------------------------------------------------------------------
std::string query_text (
database& db,
const std::string& query
public:
transaction (
database& db
);
/*!
ensures
- executes the given SQL query against db. If the query results in a
single row and column being returned then the data in the column is
converted to text and returned.
throws
- sqlite_error if an error occurs which prevents this operation from
succeeding.
- Begins a database transaction which will be rolled back
if commit() isn't called eventually.
- In particular, performs: db.exec("begin transaction");
!*/
// ------------------------------------------------------------------------------------
double query_double (
database& db,
const std::string& query
void commit (
);
/*!
ensures
- executes the given SQL query against db. If the query results in a
single row and column being returned then the data in the column is
converted to a double and returned.
throws
- sqlite_error if an error occurs which prevents this operation from
succeeding.
- if (commit() hasn't already been called) then
- Commits all changes made during this database transaction.
- In particular, performs: db.exec("commit");
- else
- does nothing
!*/
// ------------------------------------------------------------------------------------
int query_int (
database& db,
const std::string& query
~transaction(
);
/*!
ensures
- executes the given SQL query against db. If the query results in a
single row and column being returned then the data in the column is
converted to an int and returned.
throws
- sqlite_error if an error occurs which prevents this operation from
succeeding.
- if (commit() was never called) then
- rolls back any changes made to the database during this transaction.
- In particular, performs: db.exec("rollback");
- else
- does nothing
!*/
// ------------------------------------------------------------------------------------
};
int64 query_int64 (
database& db,
const std::string& query
);
/*!
ensures
- executes the given SQL query against db. If the query results in a
single row and column being returned then the data in the column is
converted to an int64 and returned.
throws
- sqlite_error if an error occurs which prevents this operation from
succeeding.
!*/
// ----------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------
template <
typename T
>
void query_object (
database& db,
const std::string& query,
T& item
);
/*!
ensures
- executes the given SQL query against db. If the query results in a
single row and column being returned then the data in the column is
interpreted as a binary BLOB and deserialized into item.
throws
- sqlite_error or serialization_error if an error occurs which prevents
this operation from succeeding.
!*/
const std::vector<char> query_blob (
database& db,
const std::string& query
);
/*!
ensures
- executes the given SQL query against db. If the query results in a
single row and column being returned then the data in the column is
returned as a binary BLOB.
throws
- sqlite_error if an error occurs which prevents this operation from
succeeding.
!*/
// ----------------------------------------------------------------------------------------
std::string query_text (
database& db,
const std::string& query
);
/*!
ensures
- executes the given SQL query against db. If the query results in a
single row and column being returned then the data in the column is
converted to text and returned.
throws
- sqlite_error if an error occurs which prevents this operation from
succeeding.
!*/
// ----------------------------------------------------------------------------------------
double query_double (
database& db,
const std::string& query
);
/*!
ensures
- executes the given SQL query against db. If the query results in a
single row and column being returned then the data in the column is
converted to a double and returned.
throws
- sqlite_error if an error occurs which prevents this operation from
succeeding.
!*/
// ----------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------
int query_int (
database& db,
const std::string& query
);
/*!
ensures
- executes the given SQL query against db. If the query results in a
single row and column being returned then the data in the column is
converted to an int and returned.
throws
- sqlite_error if an error occurs which prevents this operation from
succeeding.
!*/
// ----------------------------------------------------------------------------------------
int64 query_int64 (
database& db,
const std::string& query
);
/*!
ensures
- executes the given SQL query against db. If the query results in a
single row and column being returned then the data in the column is
converted to an int64 and returned.
throws
- sqlite_error if an error occurs which prevents this operation from
succeeding.
!*/
// ----------------------------------------------------------------------------------------
const std::vector<char> query_blob (
database& db,
const std::string& query
);
/*!
ensures
- executes the given SQL query against db. If the query results in a
single row and column being returned then the data in the column is
returned as a binary BLOB.
throws
- sqlite_error if an error occurs which prevents this operation from
succeeding.
!*/
// ----------------------------------------------------------------------------------------
}
}
#endif // DLIB_SQLiTE_TOOLS_H_
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment