public  void addDataSourceProperty(QName name,
    String value) 
{
        dataSourceProps.put(name, value);
}

 public  void addDataSourceProperty(String name,
    String value) 
{
        dataSourceProps.put(name, value);
}

 public  void addStatement(Statement stmnt) 
{
        statementList.add(stmnt);
}

 public  void destroy() 
{
        if (this.dataSource instanceof BasicDataSource) {
            try {
                ((BasicDataSource) this.dataSource).close();
                log.info("Successfully shut down DB connection pool for URL : " + getDSName());
            } catch (SQLException e) {
                log.warn("Error shutting down DB connection pool for URL : " + getDSName());
            }
        } else if (this.dataSource instanceof PerUserPoolDataSource) {
            ((PerUserPoolDataSource) this.dataSource).close();
            log.info("Successfully shut down DB connection pool for URL : " + getDSName());
        }
}

Destroys the mediator. If we are using our custom DataSource, then shut down the connections

 protected String getDSName() 
{
        return (String) dataSourceProps.get(AbstractDBMediatorFactory.URL_Q);
}

Return the name or (hopefully) unique connection URL specific to the DataSource being used This is used for logging purposes only

 public DataSource getDataSource() 
{
        return dataSource;
}

 public Map getDataSourceProps() 
{
        return dataSourceProps;
}

 protected PreparedStatement getPreparedStatement(Statement stmnt,
    MessageContext msgCtx) throws SQLException 
{
        boolean traceOn = isTraceOn(msgCtx);
        boolean traceOrDebugOn = isTraceOrDebugOn(traceOn);
        Log serviceLog = msgCtx.getServiceLog();
        if (traceOrDebugOn) {
            traceOrDebug(traceOn, "Getting a connection from DataSource " + getDSName() +
                " and preparing statement : " + stmnt.getRawStatement());
        }
        Connection con = getDataSource().getConnection();
        PreparedStatement ps = con.prepareStatement(stmnt.getRawStatement());
        // set parameters if any
        List params = stmnt.getParameters();
        int column = 1;
        for (Iterator pi = params.iterator(); pi.hasNext(); ) {
            Statement.Parameter param = (Statement.Parameter) pi.next();
            String value = (param.getPropertyName() != null ?
                param.getPropertyName() : param.getXpath().stringValueOf(msgCtx));
            if (traceOrDebugOn) {
                traceOrDebug(traceOn, "Setting as parameter : " + column + " value : " + value +
                    " as JDBC Type : " + param.getType() + "(see java.sql.Types for valid types)");
            }
            switch (param.getType()) {
                // according to J2SE 1.5 /docs/guide/jdbc/getstart/mapping.html
                case Types.CHAR:
                case Types.VARCHAR:
                case Types.LONGVARCHAR: {
                    ps.setString(column++, value);
                    break;
                }
                case Types.NUMERIC:
                case Types.DECIMAL: {
                    ps.setBigDecimal(column++, new BigDecimal(value));
                    break;
                }
                case Types.BIT: {
                    ps.setBoolean(column++, Boolean.parseBoolean(value));
                    break;
                }
                case Types.TINYINT: {
                    ps.setByte(column++, Byte.parseByte(value));
                    break;
                }
                case Types.SMALLINT: {
                    ps.setShort(column++, Short.parseShort(value));
                    break;
                }
                case Types.INTEGER: {
                    ps.setInt(column++, Integer.parseInt(value));
                    break;
                }
                case Types.BIGINT: {
                    ps.setLong(column++, Long.parseLong(value));
                    break;
                }
                case Types.REAL: {
                    ps.setFloat(column++, Float.parseFloat(value));
                    break;
                }
                case Types.FLOAT: {
                    ps.setDouble(column++, Double.parseDouble(value));
                    break;
                }
                case Types.DOUBLE: {
                    ps.setDouble(column++, Double.parseDouble(value));
                    break;
                }
                // skip BINARY, VARBINARY and LONGVARBINARY
                case Types.DATE: {
                    ps.setDate(column++, Date.valueOf(value));
                    break;
                }
                case Types.TIME: {
                    ps.setTime(column++, Time.valueOf(value));
                    break;
                }
                case Types.TIMESTAMP: {
                    ps.setTimestamp(column++, Timestamp.valueOf(value));
                    break;
                }
                // skip CLOB, BLOB, ARRAY, DISTINCT, STRUCT, REF, JAVA_OBJECT
                default: {
                    String msg = "Trying to set an un-supported JDBC Type : " + param.getType() +
                        " against column : " + column + " and statement : " + stmnt.getRawStatement() +
                        " used by a DB mediator against DataSource : " + getDSName() +
                        " (see java.sql.Types for valid type values)";
                    handleException(msg, msgCtx);
                }
            }
        }
        if (traceOrDebugOn) {
            traceOrDebug(traceOn, "Successfully prepared statement : " + stmnt.getRawStatement() +
                " against DataSource : " + getDSName());
        }
        return ps;
}

Return a Prepared statement for the given Statement object, which is ready to be executed

 public List getStatementList() 
{
        return statementList;
}

 public  void init(SynapseEnvironment se) 
{
        // do nothing
}

Initializes the mediator. Does nothing right now. If DataSource lookup is supported, could do the IC lookup here

 public boolean mediate(MessageContext synCtx) 
{
        String name = (this instanceof DBLookupMediator ? "DBLookup" : "DBReport");
        boolean traceOn = isTraceOn(synCtx);
        boolean traceOrDebugOn = isTraceOrDebugOn(traceOn);
        if (traceOrDebugOn) {
            traceOrDebug(traceOn, "Start : " + name + " mediator");
            if (traceOn && trace.isTraceEnabled()) {
                trace.trace("Message : " + synCtx.getEnvelope());
            }
        }
        for (Iterator iter = statementList.iterator(); iter.hasNext(); ) {
            processStatement((Statement) iter.next(), synCtx);
        }
        if (traceOrDebugOn) {
            traceOrDebug(traceOn, "End : " + name + " mediator");
        }
        return true;
}

Process each SQL statement against the current message

 abstract protected  void processStatement(Statement query,
    MessageContext msgCtx)
Subclasses must specify how each SQL statement is processed

 public  void setDataSource(DataSource dataSource) 
{
        this.dataSource = dataSource;
}