path: root/src/com/iciql/TableDefinition.java

/*
 * Copyright 2004-2011 H2 Group.
 * Copyright 2011 James Moger.
 *
 * 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.iciql;

import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;

import com.iciql.Iciql.EnumId;
import com.iciql.Iciql.EnumType;
import com.iciql.Iciql.IQColumn;
import com.iciql.Iciql.IQEnum;
import com.iciql.Iciql.IQIgnore;
import com.iciql.Iciql.IQIndex;
import com.iciql.Iciql.IQIndexes;
import com.iciql.Iciql.IQSchema;
import com.iciql.Iciql.IQTable;
import com.iciql.Iciql.IQVersion;
import com.iciql.Iciql.IndexType;
import com.iciql.util.IciqlLogger;
import com.iciql.util.StatementBuilder;
import com.iciql.util.StringUtils;
import com.iciql.util.Utils;

/**
 * A table definition contains the index definitions of a table, the field
 * definitions, the table name, and other meta data.
 * 
 * @param <T>
 *            the table type
 */

public class TableDefinition<T> {

	/**
	 * The meta data of an index.
	 */

	public static class IndexDefinition {
		public IndexType type;
		public String indexName;

		public List<String> columnNames;
	}

	/**
	 * The meta data of a field.
	 */

	static class FieldDefinition {
		String columnName;
		Field field;
		String dataType;
		int length;
		int scale;
		boolean isPrimaryKey;
		boolean isAutoIncrement;
		boolean trim;
		boolean nullable;
		String defaultValue;
		EnumType enumType;
		boolean isPrimitive;

		Object getValue(Object obj) {
			try {
				return field.get(obj);
			} catch (Exception e) {
				throw new IciqlException(e);
			}
		}

		private Object initWithNewObject(Object obj) {
			Object o = Utils.newObject(field.getType());
			setValue(obj, o);
			return o;
		}

		private void setValue(Object obj, Object o) {
			try {
				if (!field.isAccessible()) {
					field.setAccessible(true);
				}
				Class<?> targetType = field.getType();
				if (targetType.isEnum()) {
					o = Utils.convertEnum(o, targetType, enumType);
				} else {
					o = Utils.convert(o, targetType);
				}
				field.set(obj, o);
			} catch (IciqlException e) {
				throw e;
			} catch (Exception e) {
				throw new IciqlException(e);
			}
		}

		private Object read(ResultSet rs, int columnIndex) {
			try {
				return rs.getObject(columnIndex);
			} catch (SQLException e) {
				throw new IciqlException(e);
			}
		}
	}

	public ArrayList<FieldDefinition> fields = Utils.newArrayList();
	String schemaName;
	String tableName;
	int tableVersion;
	List<String> primaryKeyColumnNames;
	boolean memoryTable;
	boolean multiplePrimitiveBools;

	private boolean createIfRequired = true;
	private Class<T> clazz;
	private IdentityHashMap<Object, FieldDefinition> fieldMap = Utils.newIdentityHashMap();
	private ArrayList<IndexDefinition> indexes = Utils.newArrayList();

	TableDefinition(Class<T> clazz) {
		this.clazz = clazz;
		schemaName = null;
		tableName = clazz.getSimpleName();
	}

	Class<T> getModelClass() {
		return clazz;
	}

	List<FieldDefinition> getFields() {
		return fields;
	}

	void defineSchemaName(String schemaName) {
		this.schemaName = schemaName;
	}

	void defineTableName(String tableName) {
		this.tableName = tableName;
	}

	void defineMemoryTable() {
		this.memoryTable = true;
	}

	void defineSkipCreate() {
		this.createIfRequired = false;
	}

	/**
	 * Define a primary key by the specified model fields.
	 * 
	 * @param modelFields
	 *            the ordered list of model fields
	 */
	void definePrimaryKey(Object[] modelFields) {
		List<String> columnNames = mapColumnNames(modelFields);
		setPrimaryKey(columnNames);
	}

	/**
	 * Define a primary key by the specified column names.
	 * 
	 * @param columnNames
	 *            the ordered list of column names
	 */
	private void setPrimaryKey(List<String> columnNames) {
		primaryKeyColumnNames = Utils.newArrayList(columnNames);
		// set isPrimaryKey flag for all field definitions
		for (FieldDefinition fieldDefinition : fieldMap.values()) {
			fieldDefinition.isPrimaryKey = this.primaryKeyColumnNames.contains(fieldDefinition.columnName);
		}
	}

