sqlwhereclauseadapter.java

esri的ArcGIS Server超级学习模板程序（for java）

package com.esri.solutions.jitk.web.wfs.adapters;

import java.util.List;

import com.esri.solutions.jitk.datasources.ogc.filters.AttributeClause;
import com.esri.solutions.jitk.datasources.ogc.filters.AttributeOperator;
import com.esri.solutions.jitk.datasources.ogc.filters.Filter;
import com.esri.solutions.jitk.datasources.ogc.filters.FilterLogicalOperator;
import com.esri.solutions.jitk.datasources.ogc.filters.IFilter;
import com.esri.solutions.jitk.datasources.ogc.filters.IFilterClause;
import com.esri.solutions.jitk.datasources.ogc.filters.LiteralAttributeClause;
import com.esri.solutions.jitk.datasources.ogc.filters.LogicalOperatorClause;
import com.esri.solutions.jitk.datasources.ogc.filters.PropertyAttributeClause;
import com.esri.solutions.jitk.web.wfs.data.query.sql.InvalidSyntaxException;
import com.esri.solutions.jitk.web.wfs.data.query.sql.InvalidTokenException;
import com.esri.solutions.jitk.web.wfs.data.query.sql.LogicalOperator;
import com.esri.solutions.jitk.web.wfs.data.query.sql.Tuple;
import com.esri.solutions.jitk.web.wfs.data.query.sql.WhereClauseSyntaxAnalyzer;
import com.esri.solutions.jitk.web.wfs.data.query.sql.WhereClauseTokenType;

public class SQLWhereClauseAdapter {
	protected String _wc;
	
	public SQLWhereClauseAdapter(String whereClause) {
		_wc = whereClause;
	}
	
	public AttributeClause getAttributeClause(Tuple tuple) 
	throws InvalidSyntaxException {
		AttributeClause ac;
		WhereClauseTokenType leftTType = tuple.getLeftOperand().getType();
		WhereClauseTokenType rightTType = tuple.getRightOperand().getType();
		
		if ((leftTType == WhereClauseTokenType.Literal) && 
				(rightTType == WhereClauseTokenType.Literal)) {
			throw new InvalidSyntaxException("Left and Right Operands can not both be literals");
		} else if (leftTType == WhereClauseTokenType.Literal) {
			LiteralAttributeClause lac = new LiteralAttributeClause();
			String relationalOp = tuple.getRelationalOperator().getToken();
			lac.setLeftOperandPropertyName(tuple.getLeftOperand().getToken());	
			lac.setOperator(getOperatorFromString(relationalOp));
			lac.setLiteralValue(stripQuotes(tuple.getRightOperand().getToken()));
			lac.setOperandsInverted(true);
			ac = lac;
		} else if (rightTType == WhereClauseTokenType.Literal) {
			LiteralAttributeClause lac = new LiteralAttributeClause();
			String relationalOp = tuple.getRelationalOperator().getToken();
			lac.setLeftOperandPropertyName(tuple.getLeftOperand().getToken());	
			lac.setOperator(getOperatorFromString(relationalOp));
			lac.setLiteralValue(stripQuotes(tuple.getRightOperand().getToken()));	
			lac.setOperandsInverted(false);
			ac = lac;
		} else {
			PropertyAttributeClause pac = new PropertyAttributeClause();
			String relationalOp = tuple.getRelationalOperator().getToken();
			pac.setLeftOperandPropertyName(tuple.getLeftOperand().getToken());	
			pac.setOperator(getOperatorFromString(relationalOp));
			pac.setRightOperandPropertyName(tuple.getRightOperand().getToken());	
			ac = pac;
		}

		return ac;
	}
	
	public IFilter getFilter() throws InvalidTokenException, InvalidSyntaxException {
		WhereClauseSyntaxAnalyzer analyzer = new WhereClauseSyntaxAnalyzer(_wc);
		analyzer.analyze();
		
		List<Tuple> tuples = analyzer.getCurrentTuple();
		List<LogicalOperator> ops = analyzer.getOperators();
		
		IFilter filter = null;
		
		if (tuples.size() != 0) {
			int tupleIndex = 0;
			Tuple tuple = tuples.get(tupleIndex);
			
			LogicalOperatorClause loc = null;
			IFilterClause fc = getAttributeClause(tuple);
			
			for (LogicalOperator op : ops) {
				switch (op) {
				case AND:
					loc = new LogicalOperatorClause(FilterLogicalOperator.AND);
					loc.appendClause(fc);
					tupleIndex++;
					tuple = tuples.get(tupleIndex);
					fc = getAttributeClause(tuple);
					loc.appendClause(fc);
					tupleIndex++;
					fc = loc;				
					break;
					
				case OR:
					loc = new LogicalOperatorClause(FilterLogicalOperator.OR);
					loc.appendClause(fc);
					tupleIndex++;
					tuple = tuples.get(tupleIndex);
					fc = getAttributeClause(tuple);
					loc.appendClause(fc);
					tupleIndex++;
					fc = loc;
					break;
					
				case NOT:
					loc = new LogicalOperatorClause(FilterLogicalOperator.NOT);
					loc.appendClause(fc);
					tupleIndex++;
					fc = loc;
					break;
					
				case LeftParen:
					break;
					
				case RightParen:
					break;
					
				default:
					throw new InvalidSyntaxException("Unexpected logical operator encountered.");
				}
			}
			
			filter = new Filter();
			filter.pushClause(fc);				
		}
	
		return filter;
	}
	
	protected String stripQuotes(String s) {
		String strippedString = s;
		
		if (s.length() > 2) {
			if ((s.charAt(0) == '\'') && (s.charAt(s.length() - 1) == '\'')) {
				strippedString = s.substring(1, s.length() - 1);
			}
		}
		
		return strippedString;
	}
	
	protected AttributeOperator getOperatorFromString(String s) 
	throws InvalidSyntaxException {
		AttributeOperator op = AttributeOperator.Between;
		
		//TODO: Add conversion for NullCheck
		
		if (s.toUpperCase().equals("BETWEEN")) {
			op = AttributeOperator.Between;
		} else if (s.toUpperCase().equals("=")) {
			op = AttributeOperator.EqualTo;
		} else if (s.toUpperCase().equals(">")) {
			op = AttributeOperator.GreaterThan;
		} else if (s.toUpperCase().equals(">=")) {
			op = AttributeOperator.GreaterThanEqualTo;
		} else if (s.toUpperCase().equals("<")) {
			op = AttributeOperator.LessThan;			
		} else if (s.toUpperCase().equals("<=")) {
			op = AttributeOperator.LessThanEqualTo;			
		} else if (s.toUpperCase().equals("LIKE")) {
			op = AttributeOperator.Like;	
		} else if (s.toUpperCase().equals("<>")) {
			op = AttributeOperator.NotEqualTo;				
		} else {
			throw new InvalidSyntaxException(s + " not an expected logical keyword");
		}	
		
		return op;
	}
}