org.eobjects.metamodel.jdbc.dialects.AbstractQueryRewriter Maven / Gradle / Ivy

Go to download
/**
 * eobjects.org MetaModel
 * Copyright (C) 2010 eobjects.org
 *
 * This copyrighted material is made available to anyone wishing to use, modify,
 * copy, or redistribute it subject to the terms and conditions of the GNU
 * Lesser General Public License, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this distribution; if not, write to:
 * Free Software Foundation, Inc.
 * 51 Franklin Street, Fifth Floor
 * Boston, MA  02110-1301  USA
 */

package org.eobjects.metamodel.jdbc.dialects;

import java.util.List;

import org.eobjects.metamodel.jdbc.JdbcDataContext;
import org.eobjects.metamodel.query.AbstractQueryClause;
import org.eobjects.metamodel.query.FilterClause;
import org.eobjects.metamodel.query.FilterItem;
import org.eobjects.metamodel.query.FromClause;
import org.eobjects.metamodel.query.FromItem;
import org.eobjects.metamodel.query.GroupByClause;
import org.eobjects.metamodel.query.GroupByItem;
import org.eobjects.metamodel.query.OrderByClause;
import org.eobjects.metamodel.query.OrderByItem;
import org.eobjects.metamodel.query.Query;
import org.eobjects.metamodel.query.SelectClause;
import org.eobjects.metamodel.query.SelectItem;
import org.eobjects.metamodel.schema.ColumnType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Abstract implementation of query rewriter. This implementation delegates the
 * rewriting of the Query into several subtasks according to the query items to
 * be rendered. This makes it easy to overload single methods in order to
 * correct syntax quirks.
 */
public abstract class AbstractQueryRewriter implements IQueryRewriter {

	protected final Logger logger = LoggerFactory.getLogger(getClass());

	private final JdbcDataContext _dataContext;

	public AbstractQueryRewriter(JdbcDataContext dataContext) {
		_dataContext = dataContext;
	}

	public JdbcDataContext getDataContext() {
		return _dataContext;
	}

	@Override
	public ColumnType getColumnType(int jdbcType, String nativeType, Integer columnSize) {
		return ColumnType.convertColumnType(jdbcType);
	}

	public String rewriteQuery(Query query) {
		query = beforeRewrite(query);

		final StringBuilder sb = new StringBuilder();
		sb.append(rewriteSelectClause(query, query.getSelectClause()));
		sb.append(rewriteFromClause(query, query.getFromClause()));
		sb.append(rewriteWhereClause(query, query.getWhereClause()));
		sb.append(rewriteGroupByClause(query, query.getGroupByClause()));
		sb.append(rewriteHavingClause(query, query.getHavingClause()));
		sb.append(rewriteOrderByClause(query, query.getOrderByClause()));
		return sb.toString();
	}
	
	public boolean isSchemaIncludedInColumnPaths() {
		return false;
	}

	/**
	 * Method to modify query before rewriting begins. Overwrite this method if
	 * you want to change parts of the query that are not just rendering
	 * related. Cloning the query before modifying is recommended in order to
	 * not violate referential integrity of clients (the query is mutable).
	 * 
	 * @param strategy
	 * @param query
	 * @return the modified query
	 */
	protected Query beforeRewrite(Query query) {
		return query;
	}
	
	@Override
	public String rewriteColumnType(ColumnType columnType) {
		return columnType.toString();
	}

	protected String rewriteOrderByClause(Query query, OrderByClause orderByClause) {
		StringBuilder sb = new StringBuilder();
		if (orderByClause.getItemCount() > 0) {
			sb.append(AbstractQueryClause.PREFIX_ORDER_BY);
			List items = orderByClause.getItems();
			for (int i = 0; i < items.size(); i++) {
				OrderByItem item = items.get(i);
				if (i != 0) {
					sb.append(AbstractQueryClause.DELIM_COMMA);
				}
				sb.append(rewriteOrderByItem(query, item));
			}
		}
		return sb.toString();
	}

	@Override
	public String rewriteFromItem(FromItem item) {
		return rewriteFromItem(item.getQuery(), item);
	}