	private <A> String getColumnName(A fieldObject) {
		FieldDefinition def = fieldMap.get(fieldObject);
		return def == null ? null : def.columnName;
	}

	private ArrayList<String> mapColumnNames(Object[] columns) {
		ArrayList<String> columnNames = Utils.newArrayList();
		for (Object column : columns) {
			columnNames.add(getColumnName(column));
		}
		return columnNames;
	}

	/**
	 * Defines an index with the specified model fields.
	 * 
	 * @param name
	 *            the index name (optional)
	 * @param type
	 *            the index type (STANDARD, HASH, UNIQUE, UNIQUE_HASH)
	 * @param modelFields
	 *            the ordered list of model fields
	 */
	void defineIndex(String name, IndexType type, Object[] modelFields) {
		List<String> columnNames = mapColumnNames(modelFields);
		addIndex(name, type, columnNames);
	}

	/**
	 * Defines an index with the specified column names.
	 * 
	 * @param type
	 *            the index type (STANDARD, HASH, UNIQUE, UNIQUE_HASH)
	 * @param columnNames
	 *            the ordered list of column names
	 */
	private void addIndex(String name, IndexType type, List<String> columnNames) {
		IndexDefinition index = new IndexDefinition();
		if (StringUtils.isNullOrEmpty(name)) {
			index.indexName = tableName + "_" + indexes.size();
		} else {
			index.indexName = name;
		}
		index.columnNames = Utils.newArrayList(columnNames);
		index.type = type;
		indexes.add(index);
	}

	void defineColumnName(Object column, String columnName) {
		FieldDefinition def = fieldMap.get(column);
		if (def != null) {
			def.columnName = columnName;
		}
	}

	void defineAutoIncrement(Object column) {
		FieldDefinition def = fieldMap.get(column);
		if (def != null) {
			def.isAutoIncrement = true;
		}
	}

	void defineLength(Object column, int length) {
		FieldDefinition def = fieldMap.get(column);
		if (def != null) {
			def.length = length;
		}
	}

	void defineScale(Object column, int scale) {
		FieldDefinition def = fieldMap.get(column);
		if (def != null) {
			def.scale = scale;
		}
	}

	void defineTrim(Object column) {
		FieldDefinition def = fieldMap.get(column);
		if (def != null) {
			def.trim = true;
		}
	}

	void defineNullable(Object column, boolean isNullable) {
		FieldDefinition def = fieldMap.get(column);
		if (def != null) {
			def.nullable = isNullable;
		}
	}

	void defineDefaultValue(Object column, String defaultValue) {
		FieldDefinition def = fieldMap.get(column);
		if (def != null) {
			def.defaultValue = defaultValue;
		}
	}

