hello,

by the following Action I want to ask database and  i want pass the result at 
generator. on the again into certain format i want to pass at Transformer:

<?xml version="1.0" encoding="UTF-8"?>
<map:sitemap xmlns:map="http://apache.org/cocoon/sitemap/1.0";>

<map:components>
        <map:actions>
         <map:action name="select" logger="sitemap.action.select" 
                src="dbmanager.AmeliSelect"/>
      </map:actions>
</map:components>

<map:pipelines >
<!--internal-only="true"-->
  <map:pipeline > 
     <map:match pattern="">
        <map:act type="select">
                <map:generate type="file" src="content/ObjectionHTML.xml"/>
                <map:transform src="stylesheets/objection04.xslt"/>
                <map:serialize type="html" />
        </map:act>
     </map:match>
   </map:pipeline>
   
   <!--map:pipeline> 
  <map:match pattern=""> 
    <map:generate type="request" src="cocoon:/select/"/> 
    <map:serialize type="xml" />
  </map:match> 
</map:pipeline--> 
   
</map:pipelines>

</map:sitemap>



package dbmanager;

import java.awt.Component;
import java.awt.event.ActionEvent;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.avalon.excalibur.datasource.DataSourceComponent;
import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.component.ComponentManager;
import org.apache.avalon.framework.component.ComponentSelector;
import org.apache.avalon.framework.component.Composable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.parameters.Parameters;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.thread.ThreadSafe;
import org.apache.cocoon.Constants;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.acting.AbstractAction;
import org.apache.cocoon.acting.AbstractDatabaseAction;
import org.apache.cocoon.acting.DatabaseSelectAction;

import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Redirector;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.environment.SourceResolver;
import org.apache.commons.lang.StringUtils;
import org.xml.sax.InputSource;

import wohland.de.Framework.JDBC.Default.Persistable;
import wohland.de.Framework.JDBC.Default.DefaultSqlOperation.BooleanMapper;
import wohland.de.Framework.JDBC.Default.DefaultSqlOperation.ByteMapper;
import wohland.de.Framework.JDBC.Default.DefaultSqlOperation.DateMapper;
import wohland.de.Framework.JDBC.Default.DefaultSqlOperation.DefaultPersistable;
import wohland.de.Framework.JDBC.Default.DefaultSqlOperation.DoubleMapper;
import wohland.de.Framework.JDBC.Default.DefaultSqlOperation.FloatMapper;
import wohland.de.Framework.JDBC.Default.DefaultSqlOperation.IntMapper;
import wohland.de.Framework.JDBC.Default.DefaultSqlOperation.LongMapper;
import wohland.de.Framework.JDBC.Default.DefaultSqlOperation.Mapper;
import wohland.de.Framework.JDBC.Default.DefaultSqlOperation.NumericMapper;
import wohland.de.Framework.JDBC.Default.DefaultSqlOperation.ShortMapper;
import wohland.de.Framework.JDBC.Default.DefaultSqlOperation.StringMapper;
import wohland.de.Framework.JDBC.Default.DefaultSqlOperation.TimeMapper;
import wohland.de.Framework.JDBC.Default.DefaultSqlOperation.TimestampMapper;
import wohland.de.Framework.JDBC.Default.DefaultSqlOperation.TinyBooleanMapper;

import cuba.ComponentException;