	protected String rewriteOrderByItem(Query query, OrderByItem item) {
		return item.toSql(isSchemaIncludedInColumnPaths());
	}

	protected String rewriteHavingClause(Query query, FilterClause havingClause) {
		StringBuilder sb = new StringBuilder();
		if (havingClause.getItemCount() > 0) {
			sb.append(AbstractQueryClause.PREFIX_HAVING);
			List items = havingClause.getItems();
			for (int i = 0; i < items.size(); i++) {
				FilterItem item = items.get(i);
				if (i != 0) {
					sb.append(AbstractQueryClause.DELIM_AND);
				}
				sb.append(rewriteFilterItem(item));
			}
		}
		return sb.toString();
	}

	protected String rewriteGroupByClause(Query query, GroupByClause groupByClause) {
		StringBuilder sb = new StringBuilder();
		if (groupByClause.getItemCount() > 0) {
			sb.append(AbstractQueryClause.PREFIX_GROUP_BY);
			List items = groupByClause.getItems();
			for (int i = 0; i < items.size(); i++) {
				GroupByItem item = items.get(i);
				if (i != 0) {
					sb.append(AbstractQueryClause.DELIM_COMMA);
				}
				sb.append(rewriteGroupByItem(query, item));
			}
		}
		return sb.toString();
	}

	protected String rewriteGroupByItem(Query query, GroupByItem item) {
		return item.toSql(isSchemaIncludedInColumnPaths());
	}

	protected String rewriteWhereClause(Query query, FilterClause whereClause) {
		StringBuilder sb = new StringBuilder();
		if (whereClause.getItemCount() > 0) {
			sb.append(AbstractQueryClause.PREFIX_WHERE);
			List items = whereClause.getItems();
			for (int i = 0; i < items.size(); i++) {
				FilterItem item = items.get(i);
				if (i != 0) {
					sb.append(AbstractQueryClause.DELIM_AND);
				}
				sb.append(rewriteFilterItem(item));
			}
		}
		return sb.toString();
	}

	@Override
	public String rewriteFilterItem(FilterItem item) {
		if (item.isCompoundFilter()) {
			FilterItem[] childItems = item.getChildItems();
			StringBuilder sb = new StringBuilder();
			sb.append('(');
			for (int i = 0; i < childItems.length; i++) {
				FilterItem child = childItems[i];
				if (i != 0) {
					sb.append(' ');
					sb.append(item.getLogicalOperator().toString());
					sb.append(' ');
				}
				sb.append(rewriteFilterItem(child));
			}
			sb.append(')');
			return sb.toString();
		}
		return item.toSql(isSchemaIncludedInColumnPaths());
	}

	protected String rewriteFromClause(Query query, FromClause fromClause) {
		StringBuilder sb = new StringBuilder();
		if (fromClause.getItemCount() > 0) {
			sb.append(AbstractQueryClause.PREFIX_FROM);
			List items = fromClause.getItems();
			for (int i = 0; i < items.size(); i++) {
				FromItem item = items.get(i);
				if (i != 0) {
					sb.append(AbstractQueryClause.DELIM_COMMA);
				}
				sb.append(rewriteFromItem(query, item));
			}
		}
		return sb.toString();
	}

	protected String rewriteFromItem(Query query, FromItem item) {
		return item.toSql(isSchemaIncludedInColumnPaths());
	}

	protected String rewriteSelectClause(Query query, SelectClause selectClause) {
		StringBuilder sb = new StringBuilder();
		if (selectClause.getItemCount() > 0) {
			sb.append(AbstractQueryClause.PREFIX_SELECT);
			if (selectClause.isDistinct()) {
				sb.append("DISTINCT ");
			}
			List items = selectClause.getItems();
			for (int i = 0; i < items.size(); i++) {
				SelectItem item = items.get(i);
				if (i != 0) {
					sb.append(AbstractQueryClause.DELIM_COMMA);
				}
				sb.append(rewriteSelectItem(query, item));
			}
		}
		return sb.toString();
	}

	protected String rewriteSelectItem(Query query, SelectItem item) {
		return item.toSql(isSchemaIncludedInColumnPaths());
	}
}