/usr/include/dballe/sql/sql.h is in libdballe-dev 7.21-1build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 | /** @file
* Common infrastructure for talking with SQL databases
*/
#ifndef DBALLE_SQL_H
#define DBALLE_SQL_H
#include <dballe/core/error.h>
#include <dballe/transaction.h>
#include <dballe/sql/fwd.h>
#include <string>
#include <memory>
/// Define this to enable referential integrity
#undef USE_REF_INT
/** Trace macros internally used for debugging
* @{
*/
// #define TRACE_DB
#ifdef TRACE_DB
#define TRACE(...) fprintf(stderr, __VA_ARGS__)
#define IFTRACE if (1)
#else
/** Ouput a trace message */
#define TRACE(...) do { } while (0)
/** Prefix a block of code to compile only if trace is enabled */
#define IFTRACE if (0)
#endif
/** @} */
namespace dballe {
class Datetime;
namespace sql {
/** @enum ServerType
* Supported SQL servers.
*
* @cond WORKAROUND
*/
enum class ServerType
{
MYSQL,
SQLITE,
ORACLE,
POSTGRES,
};
/// @endcond
/**
* Return a string description for a ServerType value
*/
const char* format_server_type(ServerType type);
class Connection
{
protected:
std::string url;
bool profile = false;
unsigned profile_query_count = 0;
public:
/**
* Type of SQL server we are connected to.
*
* Use this to tell which SQL dialect to use, in case standard SQL
* behaviour is not enough
*/
ServerType server_type;
Connection();
virtual ~Connection();
const std::string& get_url() const { return url; }
/**
* Begin a transaction.
*
* The transaction will be controller by the returned Transaction object,
* and will end when its destuctor is called.
*/
virtual std::unique_ptr<Transaction> transaction() = 0;
/// Check if the database contains a table
virtual bool has_table(const std::string& name) = 0;
/**
* Get a value from the settings table.
*
* Returns the empty string if the table does not exist.
*/
virtual std::string get_setting(const std::string& key) = 0;
/**
* Set a value in the settings table.
*
* The table is created if it does not exist.
*/
virtual void set_setting(const std::string& key, const std::string& value) = 0;
/// Drop the settings table
virtual void drop_settings() = 0;
/// Format a datetime and add it to the querybuf
virtual void add_datetime(Querybuf& qb, const Datetime& dt) const;
/// Execute a query without reading its results
virtual void execute(const std::string& query) = 0;
/// Format and print the EXPLAIN output for the query to the given file
virtual void explain(const std::string& query, FILE* out) = 0;
/// Create a new connection from a URL
static std::unique_ptr<Connection> create_from_url(const char* url);
/// Create a new connection from a URL
static std::unique_ptr<Connection> create_from_url(const std::string& url);
};
/**
* A RAII transaction interface.
*
* The transaction will be valid during the lifetime of this object.
*
* You can commit or rollback the transaction using its methods. If at
* destruction time the transaction has not been committed or rolled back, a
* rollback is automatically performed.
*/
class Transaction : public dballe::Transaction
{
public:
Transaction() {}
Transaction(const Transaction&) = delete;
Transaction& operator=(const Transaction&) = delete;
/// Get an exclusive lock on the given table until the end of the
/// transaction
virtual void lock_table(const char* name) = 0;
};
}
}
#endif
|