Java tutorial
package org.apache.torque; /* * 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 org.apache.commons.lang.StringUtils; import org.apache.commons.lang.builder.EqualsBuilder; import org.apache.commons.lang.builder.HashCodeBuilder; /** * An implementation of the column interface. * This class is immutable, i.e cannot be changed once constructed. * * @version $Id: ColumnImpl.java 1448414 2013-02-20 21:06:35Z tfischer $ */ public class ColumnImpl implements Column, Serializable { /** Serial version uid. **/ private static final long serialVersionUID = 1L; /** Delimiters for SQL functions. */ private static final String[] FUNCTION_DELIMITERS = { " ", ",", "(", ")", "<", ">" }; /** Constant for the dot. */ private static final String DOT = "."; /** The column name, may be null but not empty. */ private String columnName; /** The table name, may be null but not empty. */ private String tableName; /** The schema name, may be null but not empty. */ private String schemaName; /** The SQL expression for the column, not null. */ private String sqlExpression; /** * Constructor. * * @param tableName the table name, not null or blank. * @param columnName the column name, not null or blank. * * @throws NullPointerException if columnName or tableName are null. * @throws IllegalArgumentException if columnName or tableName are blank. */ public ColumnImpl(String tableName, String columnName) { if (columnName == null) { throw new NullPointerException("columnName must not be null"); } if (tableName == null) { throw new NullPointerException("tableName must not be null"); } setColumnName(columnName); setTableName(tableName); this.sqlExpression = tableName + DOT + columnName; } /** * Constructor. * * @param schemaName the schema name, may be null but not blank. * @param tableName the table name, may be null but not blank. * If it contains a dot, then only the portion after the dot * will be taken as table name. * If it contains a dot and schemaName is null, then the schema * name will be set as the portion before the dot. * @param columnName the column name, not null or blank. * * @throws NullPointerException if columnName or tableName are null. * @throws IllegalArgumentException if columnName or tableName are blank. */ public ColumnImpl(String schemaName, String tableName, String columnName) { if (columnName == null) { throw new NullPointerException("columnName must not be null"); } setColumnName(columnName); setTableName(tableName); setSchemaName(schemaName); if (this.tableName == null) { this.sqlExpression = this.columnName; } else { this.sqlExpression = this.tableName + DOT + this.columnName; } } /** * Constructor. * * @param schemaName the schema name, may be null but not blank. * @param tableName the table name, may be null but not blank. * If it contains a dot, then only the portion after the dot * will be taken as table name. * If it contains a dot and schemaName is null, then the schema * name will be set as the portion before the dot. * @param columnName the column name, may be null but not blank. * @param sqlExpression the SQL expression for the column, * not null or blank. * * @throws NullPointerException if tableName or sqlExpression are null. * @throws IllegalArgumentException if tableName or sqlExpression are blank. */ public ColumnImpl(String schemaName, String tableName, String columnName, String sqlExpression) { setColumnName(columnName); setTableName(tableName); setSchemaName(schemaName); setSqlExpression(sqlExpression); } /** * Constructor which tries to guess schema, table and column names from * an SQL expression. If a schema name can be identified in the * SQL expression, it is removed from the SQL expression in the column. * * @param sqlExpression the SQL expression, not null, not blank. * * @throws NullPointerException if sqlExpression is null. * @throws IllegalArgumentException if table or column name cannot be * guessed from sqlExpression. */ public ColumnImpl(String sqlExpression) { setSqlExpression(sqlExpression); // Find Table.Column int dotIndex = sqlExpression.lastIndexOf(DOT); if (dotIndex == -1) { if (StringUtils.contains(sqlExpression, "*")) { return; } if (StringUtils.indexOfAny(sqlExpression, FUNCTION_DELIMITERS) != -1) { throw new IllegalArgumentException("sqlExpression " + sqlExpression + " is unparseable, it does not contain a dot (.) " + " but function delimiters."); } setColumnName(sqlExpression); return; } String pre = sqlExpression.substring(0, dotIndex); String post = sqlExpression.substring(dotIndex + 1, sqlExpression.length()); if (StringUtils.isBlank(pre)) { throw new IllegalArgumentException("sqlExpression " + sqlExpression + " is blank before the dot (.)"); } int startIndex = StringUtils.lastIndexOfAny(pre, FUNCTION_DELIMITERS); int endIndex = StringUtils.indexOfAny(post, FUNCTION_DELIMITERS); if (endIndex < 0) { endIndex = sqlExpression.length(); } else { // relative to sqlExpression not to post endIndex += dotIndex + 1; } if (startIndex + 1 == dotIndex) { throw new IllegalArgumentException( "sqlExpression " + sqlExpression + " is blank between the last function delimiter (" + StringUtils.join(FUNCTION_DELIMITERS) + ") and the dot"); } setColumnName(sqlExpression.substring(dotIndex + 1, endIndex)); // if startIndex == -1 the formula is correct String fullTableName = sqlExpression.substring(startIndex + 1, dotIndex); setTableName(fullTableName); if (fullTableName.contains(DOT)) { int fullTableNameDotIndex = fullTableName.lastIndexOf(DOT); String extractedSchemaName = fullTableName.substring(0, fullTableNameDotIndex); setSchemaName(extractedSchemaName); StringBuilder sqlExpressionBuilder = new StringBuilder(); if (startIndex != -1) { sqlExpressionBuilder.append(sqlExpression.substring(0, startIndex + 1)); } sqlExpressionBuilder.append(getTableName()).append(DOT).append(post); setSqlExpression(sqlExpressionBuilder.toString()); } } /** * Returns the column name. * * @return the column name, may be null. */ public String getColumnName() { return columnName; } /** * Sets the column name, using null if * is passed. * * @param columnName the column name, not blank. */ private void setColumnName(String columnName) { if (columnName != null && StringUtils.isBlank(columnName)) { throw new IllegalArgumentException("columnName must not be blank"); } if ("*".equals(columnName)) { this.columnName = null; } else { this.columnName = columnName; } } /** * Returns the table name. * * @return the table name, may be null. */ public String getTableName() { return tableName; } /** * {@inheritDoc} */ public String getFullTableName() { if (schemaName != null) { return schemaName + '.' + tableName; } return tableName; } /** * Sets the table name. * If a table name with schema prefix is passed, then the unqualified table * name is used as table name and the schema name will be set to the * extracted schema name. * * @param tableName the table name, not blank, may be null. * * @throws IllegalArgumentException if tableName is blank or null. */ private void setTableName(String tableName) { if (tableName != null && StringUtils.isBlank(tableName)) { throw new IllegalArgumentException("tableName must not be blank"); } if (StringUtils.contains(tableName, DOT)) { int dotIndex = tableName.lastIndexOf(DOT); this.schemaName = tableName.substring(0, dotIndex); this.tableName = tableName.substring(dotIndex + 1); return; } this.tableName = tableName; } /** * Returns the name of any fixed schema prefix for the column's table * (if any). * * @return the schema name, or null if the schema is not known. */ public String getSchemaName() { return schemaName; } /** * Sets the schema name, if a non-null value is passed. * * @param schemaName the schema name, or null. * * @throws IllegalArgumentException if schemaName is blank. */ private void setSchemaName(String schemaName) { if (schemaName == null) { return; } if (StringUtils.isBlank(schemaName)) { throw new IllegalArgumentException("schemaName must not be blank"); } this.schemaName = schemaName; } /** * {@inheritDoc} */ public String getSqlExpression() { return sqlExpression; } /** * Sets the sql expression. * * @param sqlExpression the sql expression, not null. * * @throws NullPointerException if sqlExpression is null. * @throws IllegalArgumentException if sqlExpression is blank. */ private void setSqlExpression(String sqlExpression) { if (sqlExpression == null) { throw new IllegalArgumentException("sqlExpression must not be null"); } if (StringUtils.isBlank(sqlExpression)) { throw new IllegalArgumentException("sqlExpression must not be blank"); } this.sqlExpression = sqlExpression; } @Override public int hashCode() { return new HashCodeBuilder().append(sqlExpression).append(columnName).append(tableName).append(schemaName) .toHashCode(); } @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } ColumnImpl other = (ColumnImpl) obj; return new EqualsBuilder().append(sqlExpression, other.sqlExpression).append(columnName, other.columnName) .append(tableName, other.tableName).append(schemaName, other.schemaName).isEquals(); } @Override public String toString() { return "ColumnImpl [columnName=" + columnName + ", tableName=" + tableName + ", schemaName=" + schemaName + ", sqlExpression=" + sqlExpression + "]"; } }