//***************************************************************************
/*
* TOra - An Oracle Toolkit for DBA's and developers
* Copyright (C) 2003 Quest Software, Inc
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; only version 2 of
* the License is valid for this program.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* As a special exception, you have permission to link this program
* with the Oracle Client libraries and distribute executables, as long
* as you follow the requirements of the GNU GPL in regard to all of the
* software in the executable aside from Oracle client libraries.
*
* Specifically you are not permitted to link this program with the
* Qt/UNIX, Qt/Windows or Qt Non Commercial products of TrollTech.
* And you are not permitted to distribute binaries compiled against
* these libraries without written consent from Quest Software, Inc.
* Observe that this does not disallow linking to the Qt Free Edition.
*
* All trademarks belong to their respective owners.
*
****************************************************************************/
#ifndef TOCONNECTION_H
#define TOCONNECTION_H
#include "toqvalue.h"
#include "tothread.h"
#include <list>
#include <map>
#include <qstring.h>
class QWidget;
class toConnection;
class toConnectionProvider;
class toSQL;
class toQuery;
/** This class is an abstract definition of an actual connection to a database.
* Each @ref toConnection object can have one or more actual connections to the
* database depending on long running queries. Normally you will never need to
* bother with this class if you aren't creating a new database provider
* (@ref toConnectionProvider).
*/
class toConnectionSub {
toQuery *Query;
public:
/** Create connection to database.
*/
toConnectionSub()
{ Query=NULL; }
/** Close connection.
*/
virtual ~toConnectionSub()
{ }
/** Query current running on connection or NULL.
*/
toQuery *query()
{ return Query; }
/** Set query currently running on connection. NULL means none.
*/
void setQuery(toQuery *query)
{ Query=query; }
/** Cancel anything running on this sub.
*/
virtual void cancel(void)
{ }
};
/** This class is used to perform a query on a database connection.
*/
class toQuery {
public:
/** Represent different modes to run a query in.
*/
enum queryMode {
/** Run the query normally on the main connection of the @ref toConnection object.
*/
Normal,
/** Run the query normally on the main backgrround connection of the
* @ref toConnection object. This can be the same as the main connection depending
* on settings.
*/
Background,
/** Run the query in a separate connection for long running queries.
*/
Long,
/** Run the query on all non occupied connections of the @ref toConnection object.
*/
All
};
/** This structure is used to describe the resultset of a query.
*/
struct queryDescribe {
/** Column name
*/
QString Name;
/** Datatype of string.
*/
QString Datatype;
/** If column can contain null values.
*/
bool Null;
/** Preferred alignment of this kind of value.
*/
bool AlignRight;
/** Comment on column (Only filled out in column cache.
*/
QString Comment;
};
/** Abstract parent of implementations of a query for a database provider
* (See @ref toConnection::connectionImpl and @ref toConnectionProvider)
*/
class queryImpl {
toQuery *Parent;
public:
/** Get the parent query object. All the parameters of the query must be read from here.
* nothing is passed to the functions.
*/
toQuery *query()
{ return Parent; }
/** Create a query implementation. The constructor must not perform any actions with the
* database that could block for a noticable time (Like execute or parse a query). The
* data for the query may not be available when this object created.
* @param query Parent query object.
*/
queryImpl(toQuery *query)
: Parent(query)
{ }
/** Destroy query implementation.
*/
virtual ~queryImpl()
{ }
/** Execute a query. Parameters can be gotten from the @ref toQuery object.
*/
virtual void execute(void) = 0;
/** Read the next value from the stream.
* @return The value read from the query.
*/
virtual toQValue readValue(void) = 0;
/** Check if the end of the query has been reached.
* @return True if all values have been read.
*/
virtual bool eof(void) = 0;
/** Get the number of rows processed in the last executed query.
*/
virtual int rowsProcessed(void) = 0;
/** Describe the currently running query.
* @return A list of column descriptions of the query.
*/
virtual std::list<queryDescribe> describe(void) = 0;
/** Get number of columns in the resultset.
* @return Column number.
*/
virtual int columns(void) = 0;
/** Cancel the current execution of a query. This will usually be called from another
* thread than is executing the query.
*/
virtual void cancel(void) = 0;
};
private:
toConnection &Connection;
toConnectionSub *ConnectionSub;
std::list<toQValue> Params;
QCString SQL;
queryMode Mode;
queryImpl *Query;
toQuery(const toQuery &);
public:
/** Create a normal query.
* @param conn Connection to create query on.
* @param sql SQL to run.
* @param params Parameters to pass to query.
*/
toQuery(toConnection &conn,const toSQL &sql,const std::list<toQValue> ¶ms);
/** Create a normal query.
* @param conn Connection to create query on.
* @param sql SQL to run.
* @param params Parameters to pass to query.
*/
toQuery(toConnection &conn,const QString &sql,const std::list<toQValue> ¶ms);
/** Create a normal query.
* @param conn Connection to create query on.
* @param sql SQL to run.
* @param arg1 Arguments to pass to query.
*/
toQuery(toConnection &conn,const toSQL &sql,
const QString &arg1=QString::null,const QString &arg2=QString::null,
const QString &arg3=QString::null,const QString &arg4=QString::null,
const QString &arg5=QString::null,const QString &arg6=QString::null,
const QString &arg7=QString::null,const QString &arg8=QString::null,
const QString &arg9=QString::null);
/** Create a normal query.
* @param conn Connection to create query on.
* @param sql SQL to run.
* @param arg1 Arguments to pass to query.
*/
toQuery(toConnection &conn,const QString &sql,
const QString &arg1=QString::null,const QString &arg2=QString::null,
const QString &arg3=QString::null,const QString &arg4=QString::null,
const QString &arg5=QString::null,const QString &arg6=QString::null,
const QString &arg7=QString::null,const QString &arg8=QString::null,
const QString &arg9=QString::null);
/** Create a query.
* @param conn Connection to create query on.
* @param mode Mode to run query in.
* @param sql SQL to run.
* @param params Arguments to pass to query.
*/
toQuery(toConnection &conn,queryMode mode,const toSQL &sql,const std::list<toQValue> ¶ms);
/** Create a query.
* @param conn Connection to create query on.
* @param mode Mode to run query in.
* @param sql SQL to run.
* @param params Arguments to pass to query.
*/
toQuery(toConnection &conn,queryMode mode,const QString &sql,const std::list<toQValue> ¶ms);
/** Create a query. Don't runn any SQL using it yet. Observe though that the @ref
* toConnectionSub object is assigned here so you know that all queries run using this
* query object will run on the same actual connection to the database (Unless mode is All off
* course).
* @param conn Connection to create query for.
* @param mode Mode to execute queries in.
*/
toQuery(toConnection &conn,queryMode mode=Normal);
/** Destroy query.
*/
virtual ~toQuery();
/** Execute an SQL statement using this query.
* @param sql SQL to run.
* @param params Parameters to pass to query.
*/
void execute(const toSQL &sql,const std::list<toQValue> ¶ms);
/** Execute an SQL statement using this query.
* @param sql SQL to run.
* @param params Parameters to pass to query.
*/
void execute(const QString &sql,const std::list<toQValue> ¶ms);
/** Connection object of this object.
*/
toConnection &connection(void)
{ return Connection; }
/** Actual database connection that this query is currently using.
*/
toConnectionSub *connectionSub(void)
{ return ConnectionSub; }
/** Parameters of the current query.
*/
std::list<toQValue> ¶ms(void)
{ return Params; }
/** SQL to run. Observe that this string is in UTF8 format.
*/
QCString sql(void)
{ return SQL; }
/** Get the mode this query is executed in.
*/
toQuery::queryMode mode(void) const
{ return Mode; }
/** Read a value from the query. Convert the value NULL to the string {null}.
* @return Value read.
*/
toQValue readValue(void);
/** Read a value from the query. Nulls are returned as empty @ref toQValue.
* @return Value read.
*/
toQValue readValueNull(void);
/** Check if end of query is reached.
* @return True if end of query is reached.
*/
bool eof(void);
/** Get the number of rows processed by the query.
*/
int rowsProcessed(void)
{ return Query->rowsProcessed(); }
/** Get a list of descriptions for the columns. This function is relatively slow.
*/
std::list<queryDescribe> describe(void)
{ return Query->describe(); }
/** Get the number of columns in the resultset of the query.
*/
int columns(void)
{ return Query->columns(); }
/** Execute a query and return all the values returned by it.
* @param conn Connection to run query on.
* @param sql SQL to run.
* @param params Parameters to pass to query.
* @return A list of @ref toQValues:s read from the query.
*/
static std::list<toQValue> readQuery(toConnection &conn,
const toSQL &sql,
std::list<toQValue> ¶ms);
/** Execute a query and return all the values returned by it.
* @param conn Connection to run query on.
* @param sql SQL to run.
* @param params Parameters to pass to query.
* @return A list of @ref toQValues:s read from the query.
*/
static std::list<toQValue> readQuery(toConnection &conn,
const QString &sql,
std::list<toQValue> ¶ms);
/** Execute a query and return all the values returned by it.
* @param conn Connection to run query on.
* @param sql SQL to run.
* @param arg1 Parameters to pass to query.
* @return A list of @ref toQValues:s read from the query.
*/
static std::list<toQValue> readQuery(toConnection &conn,const toSQL &sql,
const QString &arg1=QString::null,const QString &arg2=QString::null,
const QString &arg3=QString::null,const QString &arg4=QString::null,
const QString &arg5=QString::null,const QString &arg6=QString::null,
const QString &arg7=QString::null,const QString &arg8=QString::null,
const QString &arg9=QString::null);
/** Execute a query and return all the values returned by it.
* @param conn Connection to run query on.
* @param sql SQL to run.
* @param arg1 Parameters to pass to query.
* @return A list of @ref toQValues:s read from the query.
*/
static std::list<toQValue> readQuery(toConnection &conn,const QString &sql,
const QString &arg1=QString::null,const QString &arg2=QString::null,
const QString &arg3=QString::null,const QString &arg4=QString::null,
const QString &arg5=QString::null,const QString &arg6=QString::null,
const QString &arg7=QString::null,const QString &arg8=QString::null,
const QString &arg9=QString::null);
/** Execute a query and return all the values returned by it.
* @param conn Connection to run query on.
* @param sql SQL to run.
* @param params Parameters to pass to query.
* @return A list of @ref toQValues:s read from the query.
*/
static std::list<toQValue> readQueryNull(toConnection &conn,
const toSQL &sql,
std::list<toQValue> ¶ms);
/** Execute a query and return all the values returned by it.
* @param conn Connection to run query on.
* @param sql SQL to run.
* @param params Parameters to pass to query.
* @return A list of @ref toQValues:s read from the query.
*/
static std::list<toQValue> readQueryNull(toConnection &conn,
const QString &sql,
std::list<toQValue> ¶ms);
/** Execute a query and return all the values returned by it.
* @param conn Connection to run query on.
* @param sql SQL to run.
* @param arg1 Parameters to pass to query.
* @return A list of @ref toQValues:s read from the query.
*/
static std::list<toQValue> readQueryNull(toConnection &conn,const toSQL &sql,
const QString &arg1=QString::null,const QString &arg2=QString::null,
const QString &arg3=QString::null,const QString &arg4=QString::null,
const QString &arg5=QString::null,const QString &arg6=QString::null,
const QString &arg7=QString::null,const QString &arg8=QString::null,
const QString &arg9=QString::null);
/** Execute a query and return all the values returned by it.
* @param conn Connection to run query on.
* @param sql SQL to run.
* @param arg1 Parameters to pass to query.
* @return A list of @ref toQValues:s read from the query.
*/
static std::list<toQValue> readQueryNull(toConnection &conn,const QString &sql,
const QString &arg1=QString::null,const QString &arg2=QString::null,
const QString &arg3=QString::null,const QString &arg4=QString::null,
const QString &arg5=QString::null,const QString &arg6=QString::null,
const QString &arg7=QString::null,const QString &arg8=QString::null,
const QString &arg9=QString::null);
/** Cancel the current execution of a query.
*/
void cancel(void);
};
/** A short representation of a @ref toQuery::queryDescribe
*/
typedef toQuery::queryDescribe toQDescribe;
/** A short representation of list<toQuery::queryDescribe>
*/
typedef std::list<toQDescribe> toQDescList;
/** Represent a database connection in TOra. Observe that this can mean several actual
* connections to the database as queries that ae expected to run a long time are sometimes
* executed in their own connection to make sure the interface doesn't lock up for a long time.
*/
class toConnection {
QCString Provider;
QString User;
QString Password;
QString Host;
QString Database;
QString Mode;
QCString Version;
std::list<QObject *> Widgets;
std::list<QCString> InitStrings;
toLock Lock;
std::list<toConnectionSub *> Connections;
std::list<toConnectionSub *> Running;
int BackgroundCount;
toConnectionSub *BackgroundConnection;
bool NeedCommit;
public:
/** Class that could be used to throw exceptions in connection errors. Must use if you
* want to indicate error offset.
*/
class exception : public QString {
int Offset;
public:
/** Create an exception with a string description.
*/
exception(const QString &str,int offset=-1)
: QString(str)
{ Offset=offset; }
/** Get the offset of the error of the current statement.
*/
int offset(void) const
{ return Offset; }
/** Set the offset of the error of the error.
*/
void setOffset(int offset)
{ Offset=offset; }
};
/** Contain information about a tablename.
*/
struct objectName {
/** The object name
*/
QString Name;
/** The schema that owns it
*/
QString Owner;
/** Object type
*/
QString Type;
/** Comment about this object
*/
QString Comment;
/** synonyms (used for faster disk caching...)
*/
std::list <QString> Synonyms;
bool operator < (const objectName &) const;
bool operator == (const objectName &) const;
};
/** This class is an abstract baseclass to actually implement the comunication with the
* database.
* (See also @ref toQuery::queryImpl and @ref toConnectionProvider)
*/
class connectionImpl {
toConnection *Connection;
public:
/** Get the parent connection object of this connection.
*/
toConnection &connection(void)
{ return *Connection; }
/** Create a new connection implementation for a connection.
* @param conn Connection to implement.
*/
connectionImpl(toConnection *conn)
{ Connection=conn; };
/** Destructor.
*/
virtual ~connectionImpl()
{ }
/** Commit the supplied actual database connection.
*/
virtual void commit(toConnectionSub *) = 0;
/** Rollback the supplied actual database connection.
*/
virtual void rollback(toConnectionSub *) = 0;
/** If not true can never run more than one query per connection sub and TOra will
* work around this limitation by opening more connections if needed.
*/
virtual bool handleMultipleQueries()
{ return true; }
/** Create a new connection to the database.
*/
virtual toConnectionSub *createConnection(void) = 0;
/** Close a connection to the database.
*/
virtual void closeConnection(toConnectionSub *) = 0;
/** Get the version of the database connected to.
*/
virtual QCString version(toConnectionSub *) = 0;
/** Return a string representation to address an object.
* @param name The name to be quoted.
* @return String addressing table.
*/
virtual QString quote(const QString &name)
{ return name; }
/** Perform the opposite of @ref quote.
* @param name The name to be un-quoted.
* @return String addressing table.
*/
virtual QString unQuote(const QString &name)
{ return name; }
/** Extract available objects to query for connection. Any access to the
* database should always be run using a long running query. If something
* goes wrong should throw exception.
* @return List of available objects.
*/
virtual std::list<objectName> objectNames(void);
/** Get synonyms available for connection. Any access to the
* database should always be run using a long running query. If something
* goes wrong should throw exception.
* @param objects Available objects for the connection. Objects
* are sorted in owner and name order. Don't modify
* this list.
* @return Map of synonyms to objectnames.
*/
virtual std::map<QString,objectName> synonymMap(std::list<objectName> &objects);
/* Extract available columns to query for a table.
* @param table Table to get column for.
* @return List of columns for table or view.
*/
virtual toQDescList columnDesc(const objectName &table);
/** Create a new query implementation for this connection.
* @return A query implementation, allocated with new.
*/
virtual toQuery::queryImpl *createQuery(toQuery *query,toConnectionSub *conn) = 0;
/** Execute a query on an actual connection without caring about the result.
* @param conn Connection to execute on.
* @param sql SQL to execute.
* @param params Parameters to pass to query.
*/
virtual void execute(toConnectionSub *conn,const QCString &sql,toQList ¶ms) = 0;
/** Parse a query on an actual connection and report any syntax problems encountered.
* Defaults to not implemented.
* @param conn Connection to execute on.
* @param sql SQL to parse
*/
virtual void parse(toConnectionSub *conn,const QCString &sql);
};
private:
void addConnection(void);
std::list<toConnectionSub *> &connections(void)
{ return Connections; }
connectionImpl *Connection;
class cacheObjects : public toTask {
toConnection &Connection;
public:
cacheObjects(toConnection &conn)
: Connection(conn)
{ }
virtual void run(void);
};
friend class cacheObjects;
bool ReadingCache;
toSemaphore ReadingValues;
bool Abort;
std::map<objectName,toQDescList> ColumnCache;
std::list<objectName> ObjectNames;
std::map<QString,objectName> SynonymMap;
toConnectionSub *mainConnection(void);
toConnectionSub *longConnection(void);
toConnectionSub *backgroundConnection(void);
void freeConnection(toConnectionSub *);
void readObjects(void);
public:
/** Create a new connection.
* @param provider Which database provider to use for this connection.
* (See @ref to toDatabaseConnection)
* @param user User to connect to the database with.
* @param password Password to connect with.
* @param host Host to connect to the database with.
* @param database Database to connect to.
* @param mode Mode to connect to the database with.
* @param cache Enable object cache for this connection.
*/
toConnection(const QCString &provider,const QString &user,const QString &password,
const QString &host,const QString &database,const QString &mode=QString::null,
bool cache=true);
/** Create a copy of a connection. Will not cache objects, so objects will never be available
* in a subconnection.
* @param conn Connection to copy.
*/
toConnection(const toConnection &conn);
/** Destroy connection.
*/
virtual ~toConnection();
/** Try to close all the widgets associated with this connection.
* @return True if all widgets agreed to close.
*/
bool closeWidgets(void);
/** Get username of connection.
*/
const QString &user() const
{ return User; }
/** Get password of connection.
*/
const QString &password() const
{ return Password; }
/** Change password of connection.
*/
void setPassword(const QString &pwd)
{ Password=pwd; }
/** Get host of connection.
*/
const QString &host() const
{ return Host; }
/** Get database of connection.
*/
const QString &database() const
{ return Database; }
/** Get mode of connection.
*/
const QString &mode() const
{ return Mode; }
/** Get version of connection.
*/
const QCString &version() const
{ return Version; }
/** Get provider of connection.
*/
const QCString &provider() const;
/** Get a description of this connection.
* @version Include version in returned string.
*/
virtual QString description(bool version=true) const;
/** Set if this connection needs to be commited.
*/
void setNeedCommit(bool needCommit=true)
{ NeedCommit=needCommit; }
/**
* Get information about if the connection has uncommited data.
*
* @return Whether uncommited data is available.
*/
bool needCommit(void) const
{ return NeedCommit; }
/**
* Commit connection. This will also close all extra connections except one.
*/
virtual void commit(void);
/**
* Rollback connection. This will also close all extra connections except one.
*/
virtual void rollback(void);
/** Parse a query on an actual connection and report any syntax problems encountered.
* Defaults to not implemented.
* @param conn Connection to execute on.
* @param sql SQL to parse
*/
void parse(const QString &sql);
/** Parse a query on an actual connection and report any syntax problems encountered.
* Defaults to not implemented.
* @param conn Connection to execute on.
* @param sql SQL to parse
*/
void parse(const toSQL &sql);
/** Execute a statement without caring about the result.
* @param sql SQL to execute
* @param params Parameters to pass to query.
*/
void execute(const toSQL &sql,
toQList ¶ms);
/** Execute a statement without caring about the result.
* @param sql SQL to execute
* @param params Parameters to pass to query.
*/
void execute(const QString &sql,
toQList ¶ms);
/** Execute a statement without caring about the result.
* @param sql SQL to execute
* @param arg1 Parameters to pass to query.
*/
void execute(const toSQL &sql,
const QString &arg1=QString::null,const QString &arg2=QString::null,
const QString &arg3=QString::null,const QString &arg4=QString::null,
const QString &arg5=QString::null,const QString &arg6=QString::null,
const QString &arg7=QString::null,const QString &arg8=QString::null,
const QString &arg9=QString::null);
/** Execute a statement without caring about the result.
* @param sql SQL to execute
* @param arg1 Parameters to pass to query.
*/
void execute(const QString &sql,
const QString &arg1=QString::null,const QString &arg2=QString::null,
const QString &arg3=QString::null,const QString &arg4=QString::null,
const QString &arg5=QString::null,const QString &arg6=QString::null,
const QString &arg7=QString::null,const QString &arg8=QString::null,
const QString &arg9=QString::null);
/** Execute a statement without caring about the result on all open database connections.
* @param sql SQL to execute
* @param params Parameters to pass to query.
*/
void allExecute(const toSQL &sql,
toQList ¶ms);
/** Execute a statement without caring about the result on all open database connections.
* @param sql SQL to execute
* @param params Parameters to pass to query.
*/
void allExecute(const QString &sql,
toQList ¶ms);
/** Execute a statement without caring about the result on all open database connections.
* @param sql SQL to execute
* @param arg1 Parameters to pass to query.
*/
void allExecute(const toSQL &sql,
const QString &arg1=QString::null,const QString &arg2=QString::null,
const QString &arg3=QString::null,const QString &arg4=QString::null,
const QString &arg5=QString::null,const QString &arg6=QString::null,
const QString &arg7=QString::null,const QString &arg8=QString::null,
const QString &arg9=QString::null);
/** Execute a statement without caring about the result on all open database connections.
* @param sql SQL to execute
* @param arg1 Parameters to pass to query.
*/
void allExecute(const QString &sql,
const QString &arg1=QString::null,const QString &arg2=QString::null,
const QString &arg3=QString::null,const QString &arg4=QString::null,
const QString &arg5=QString::null,const QString &arg6=QString::null,
const QString &arg7=QString::null,const QString &arg8=QString::null,
const QString &arg9=QString::null);
/**
* Add a object that uses this connection. This is needed to ensure that all widgets
* that make use of a connection are destroyed when the connection is closed. Usually
* tool windows need to call this function.
*
* @param widget The widget to add to the connection.
*/
void addWidget(QObject *widget)
{ Widgets.insert(Widgets.end(),widget); }
/**
* Remove a widget from this connection. Should be called by the destructor of the
* widget that has called addWidget.
*
* @see addWidget
* @param widget Widget to remove from the widget list.
*/
void delWidget(QObject *widget);
/**
* Add a statement to be run uppon making new connections.
* @param sql Statement to run.
*/
void addInit(const QString &sql);
/**
* Remove a statement that was added using @ref addInit.
*/
void delInit(const QString &sql);
/** Return a string representation to address an object.
* @param name The name to be quoted.
* @return String addressing table.
*/
QString quote(const QString &name);
/** Perform the opposite of @ref quote.
* @param name The name to be un-quoted.
* @return String addressing table.
*/
QString unQuote(const QString &name);
/**
* Get the objects available for the current user. Do not modify the returned list.
* @param block Indicate wether or not to block until cached objects are available.
* @return A list of object available for the current user. The list is sorted in
* owner and name order.
*/
std::list<objectName> &objects(bool block);
/** Add a new object to the objectlist if it doesn't exist already.
* @param object The object to add
*/
void addIfNotExists(objectName &object);
/**
* Get the synonyms available for objects. Do not modify the returned list.
* @param block Indicate wether or not to block until cached objects are available.
* @return A list of synonyms to objects available for the current user.
*/
std::map<QString,objectName> &synonyms(bool block);
/**
* Get a list of the available columns for a table. This function caches the responses
* and should be fairly fast after the first call. Do not modify the returned list.
* @param table The table to describe.
* @param nocache Don't use cached values even if they are available.
* @return A list of the columns for a table.
*/
toQDescList &columns(const objectName &table,bool nocache=false);
/**
* Reread the object and column cache.
*/
void rereadCache(void);
/**
* Get the real object name of an object.
* @param object Object name
* @param block Block if not done caching object.
*/
const objectName &realName(const QString &object,bool block);
/**
* Get the real object name of a synonym.
* @param object Object name
* @param synonym Filled with the synonym used to access the object returned or empty.
* @param block Block if not done caching object.
*/
const objectName &realName(const QString &object,QString &synonym,bool block);
/** Check if cache is available or not.
* @param synonyms If synonyms are needed or not.
* @param block Block until cache is done.
* @param true True if you need the cache, or just checking.
* @return True if cache is available.
*/
bool cacheAvailable(bool synonyms,bool block=false,bool need=true);
/** Try to stop all running queries.
*/
void cancelAll(void);
/** load disk cache
*/
bool loadDiskCache(void);
/** write disk cache
*/
void writeDiskCache(void);
/** Get a list of currently running SQL.
*/
std::list<QString> running(void);
void logMessage(QString text);
friend class toQuery;
};
/** This class is used to implement new database providers.
*/
class toConnectionProvider {
static std::map<QCString,toConnectionProvider *> *Providers;
static std::map<QCString,toConnectionProvider *> *Types;
QCString Provider;
static void checkAlloc(void);
/** Get the provider object for a given provider name.
* @param provider Name of provider.
* @return Reference to provider object.
*/
static toConnectionProvider &fetchProvider(const QCString &provider);
protected:
/** Add a provider to the list that this provider can handle.
*/
void addProvider(const QCString &provider);
/** Remove a provider from the list that this provider can handle.
*/
void removeProvider(const QCString &provider);
public:
/** Create a new provider with the specified name.
* @param provider Name of the provider.
*/
toConnectionProvider(const QCString &provider,bool add=true);
/** Destructor.
*/
virtual ~toConnectionProvider();
/** Create an implementation of a connection to this database.
* @return A connection implementation created with new.
*/
virtual toConnection::connectionImpl *provideConnection(const QCString &provider,
toConnection *conn)=0;
/** List the available modes for this database.
* @return A list of modes that the connection implementation understands.
*/
virtual std::list<QString> providedModes(const QCString &provider);
/** List the available hosts this database provider knows about.
* @return A list of hosts.
*/
virtual std::list<QString> providedHosts(const QCString &provider);
/** List the available databases this provider knows about for a given host.
* @param host Host to return connections for.
* @param user That might be needed.
* @param password That might be needed.
* @return A list of databases available for a given host.
*/
virtual std::list<QString> providedDatabases(const QCString &provider,
const QString &host,
const QString &user,
const QString &pwd)=0;
/** Will be called after program has been started and before connections have been opened.
* Use for initialization.
*/
virtual void initialize(void)
{ }
/**
* Create and return configuration tab for this connectiontype. The returned widget should also
* be a childclass of @ref toSettingTab.
*
* @return A pointer to the widget containing the setup tab for this tool or NULL of
* no settings are available.
*/
virtual QWidget *providerConfigurationTab(const QCString &provider,QWidget *parent);
/** Get a list of names for providers.
*/
static QWidget *configurationTab(const QCString &provider,QWidget *parent);
/** Get a list of names for providers.
*/
static std::list<QCString> providers();
/** Get a list of modes for a given provider.
*/
static std::list<QString> modes(const QCString &provider);
/** Implement a connection for a given provider.
* @param provider Provider to implement.
* @param conn Connection to create implementation for.
*/
static toConnection::connectionImpl *connection(const QCString &provider,toConnection *conn);
/** Get a list of hosts this provider knows about.
*/
static std::list<QString> hosts(const QCString &provider);
/** Get a list of databases for a given provider and host.
* @param provider Provider to fetch databases for.
* @param host Host to fetch databases for.
* @param user That might be needed.
* @param password That might be needed.
* @return List of known databases.
*/
static std::list<QString> databases(const QCString &provider,const QString &host,
const QString &user,const QString &pwd);
/**
* Get connection specific settings.
*
* Setting names are hierachical separated by ':' instead of '/' usually used
* in filenames. As an example all settings for the tool 'Example' would be
* under the 'Example:{settingname}' name. Observe that the settings are stored
* under the main provider name as passed to the toConnectionProvider constructor.
*
* @param tag The name of the configuration setting.
* @param def Contents of this setting.
*/
const QString &config(const QCString &tag,const QCString &def);
/**
* Change connectionspecific setting. Depending on the implementation this can change the
* contents on disk or not.
*
* Setting names are hierachical separated by ':' instead of '/' usually used
* in filenames. As an example all settings for the tool 'Example' would be
* under the 'Example:{settingname}' name. Observe that the settings are stored
* under the main provider name as passed to the toConnectionProvider constructor.
*
* @param tag The name of the configuration setting.
* @param def Default value of the setting, if it is not available.
*/
void setConfig(const QCString &tag,const QCString &value);
/** Call all initializers
*/
static void initializeAll(void);
};
#endif