	void mapFields() {
		boolean byAnnotationsOnly = false;
		boolean inheritColumns = false;
		if (clazz.isAnnotationPresent(IQTable.class)) {
			IQTable tableAnnotation = clazz.getAnnotation(IQTable.class);
			byAnnotationsOnly = tableAnnotation.annotationsOnly();
			inheritColumns = tableAnnotation.inheritColumns();
		}

		List<Field> classFields = Utils.newArrayList();
		classFields.addAll(Arrays.asList(clazz.getDeclaredFields()));
		if (inheritColumns) {
			Class<?> superClass = clazz.getSuperclass();
			classFields.addAll(Arrays.asList(superClass.getDeclaredFields()));
		}

		T defaultObject = Db.instance(clazz);
		for (Field f : classFields) {
			// check if we should skip this field
			if (f.isAnnotationPresent(IQIgnore.class)) {
				continue;
			}

			// default to field name
			String columnName = f.getName();
			boolean isAutoIncrement = false;
			boolean isPrimaryKey = false;
			int length = 0;
			int scale = 0;
			boolean trim = false;
			boolean nullable = !f.getType().isPrimitive();
			EnumType enumType = null;
			String defaultValue = "";
			// configure Java -> SQL enum mapping
			if (f.getType().isEnum()) {
				enumType = EnumType.DEFAULT_TYPE;
				if (f.getType().isAnnotationPresent(IQEnum.class)) {
					// enum definition is annotated for all instances
					IQEnum iqenum = f.getType().getAnnotation(IQEnum.class);
					enumType = iqenum.value();
				}
				if (f.isAnnotationPresent(IQEnum.class)) {
					// this instance of the enum is annotated
					IQEnum iqenum = f.getAnnotation(IQEnum.class);
					enumType = iqenum.value();
				}
			}

			// try using default object
			try {
				f.setAccessible(true);
				Object value = f.get(defaultObject);
				if (value != null) {
					if (value.getClass().isEnum()) {
						// enum default, convert to target type
						Enum<?> anEnum = (Enum<?>) value;
						Object o = Utils.convertEnum(anEnum, enumType);
						defaultValue = ModelUtils.formatDefaultValue(o);
					} else {
						// object default
						defaultValue = ModelUtils.formatDefaultValue(value);
					}
				}
			} catch (IllegalAccessException e) {
				throw new IciqlException(e, "failed to get default object for {0}", columnName);
			}

			boolean hasAnnotation = f.isAnnotationPresent(IQColumn.class);
			if (hasAnnotation) {
				IQColumn col = f.getAnnotation(IQColumn.class);
				if (!StringUtils.isNullOrEmpty(col.name())) {
					columnName = col.name();
				}
				isAutoIncrement = col.autoIncrement();
				isPrimaryKey = col.primaryKey();
				length = col.length();
				scale = col.scale();
				trim = col.trim();
				nullable = col.nullable();

				// annotation overrides
				if (!StringUtils.isNullOrEmpty(col.defaultValue())) {
					defaultValue = col.defaultValue();
				}
			}

			boolean reflectiveMatch = !byAnnotationsOnly;
			if (reflectiveMatch || hasAnnotation) {
				FieldDefinition fieldDef = new FieldDefinition();
				fieldDef.isPrimitive = f.getType().isPrimitive();
				fieldDef.field = f;
				fieldDef.columnName = columnName;
				fieldDef.isAutoIncrement = isAutoIncrement;
				fieldDef.isPrimaryKey = isPrimaryKey;
				fieldDef.length = length;
				fieldDef.scale = scale;
				fieldDef.trim = trim;
				fieldDef.nullable = nullable;
				fieldDef.defaultValue = defaultValue;
				fieldDef.enumType = enumType;
				fieldDef.dataType = ModelUtils.getDataType(fieldDef);
				fields.add(fieldDef);
			}
		}
		List<String> primaryKey = Utils.newArrayList();
		int primitiveBoolean = 0;
		for (FieldDefinition fieldDef : fields) {
			if (fieldDef.isPrimaryKey) {
				primaryKey.add(fieldDef.columnName);
			}
			if (fieldDef.isPrimitive && fieldDef.field.getType().equals(boolean.class)) {
				primitiveBoolean++;
			}
		}
		if (primitiveBoolean > 1) {
			multiplePrimitiveBools = true;
			IciqlLogger
					.warn("Model {0} has multiple primitive booleans! Possible where,set,join clause problem!");
		}
		if (primaryKey.size() > 0) {
			setPrimaryKey(primaryKey);
		}
	}

	void checkMultipleBooleans() {
		if (multiplePrimitiveBools) {
			throw new IciqlException(
					"Can not explicitly reference a primitive boolean if there are multiple boolean fields in your model class!");
		}
	}

	void checkMultipleEnums(Object o) {
		if (o == null) {
			return;
		}
		Class<?> clazz = o.getClass();
		if (!clazz.isEnum()) {
			return;
		}

		int fieldCount = 0;
		for (FieldDefinition fieldDef : fields) {
			Class<?> targetType = fieldDef.field.getType();
			if (clazz.equals(targetType)) {
				fieldCount++;
			}
		}

		if (fieldCount > 1) {
			throw new IciqlException(
					"Can not explicitly reference {0} because there are {1} {0} fields in your model class!",
					clazz.getSimpleName(), fieldCount);
		}
	}

	/**
	 * Optionally truncates strings to the maximum length and converts
	 * java.lang.Enum types to Strings or Integers.
	 */
	Object getValue(Object obj, FieldDefinition field) {
		Object value = field.getValue(obj);
		if (value == null) {
			return value;
		}
		if (field.enumType != null) {
			// convert enumeration to INT or STRING
			Enum<?> iqenum = (Enum<?>) value;
			switch (field.enumType) {
			case NAME:
				if (field.trim && field.length > 0) {
					if (iqenum.name().length() > field.length) {
						return iqenum.name().substring(0, field.length);
					}
				}
				return iqenum.name();
			case ORDINAL:
				return iqenum.ordinal();
			case ENUMID:
				if (!EnumId.class.isAssignableFrom(value.getClass())) {
					throw new IciqlException(field.field.getName() + " does not implement EnumId!");
				}
				EnumId enumid = (EnumId) value;
				return enumid.enumId();
			}
		}

		if (field.trim && field.length > 0) {
			if (value instanceof String) {
				// clip strings
				String s = (String) value;
				if (s.length() > field.length) {
					return s.substring(0, field.length);
				}
				return s;
			}
			return value;
		}

		// return the value unchanged
		return value;
	}

