jodd.db.oom.sqlgen.chunks.ColumnsSelectChunk Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jodd-db Show documentation
Jodd DB is efficient and thin database facade; DbOom is convenient database object mapper.
There is a newer version: 6.0.0
// Copyright (c) 2003-2012, Jodd Team (jodd.org). All Rights Reserved.

package jodd.db.oom.sqlgen.chunks;

import jodd.db.oom.ColumnAliasType;
import jodd.db.oom.DbEntityDescriptor;
import jodd.db.oom.DbEntityColumnDescriptor;
import jodd.db.oom.sqlgen.DbSqlBuilderException;
import jodd.db.oom.sqlgen.TemplateData;
import jodd.util.StringPool;

/**
 * Columns select chunk resolves entity column(s) from column references. Should be used for SELECT queries.
 * 
 * Column reference is specified as: {@link TableChunk tableReference}.propertyName where property name is
 * a property of the entity references by table reference. Result is rendered as:
 * tableName.column or alias.column (if table has an alias).
 * 

 * There are some special values for propertyName
 * 
 * wildcard (*), all table columns will be listed
 * id sign (+), all table id columns will be listed
 * 
 * If previous chunk is also a column chunk, comma separator will be added in between.
 * 

 * Note that column alias are appended to the column name (using 'as' construct).
 * 

 * Macro rules:
 * 

 * $C{tableRef} is rendered as FOO.col1, FOO.col2,...
 * $C{tableRef.*} is equal to above, renders all entity columns
 * $C{tableRef.+} renders to only identity columns
 * $C{tableRef.colRef} is rendered as FOO.column
 * $C{entityRef.colRef} renders to FOO$column
 * $C{hint.entityRef...} defines a hint
 * $C{hint:entityRef...} defines a hint with custom name
 * $C{.columName} renders as column name
 * $C{hint:.columName} renders as column name and defines its hint
 * 
 */
public class ColumnsSelectChunk extends SqlChunk {

	private static final String AS = " as ";

	protected final String tableRef;
	protected final String columnRef;
	protected final int includeColumns;
	protected final String hint;

	protected ColumnsSelectChunk(String tableRef, String columnRef, int includeColumns, String hint) {
		super(CHUNK_SELECT_COLUMNS);
		this.tableRef = tableRef;
		this.columnRef = columnRef;
		this.includeColumns = includeColumns;
		this.hint = hint;
	}

	public ColumnsSelectChunk(String tableRef, String columnRef) {
		this(tableRef, columnRef, COLS_NA, null);
	}

	public ColumnsSelectChunk(String tableRef, boolean includeAll) {
		this(tableRef, null, includeAll == true ? COLS_ALL : COLS_ONLY_IDS, null);
	}

	public ColumnsSelectChunk(String reference) {
		super(CHUNK_SELECT_COLUMNS);
		reference = reference.trim();
		int dotNdx = reference.lastIndexOf('.');
		if (dotNdx == -1) {
			this.tableRef = reference;
			this.columnRef = null;
			this.includeColumns = COLS_ALL;
			this.hint = null;
		} else {

			String tref = reference.substring(0, dotNdx);
			reference = reference.substring(dotNdx + 1);

			// table
			dotNdx = tref.lastIndexOf('.');
			if (dotNdx == -1) {
				this.tableRef = tref;
				this.hint = null;
			} else {
				int doubleColumnNdx = tref.indexOf(':');
				if (doubleColumnNdx == -1) {
					// no special hint
					this.tableRef = tref.substring(dotNdx + 1);
					this.hint = tref;
				} else {
					// hint is different
					this.tableRef = tref.substring(doubleColumnNdx + 1);
					this.hint = tref.substring(0, doubleColumnNdx);
				}
			}

			// column
			if (reference.equals(StringPool.STAR)) {
				this.columnRef = null;
				this.includeColumns = COLS_ALL;
			} else if (reference.equals(StringPool.PLUS)) {
				this.columnRef = null;
				this.includeColumns = COLS_ONLY_IDS;
			} else {
				this.columnRef = reference;
				this.includeColumns = COLS_NA;
			}
		}
	}

