001: /**********************************************************************
002: Copyright (c) 2007 Andy Jefferson and others. All rights reserved.
003: Licensed under the Apache License, Version 2.0 (the "License");
004: you may not use this file except in compliance with the License.
005: You may obtain a copy of the License at
006:
007: http://www.apache.org/licenses/LICENSE-2.0
008:
009: Unless required by applicable law or agreed to in writing, software
010: distributed under the License is distributed on an "AS IS" BASIS,
011: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
012: See the License for the specific language governing permissions and
013: limitations under the License.
014:
015: Contributors:
016: ...
017: **********************************************************************/package org.jpox.metadata;
018:
019: import java.util.ArrayList;
020: import java.util.HashMap;
021: import java.util.Iterator;
022: import java.util.List;
023: import java.util.Map;
024:
025: import org.jpox.util.StringUtils;
026:
027: /**
028: * Representation of the mapping of (SQL) Query results into a desired output form.
029: * The results of a (SQL) query can be mapped into a mixture of
030: * <ul>
031: * <li>instances of persistent classes - mapping from the result columns to the persistent fields</li>
032: * <li>scalar values - names of result columns that are returned as scalars (Integer, String etc)</li>
033: * </ul>
034: * @version $Revision: 1.5 $
035: */
036: public class QueryResultMetaData extends MetaData {
037: /** Name of the query result mapping. */
038: protected final String name;
039:
040: /** Collection of mappings of persistent types returned from the result set. */
041: protected List persistentTypeMappings;
042:
043: /** Collection of column names in the result set that are returned as scalars. */
044: protected List scalarColumns;
045:
046: /**
047: * Constructor.
048: * @param parent the parent of the Query
049: * @param name The Query name
050: */
051: public QueryResultMetaData(final MetaData parent, final String name) {
052: super (parent);
053:
054: this .name = name;
055: }
056:
057: /**
058: * Accessor for the name of the result mapping.
059: * @return Name of the mapping
060: */
061: public String getName() {
062: return name;
063: }
064:
065: /**
066: * Method to add a persistent type as an output for the mapping.
067: * @param className Name of the persistent type
068: * @param fieldColumnMap Map of column name, keyed by the field name in the persistent type
069: * @param discrimColumn Name of any discriminator column
070: */
071: public void addPersistentTypeMapping(String className,
072: Map fieldColumnMap, String discrimColumn) {
073: if (persistentTypeMappings == null) {
074: persistentTypeMappings = new ArrayList();
075: }
076: PersistentTypeMapping m = new PersistentTypeMapping();
077: m.className = className;
078: m.discriminatorColumn = (StringUtils
079: .isWhitespace(discrimColumn) ? null : discrimColumn);
080: m.fieldColumnMap = fieldColumnMap;
081: persistentTypeMappings.add(m);
082: }
083:
084: /**
085: * Method to add a mapping for the specified persistent class.
086: * @param className Name of the persistent class
087: * @param fieldName Field in the persistent class
088: * @param columnName Name of the column in the result set to map to this field
089: */
090: public void addMappingForPersistentTypeMapping(String className,
091: String fieldName, String columnName) {
092: PersistentTypeMapping m = null;
093: if (persistentTypeMappings == null) {
094: persistentTypeMappings = new ArrayList();
095: } else {
096: Iterator iter = persistentTypeMappings.iterator();
097: while (iter.hasNext()) {
098: PersistentTypeMapping mapping = (PersistentTypeMapping) iter
099: .next();
100: if (mapping.className.equals(className)) {
101: m = mapping;
102: break;
103: }
104: }
105: }
106: if (m == null) {
107: m = new PersistentTypeMapping();
108: m.className = className;
109: }
110: if (m.fieldColumnMap == null) {
111: m.fieldColumnMap = new HashMap();
112: }
113: // Add the field/column pair
114: m.fieldColumnMap.put(fieldName, columnName);
115: }
116:
117: /**
118: * Class to wrap the mapping for a persistent type.
119: *
120: * @version $Revision: 1.5 $
121: */
122: public class PersistentTypeMapping {
123: String className;
124: Map fieldColumnMap;
125: String discriminatorColumn;
126:
127: public String getClassName() {
128: return className;
129: }
130:
131: public String getDiscriminatorColumn() {
132: return discriminatorColumn;
133: }
134:
135: public String getColumnForField(String fieldName) {
136: if (fieldColumnMap == null) {
137: return null;
138: }
139: return (String) fieldColumnMap.get(fieldName);
140: }
141: }
142:
143: /**
144: * Method to register a column as being scalar.
145: * @param columnName Name of the column
146: */
147: public void addScalarColumn(String columnName) {
148: if (scalarColumns == null) {
149: scalarColumns = new ArrayList();
150: }
151: scalarColumns.add(columnName);
152: }
153:
154: /**
155: * Accessor for the persistent type mapping information for this result set.
156: * @return Array of persistent types and their mapping info
157: */
158: public PersistentTypeMapping[] getPersistentTypeMappings() {
159: if (persistentTypeMappings == null) {
160: return null;
161: }
162: return (PersistentTypeMapping[]) persistentTypeMappings
163: .toArray(new PersistentTypeMapping[persistentTypeMappings
164: .size()]);
165: }
166:
167: /**
168: * Accessor for the names of the result set columns that are returned as scalars.
169: * @return Column names whose values are returned as scalars
170: */
171: public String[] getScalarColumns() {
172: if (scalarColumns == null) {
173: return null;
174: }
175: return (String[]) scalarColumns
176: .toArray(new String[scalarColumns.size()]);
177: }
178: }
|