	long insert(Db db, Object obj, boolean returnKey) {
		SQLStatement stat = new SQLStatement(db);
		StatementBuilder buff = new StatementBuilder("INSERT INTO ");
		buff.append(db.getDialect().prepareTableName(schemaName, tableName)).append('(');
		for (FieldDefinition field : fields) {
			if (skipInsertField(field, obj)) {
				continue;
			}
			buff.appendExceptFirst(", ");
			buff.append(db.getDialect().prepareColumnName(field.columnName));
		}
		buff.append(") VALUES(");
		buff.resetCount();
		for (FieldDefinition field : fields) {
			if (skipInsertField(field, obj)) {
				continue;
			}
			buff.appendExceptFirst(", ");
			buff.append('?');
			Object value = getValue(obj, field);
			if (value == null && !field.nullable) {
				// try to interpret and instantiate a default value
				value = ModelUtils.getDefaultValue(field, db.getDialect().getDateTimeClass());
			}
			stat.addParameter(value);
		}
		buff.append(')');
		stat.setSQL(buff.toString());
		IciqlLogger.insert(stat.getSQL());
		if (returnKey) {
			return stat.executeInsert();
		}
		return stat.executeUpdate();
	}

	private boolean skipInsertField(FieldDefinition field, Object obj) {
		if (field.isAutoIncrement) {
			Object value = getValue(obj, field);
			if (field.isPrimitive) {
				// skip uninitialized primitive autoincrement values
				if (value.toString().equals("0")) {
					return true;
				}
			} else if (value == null) {
				// skip null object autoincrement values
				return true;
			}
		} else {
			// conditionally skip insert of null
			Object value = getValue(obj, field);
			if (value == null) {
				if (field.nullable) {
					// skip null assignment, field is nullable
					return true;
				} else if (StringUtils.isNullOrEmpty(field.defaultValue)) {
					IciqlLogger.warn("no default value, skipping null insert assignment for {0}.{1}",
							tableName, field.columnName);
					return true;
				}
			}
		}
		return false;
	}

	int merge(Db db, Object obj) {
		if (primaryKeyColumnNames == null || primaryKeyColumnNames.size() == 0) {
			throw new IllegalStateException("No primary key columns defined for table " + obj.getClass()
					+ " - no update possible");
		}
		SQLStatement stat = new SQLStatement(db);
		db.getDialect().prepareMerge(stat, schemaName, tableName, this, obj);
		IciqlLogger.merge(stat.getSQL());
		return stat.executeUpdate();
	}

	int update(Db db, Object obj) {
		if (primaryKeyColumnNames == null || primaryKeyColumnNames.size() == 0) {
			throw new IllegalStateException("No primary key columns defined for table " + obj.getClass()
					+ " - no update possible");
		}
		SQLStatement stat = new SQLStatement(db);
		StatementBuilder buff = new StatementBuilder("UPDATE ");
		buff.append(db.getDialect().prepareTableName(schemaName, tableName)).append(" SET ");
		buff.resetCount();

		for (FieldDefinition field : fields) {
			if (!field.isPrimaryKey) {
				Object value = getValue(obj, field);
				if (value == null && !field.nullable) {
					// try to interpret and instantiate a default value
					value = ModelUtils.getDefaultValue(field, db.getDialect().getDateTimeClass());
				}
				buff.appendExceptFirst(", ");
				buff.append(db.getDialect().prepareColumnName(field.columnName));
				buff.append(" = ?");
				stat.addParameter(value);
			}
		}
		Object alias = Utils.newObject(obj.getClass());
		Query<Object> query = Query.from(db, alias);
		boolean firstCondition = true;
		for (FieldDefinition field : fields) {
			if (field.isPrimaryKey) {
				Object fieldAlias = field.getValue(alias);
				Object value = field.getValue(obj);
				if (field.isPrimitive) {
					fieldAlias = query.getPrimitiveAliasByValue(fieldAlias);
				}
				if (!firstCondition) {
					query.addConditionToken(ConditionAndOr.AND);
				}
				firstCondition = false;
				query.addConditionToken(new Condition<Object>(fieldAlias, value, CompareType.EQUAL));
			}
		}
		stat.setSQL(buff.toString());
		query.appendWhere(stat);
		IciqlLogger.update(stat.getSQL());
		return stat.executeUpdate();
	}

