001: /**
002: * Copyright 2006 Webmedia Group Ltd.
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: **/package org.araneaframework.backend.list.helper.builder.expression;
016:
017: import org.araneaframework.backend.list.SqlExpression;
018: import org.araneaframework.backend.list.SqlLikeUtil;
019: import org.araneaframework.backend.list.helper.builder.ExpressionToSqlExprBuilder;
020: import org.araneaframework.backend.list.helper.builder.ValueConverter;
021: import org.araneaframework.backend.list.memorybased.Expression;
022: import org.araneaframework.backend.list.memorybased.Variable;
023: import org.araneaframework.backend.list.memorybased.expression.AlwaysTrueExpression;
024: import org.araneaframework.backend.list.memorybased.expression.CompositeExpression;
025: import org.araneaframework.backend.list.memorybased.expression.LazyExpression;
026: import org.araneaframework.backend.list.memorybased.expression.Value;
027: import org.araneaframework.backend.list.memorybased.expression.VariableResolver;
028: import org.araneaframework.backend.list.memorybased.expression.compare.ComparedEqualsExpression;
029: import org.araneaframework.backend.list.memorybased.expression.compare.EqualsExpression;
030: import org.araneaframework.backend.list.memorybased.expression.compare.GreaterThanExpression;
031: import org.araneaframework.backend.list.memorybased.expression.compare.IsNullExpression;
032: import org.araneaframework.backend.list.memorybased.expression.compare.LikeExpression;
033: import org.araneaframework.backend.list.memorybased.expression.compare.LowerThanExpression;
034: import org.araneaframework.backend.list.memorybased.expression.constant.ValueExpression;
035: import org.araneaframework.backend.list.memorybased.expression.logical.AndExpression;
036: import org.araneaframework.backend.list.memorybased.expression.logical.NotExpression;
037: import org.araneaframework.backend.list.memorybased.expression.logical.OrExpression;
038: import org.araneaframework.backend.list.memorybased.expression.procedure.ProcedureExpression;
039: import org.araneaframework.backend.list.memorybased.expression.string.ConcatenationExpression;
040: import org.araneaframework.backend.list.memorybased.expression.variable.VariableExpression;
041: import org.araneaframework.backend.list.sqlexpr.SqlAlwaysTrueExpression;
042: import org.araneaframework.backend.list.sqlexpr.SqlBracketsExpression;
043: import org.araneaframework.backend.list.sqlexpr.SqlEscapeExpression;
044: import org.araneaframework.backend.list.sqlexpr.compare.SqlEqualsExpression;
045: import org.araneaframework.backend.list.sqlexpr.compare.SqlGreaterThanExpression;
046: import org.araneaframework.backend.list.sqlexpr.compare.SqlIsNullExpression;
047: import org.araneaframework.backend.list.sqlexpr.compare.SqlLikeExpression;
048: import org.araneaframework.backend.list.sqlexpr.compare.SqlLowerThanExpression;
049: import org.araneaframework.backend.list.sqlexpr.constant.SqlStringExpression;
050: import org.araneaframework.backend.list.sqlexpr.constant.SqlValueExpression;
051: import org.araneaframework.backend.list.sqlexpr.logical.SqlAndExpression;
052: import org.araneaframework.backend.list.sqlexpr.logical.SqlNotExpression;
053: import org.araneaframework.backend.list.sqlexpr.logical.SqlOrExpression;
054: import org.araneaframework.backend.list.sqlexpr.procedure.SqlProcedureExpression;
055: import org.araneaframework.backend.list.sqlexpr.string.SqlConcatenationExpression;
056: import org.araneaframework.backend.list.sqlexpr.string.SqlUpperExpression;
057:
058: public class StandardExpressionToSqlExprBuilder extends
059: BaseExpressionToSqlExprBuilder {
060:
061: public static final String ESCAPE_CHAR = "\\";
062:
063: protected VariableResolver mapper;
064:
065: protected ValueConverter converter;
066:
067: public StandardExpressionToSqlExprBuilder() {
068: addTranslator(LazyExpression.class, new LazyTranslator());
069: addTranslator(ValueExpression.class, new ValueTranslator());
070: addTranslator(VariableExpression.class,
071: new VariableTranslator());
072: addTranslator(AlwaysTrueExpression.class,
073: new AlwaysTrueTranslator());
074: addTranslator(EqualsExpression.class, new EqualsTranslator());
075: addTranslator(IsNullExpression.class, new IsNullTranslator());
076: addTranslator(ComparedEqualsExpression.class,
077: new ComparedEqualsTranslator());
078: addTranslator(GreaterThanExpression.class,
079: new GreaterThanTranslator());
080: addTranslator(LowerThanExpression.class,
081: new LowerThanTranslator());
082: addTranslator(AndExpression.class, new AndTranslator());
083: addTranslator(OrExpression.class, new OrTranslator());
084: addTranslator(NotExpression.class, new NotTranslator());
085: addTranslator(LikeExpression.class, new LikeTranslator());
086: addTranslator(ConcatenationExpression.class,
087: new ConcatenationTranslator());
088: addTranslator(ProcedureExpression.class,
089: new ProcedureTranslator());
090: }
091:
092: public void setConverter(ValueConverter converter) {
093: this .converter = converter;
094: }
095:
096: public void setMapper(VariableResolver mapper) {
097: this .mapper = mapper;
098: }
099:
100: protected Object convertValue(Value value) {
101: return this .converter != null ? this .converter.convert(value)
102: : value.getValue();
103: }
104:
105: protected String resolveVariable(Variable variable) {
106: return this .mapper != null ? (String) this .mapper
107: .resolve(variable) : variable.getName();
108: }
109:
110: // lazy
111:
112: class LazyTranslator implements ExprToSqlExprTranslator {
113: public SqlExpression translate(Expression expr,
114: ExpressionToSqlExprBuilder builder) {
115: LazyExpression lazyExpr = (LazyExpression) expr;
116: return buildSqlExpression(lazyExpr.getExpression());
117: }
118: }
119:
120: // constant
121:
122: class ValueTranslator implements ExprToSqlExprTranslator {
123: public SqlExpression translate(Expression expr,
124: ExpressionToSqlExprBuilder builder) {
125: return new SqlValueExpression(convertValue((Value) expr));
126: }
127: }
128:
129: class VariableTranslator implements ExprToSqlExprTranslator {
130: public SqlExpression translate(Expression expr,
131: ExpressionToSqlExprBuilder builder) {
132: return new SqlStringExpression(
133: resolveVariable((Variable) expr));
134: }
135: }
136:
137: static class AlwaysTrueTranslator implements
138: ExprToSqlExprTranslator {
139: public SqlExpression translate(Expression expr,
140: ExpressionToSqlExprBuilder builder) {
141: return new SqlAlwaysTrueExpression();
142: }
143: }
144:
145: // comparing
146:
147: static class EqualsTranslator implements ExprToSqlExprTranslator {
148: // TODO check values to be null deeply
149: public SqlExpression translate(Expression expr,
150: ExpressionToSqlExprBuilder builder) {
151: Expression[] children = ((CompositeExpression) expr)
152: .getChildren();
153: Expression leftExpr = children[0];
154: Expression rightExpr = children[1];
155: if (ValueExpression.class.isAssignableFrom(rightExpr
156: .getClass())
157: && ((ValueExpression) rightExpr).getValue() == null) {
158: return new SqlIsNullExpression(builder
159: .buildSqlExpression(leftExpr));
160: }
161: if (ValueExpression.class.isAssignableFrom(leftExpr
162: .getClass())
163: && ((ValueExpression) leftExpr).getValue() == null) {
164: return new SqlIsNullExpression(builder
165: .buildSqlExpression(rightExpr));
166: }
167: return new SqlEqualsExpression(builder
168: .buildSqlExpression(leftExpr), builder
169: .buildSqlExpression(rightExpr));
170: }
171: }
172:
173: static class IsNullTranslator extends
174: CompositeExprToSqlExprTranslator {
175: protected SqlExpression translateParent(Expression expr,
176: SqlExpression[] sqlChildren) {
177: return new SqlIsNullExpression(sqlChildren[0]);
178: }
179: }
180:
181: static class ComparedEqualsTranslator extends
182: ComparingExprToSqlExprTranslator {
183: protected SqlExpression translateComparable(Expression expr,
184: SqlExpression sql1, SqlExpression sql2) {
185: return new SqlEqualsExpression(sql1, sql2);
186: }
187: }
188:
189: static class GreaterThanTranslator extends
190: ComparingExprToSqlExprTranslator {
191: protected SqlExpression translateComparable(Expression expr,
192: SqlExpression sql1, SqlExpression sql2) {
193: return new SqlGreaterThanExpression(sql1, sql2);
194: }
195: }
196:
197: static class LowerThanTranslator extends
198: ComparingExprToSqlExprTranslator {
199: protected SqlExpression translateComparable(Expression expr,
200: SqlExpression sql1, SqlExpression sql2) {
201: return new SqlLowerThanExpression(sql1, sql2);
202: }
203: }
204:
205: // logical
206:
207: static class AndTranslator extends CompositeExprToSqlExprTranslator {
208: protected SqlExpression translateParent(Expression expr,
209: SqlExpression[] sqlChildren) {
210: SqlExpression temp = new SqlAndExpression()
211: .setChildren(sqlChildren);
212: return sqlChildren.length > 1 ? new SqlBracketsExpression(
213: temp) : temp;
214: }
215: }
216:
217: static class OrTranslator extends CompositeExprToSqlExprTranslator {
218: protected SqlExpression translateParent(Expression expr,
219: SqlExpression[] sqlChildren) {
220: SqlExpression temp = new SqlOrExpression()
221: .setChildren(sqlChildren);
222: return sqlChildren.length > 1 ? new SqlBracketsExpression(
223: temp) : temp;
224: }
225: }
226:
227: static class NotTranslator extends CompositeExprToSqlExprTranslator {
228: protected SqlExpression translateParent(Expression expr,
229: SqlExpression[] sqlChildren) {
230: return new SqlNotExpression(sqlChildren[0]);
231: }
232: }
233:
234: // String
235:
236: class LikeTranslator extends CompositeExprToSqlExprTranslator {
237: protected SqlExpression translateParent(Expression expr,
238: SqlExpression[] sqlChildren) {
239: LikeExpression like = (LikeExpression) expr;
240: SqlExpression var = sqlChildren[0];
241: String value = (String) convertValue(like.getMask());
242: SqlExpression mask = new SqlValueExpression(SqlLikeUtil
243: .convertMask(value, like.getConfiguration(),
244: ESCAPE_CHAR));
245: if (like.getIgnoreCase()) {
246: var = new SqlUpperExpression(var);
247: mask = new SqlUpperExpression(mask);
248: }
249: SqlExpression sqlLike = new SqlLikeExpression(var, mask);
250: return new SqlEscapeExpression(sqlLike, ESCAPE_CHAR);
251: }
252: }
253:
254: static class ConcatenationTranslator extends
255: CompositeExprToSqlExprTranslator {
256: protected SqlExpression translateParent(Expression expr,
257: SqlExpression[] sqlChildren) {
258: return new SqlConcatenationExpression()
259: .setChildren(sqlChildren);
260: }
261: }
262:
263: // procedure
264:
265: static class ProcedureTranslator extends
266: CompositeExprToSqlExprTranslator {
267: protected SqlExpression translateParent(Expression expr,
268: SqlExpression[] sqlChildren) {
269: ProcedureExpression expr0 = (ProcedureExpression) expr;
270: return new SqlProcedureExpression(expr0.getName())
271: .setChildren(sqlChildren);
272: }
273: }
274: }
|