Java tutorial
package org.apache.torque.map; /* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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. */ import java.io.Serializable; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Set; import java.util.StringTokenizer; import org.apache.commons.lang.StringUtils; import org.apache.torque.Database; import org.apache.torque.Torque; import org.apache.torque.TorqueException; import org.apache.torque.adapter.IDMethod; /** * TableMap is used to model a table in a database. * * @author <a href="mailto:jmcnally@collab.net">John D. McNally</a> * @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a> * @author <a href="mailto:greg.monroe@dukece.com">Greg Monroe</a> * @version $Id: TableMap.java 1405645 2012-11-04 21:57:18Z tfischer $ */ public class TableMap implements Serializable { /** * Serial version. */ private static final long serialVersionUID = 1L; /** The dot String. */ private static final String DOT = "."; /** The columns in the table. XML Order is preserved. */ private final Map<String, ColumnMap> columns = Collections .synchronizedMap(new LinkedHashMap<String, ColumnMap>()); /** The foreign keys in the table. XML Order is preserved. */ private final List<ForeignKeyMap> foreignKeys = new ArrayList<ForeignKeyMap>(); /** The database this table belongs to. */ private DatabaseMap dbMap; /** The name of the table. */ private String tableName; /** * The name of the schema to which this table belongs, * or null for the default schema. */ private String schemaName; /** The JavaName of the table as defined in XML */ private String javaName; /** The prefix on the table name. */ private String prefix; /** The primary key generation method. */ private IDMethod primaryKeyMethod = IDMethod.NO_ID_METHOD; /** The table description info. */ private String description = ""; /** The Peer Class for this table. */ private Class<?> peerClass; /** The OM Root Class for this table. */ private Class<?> omClass; /** Whether any column uses Inheritance. */ private boolean useInheritance = false; /** Whether cache managers are used. */ private boolean useManager = false; /** The associated cache manager class. */ private Class<?> managerClass; /** Overrides the information stored in the pkInfoMap for all id methods. */ private Object pkInfoOverride; /** * Stores information that is needed for generating primary keys. * The information is keyed by the idMethodType because it might be * different for different id methods. */ private final Map<IDMethod, Object> pkInfoMap = new HashMap<IDMethod, Object>(); /** Associated options. */ private final Map<String, String> optionsMap = Collections.synchronizedMap(new LinkedHashMap<String, String>()); /** * Constructor. * * @param tableName The name of the table, may be prefixed with a * schema name, not null. * @param containingDB A DatabaseMap that this table belongs to. */ public TableMap(String tableName, DatabaseMap containingDB) { setTableName(tableName); dbMap = containingDB; } /** * Constructor. * * @param tableName The name of the table, may be prefixed with a * schema name, not null. * @param prefix The prefix for the table name (ie: SCARAB for * SCARAB_PROJECT). * @param containingDB A DatabaseMap that this table belongs to. */ public TableMap(String tableName, String prefix, DatabaseMap containingDB) { setTableName(tableName); this.prefix = prefix; dbMap = containingDB; } private void setTableName(String tableName) { if (tableName == null) { throw new NullPointerException("tableName must not be null"); } int dotIndex = tableName.indexOf(DOT); if (dotIndex != -1) { this.schemaName = tableName.substring(0, dotIndex); this.tableName = tableName.substring(dotIndex + 1); } else { this.tableName = tableName; } } /** * Sets the database map this table belongs to. * @param databaseMap */ void setDatabaseMap(DatabaseMap databaseMap) { dbMap = databaseMap; } /** * Does this table contain the specified column? * * @param column A ColumnMap. * @return True if the table contains the column. */ public boolean containsColumn(ColumnMap column) { return containsColumn(column.getColumnName()); } /** * Does this table contain the specified column? * * @param name A String with the name of the column. * @return True if the table contains the column. */ public boolean containsColumn(String name) { if (name.indexOf('.') > 0) { name = name.substring(name.indexOf('.') + 1); } return columns.containsKey(name); } /** * Get the DatabaseMap containing this TableMap. * * @return A DatabaseMap. */ public DatabaseMap getDatabaseMap() { return dbMap; } /** * Returns true if this tableMap contains a column with object * data. If the type of the column is not a string, a number or a * date, it is assumed that it is object data. * * @return True if map contains a column with object data. */ public boolean containsObjectColumn() { synchronized (columns) { Iterator<ColumnMap> it = columns.values().iterator(); while (it.hasNext()) { Object theType = it.next().getType(); if (!(theType instanceof String || theType instanceof Number || theType instanceof java.util.Date)) { return true; } } } return false; } /** * Get the name of the Table, not prefixed by a possible schema name * * @return A String with the name of the table, not null. */ public String getName() { return tableName; } /** * Get the schema to which the table belongs to. * * @return the schema name, or null if the default schema should be used. */ public String getSchemaName() { return schemaName; } /** * Returns the fully qualified table name, if available. * * @return the fully qualified table name, if a schema is set, * or just the table name if no schema is set, not null. */ public String getFullyQualifiedTableName() { if (!StringUtils.isEmpty(schemaName)) { return schemaName + DOT + tableName; } return tableName; } /** * Get the Java name of the table as defined in XML. * * @return A String with the Java name of the table. */ public String getJavaName() { return javaName; } /** * Set the Java name of the table as defined by generator/XML. * * @param value A String with the Java name of the table. */ public void setJavaName(String value) { this.javaName = value; } /** * Get table prefix name. * * @return A String with the prefix. */ public String getPrefix() { return this.prefix; } /** * Set table prefix name. * * @param prefix The prefix for the table name (ie: SCARAB for * SCARAB_PROJECT). */ public void setPrefix(String prefix) { this.prefix = prefix; } /** * Get the method used to generate primary keys for this table. * * @return A String with the method. */ public IDMethod getPrimaryKeyMethod() { return primaryKeyMethod; } /** * Get the information used to generate a primary key * * @return An Object. */ public Object getPrimaryKeyMethodInfo(IDMethod idMethod) { if (pkInfoOverride != null) { return pkInfoOverride; } return pkInfoMap.get(idMethod); } /** * Get a ColumnMap[] of the columns in this table. * * @return A ColumnMap[]. */ public ColumnMap[] getColumns() { ColumnMap[] tableColumns = new ColumnMap[columns.size()]; synchronized (columns) { Iterator<ColumnMap> it = columns.values().iterator(); int i = 0; while (it.hasNext()) { tableColumns[i++] = it.next(); } } return tableColumns; } /** * Get all foreign keys in the table.. * * @return All foreign keys, not null. */ public List<ForeignKeyMap> getForeignKeys() { return Collections.unmodifiableList(foreignKeys); } /** * Get a ColumnMap for the named table. * * @param name A String with the name of the table. * @return A ColumnMap. */ public ColumnMap getColumn(String name) { try { return columns.get(name); } catch (Exception e) { return null; } } /** * Add a pre-created column to this table. It will replace any * existing column. * * @param cmap A ColumnMap. */ public void addColumn(ColumnMap cmap) { columns.put(cmap.getColumnName(), cmap); } /** * Add a foreign key to this table. * * @param foreignKey the foreign key map, not null */ public void addForeignKey(ForeignKeyMap foreignKey) { foreignKeys.add(foreignKey); } /** * Sets the method used to generate a key for this table. Valid * values are as specified in the {@link * org.apache.torque.adapter.IDMethod} interface. * * @param method The ID generation method type, not null. */ public void setPrimaryKeyMethod(IDMethod method) { if (method == null) { throw new NullPointerException("method must not be null"); } primaryKeyMethod = method; if (IDMethod.ID_BROKER == method) { Database database = Torque.getOrCreateDatabase(getDatabaseMap().getName()); database.createAndRegisterIdBroker(); } } /** * Sets the pk information needed to generate a key. * This overrides all information set by * <code>setPrimaryKeyMethodInfo(String, Object)</code>. * * @param pkInfo information needed to generate a key */ public void setPrimaryKeyMethodInfo(Object pkInfo) { pkInfoOverride = pkInfo; } /** * Sets the pk information needed to generate a key. * * @param idMethod the id method for which this information is stored. * @param pkInfo information needed to generate a key. */ public void setPrimaryKeyMethodInfo(IDMethod idMethod, Object pkInfo) { pkInfoMap.put(idMethod, pkInfo); } //---Utility methods for doing intelligent lookup of table names /** * Tell me if i have PREFIX in my string. * * @param data A String. * @return True if prefix is contained in data. */ private boolean hasPrefix(String data) { return (data.indexOf(getPrefix()) != -1); } /** * Removes the PREFIX. * * @param data A String. * @return A String with data, but with prefix removed. */ private String removePrefix(String data) { return data.substring(getPrefix().length()); } /** * Removes the PREFIX, removes the underscores and makes * first letter caps. * * SCARAB_FOO_BAR becomes FooBar. * * @param data A String. * @return A String with data processed. */ public final String removeUnderScores(String data) { String tmp = null; StringBuffer out = new StringBuffer(); if (hasPrefix(data)) { tmp = removePrefix(data); } else { tmp = data; } StringTokenizer st = new StringTokenizer(tmp, "_"); while (st.hasMoreTokens()) { String element = ((String) st.nextElement()).toLowerCase(); out.append(StringUtils.capitalize(element)); } return out.toString(); } /** * Returns the table description info. * * @return Returns the description. */ public String getDescription() { return description; } /** * Sets the table description. * * @param description The description to set. */ public void setDescription(String description) { this.description = description; } /** * Returns the OM class for this table. * * @return the OM class. */ public Class<?> getOMClass() { return omClass; } /** * Sets the OM root class for this table. * * @param omClass The OM root class for this table. */ public void setOMClass(Class<?> omClass) { this.omClass = omClass; } /** * Returns the Peer Class for this table. * * @return The peerClass for this table. */ public Class<?> getPeerClass() { return peerClass; } /** * Sets the Peer class for this table. * * @param peerClass The peerClass to set. */ public void setPeerClass(Class<?> peerClass) { this.peerClass = peerClass; } /** * Returns the database map for this table. * * @return the database map for this table. */ public DatabaseMap getDbMap() { return dbMap; } /** * Returns whether this table uses inheritance. * * @return whether inheritance is used. */ public boolean isUseInheritance() { return useInheritance; } /** * Sets whether this table uses inheritance. * * @param useInheritance whether this table uses inheritance. */ public void setUseInheritance(boolean useInheritance) { this.useInheritance = useInheritance; } /** * Returns whether managers are used for this table. * * @return whether managers are used for this table. */ public boolean isUseManager() { return useManager; } /** * Sets whether managers are used for this table. * * @param useManager whether managers are used for this table. */ public void setUseManager(boolean useManager) { this.useManager = useManager; } /** * Returns the manager class for this table. * * @return the managerClass. */ public Class<?> getManagerClass() { return managerClass; } /** * Sets the manager class for this table. * * @param managerClass the manager class for this table. */ public void setManagerClass(Class<?> managerClass) { this.managerClass = managerClass; } /** * Returns an unmodifiable map of all options. * * @return A map containing all options, not null. */ public Map<String, String> getOptions() { return Collections.unmodifiableMap(optionsMap); } /** * Sets an option. * * @param key the key of the option * @param value the value of the option. */ public void setOption(String key, String value) { optionsMap.put(key, value); } /** * Returns the value of an option. * * @param key the key of the option. * * @return the value of the option, or null if not set. */ public String getOption(String key) { return optionsMap.get(key); } /** * Returns the single primary key of this table, if it exists * * @return the single primary key column. * * @throws TorqueException If the table has no primary key * or if the table has multiple primary keys. */ public ColumnMap getPrimaryKey() throws TorqueException { Set<ColumnMap> result = new HashSet<ColumnMap>(); for (ColumnMap column : columns.values()) { if (column.isPrimaryKey()) { result.add(column); } } if (result.isEmpty()) { throw new TorqueException("getPrimaryKey(): Table " + tableName + " has no primary key."); } if (result.size() > 1) { throw new TorqueException("getPrimaryKey(): Table " + tableName + " has more than one primary key."); } return result.iterator().next(); } @Override public String toString() { return "TableMap[" + tableName + "]"; } }