DatabaseException.h

Go to the documentation of this file.

/*
 * $Id:DatabaseException.h 540 2007-08-20 07:51:56Z mindstorm2600 $
 *
 * X-VR2 
 * 
 * Copyright (C) Juan V. Guerrero 2007
 * 
 * Juan V. Guerrero <mindstorm2600@users.sourceforge.net>
 * 
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */
#ifndef __XVR2_SQL_DATABASE_EXCEPTION_H__
#define __XVR2_SQL_DATABASE_EXCEPTION_H__
#include<xvr2/xvr2config.h>
#include<xvr2/CoreExceptions.h>
#include<xvr2/String.h>

namespace xvr2 {
        namespace SQL {
                class ResultSet;
                class DatabaseException:public Exception{
                        protected:
                                String _err_msg;
                        public:
                                enum ConnectionType {
                                        NET,
                                        FIFO,
                                        EMBEDDED
                                };
                                struct ConnectionParams {
                                        DatabaseException::ConnectionType type;
                                        String host;
                                        int port;
                                        String username;
                                        String password;
                                        String database;
                                        String path;
                                        ConnectionParams();
                                        ConnectionParams(DatabaseException::ConnectionType t,
                                                                        const String &h, int port, const String &db,
                                                                        const String &u, const String &p,
                                                                        const String &_path = "");
                                        ConnectionParams(const ConnectionParams &c);
                                        ConnectionParams &operator=(const ConnectionParams &c);
                                };
                                DatabaseException();
                                DatabaseException(const String &error_message);
                                DatabaseException(const String &error_message, 
                                                                        const ConnectionParams &__conn_p);
                                DatabaseException(const ConnectionParams &__conn_p);
                                const ConnectionParams &connParams();
                                const String &errorMessage();
                        protected:
                                ConnectionParams _conn_params;
                };
                
                class DriverOperationNotSupported : public DatabaseException {
                        private:
                                String op;
                        public:
                                DriverOperationNotSupported();
                                DriverOperationNotSupported(const String &_op);
                                const String &operation();
                };


                class DBServerUnreachable:public DatabaseException{
                        public:
                                DBServerUnreachable();
                };


                class AlreadyConnected2DB:public DatabaseException{
                        public:
                                AlreadyConnected2DB();
                };


                class DBConnectFirst:public DatabaseException{
                        public:
                                DBConnectFirst();
                };

                class NoDataFetch:public DatabaseException{
                        public:
                                NoDataFetch();
                };


                class NoMoreRows:public DatabaseException{
                        public:
                                NoMoreRows();
                };


                class DBConnectionFailed:public DatabaseException{
                        public:
                                DBConnectionFailed();
                };
                
                class ConnectionFailure:public DatabaseException{
                        private:
                        public:
                                ConnectionFailure();
                                ConnectionFailure(const ConnectionParams &__conn_p);
                                ConnectionFailure(const ConnectionParams &__conn_p, 
                                                                        const String &__cause);
                };


                class ServerDisconnected:public DatabaseException{
                        public:
                                ServerDisconnected();
                };

                class FieldIsNull:public  DatabaseException {
                        private:
                                String field_name;
                        public:
                                FieldIsNull();
                                FieldIsNull(const String &fn);
                                const String &fieldName();
                };


                class SQLQueryException:public DatabaseException{
                        private:
                                SQL::ResultSet *result;
                                String _query;
                        public:
                                SQLQueryException();
                                ~SQLQueryException();
                                SQLQueryException(const char *msg);
                                SQLQueryException(const char *msg, const String &__query);
                                SQLQueryException(const char *msg, SQL::ResultSet *_result);
                                SQLQueryException(const char *msg, SQL::ResultSet *_result, const String &__query);
                                const String &query();
                };


                class SQLQueryRDBMSDisconnected:public SQLQueryException{
                        public:
                                SQLQueryRDBMSDisconnected();
                };

                class UnableToParseQuery:public SQLQueryException{
                        public:
                                UnableToParseQuery();
                };

                class BulkUploadFailed:public SQLQueryException{
                        public:
                                BulkUploadFailed();
                };

                class BulkDataParse:public SQLQueryException{
                        public:
                                BulkDataParse();
                };

                class BulkUploadStart:public SQLQueryException{
                        public:
                                BulkUploadStart();
                };
        };
};

#endif

---