odbcappender.h

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _LOG4CXX_DB_ODBC_APPENDER_H
#define _LOG4CXX_DB_ODBC_APPENDER_H

#if defined(_MSC_VER)
    #pragma warning ( push )
    #pragma warning ( disable: 4231 4251 4275 4786 )
#endif


#include <log4cxx/log4cxx.h>

#include <log4cxx/helpers/exception.h>
#include <log4cxx/appenderskeleton.h>
#include <log4cxx/spi/loggingevent.h>
#include <list>

namespace log4cxx
{
namespace db
{
class LOG4CXX_EXPORT SQLException : public log4cxx::helpers::Exception
{
    public:
        SQLException(short fHandleType,
            void* hInput, const char* prolog,
            log4cxx::helpers::Pool& p);
        SQLException(const char* msg);
        SQLException(const SQLException& src);
    private:
        const char* formatMessage(short fHandleType,
            void* hInput, const char* prolog,
            log4cxx::helpers::Pool& p);
};

class LOG4CXX_EXPORT ODBCAppender : public AppenderSkeleton
{
    protected:
        LogString databaseURL;

        LogString databaseUser;

        LogString databasePassword;

        typedef void* SQLHDBC;
        typedef void* SQLHENV;
        typedef void* SQLHANDLE;
        typedef short SQLSMALLINT;

        SQLHDBC connection;
        SQLHENV env;

        LogString sqlStatement;

        size_t bufferSize;

        std::list<spi::LoggingEventPtr> buffer;

    public:
        DECLARE_LOG4CXX_OBJECT(ODBCAppender)
        BEGIN_LOG4CXX_CAST_MAP()
        LOG4CXX_CAST_ENTRY(ODBCAppender)
        LOG4CXX_CAST_ENTRY_CHAIN(AppenderSkeleton)
        END_LOG4CXX_CAST_MAP()

        ODBCAppender();
        virtual ~ODBCAppender();

        virtual void setOption(const LogString& option, const LogString& value);

        virtual void activateOptions(log4cxx::helpers::Pool& p);

        void append(const spi::LoggingEventPtr& event, log4cxx::helpers::Pool&);

    protected:
        LogString getLogStatement(const spi::LoggingEventPtr& event,
            helpers::Pool& p) const;

        virtual void execute(const LogString& sql,
            log4cxx::helpers::Pool& p) /*throw(SQLException)*/;

        virtual void closeConnection(SQLHDBC con);

        virtual SQLHDBC getConnection(log4cxx::helpers::Pool& p) /*throw(SQLException)*/;

    public:
        virtual void close();

        virtual void flushBuffer(log4cxx::helpers::Pool& p);

        virtual bool requiresLayout() const
        {
            return true;
        }

        void setSql(const LogString& s);

        inline const LogString& getSql() const
        {
            return sqlStatement;
        }


        inline void setUser(const LogString& user)
        {
            databaseUser = user;
        }


        inline void setURL(const LogString& url)
        {
            databaseURL = url;
        }


        inline void setPassword(const LogString& password)
        {
            databasePassword = password;
        }


        inline void setBufferSize(size_t newBufferSize)
        {
            bufferSize = newBufferSize;
        }

        inline const LogString& getUser() const
        {
            return databaseUser;
        }


        inline const LogString& getURL() const
        {
            return databaseURL;
        }


        inline const LogString& getPassword() const
        {
            return databasePassword;
        }

        inline size_t getBufferSize() const
        {
            return bufferSize;
        }
    private:
        ODBCAppender(const ODBCAppender&);
        ODBCAppender& operator=(const ODBCAppender&);
#if LOG4CXX_WCHAR_T_API || LOG4CXX_LOGCHAR_IS_WCHAR_T || defined(WIN32) || defined(_WIN32)
        static void encode(wchar_t** dest, const LogString& src,
            log4cxx::helpers::Pool& p);
#endif
        static void encode(unsigned short** dest, const LogString& src,
            log4cxx::helpers::Pool& p);
}; // class ODBCAppender
LOG4CXX_PTR_DEF(ODBCAppender);

} // namespace db
} // namespace log4cxx

#if defined(_MSC_VER)
    #pragma warning ( pop )
#endif

#endif // _LOG4CXX_DB_ODBC_APPENDER_H