protected StringBuffer buildList(Configuration[] values,
    String separator) throws ConfigurationException 
{
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i <  values.length; i++) {
            if (i  > 0) {
                buffer.append(separator);
            }
            buffer.append(values[i].getAttribute("dbcol"));
            buffer.append(" = ?");
        }
        return buffer;
}

Build a separed list with the Values of a Configuration Array

 protected StringBuffer buildList(Configuration[] values,
    int begin) throws ConfigurationException 
{
        StringBuffer buffer = new StringBuffer();
        int length = values.length;
        boolean prependComma = begin  > 0;
        for (int i = 0; i <  length; i++) {
            if (prependComma) {
                buffer.append(", ");
            } else {
                prependComma = true;
            }
            buffer.append(values[i].getAttribute("dbcol"));
        }
        return buffer;
}

Build a separed list with the Values of a Configuration Array

 public  void dispose() 
{
        this.manager.release(dbselector);
}

dispose

 protected Object getColumn(ResultSet set,
    Request request,
    Configuration entry) throws Exception 
{
        Integer type = (Integer) AbstractDatabaseAction.typeConstants.get(entry.getAttribute("type"));
        String attribute = entry.getAttribute("param", "");
        String dbcol = entry.getAttribute("dbcol", "");
        Object value = null;
        switch (type.intValue()) {
            case Types.CLOB:
                Clob dbClob = set.getClob(dbcol);
                if (dbClob != null) {
                    int length = (int) dbClob.length();
                    InputStream is = new BufferedInputStream(dbClob.getAsciiStream());
                    try {
                        byte[] buffer = new byte[length];
                        length = is.read(buffer);
                        value = new String(buffer, 0, length);
                    } finally {
                        is.close();
                    }
                }
                break;
            case Types.BIGINT:
                value = set.getBigDecimal(dbcol);
                break;
            case Types.TINYINT:
                value = new Byte(set.getByte(dbcol));
                break;
            case Types.VARCHAR:
                value  = set.getString(dbcol);
                break;
            case Types.DATE:
                value = set.getDate(dbcol);
                break;
            case Types.DOUBLE:
                value = new Double(set.getDouble(dbcol));
                break;
            case Types.FLOAT:
                value = new Float(set.getFloat(dbcol));
                break;
            case Types.INTEGER:
                value = new Integer(set.getInt(dbcol));
                break;
            case Types.NUMERIC:
                value = new Long(set.getLong(dbcol));
                break;
            case Types.SMALLINT:
                value = new Short(set.getShort(dbcol));
                break;
            case Types.TIME:
                value = set.getTime(dbcol);
                break;
            case Types.TIMESTAMP:
                value = set.getTimestamp(dbcol);
                break;
            case Types.ARRAY:
                value = set.getArray(dbcol);
                break;
            case Types.BIT:
                value = new Integer(set.getInt(dbcol));
                break;
            case Types.CHAR:
                value = new Integer(set.getInt(dbcol));
                break;
        case Types.STRUCT:
        value = set.getObject(dbcol);
        break;
        case Types.OTHER:
        value = set.getObject(dbcol);
        break;
            default:
                // The blob types have to be requested separately, via a Reader.
                value = "";
                break;
        }
        setRequestAttribute(request,attribute,value);
        return value;
}

Get the Statement column so that the results are mapped correctly.

 protected final DataSourceComponent getDataSource(Configuration conf) throws ServiceException 
{
        Configuration dsn = conf.getChild("connection");
        return (DataSourceComponent) this.dbselector.select(dsn.getValue(""));
}

Get the Datasource we need.

 protected Object getRequestAttribute(Request request,
    String key) 
{
      return request.getAttribute("org.apache.cocoon.acting.AbstractDatabaseAction:"+key);
}

Retreive a value from the request attributes.

 protected final boolean isLargeObject(String type) 
{
        if ("ascii".equals(type)) return true;
        if ("binary".equals(type)) return true;
        if ("image".equals(type)) return true;
        return false;
}