	// ---------------------------------------------------------------- process


	/**
	 * Counts actual real hints.
	 */
	@Override
	public void init(TemplateData templateData) {
		super.init(templateData);
		if (hint != null) {
			templateData.incrementHintsCount();
		}
	}

	@Override
	public void process(StringBuilder out) {
		// hints
		if (templateData.hasHints()) {
			templateData.registerHint(hint == null ? tableRef : hint);
		}

		// columns
		separateByCommaOrSpace(out);

		// special case, only column name, no table ref/name
		if (tableRef.length() == 0) {
			out.append(columnRef);
			return;
		}

		boolean useTableReference = true;
		DbEntityDescriptor ded = lookupTableRef(tableRef, false);
		if (ded == null) {
			useTableReference = false;
			ded = lookupName(tableRef);
		}

		if (columnRef == null) {
			DbEntityColumnDescriptor[] decList = ded.getColumnDescriptors();
			int count = 0;
			for (DbEntityColumnDescriptor dec : decList) {
				if ((includeColumns == COLS_ONLY_IDS) && (dec.isId() == false)) {
					continue;
				}
				if (count > 0) {
					out.append(',').append(' ');
				}
				templateData.lastColumnDec = dec;

				if (useTableReference) {
					appendColumnName(out, ded, dec.getColumnName());
				} else {
					appendAlias(out, ded, dec.getColumnName());
				}
				count++;
			}
		} else {
			DbEntityColumnDescriptor dec = ded.findByPropertyName(columnRef);
			templateData.lastColumnDec = dec;
			String columnName = dec == null ? null : dec.getColumnName();
			//String columnName = ded.getColumnName(columnRef);
			if (columnName == null) {
				throw new DbSqlBuilderException("Unable to resolve column reference: " + tableRef + '.' + columnRef);
			}
			if (useTableReference) {
				appendColumnName(out, ded, columnName);
			} else {
				appendAlias(out, ded, columnName);
			}
		}
	}

	/**
	 * Appends alias.
	 */
	protected void appendAlias(StringBuilder query, DbEntityDescriptor ded, String column) {
		String tableName = ded.getTableName();

		ColumnAliasType columnAliasType = templateData.getColumnAliasType();
		String columnAliasSeparator = templateData.getDbOomManager().getColumnAliasSeparator();

		if (columnAliasType == null || columnAliasType == ColumnAliasType.TABLE_REFERENCE) {
			templateData.registerColumnDataForTableRef(tableRef, tableName);
			query.append(tableRef).append(columnAliasSeparator).append(column);
		} else
		if (columnAliasType == ColumnAliasType.COLUMN_CODE) {
			String code = templateData.registerColumnDataForColumnCode(tableName, column);
			query.append(code);
		} else
		if (columnAliasType == ColumnAliasType.TABLE_NAME) {
			query.append(tableName).append(columnAliasSeparator).append(column);
		}
	}

	/**
	 * Simply appends column name with optional table reference and alias.
	 */
	protected void appendColumnName(StringBuilder query, DbEntityDescriptor ded, String column) {
		query.append(resolveTable(tableRef, ded)).append('.').append(column);
		
		if (templateData.getColumnAliasType() != null) {     // create column aliases
			String tableName = ded.getTableName();
			query.append(AS);
			switch (templateData.getColumnAliasType()) {
				case TABLE_NAME:
					query.append(tableName).append(templateData.getDbOomManager().getColumnAliasSeparator()).append(column);
					break;
				case TABLE_REFERENCE:
					templateData.registerColumnDataForTableRef(tableRef, tableName);
					query.append(tableRef).append(templateData.getDbOomManager().getColumnAliasSeparator()).append(column);
					break;
				case COLUMN_CODE:
					String code = templateData.registerColumnDataForColumnCode(tableName, column);
					query.append(code);
					break;
			}
		}
	}

	// ---------------------------------------------------------------- clone

	@Override
	public SqlChunk clone() {
		return new ColumnsSelectChunk(tableRef, columnRef, includeColumns, hint);
	}
}