public class AmeliSelect extends DatabaseSelectAction  implements ThreadSafe,
                Composable, Disposable {

        // private static final Map selectStatements = new HashMap();
        // private DBManager dbm = null;
        // private ServiceManager manager = null;
        // private InputSource inputSource = null;
        // DataSourceComponent datasource = null;
          private  ResultSet resultSet ;
           private DBManager dbm; 
//         private ServiceManager manager;
        protected ComponentSelector dbselector;

        protected ComponentManager manager;

        private static HashMap mappers = null;

        // public void service(ServiceManager serviceManager) throws
        // ServiceException {
        // System.out.println("[User.java | service] beginn");
        // this.manager = serviceManager;
        //
        // }
        public void compose(ComponentManager  manager) throws 
org.apache.avalon.framework.component.ComponentException  {
                // TODO Auto-generated method stub
                this.dbselector = (ComponentSelector) manager
                                .lookup(DataSourceComponent.ROLE + "Selector");

        }

        //      public void compose()
        //                      throws 
org.apache.avalon.framework.component.ComponentException {
        //              this.dbselector = (ComponentSelector) manager
        //                              .lookup(DataSourceComponent.ROLE + 
"Selector");
        //      }

        protected final DataSourceComponent getDataSource(String pool)
                        throws 
org.apache.avalon.framework.component.ComponentException {
                return (DataSourceComponent) this.dbselector.select(pool);
        }

        public Map act(Redirector redirector, SourceResolver resolver,
                        Map objectModel, String source, Parameters param) 
throws Exception {
                
                String query = " select * FROM Field_Descriptions";

                // AmeliSelect.selectStatements.put(conf, query);

                Request request = ObjectModelHelper.getRequest(objectModel);
                Map map = new HashMap();
//              DataSourceComponent dataSource = 
getDataSource("ameli_para_dev_datasource");
//              Connection connection = null;
                
                try {
//                      connection = dataSource.getConnection();
//                      Statement statement = connection.createStatement();
//                      String cmd = query;
//
//                      ResultSet rs = statement.executeQuery(cmd);
                        System.out.println("[User.java | User] pre"); 
                 this.dbm = (DBManager)this.manager.lookup(DBManager.ROLE);
                 
                    System.out.println("[User.java | User] middle"); 
//                  resultSet = dbm.sqlSelect("select *  from 
Field_Descriptions");
                    List list = dbm. sqlSelect2List("select *  from 
Field_Descriptions");
                    System.out.println("[User.java | User] after"); 
//                      map = constructResultFromResultSet( resultSet);
                    
                        Iterator iterator = list.iterator();
                        while (iterator.hasNext()) {
                                // Get key
                                int i=0;
                                request.setAttribute(new 
Integer(i++).toString(), list.get(i));
                        }
                        
                        return EMPTY_MAP;
                } catch (Exception e) {
                        // TODO: handle exception
                                        getLogger().error("Query failed: ", e);
                } 
//              finally {
//                      try {
//                              if (connection != null) {
//                                      connection.close();
//                              }
//                      } catch (SQLException sqe) {
//                              // TODO: handle exception
//                              getLogger().error("Error closing the 
datasource", sqe);
//                      }
//
//              }
                return null;

                //              return (map);
        }

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

        protected String getSelectQuery(Configuration conf)
                        throws ConfigurationException {
                String query = null;

                // synchronized (AmeliSelect.selectStatements) {
                // query = (String)AmeliSelect.selectStatements.get(conf);

                // if (query == null) {
                // Configuration table = conf.getChild("table");
                // Configuration[] keys = 
table.getChild("keys").getChildren("key");
                // Configuration[] values =
                // table.getChild("values").getChildren("value");
                //
                // StringBuffer queryBuffer = new StringBuffer("SELECT ");
                // queryBuffer.append(buildList(keys, 0));
                // queryBuffer.append(buildList(values, keys.length));
                // queryBuffer.append(" FROM ");
                // queryBuffer.append(table.getAttribute("name"));
                //
                // queryBuffer.append(" WHERE ");
                // queryBuffer.append(buildList(keys, " AND "));
                // query = queryBuffer.toString();
                query = " select ID_Entity AS ID_Entity, ID_Field AS ID_Field, 
DataType AS DataType, Caption AS Caption , Mask AS Mask, DefaultValue AS 
DefaultValue, Mandatory AS Mandatory, ValueCheck AS ValueCheck , Enabled AS 
Enabled, Visible AS Visible, Range_Lower AS Range_Lower, Range_Upper AS 
Range_Upper , ValueCheck AS ValueCheck, Size AS Size , Icon AS Icon, Language 
AS Language FROM Field_Descriptions";

                // AmeliSelect.selectStatements.put(conf, query);
                // }
                // }
                // // return query;
                return null;
        }

        protected HashMap constructResultFromResultSet(ResultSet rs)
                        throws SQLException {
                ResultSetMetaData md = rs.getMetaData();
                int columnCount = md.getColumnCount();
                List results = new ArrayList();
                Map resultsmap = new Hashtable();
                // save information in first row
                HashMap propInfo = new HashMap();
                HashMap props = new HashMap();
                for (int i = 0; i < columnCount; i++) {
                        String columnName = md.getColumnName(i + 1);
                        propInfo.put("column" + i, columnName);
                }
                Persistable pInfo = getNewPersistable();
                pInfo.setProperties(propInfo);
                results.add(pInfo);
                // get data from rs start from pos 1
                while ((rs != null) && (rs.next())) {

                        for (int i = 0; i < columnCount; i++) {
                                String columnName = md.getColumnName(i + 1);
                                int type = md.getColumnType(i + 1);
                                Object o = getValue(rs, type, i + 1);
                                //                              if (debugSQL())
                                //                                      
System.err.println(columnName + " = " + o);
                                if (o != null) {
                                        props.put(columnName, o);
                                } else {
                                        // props.put(columnName, "<null>");
                                }
                        }
                        Persistable p = getNewPersistable();
                        // if (debugSQL())
                        // System.err.println("Setting properties with: " + 
props);
                        //                      logger.debug("Setting 
properties with: " + props);
                        p.setProperties(props);
                        results.add(p);
                }
                //              return results;
                return propInfo;
        }

        protected Persistable getNewPersistable() {
                return new DefaultPersistable();
        }

        protected Object getValue(ResultSet rs, int type, int index) {
                // if (debugSQL())
                // System.err.println("COLUMN TYPE = " + type);
                // logger.debug("COLUMN TYPE = " + type);

                try {

                        // handle the mysql TINYINT to Boolean Type
                        if ((rs.toString().indexOf("mysql") > 0) && (type == 
Types.TINYINT)) {
                                // type for TinyBoolean in mysql !! not standard
                                type = -1111;
                        }

                        if ((rs.toString().indexOf("microsoft") > 0)
                                        && (type == Types.FLOAT)) {
                                // type for Float in sqlserver !! not standard
                                type = Types.DOUBLE;
                                //                              
System.out.println("type " + type);                             
                        }

                        Mapper m = getMapper(new Integer(type));
                        if (m != null) {
                                return m.getValue(rs, index);
                        }
                } catch (Exception x) {
                        // NULL values in the database cause most of the Mapper 
classes to
                        // fail
                        // a NULL value will result in the absence of this 
property from the
                        // result.
                        // if (debugSQL())
                        // System.err.println(
                        // "Warning: Unknown column type or NULL value for 
column " +
                        // index);
                        //                      logger.fatal(
                        //                                      "Warning: 
Unknown column type or NULL value for column "
                        //                                                      
+ index, x);
                }
                return null;
        }

        protected Mapper getMapper(Object key) {
                if (mappers == null) {
                        mappers = new HashMap();
                        registerMapper(Byte.class, Types.TINYINT, new 
ByteMapper());
                        DateMapper dm = new DateMapper();
                        registerMapper(java.util.Date.class, Types.DATE, dm);
                        // always convert sql Dates to util Dates from 
ResultSets
                        registerMapper(java.sql.Date.class, 0, dm);
                        registerMapper(Double.class, Types.DOUBLE, new 
DoubleMapper());
                        registerMapper(Float.class, Types.FLOAT, new 
FloatMapper());
                        registerMapper(Integer.class, Types.INTEGER, new 
IntMapper());
                        registerMapper(java.math.BigDecimal.class, 
Types.NUMERIC,
                                        new NumericMapper());
                        registerMapper(Long.class, Types.BIGINT, new 
LongMapper());
                        registerMapper(Short.class, Types.SMALLINT, new 
ShortMapper());
                        StringMapper strm = new StringMapper();
                        registerMapper(String.class, Types.VARCHAR, strm);
                        // mySQL return VARCHAR as CHAR
                        registerMapper(String.class, Types.CHAR, strm);
                        registerMapper(null, Types.LONGVARCHAR, strm);
                        registerMapper(Time.class, Types.TIME, new 
TimeMapper());
                        registerMapper(Timestamp.class, Types.TIMESTAMP,
                                        new TimestampMapper());
                        // assume blob as string
                        // mySQL return blob as LONGVARBINARY
                        registerMapper(String.class, Types.BLOB, strm);
                        registerMapper(String.class, Types.LONGVARBINARY, strm);
                        // mySQL return tinyint as Boolean
                        registerMapper(Boolean.class, -1111, new 
TinyBooleanMapper());
                        // SQLServer return value
                        registerMapper(Boolean.class, Types.BIT, new 
BooleanMapper());
                }
                return (Mapper) mappers.get(key);
        }

        public static void registerMapper(Class valueType, int sqlType,
                        Mapper aMapper) {
                if (valueType != null)
                        mappers.put(valueType, aMapper);
                if (sqlType != 0)
                        mappers.put(new Integer(sqlType), aMapper);
        }
}


which generator i must to use ? which Object must i pass from Action to 
ggenerator?

-- 


Der GMX SmartSurfer hilft bis zu 70% Ihrer Onlinekosten zu sparen!
Ideal für Modem und ISDN: http://www.gmx.net/de/go/smartsurfer

---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]

Reply via email to