	int delete(Db db, Object obj) {
		if (primaryKeyColumnNames == null || primaryKeyColumnNames.size() == 0) {
			throw new IllegalStateException("No primary key columns defined for table " + obj.getClass()
					+ " - no update possible");
		}
		SQLStatement stat = new SQLStatement(db);
		StatementBuilder buff = new StatementBuilder("DELETE FROM ");
		buff.append(db.getDialect().prepareTableName(schemaName, tableName));
		buff.resetCount();
		Object alias = Utils.newObject(obj.getClass());
		Query<Object> query = Query.from(db, alias);
		boolean firstCondition = true;
		for (FieldDefinition field : fields) {
			if (field.isPrimaryKey) {
				Object fieldAlias = field.getValue(alias);
				Object value = field.getValue(obj);
				if (field.isPrimitive) {
					fieldAlias = query.getPrimitiveAliasByValue(fieldAlias);
				}
				if (!firstCondition) {
					query.addConditionToken(ConditionAndOr.AND);
				}
				firstCondition = false;
				query.addConditionToken(new Condition<Object>(fieldAlias, value, CompareType.EQUAL));
			}
		}
		stat.setSQL(buff.toString());
		query.appendWhere(stat);
		IciqlLogger.delete(stat.getSQL());
		return stat.executeUpdate();
	}

	TableDefinition<T> createIfRequired(Db db) {
		if (!createIfRequired) {
			// skip table and index creation
			// but still check for upgrades
			db.upgradeTable(this);
			return this;
		}
		if (db.hasCreated(clazz)) {
			return this;
		}
		SQLStatement stat = new SQLStatement(db);
		db.getDialect().prepareCreateTable(stat, this);
		IciqlLogger.create(stat.getSQL());
		try {
			stat.executeUpdate();
		} catch (IciqlException e) {
			if (e.getIciqlCode() != IciqlException.CODE_OBJECT_ALREADY_EXISTS) {
				throw e;
			}
		}

		// create indexes
		for (IndexDefinition index : indexes) {
			stat = new SQLStatement(db);
			db.getDialect().prepareCreateIndex(stat, schemaName, tableName, index);
			IciqlLogger.create(stat.getSQL());
			try {
				stat.executeUpdate();
			} catch (IciqlException e) {
				if (e.getIciqlCode() != IciqlException.CODE_OBJECT_ALREADY_EXISTS
						&& e.getIciqlCode() != IciqlException.CODE_DUPLICATE_KEY) {
					throw e;
				}
			}
		}

		// tables are created using IF NOT EXISTS
		// but we may still need to upgrade
		db.upgradeTable(this);
		return this;
	}

	void mapObject(Object obj) {
		fieldMap.clear();
		initObject(obj, fieldMap);

		if (clazz.isAnnotationPresent(IQSchema.class)) {
			IQSchema schemaAnnotation = clazz.getAnnotation(IQSchema.class);
			// setup schema name mapping, if properly annotated
			if (!StringUtils.isNullOrEmpty(schemaAnnotation.value())) {
				schemaName = schemaAnnotation.value();
			}
		}

		if (clazz.isAnnotationPresent(IQTable.class)) {
			IQTable tableAnnotation = clazz.getAnnotation(IQTable.class);

			// setup table name mapping, if properly annotated
			if (!StringUtils.isNullOrEmpty(tableAnnotation.name())) {
				tableName = tableAnnotation.name();
			}

			// allow control over createTableIfRequired()
			createIfRequired = tableAnnotation.create();

			// model version
			if (clazz.isAnnotationPresent(IQVersion.class)) {
				IQVersion versionAnnotation = clazz.getAnnotation(IQVersion.class);
				if (versionAnnotation.value() > 0) {
					tableVersion = versionAnnotation.value();
				}
			}

			// setup the primary index, if properly annotated
			if (tableAnnotation.primaryKey().length > 0) {
				List<String> primaryKey = Utils.newArrayList();
				primaryKey.addAll(Arrays.asList(tableAnnotation.primaryKey()));
				setPrimaryKey(primaryKey);
			}
		}

		if (clazz.isAnnotationPresent(IQIndex.class)) {
			// single table index
			IQIndex index = clazz.getAnnotation(IQIndex.class);
			addIndex(index);
		}

		if (clazz.isAnnotationPresent(IQIndexes.class)) {
			// multiple table indexes
			IQIndexes indexes = clazz.getAnnotation(IQIndexes.class);
			for (IQIndex index : indexes.value()) {
				addIndex(index);
			}
		}
	}