Return whether a type is a Large Object (BLOB/CLOB).

 public  void service(ServiceManager manager) throws ServiceException 
{
     
        /*
         * Initialize the map of type names to jdbc column types.
         * Note that INTEGER, BLOB, and VARCHAR column types map to more than
         * one type name.
         */
        Map constants = new HashMap();
        constants.put("ascii", new Integer(Types.CLOB));
        constants.put("big-decimal", new Integer(Types.BIGINT));
        constants.put("binary", new Integer(Types.BLOB));
        constants.put("byte", new Integer(Types.TINYINT));
        constants.put("string", new Integer(Types.VARCHAR));
        constants.put("date", new Integer(Types.DATE));
        constants.put("double", new Integer(Types.DOUBLE));
        constants.put("float", new Integer(Types.FLOAT));
        constants.put("int", new Integer(Types.INTEGER));
        constants.put("long", new Integer(Types.NUMERIC));
        constants.put("short", new Integer(Types.SMALLINT));
        constants.put("time", new Integer(Types.TIME));
        constants.put("time-stamp", new Integer(Types.TIMESTAMP));
        constants.put("now", new Integer(Types.LONGVARBINARY));
        //constants.put("image", new Integer(Types.DISTINCT));
        //constants.put("image-width", new Integer(Types.ARRAY));
        //constants.put("image-height", new Integer(Types.BIT));
        //constants.put("image-size", new Integer(Types.CHAR));
        constants.put("image",new Integer(Types.BLOB));
        constants.put("image-width",new Integer(Types.INTEGER));
        constants.put("image-height",new Integer(Types.INTEGER));
        constants.put("image-size",new Integer(Types.INTEGER));
        constants.put("row-index",new Integer(Types.INTEGER));
        constants.put("image-mime-type",new Integer(Types.VARCHAR));
        constants.put("array", new Integer(Types.ARRAY));
        constants.put("row", new Integer(Types.STRUCT));
        constants.put("object", new Integer(Types.OTHER));
        typeConstants = Collections.unmodifiableMap(constants);
        super.service(manager);
        this.dbselector = (ServiceSelector) manager.lookup(DataSourceComponent.ROLE + "Selector");
}

Compose the Actions so that we can select our databases.

 protected  void setColumn(PreparedStatement statement,
    int position,
    Request request,
    Configuration entry) throws Exception 
{
        setColumn(statement,position,request,entry,entry.getAttribute("param",""));
}

Set the Statement column so that the results are mapped correctly. The name of the parameter is retrieved from the configuration object.

 protected  void setColumn(PreparedStatement statement,
    int position,
    Request request,
    Configuration entry,
    String param) throws Exception 
{
        Object value = request.getParameter(param);
        if (value == null) value = request.getAttribute(param);
        if (value == null) value = request.get(param);
        setColumn(statement,position,request,entry,param,value);
}

Set the Statement column so that the results are mapped correctly. The value of the column is retrieved from the request object. If the named parameter exists in the request object's parameters, that value is used. Otherwise if the named parameter exists in the request object's attributes, that value is used. Otherwise the request object is retrieved using Request.get(attribute), which is documented to be the same as Request.getAttribute(attribute), so something weird must be going on.

 protected  void setColumn(PreparedStatement statement,
    int position,
    Request request,
    Configuration entry,
    String param,
    Object value) throws Exception 
{
        setColumn(statement,position,request,entry,param,value,0);
}

