dk.eobjects.metamodel.dialects.AbstractQueryRewriter Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of MetaModel Show documentation
The eobjects.dk MetaModel is a common domain model, query-engine and optimizer for different kinds of datastores.
The newest version!
/*
 * Copyright 2008 eobjects.dk
 *
 * 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 dk.eobjects.metamodel.dialects;

import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import dk.eobjects.metamodel.JdbcDataContextStrategy;
import dk.eobjects.metamodel.query.FilterClause;
import dk.eobjects.metamodel.query.FilterItem;
import dk.eobjects.metamodel.query.FromClause;
import dk.eobjects.metamodel.query.FromItem;
import dk.eobjects.metamodel.query.GroupByClause;
import dk.eobjects.metamodel.query.GroupByItem;
import dk.eobjects.metamodel.query.OrderByClause;
import dk.eobjects.metamodel.query.OrderByItem;
import dk.eobjects.metamodel.query.Query;
import dk.eobjects.metamodel.query.QueryClause;
import dk.eobjects.metamodel.query.SelectClause;
import dk.eobjects.metamodel.query.SelectItem;

/**
 * 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 class AbstractQueryRewriter implements IQueryRewriter {

	protected final Log _log = LogFactory.getLog(getClass());

	public String rewriteQuery(JdbcDataContextStrategy strategy, Query query) {
		query = beforeRewrite(strategy, query);

		StringBuilder sb = new StringBuilder();
		sb
				.append(rewriteSelectClause(strategy, query, query
						.getSelectClause()));
		sb.append(rewriteFromClause(strategy, query, query.getFromClause()));
		sb.append(rewriteWhereClause(strategy, query, query.getWhereClause()));
		sb.append(rewriteGroupByClause(strategy, query, query
				.getGroupByClause()));
		sb
				.append(rewriteHavingClause(strategy, query, query
						.getHavingClause()));
		sb.append(rewriteOrderByClause(strategy, query, query
				.getOrderByClause()));
		return sb.toString();
	}

	/**
	 * 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
	 */
	protected Query beforeRewrite(JdbcDataContextStrategy strategy, Query query) {
		return query;
	}

	protected String rewriteOrderByClause(JdbcDataContextStrategy strategy,
			Query query, OrderByClause orderByClause) {
		StringBuilder sb = new StringBuilder();
		if (orderByClause.getItemCount() > 0) {
			sb.append(QueryClause.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(QueryClause.DELIM_COMMA);
				}
				sb.append(rewriteOrderByItem(strategy, query, item));
			}
		}
		return sb.toString();
	}

	protected String rewriteOrderByItem(JdbcDataContextStrategy strategy,
			Query query, OrderByItem item) {
		return item.toString();
	}

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

	protected String rewriteGroupByClause(JdbcDataContextStrategy strategy,
			Query query, GroupByClause groupByClause) {
		StringBuilder sb = new StringBuilder();
		if (groupByClause.getItemCount() > 0) {
			sb.append(QueryClause.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(QueryClause.DELIM_COMMA);
				}
				sb.append(rewriteGroupByItem(strategy, query, item));
			}
		}
		return sb.toString();
	}

	protected String rewriteGroupByItem(JdbcDataContextStrategy strategy,
			Query query, GroupByItem item) {
		return item.toString();
	}

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

	protected String rewriteFilterItem(JdbcDataContextStrategy strategy,
			Query query, FilterItem item) {
		return item.toString();
	}

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

	protected String rewriteFromItem(JdbcDataContextStrategy strategy,
			Query query, FromItem item) {
		return item.toString();
	}

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

	protected String rewriteSelectItem(JdbcDataContextStrategy strategy,
			Query query, SelectItem item) {
		return item.toString();
	}
}