	private void addIndex(IQIndex index) {
		List<String> columns = Arrays.asList(index.value());
		addIndex(index.name(), index.type(), columns);
	}

	List<IndexDefinition> getIndexes() {
		return indexes;
	}

	private void initObject(Object obj, Map<Object, FieldDefinition> map) {
		for (FieldDefinition def : fields) {
			Object newValue = def.initWithNewObject(obj);
			map.put(newValue, def);
		}
	}

	void initSelectObject(SelectTable<T> table, Object obj, Map<Object, SelectColumn<T>> map) {
		for (FieldDefinition def : fields) {
			Object newValue = def.initWithNewObject(obj);
			SelectColumn<T> column = new SelectColumn<T>(table, def);
			map.put(newValue, column);
		}
	}

	/**
	 * Most queries executed by iciql have named select lists (select alpha,
	 * beta where...) but sometimes a wildcard select is executed (select *).
	 * When a wildcard query is executed on a table that has more columns than
	 * are mapped in your model object, this creates a column mapping issue.
	 * JaQu assumed that you can always use the integer index of the
	 * reflectively mapped field definition to determine position in the result
	 * set.
	 * 
	 * This is not always true.
	 * 
	 * iciql identifies when a select * query is executed and maps column names
	 * to a column index from the result set. If the select statement is
	 * explicit, then the standard assumed column index is used instead.
	 * 
	 * @param rs
	 * @return
	 */
	int[] mapColumns(boolean wildcardSelect, ResultSet rs) {
		int[] columns = new int[fields.size()];
		for (int i = 0; i < fields.size(); i++) {
			try {
				FieldDefinition def = fields.get(i);
				int columnIndex;
				if (wildcardSelect) {
					// select *
					// create column index by field name
					columnIndex = rs.findColumn(def.columnName);
				} else {
					// select alpha, beta, gamma, etc
					// explicit select order
					columnIndex = i + 1;
				}
				columns[i] = columnIndex;
			} catch (SQLException s) {
				throw new IciqlException(s);
			}
		}
		return columns;
	}

	void readRow(Object item, ResultSet rs, int[] columns) {
		for (int i = 0; i < fields.size(); i++) {
			FieldDefinition def = fields.get(i);
			int index = columns[i];
			Object o = def.read(rs, index);
			def.setValue(item, o);
		}
	}

	void appendSelectList(SQLStatement stat) {
		for (int i = 0; i < fields.size(); i++) {
			if (i > 0) {
				stat.appendSQL(", ");
			}
			FieldDefinition def = fields.get(i);
			stat.appendColumn(def.columnName);
		}
	}

	<Y, X> void appendSelectList(SQLStatement stat, Query<Y> query, X x) {
		// select t0.col1, t0.col2, t0.col3...
		// select table1.col1, table1.col2, table1.col3...
		String selectDot = "";
		SelectTable<?> sel = query.getSelectTable(x);
		if (sel != null) {
			if (query.isJoin()) {
				selectDot = sel.getAs() + ".";
			} else {
				String sn = sel.getAliasDefinition().schemaName;
				String tn = sel.getAliasDefinition().tableName;
				selectDot = query.getDb().getDialect().prepareTableName(sn, tn) + ".";
			}
		}

		for (int i = 0; i < fields.size(); i++) {
			if (i > 0) {
				stat.appendSQL(", ");
			}
			stat.appendSQL(selectDot);
			FieldDefinition def = fields.get(i);
			if (def.isPrimitive) {
				Object obj = def.getValue(x);
				Object alias = query.getPrimitiveAliasByValue(obj);
				query.appendSQL(stat, x, alias);
			} else {
				Object obj = def.getValue(x);
				query.appendSQL(stat, x, obj);
			}
		}
	}
}