public JDBCAppender() 
{
    
    super();
    buffer = new ArrayList(bufferSize);
    removes = new ArrayList(bufferSize);
}

 public  void append(LoggingEvent event) 
{
    buffer.add(event);
    if (buffer.size()  >= bufferSize)
      flushBuffer();
}

Adds the event to the buffer. When full the buffer is flushed.

 public  void close() 
{
    flushBuffer();
    try {
      if (connection != null && !connection.isClosed())
          connection.close();
    } catch (SQLException e) {
        errorHandler.error("Error closing connection", e, ErrorCode.GENERIC_FAILURE);
    }
    this.closed = true;
}

Closes the appender, flushing the buffer first then closing the default connection if it is open.

 protected  void closeConnection(Connection con) 
{

}

Override this to return the connection to a pool, or to clean up the resource. The default behavior holds a single connection open until the appender is closed (typically when garbage collected).

 protected  void execute(String sql) throws SQLException 
{
    Connection con = null;
    Statement stmt = null;
    try {
        con = getConnection();
        stmt = con.createStatement();
        stmt.executeUpdate(sql);
    } catch (SQLException e) {
       if (stmt != null)
	     stmt.close();
       throw e;
    }
    stmt.close();
    closeConnection(con);
    //System.out.println("Execute: " + sql);
}

Override this to provide an alertnate method of getting connections (such as caching). One method to fix this is to open connections at the start of flushBuffer() and close them at the end. I use a connection pool outside of JDBCAppender which is accessed in an override of this method.

 public  void finalize() 
{
    close();
}

closes the appender before disposal

 public  void flushBuffer() 
{
    //Do the actual logging
    removes.ensureCapacity(buffer.size());
    for (Iterator i = buffer.iterator(); i.hasNext();) {
      try {
        LoggingEvent logEvent = (LoggingEvent)i.next();
	    String sql = getLogStatement(logEvent);
	    execute(sql);
        removes.add(logEvent);
      }
      catch (SQLException e) {
	    errorHandler.error("Failed to excute sql", e,
			   ErrorCode.FLUSH_FAILURE);
      }
    }
    // remove from the buffer any events that were reported
    buffer.removeAll(removes);
    // clear the buffer of reported events
    removes.clear();
}

loops through the buffer of LoggingEvents, gets a sql string from getLogStatement() and sends it to execute(). Errors are sent to the errorHandler. If a statement fails the LoggingEvent stays in the buffer!

 public int getBufferSize() 
{
    return bufferSize;
}

 protected Connection getConnection() throws SQLException 
{
      if (!DriverManager.getDrivers().hasMoreElements())
	     setDriver("sun.jdbc.odbc.JdbcOdbcDriver");
      if (connection == null) {
        connection = DriverManager.getConnection(databaseURL, databaseUser,
					databasePassword);
      }
      return connection;
}

Override this to link with your connection pooling system. By default this creates a single connection which is held open until the object is garbage collected.

 protected String getLogStatement(LoggingEvent event) 
{
    return getLayout().format(event);
}

By default getLogStatement sends the event to the required Layout object. The layout will format the given pattern into a workable SQL string. Overriding this provides direct access to the LoggingEvent when constructing the logging statement.

 public String getPassword() 
{
    return databasePassword;
}

 public String getSql() 
{
    return sqlStatement;
}

Returns pre-formated statement eg: insert into LogTable (msg) values ("%m")

 public String getURL() 
{
    return databaseURL;
}

 public String getUser() 
{
    return databaseUser;
}

 public boolean requiresLayout() 
{
    return true;
}

JDBCAppender requires a layout.

 public  void setBufferSize(int newBufferSize) 
{
    bufferSize = newBufferSize;
    buffer.ensureCapacity(bufferSize);
    removes.ensureCapacity(bufferSize);
}

 public  void setDriver(String driverClass) 
{
    try {
      Class.forName(driverClass);
    } catch (Exception e) {
      errorHandler.error("Failed to load driver", e,
			 ErrorCode.GENERIC_FAILURE);
    }
}

Ensures that the given driver class has been loaded for sql connection creation.

 public  void setPassword(String password) 
{
    databasePassword = password;
}

 public  void setSql(String s) 
{
    sqlStatement = s;
    if (getLayout() == null) {
        this.setLayout(new PatternLayout(s));
    }
    else {
        ((PatternLayout)getLayout()).setConversionPattern(s);
    }
}

 public  void setURL(String url) 
{
    databaseURL = url;
}

 public  void setUser(String user) 
{
    databaseUser = user;
}