/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.sourcetap.sfa.util;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.commons.beanutils.BasicDynaBean;
import org.apache.commons.beanutils.DynaBean;
import org.apache.commons.beanutils.DynaClass;
import org.apache.commons.beanutils.DynaProperty;
import org.ofbiz.base.util.Debug;
import org.ofbiz.entity.GenericDelegator;
import org.ofbiz.entity.GenericEntityException;
import org.ofbiz.entity.GenericValue;
import org.ofbiz.entity.jdbc.SqlJdbcUtil;
import org.ofbiz.entity.model.ModelEntity;
import org.ofbiz.entity.model.ModelField;
import org.ofbiz.entity.model.ModelFieldType;
import org.ofbiz.entity.model.ModelViewEntity;
/**
* <p>Implementation of {@link DynaClass} that creates an in-memory collection
* of {@link DynaBean}s representing the results of an SQL query. Once the
* {@link DynaClass} instance has been created, the JDBC <code>ResultSet</code>
* and <code>Statement</code> on which it is based can be closed, and the
* underlying <code>Connection</code> can be returned to its connection pool
* (if you are using one).</p>
*
* <p>The normal usage pattern is something like:</p>
* <pre>
* Connection conn = ...; // Acquire connection from pool
* Statement stmt = conn.createStatement();
* ResultSet rs = stmt.executeQuery("SELECT ...");
* RowSetDynaClass rsdc = new RowSetDynaClass(rs);
* rs.close();
* stmt.close();
* ...; // Return connection to pool
* List rows = rsdc.getRows();
* ...; // Process the rows as desired
* </pre>
*
* <p>Each column in the result set will be represented as a {@link DynaBean}
* property of the corresponding name (optionally forced to lower case
* for portability). There will be one {@link DynaBean} in the
* <code>List</code> returned by <code>getRows()</code> for each
* row in the original <code>ResultSet</code>.</p>
*
* <p>In general, instances of {@link RowSetDynaClass} can be serialized
* and deserialized, which will automatically include the list of
* {@link DynaBean}s representing the data content. The only exception
* to this rule would be when the underlying property values that were
* copied from the <code>ResultSet</code> originally cannot themselves
* be serialized. Therefore, a {@link RowSetDynaClass} makes a very
* convenient mechanism for transporting data sets to remote Java-based
* application components.</p>
*
* @author Craig R. McClanahan
*/
public class GenericValueListDynaClass implements DynaClass, Serializable {
public static final String module = GenericValueListDynaClass.class.getName();
// ----------------------------------------------------- Instance variables
/**
* <p>Limits the size of the returned list. The call to
* <code>getRows()</code> will return at most limit number of rows.
* If less than or equal to 0, does not limit the size of the result.
*/
protected int limit = -1;
/**
* <p>The list of {@link DynaBean}s representing the contents of
* the original <code>ResultSet</code> on which this
* {@link RowSetDynaClass} was based.</p>
*/
protected List rows = new ArrayList();
protected List fieldsToSelect = null;
// ----------------------------------------------------------- Constructors
/**
* <p>Construct a new {@link RowSetDynaClass} for the specified
* <code>ResultSet</code>. The property names corresponding
* to column names in the result set will be not be lower cased.</p>
*
* @param resultSet The result set to be wrapped
*
* @exception NullPointerException if <code>resultSet</code>
* is <code>null</code>
* @exception GenericEntityException if the metadata for this result set
* cannot be introspected
*/
public GenericValueListDynaClass(List genericValueList, List fieldsToSelect) throws GenericEntityException {
this(genericValueList, fieldsToSelect, false, -1);
}
/**
* <p>Construct a new {@link RowSetDynaClass} for the specified
* <code>ResultSet</code>. The property names corresponding
* to column names in the result set will not be lower cased.</p>
*
* If <code>limit</code> is not less than 0, max <code>limit</code>
* number of rows will be copied into the list.
*
* @param resultSet The result set to be wrapped
* @param limit The maximum for the size of the result.
*
* @exception NullPointerException if <code>resultSet</code>
* is <code>null</code>
* @exception GenericEntityException if the metadata for this result set
* cannot be introspected
*/
public GenericValueListDynaClass(List genericValueList, List fieldsToSelect, int limit) throws GenericEntityException {
this(genericValueList, fieldsToSelect, false, limit);
}
/**
* <p>Construct a new {@link RowSetDynaClass} for the specified
* <code>ResultSet</code>. The property names corresponding
* to the column names in the result set will be lower cased or not,
* depending on the specified <code>lowerCase</code> value.</p>
*
* If <code>limit</code> is not less than 0, max <code>limit</code>
* number of rows will be copied into the resultset.
*
*
* @param resultSet The result set to be wrapped
* @param lowerCase Should property names be lower cased?
*
* @exception NullPointerException if <code>resultSet</code>
* is <code>null</code>
* @exception GenericEntityException if the metadata for this result set
* cannot be introspected
*/
public GenericValueListDynaClass(List genericValueList, List fieldsToSelect, boolean lowerCase)
throws GenericEntityException {
this(genericValueList, fieldsToSelect, lowerCase, -1);
}
/**
* <p>Construct a new {@link RowSetDynaClass} for the specified
* <code>ResultSet</code>. The property names corresponding
* to the column names in the result set will be lower cased or not,
* depending on the specified <code>lowerCase</code> value.</p>
*
* <p><strong>WARNING</strong> - If you specify <code>false</code>
* for <code>lowerCase</code>, the returned property names will
* exactly match the column names returned by your JDBC driver.
* Because different drivers might return column names in different
* cases, the property names seen by your application will vary
* depending on which JDBC driver you are using.</p>
*
* @param resultSet The result set to be wrapped
* @param lowerCase Should property names be lower cased?
*
* @exception NullPointerException if <code>resultSet</code>
* is <code>null</code>
* @exception GenericEntityException if the metadata for this result set
* cannot be introspected
*/
public GenericValueListDynaClass(List genericValueList, List fieldsToSelect, boolean lowerCase, int limit)
throws GenericEntityException {
if ((genericValueList == null) || (genericValueList.size() < 1)) {
throw new NullPointerException();
}
this.lowerCase = lowerCase;
this.limit = limit;
this.fieldsToSelect = fieldsToSelect;
introspect(genericValueList);
copy(genericValueList);
}
/**
* <p>Return a <code>List</code> containing the {@link DynaBean}s that
* represent the contents of each <code>Row</code> from the
* <code>ResultSet</code> that was the basis of this
* {@link RowSetDynaClass} instance. These {@link DynaBean}s are
* disconnected from the database itself, so there is no problem with
* modifying the contents of the list, or the values of the properties
* of these {@link DynaBean}s. However, it is the application's
* responsibility to persist any such changes back to the database,
* if it so desires.</p>
*/
public List getRows() {
return (this.rows);
}
// ------------------------------------------------------ Protected Methods
/**
* <p>Copy the column values for each row in the specified
* <code>ResultSet</code> into a newly created {@link DynaBean}, and add
* this bean to the list of {@link DynaBean}s that will later by
* returned by a call to <code>getRows()</code>.</p>
*
* @param resultSet The <code>ResultSet</code> whose data is to be
* copied
*
* @exception GenericEntityException if an error is encountered copying the data
*/
protected void copy(List genericValueList) throws GenericEntityException {
int cnt = 0;
Iterator gvlI = genericValueList.iterator();
while (gvlI.hasNext() && (limit < 0 || cnt++ < limit) ) {
GenericValue gv = (GenericValue) gvlI.next();
DynaBean bean = createDynaBean();
for (int i = 0; i < properties.length; i++) {
String name = properties[i].getName();
bean.set(name, gv.get(name));
}
rows.add(bean);
}
}
/**
* <p>Create and return a new {@link DynaBean} instance to be used for
* representing a row in the underlying result set.</p>
*/
protected DynaBean createDynaBean() {
return (new BasicDynaBean(this));
}
// ----------------------------------------------------- Instance Variables
/**
* <p>Flag defining whether column names should be lower cased when
* converted to property names.</p>
*/
protected boolean lowerCase = true;
/**
* <p>The set of dynamic properties that are part of this
* {@link DynaClass}.</p>
*/
protected DynaProperty properties[] = null;
/**
* <p>The set of dynamic properties that are part of this
* {@link DynaClass}, keyed by the property name. Individual descriptor
* instances will be the same instances as those in the
* <code>properties</code> list.</p>
*/
protected Map propertiesMap = new HashMap();
// ------------------------------------------------------ DynaClass Methods
/**
* <p>Return the name of this DynaClass (analogous to the
* <code>getName()</code> method of <code>java.lang.Class</code), which
* allows the same <code>DynaClass</code> implementation class to support
* different dynamic classes, with different sets of properties.</p>
*/
public String getName() {
return (this.getClass().getName());
}
/**
* <p>Return a property descriptor for the specified property, if it
* exists; otherwise, return <code>null</code>.</p>
*
* @param name Name of the dynamic property for which a descriptor
* is requested
*
* @exception IllegalArgumentException if no property name is specified
*/
public DynaProperty getDynaProperty(String name) {
if (name == null) {
throw new IllegalArgumentException("No property name specified");
}
return ((DynaProperty) propertiesMap.get(name));
}
/**
* <p>Return an array of <code>ProperyDescriptors</code> for the properties
* currently defined in this DynaClass. If no properties are defined, a
* zero-length array will be returned.</p>
*/
public DynaProperty[] getDynaProperties() {
return (properties);
}
/**
* <p>Instantiate and return a new DynaBean instance, associated
* with this DynaClass. <strong>NOTE</strong> - This operation is not
* supported, and throws an exception.</p>
*
* @exception IllegalAccessException if the Class or the appropriate
* constructor is not accessible
* @exception InstantiationException if this Class represents an abstract
* class, an array class, a primitive type, or void; or if instantiation
* fails for some other reason
*/
public DynaBean newInstance()
throws IllegalAccessException, InstantiationException {
throw new UnsupportedOperationException("newInstance() not supported");
}
/**
* <p>Loads and returns the <code>Class</code> of the given name.
* By default, a load from the thread context class loader is attempted.
* If there is no such class loader, the class loader used to load this
* class will be utilized.</p>
*
* @exception GenericEntityException if an exception was thrown trying to load
* the specified class
*/
protected Class loadClass(String className) throws GenericEntityException {
try {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
if (cl == null) {
cl = this.getClass().getClassLoader();
}
return (cl.loadClass(className));
} catch (Exception e) {
throw new GenericEntityException(
"Cannot load column class '" + className + "': " + e);
}
}
/**
* <p>Factory method to create a new DynaProperty for the given index
* into the result set metadata.</p>
*
* @param metadata is the result set metadata
* @param i is the column index in the metadata
* @return the newly created DynaProperty instance
*/
protected DynaProperty createDynaProperty(
GenericDelegator delegator,
ModelEntity modelEntity,
String fieldName)
throws GenericEntityException {
String name = null;
ModelField modelField = modelEntity.getField(fieldName);
ModelFieldType type = null;
try {
ModelEntity mainModelEntity = modelEntity;
if ( modelEntity.getEntityName().equals("DynamicViewEntity"))
mainModelEntity = ((ModelViewEntity) modelEntity).getMemberModelEntity(((ModelViewEntity) modelEntity).getAlias(0).getEntityAlias());
type = delegator.getEntityFieldType(mainModelEntity, modelField.getType());
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
if (type == null) throw new IllegalArgumentException("Type " + modelField.getType() + " not found");
String fieldType = type.getJavaType();
//modelField.get
if (lowerCase) {
name = modelField.getName().toLowerCase();
} else {
name = modelField.getName();
}
String className = null;
className = (String) fieldTypeMap.get(new Integer(SqlJdbcUtil.getType(fieldType)));
// Default to Object type if no class name could be retrieved
// from the metadata
Class clazz = Object.class;
if (className != null) {
clazz = loadClass(className);
}
return new DynaProperty(name, clazz);
}
/**
* <p>Introspect the metadata associated with our result set, and populate
* the <code>properties</code> and <code>propertiesMap</code> instance
* variables.</p>
*
* @param resultSet The <code>resultSet</code> whose metadata is to
* be introspected
*
* @exception GenericEntityException if an error is encountered processing the
* result set metadata
*/
protected void introspect(List genericValueList) throws GenericEntityException {
// Accumulate an ordered list of DynaProperties
ArrayList list = new ArrayList();
GenericValue genericValue = (GenericValue) genericValueList.get(0);
ModelEntity modelEntity = genericValue.getModelEntity();
List fieldNames = fieldsToSelect;
if ( fieldNames == null )
fieldNames = modelEntity.getAllFieldNames();
int n = fieldNames.size();
for (int i = 0; i < n; i++) {
DynaProperty dynaProperty = createDynaProperty(genericValue.getDelegator(), modelEntity, (String) fieldNames.get(i));
if (dynaProperty != null) {
list.add(dynaProperty);
}
}
// Convert this list into the internal data structures we need
properties =
(DynaProperty[]) list.toArray(new DynaProperty[list.size()]);
for (int i = 0; i < properties.length; i++) {
propertiesMap.put(properties[i].getName(), properties[i]);
}
}
protected static Map fieldTypeMap = new HashMap();
static {
fieldTypeMap.put(new Integer(1), "java.lang.String" );
fieldTypeMap.put(new Integer(2), "java.sql.Timestamp");
fieldTypeMap.put(new Integer(3), "java.sql.Time");
fieldTypeMap.put(new Integer(4), "java.sql.Date");
fieldTypeMap.put(new Integer(5), "java.lang.Integer");
fieldTypeMap.put(new Integer(6), "java.lang.Long");
fieldTypeMap.put(new Integer(7), "java.lang.Float");
fieldTypeMap.put(new Integer(8), "java.lang.Double");
fieldTypeMap.put(new Integer(9), "java.lang.Boolean");
fieldTypeMap.put(new Integer(10), "java.lang.Object");
}
}