protected Object[][] getColumnValues(Configuration tableConf,
    CacheHelper queryData,
    Map objectModel) throws ConfigurationException, ServiceException 
{
        Object[][] columnValues = new Object[ queryData.columns.length ][];
        for ( int i = 0; i <  queryData.columns.length; i++ ){
            columnValues[i] = this.getColumnValue( tableConf, queryData.columns[i], objectModel );
        }
        return columnValues;
}

Fetch all values for all columns that are needed to do the database operation.

 protected CacheHelper getQuery(Configuration table,
    Map modeTypes,
    Map defaultModeNames) throws ConfigurationException, ServiceException 
{
        LookUpKey lookUpKey = new LookUpKey( table, modeTypes );
        CacheHelper queryData = null;
        synchronized( this.cachedQueryData ) {
            queryData = (CacheHelper) this.cachedQueryData.get( lookUpKey );
            if (queryData == null) {
                Configuration[] queries = table.getChild("queries").getChildren("query");
                Configuration[] keys = table.getChild("keys").getChildren("key");
                Configuration[] values = table.getChild("values").getChildren("value");
                boolean found = false;
                String queryModeName = "";
                String query = "";
                boolean useValues = true;
                for (int i=0; i< queries.length; i++) {
                    queryModeName = queries[i].getAttribute("mode",null);
                    if ( queryModeName.equals(modeTypes.get(MODE_OTHERS)) || "all".equals(queryModeName)) {
                        query = queries[i].getValue();
                        useValues = queries[i].getAttributeAsBoolean("use-values", useValues);
                        found = true;
                        break;
                    }
                }
                if (!found) {
                    throw new ConfigurationException("Could not find query mode " +
                                                     modeTypes.get(MODE_OTHERS) + 
                                                     " for table " + table.getAttribute("name",null));
                }
                queryData = new CacheHelper( keys.length, keys.length + (useValues ? values.length : 0));
                queryData.queryString = query;
                fillModes( keys  , true , defaultModeNames, modeTypes, queryData );
                if (useValues) fillModes( values, false, defaultModeNames, modeTypes, queryData );
                this.cachedQueryData.put( lookUpKey, queryData );
            }
        }
        return queryData;
}

Get the String representation of the PreparedStatement. This is mapped to the Configuration object itself, so if it doesn't exist, it will be created.

 protected boolean honourAutoIncrement() 
{
 return false;
}

determine whether autoincrement columns should be honoured by this operation. This is usually snsible only for INSERTs.

 protected int processRow(Map objectModel,
    Connection conn,
    PreparedStatement statement,
    String outputMode,
    Configuration table,
    CacheHelper queryData,
    Object[][] columnValues,
    int rowIndex,
    Map results) throws Exception, SQLException, ConfigurationException 
{
        int currentIndex = 1;
        // ordering is different for SELECT just needs keys
        for (int i = 0; i <  queryData.columns.length; i++) {
            Column col = queryData.columns[i];
            if ( col.isKey ) {
                this.setColumn(objectModel, outputMode, results, table, col.columnConf, rowIndex,
                               columnValues[ i ][ ( col.isSet ? rowIndex : 0 ) ], statement, currentIndex );
                currentIndex++;
            }
        }
        boolean hasResult = statement.execute();
        if (!hasResult) {
            return statement.getUpdateCount();
        } else {
            // retrieve values
            ResultSet resultset = statement.getResultSet();
            ResultSetMetaData metadata = resultset.getMetaData();
            rowIndex = 0;
            while ( resultset.next() ){
                //if ( ! ( rowIndex == -1 && resultset.isLast() ) ) {
                rowIndex++;
                //}
                String tableName = "";
                String columnName = "";
                for (int i = 1; i < = metadata.getColumnCount(); i++) {
                    Object value = resultset.getObject(i);
                    tableName = metadata.getTableName(i);
                    columnName = metadata.getColumnLabel(i) + "[" + rowIndex + "]";
                    if (!tableName.equals("")) {
                        columnName = tableName + "." + columnName;
                    }
                    if (this.getLogger().isDebugEnabled()) {
                        this.getLogger().debug("retrieving " + columnName + " as " + value);
                    }
                    results.put(metadata.getTableName(i)+"."+metadata.getColumnLabel(i),value);
                }
            }
            return rowIndex;
        }
}

set all necessary ?s and execute the query

 protected String selectMode(boolean isAutoIncrement,
    Map modes) 
{
        
        return (String) modes.get( MODE_OTHERS );
}

determine which mode to use as default mode here: SELECT highly specific to operation INSERT / UPDATE / DELETE / SELECT