Set the Statement column so that the results are mapped correctly.

 protected  void setColumn(PreparedStatement statement,
    int position,
    Request request,
    Configuration entry,
    String param,
    Object value,
    int rowIndex) throws Exception 
{
        getLogger().debug("Setting column "+position+" named "+param+" with value "+value);
        if (value instanceof String) {
            value = ((String) value).trim();
        }
        String typeName = entry.getAttribute("type");
        Integer typeObject = (Integer) AbstractDatabaseAction.typeConstants.get(typeName);
        if (typeObject == null) {
            throw new SQLException("Can't set column because the type "+typeName+" is unrecognized");
        }
        if (value == null) {
            /** If the value is null, set the column value null and return **/
            if (typeName.equals("image-width") || typeName.equals("image-height") || typeName.equals("image-size") || typeName.equals("row-index") || typeName.equals("image-mime-type")) {
              /** these column types are automatically generated so it's ok **/
            } else {
              statement.setNull(position, typeObject.intValue());
              return;
            }
        }
        if ("".equals(value)) {
            switch (typeObject.intValue()) {
                case Types.CHAR:
                case Types.CLOB:
                case Types.VARCHAR:
                    /** If the value is an empty string and the column is
                        a string type, we can continue **/
                    break;
                case Types.INTEGER:
                  if (typeName.equals("image-width") || typeName.equals("image-height") || typeName.equals("image-size") || typeName.equals("row-index")) {
                    /** again, these types are okay to be absent **/
                    break;
                  }
                default:
                    /** If the value is an empty string and the column
                        is something else, we treat it as a null value **/
                    statement.setNull(position, typeObject.intValue());
                    return;
            }
        }
        /** Store the column value in the request attribute
            keyed by the request parameter name. we do this so possible future
            actions can access this data. not sure about the key tho... **/
        setRequestAttribute(request,param,value);
        File file;
        switch (typeObject.intValue()) {
            case Types.CLOB:
                int length = -1;
                InputStream asciiStream = null;
                if (value instanceof File) {
                    File asciiFile = (File) value;
                    asciiStream = new BufferedInputStream(new FileInputStream(asciiFile));
                    length = (int) asciiFile.length();
                } else {
                    String asciiText = (String) value;
                    asciiStream = new BufferedInputStream(new ByteArrayInputStream(asciiText.getBytes()));
                    length = asciiText.length();
                }
                statement.setAsciiStream(position, asciiStream, length);
                break;
            case Types.BIGINT:
                BigDecimal bd = null;
                if (value instanceof BigDecimal) {
                    bd = (BigDecimal) value;
                } else {
                    bd = new BigDecimal((String) value);
                }
                statement.setBigDecimal(position, bd);
                break;
            case Types.TINYINT:
                Byte b = null;
                if (value instanceof Byte) {
                    b = (Byte) value;
                } else {
                    b = new Byte((String) value);
                }
                statement.setByte(position, b.byteValue());
                break;
            case Types.DATE:
                Date d = null;
                if (value instanceof Date) {
                    d = (Date) value;
                } else if (value instanceof java.util.Date) {
                    d = new Date(((java.util.Date) value).getTime());
                } else {
                    d = new Date(this.dateValue((String) value, entry.getAttribute("format", "M/d/yyyy")));
                }
                statement.setDate(position, d);
                break;
            case Types.DOUBLE:
                Double db = null;
                if (value instanceof Double) {
                    db = (Double) value;
                } else {
                    db = new Double((String) value);
                }
                statement.setDouble(position, db.doubleValue());
                break;
            case Types.FLOAT:
                Float f = null;
                if (value instanceof Float) {
                    f = (Float) value;
                } else {
                    f = new Float((String) value);
                }
                statement.setFloat(position, f.floatValue());
                break;
            case Types.NUMERIC:
                Long l = null;
                if (value instanceof Long) {
                    l = (Long) value;
                } else {
                    l = new Long((String) value);
                }
                statement.setLong(position, l.longValue());
                break;
            case Types.SMALLINT:
                Short s = null;
                if (value instanceof Short) {
                    s = (Short) value;
                } else {
                    s = new Short((String) value);
                }
                statement.setShort(position, s.shortValue());
                break;
            case Types.TIME:
                Time t = null;
                if (value instanceof Time) {
                    t = (Time) value;
                } else {
                    t = new Time(this.dateValue((String) value, entry.getAttribute("format", "h:m:s a")));
                }
                statement.setTime(position, t);
                break;
            case Types.TIMESTAMP:
                Timestamp ts = null;
                if (value instanceof Time) {
                    ts = (Timestamp) value;
                } else {
                    ts = new Timestamp(this.dateValue((String) value, entry.getAttribute("format", "M/d/yyyy h:m:s a")));
                }
                statement.setTimestamp(position, ts);
                break;
            case Types.ARRAY:
                statement.setArray(position, (Array) value); // no way to convert string to array
                break;
            case Types.STRUCT:
            case Types.OTHER:
                statement.setObject(position, value);
                break;
            case Types.LONGVARBINARY:
                statement.setTimestamp(position, new Timestamp((new java.util.Date()).getTime()));
                break;
            case Types.VARCHAR:
                if ("string".equals(typeName)) {
                   statement.setString(position, (String) value);
                   break;
                } else if ("image-mime-type".equals(typeName)) {
                    String imageAttr = param.substring(0, (param.length() - "-mime-type".length()));
                    file = (File) request.get(imageAttr);
                    synchronized (this.files) {
                        Parameters parameters = (Parameters) this.files.get(file);
                        String imageMimeType = parameters.getParameter("image-mime-type",
                                                                       (String) settings.get("image-mime-type",""));
                        statement.setString(position, imageMimeType);
                        /** Store the image mime type in the request attributes.
                            Why do we do this? **/
                        setRequestAttribute(request, param, imageMimeType);
                    }
                    break;
                }
            case Types.BLOB:
                if (value instanceof File) {
                    file = (File)value;
                } else if (value instanceof String) {
                    file = new File((String)value);
                } else {
                    throw new SQLException("Invalid type for blob: "+value.getClass().getName());
                }
                //InputStream input = new BufferedInputStream(new FileInputStream(file));
                FileInputStream input = new FileInputStream(file);
                statement.setBinaryStream(position, input, (int)file.length());
                if ("image".equals(typeName)) {
                    /** If this column type is an image, store the
                        size, width, and height in a static table **/
                    Parameters parameters = new Parameters();
                    parameters.setParameter("image-size", Long.toString(file.length()));
                    ImageProperties prop = ImageUtils.getImageProperties(file);
                    parameters.setParameter("image-width", Integer.toString(prop.width));
                    parameters.setParameter("image-height", Integer.toString(prop.height));
                    // TC: if it's really mime-type shouldn't we prepend "image/"?
                    parameters.setParameter("image-mime-type",prop.type);
                    synchronized (this.files) {
                        this.files.put(file, parameters);
                    }
                }
                break;
            case Types.INTEGER:
                if ("int".equals(typeName)) {
                    Integer i = null;
                    if (value instanceof Integer) {
                        i = (Integer) value;
                    } else {
                        i = new Integer((String) value);
                    }
                    statement.setInt(position, i.intValue());
                    break;
                } else if ("image-width".equals(typeName)) {
                    /** Get the image width from the cached image data **/
                    /** Is this why we store the values in the request
                        attributes? **/
                    String imageAttr = param.substring(0, (param.length() - "-width".length()));
                    file = (File) request.get(imageAttr);
                    synchronized (this.files) {
                        Parameters parameters = (Parameters) this.files.get(file);
                        statement.setInt(position, parameters.getParameterAsInteger("image-width",
                         Integer.parseInt((String)settings.get("image-width","-1"))));
                        /** Store the image width in the request attributes.
                            Why do we do this? **/
                        setRequestAttribute(request,
                        param,
                        parameters.getParameter("image-width",
                                    (String) settings.get("image-width","")));
                    }
                    break;
                } else if ("image-height".equals(typeName)) {
                    /** Get the image height from the cached image data **/
                    String imageAttr = param.substring(0, (param.length() - "-height".length()));
                    file = (File) request.get(imageAttr);
                    synchronized (this.files) {
                        Parameters parameters = (Parameters) this.files.get(file);
                        statement.setInt(position, parameters.getParameterAsInteger("image-height",
                         Integer.parseInt((String)settings.get("image-height","-1"))));
                        setRequestAttribute(request,
                        param,
                        parameters.getParameter("image-height",
                                    (String) settings.get("image-height","")));
                    }
                    break;
                } else if ("image-size".equals(typeName)) {
                    /** Get the image file size from the cached image data **/
                    String imageAttr = param.substring(0, (param.length() - "-size".length()));
                    file = (File) request.get(imageAttr);
                    synchronized (this.files) {
                        Parameters parameters = (Parameters) this.files.get(file);
                        statement.setInt(position, parameters.getParameterAsInteger("image-size",
                         Integer.parseInt((String)settings.get("image-height","-1"))));
                        setRequestAttribute(request,
                        param,
                        parameters.getParameter("image-size",
                                    (String) settings.get("image-size","")));
                    }
                    break;
                } else if ("row-index".equals(typeName)) {
                    statement.setInt(position,rowIndex);
                    break;
                }
            default:
                throw new SQLException("Impossible exception - invalid type "+typeName);
        }
}

Set the Statement column so that the results are mapped correctly.

 protected  void setRequestAttribute(Request request,
    String key,
    Object value) 
{
      request.setAttribute("org.apache.cocoon.acting.AbstractDatabaseAction:"+key,value);
}

Store a key/value pair in the request attributes. We prefix the key with the name of this class to prevent potential name collisions.