Skip to content

GitLab

"...git@developer.sourcefind.cn:renzhc/diffusers_dcu.git" did not exist on "3d08d8dc4e7c25b28ccfba1631e72a77ae6478be"
Commit 94ff8e83 authored by Davis King's avatar Davis King
Browse files

Just removed the sqlite namespace and unindended everything.

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