1464 lines
48 KiB
Java
1464 lines
48 KiB
Java
package org.gcube.portlets.user.td.expressionwidget.server;
|
|
|
|
import java.text.ParseException;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.Date;
|
|
import java.util.List;
|
|
|
|
import org.gcube.data.analysis.tabulardata.expression.Expression;
|
|
import org.gcube.data.analysis.tabulardata.expression.MultivaluedExpression;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.ExternalReferenceExpression;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.aggregation.Avg;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.aggregation.Count;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.aggregation.Max;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.aggregation.Min;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.aggregation.ST_Extent;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.aggregation.Sum;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.arithmetic.Addition;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.arithmetic.Division;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.arithmetic.Exponentiation;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.arithmetic.Modulus;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.arithmetic.Multiplication;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.arithmetic.Subtraction;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.comparable.Equals;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.comparable.GreaterOrEquals;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.comparable.GreaterThan;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.comparable.LessOrEquals;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.comparable.LessThan;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.comparable.NotEquals;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.comparable.NotGreater;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.comparable.NotLess;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.condtional.Case;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.Concat;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.Length;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.Levenshtein;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.Lower;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.MD5;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.RepeatText;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.Similarity;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.Soundex;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.SubstringByIndex;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.SubstringByRegex;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.SubstringPosition;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.TextBeginsWith;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.TextContains;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.TextEndsWith;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.TextMatchPosixRegexp;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.TextMatchSQLRegexp;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.TextReplaceMatchingRegex;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.Trim;
|
|
import org.gcube.data.analysis.tabulardata.expression.composite.text.Upper;
|
|
import org.gcube.data.analysis.tabulardata.expression.functions.Cast;
|
|
import org.gcube.data.analysis.tabulardata.expression.leaf.ColumnReferencePlaceholder;
|
|
import org.gcube.data.analysis.tabulardata.expression.leaf.ConstantList;
|
|
import org.gcube.data.analysis.tabulardata.expression.logical.And;
|
|
import org.gcube.data.analysis.tabulardata.expression.logical.Between;
|
|
import org.gcube.data.analysis.tabulardata.expression.logical.IsNotNull;
|
|
import org.gcube.data.analysis.tabulardata.expression.logical.IsNull;
|
|
import org.gcube.data.analysis.tabulardata.expression.logical.Not;
|
|
import org.gcube.data.analysis.tabulardata.expression.logical.Or;
|
|
import org.gcube.data.analysis.tabulardata.expression.logical.ValueIsIn;
|
|
import org.gcube.data.analysis.tabulardata.model.column.ColumnLocalId;
|
|
import org.gcube.data.analysis.tabulardata.model.column.ColumnReference;
|
|
import org.gcube.data.analysis.tabulardata.model.datatype.BooleanType;
|
|
import org.gcube.data.analysis.tabulardata.model.datatype.DataType;
|
|
import org.gcube.data.analysis.tabulardata.model.datatype.DateType;
|
|
import org.gcube.data.analysis.tabulardata.model.datatype.GeometryType;
|
|
import org.gcube.data.analysis.tabulardata.model.datatype.IntegerType;
|
|
import org.gcube.data.analysis.tabulardata.model.datatype.NumericType;
|
|
import org.gcube.data.analysis.tabulardata.model.datatype.TextType;
|
|
import org.gcube.data.analysis.tabulardata.model.datatype.value.TDBoolean;
|
|
import org.gcube.data.analysis.tabulardata.model.datatype.value.TDDate;
|
|
import org.gcube.data.analysis.tabulardata.model.datatype.value.TDGeometry;
|
|
import org.gcube.data.analysis.tabulardata.model.datatype.value.TDInteger;
|
|
import org.gcube.data.analysis.tabulardata.model.datatype.value.TDNumeric;
|
|
import org.gcube.data.analysis.tabulardata.model.datatype.value.TDText;
|
|
import org.gcube.data.analysis.tabulardata.model.datatype.value.TDTypeValue;
|
|
import org.gcube.data.analysis.tabulardata.model.table.TableId;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.exception.ExpressionParserException;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.expression.C_MultivaluedExpression;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.aggregation.C_Avg;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.aggregation.C_Count;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.aggregation.C_Max;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.aggregation.C_Min;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.aggregation.C_ST_Extent;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.aggregation.C_Sum;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.arithmetic.C_Addition;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.arithmetic.C_Division;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.arithmetic.C_Modulus;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.arithmetic.C_Multiplication;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.arithmetic.C_Subtraction;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_Equals;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_GreaterOrEquals;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_GreaterThan;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_LessOrEquals;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_LessThan;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_NotEquals;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_NotGreater;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.comparable.C_NotLess;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.functions.C_Cast;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_Concat;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_Levenshtein;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_Lower;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_MD5;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_Similarity;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_Soundex;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_SubstringByIndex;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_SubstringByRegex;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_SubstringPosition;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_TextBeginsWith;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_TextContains;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_TextEndsWith;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_TextMatchSQLRegexp;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_TextReplaceMatchingRegex;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_Trim;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.composite.text.C_Upper;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.leaf.C_ColumnReference;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.leaf.C_ColumnReferencePlaceholder;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.leaf.C_ConstantList;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.leaf.TD_Value;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.logical.C_And;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.logical.C_Between;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.logical.C_IsNotNull;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.logical.C_IsNull;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.logical.C_Not;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.logical.C_Or;
|
|
import org.gcube.portlets.user.td.expressionwidget.shared.model.logical.C_ValueIsIn;
|
|
import org.gcube.portlets.user.td.widgetcommonevent.shared.TRId;
|
|
import org.gcube.portlets.user.td.widgetcommonevent.shared.expression.C_Expression;
|
|
import org.gcube.portlets.user.td.widgetcommonevent.shared.tr.column.ColumnData;
|
|
import org.gcube.portlets.user.td.widgetcommonevent.shared.tr.column.ColumnDataType;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
public class C_ExpressionParser {
|
|
private static Logger logger = LoggerFactory.getLogger(C_ExpressionParser.class);
|
|
|
|
private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
|
|
|
/**
|
|
*
|
|
* @param exp
|
|
* Expression
|
|
* @return Client Expression
|
|
* @throws ExpressionParserException
|
|
* Exception
|
|
*/
|
|
public C_Expression parse(Expression exp) throws ExpressionParserException {
|
|
logger.debug("Parse: " + exp);
|
|
C_Expression ex = null;
|
|
|
|
if (exp == null) {
|
|
return ex;
|
|
}
|
|
|
|
if (exp instanceof Addition) {
|
|
return getAddition(exp);
|
|
}
|
|
|
|
if (exp instanceof Division) {
|
|
return getDivision(exp);
|
|
}
|
|
|
|
if (exp instanceof Exponentiation) {
|
|
// TODO
|
|
return ex;
|
|
}
|
|
|
|
if (exp instanceof Equals) {
|
|
return getEquals(exp);
|
|
}
|
|
|
|
if (exp instanceof GreaterOrEquals) {
|
|
return getGreaterOrEquals(exp);
|
|
}
|
|
|
|
if (exp instanceof GreaterThan) {
|
|
return getGreaterThan(exp);
|
|
}
|
|
|
|
if (exp instanceof LessOrEquals) {
|
|
return getLessOrEquals(exp);
|
|
}
|
|
|
|
if (exp instanceof LessThan) {
|
|
return getLessThan(exp);
|
|
}
|
|
|
|
if (exp instanceof Modulus) {
|
|
return getModulus(exp);
|
|
}
|
|
|
|
if (exp instanceof Multiplication) {
|
|
return getMultiplication(exp);
|
|
}
|
|
|
|
if (exp instanceof NotEquals) {
|
|
return getNotEquals(exp);
|
|
}
|
|
|
|
if (exp instanceof NotGreater) {
|
|
return getNotGreater(exp);
|
|
}
|
|
|
|
if (exp instanceof NotLess) {
|
|
return getNotLess(exp);
|
|
}
|
|
|
|
if (exp instanceof Subtraction) {
|
|
return getSubtraction(exp);
|
|
}
|
|
|
|
if (exp instanceof TextBeginsWith) {
|
|
return getTextBeginWith(exp);
|
|
}
|
|
|
|
if (exp instanceof TextContains) {
|
|
return getTextContains(exp);
|
|
}
|
|
|
|
if (exp instanceof TextEndsWith) {
|
|
return getTextEndWith(exp);
|
|
}
|
|
|
|
if (exp instanceof TextMatchSQLRegexp) {
|
|
return getTextMatchSQLRegexp(exp);
|
|
}
|
|
|
|
if (exp instanceof TextMatchPosixRegexp) {
|
|
// TODO
|
|
return ex;
|
|
}
|
|
|
|
if (exp instanceof TextReplaceMatchingRegex) {
|
|
return getTextReplaceMatchingRegex(exp);
|
|
}
|
|
|
|
if (exp instanceof SubstringByRegex) {
|
|
return getSubstringByRegex(exp);
|
|
}
|
|
|
|
if (exp instanceof SubstringByIndex) {
|
|
return getSubstringByIndex(exp);
|
|
}
|
|
|
|
if (exp instanceof SubstringPosition) {
|
|
return getSubstringPosition(exp);
|
|
}
|
|
|
|
if (exp instanceof RepeatText) {
|
|
// TODO
|
|
return ex;
|
|
}
|
|
|
|
if (exp instanceof Trim) {
|
|
return getTrim(exp);
|
|
}
|
|
|
|
if (exp instanceof Length) {
|
|
// TODO
|
|
return ex;
|
|
}
|
|
|
|
if (exp instanceof Upper) {
|
|
return getUpper(exp);
|
|
}
|
|
|
|
if (exp instanceof Lower) {
|
|
return getLower(exp);
|
|
}
|
|
|
|
if (exp instanceof Concat) {
|
|
return getConcat(exp);
|
|
}
|
|
|
|
if (exp instanceof MD5) {
|
|
return getMD5(exp);
|
|
}
|
|
|
|
if (exp instanceof Soundex) {
|
|
return getSoundex(exp);
|
|
}
|
|
|
|
if (exp instanceof Similarity) {
|
|
return getSimilarity(exp);
|
|
}
|
|
|
|
if (exp instanceof Levenshtein) {
|
|
return getLevenshtein(exp);
|
|
}
|
|
|
|
if (exp instanceof ValueIsIn) {
|
|
return getValueIsIn(exp);
|
|
}
|
|
|
|
if (exp instanceof ExternalReferenceExpression) {
|
|
// TODO
|
|
return ex;
|
|
}
|
|
|
|
if (exp instanceof Between) {
|
|
return getBetween(exp);
|
|
}
|
|
|
|
// Multiple
|
|
if (exp instanceof And) {
|
|
return getAnd(exp);
|
|
}
|
|
|
|
if (exp instanceof Or) {
|
|
return getOr(exp);
|
|
}
|
|
|
|
if (exp instanceof Case) {
|
|
// TODO
|
|
return ex;
|
|
}
|
|
|
|
// Unary
|
|
if (exp instanceof IsNotNull) {
|
|
return getIsNotNull(exp);
|
|
}
|
|
|
|
if (exp instanceof IsNull) {
|
|
return getIsNull(exp);
|
|
}
|
|
|
|
if (exp instanceof Not) {
|
|
return getNot(exp);
|
|
}
|
|
|
|
// Leaf
|
|
if (exp instanceof ColumnReference) {
|
|
return getColumnReference(exp);
|
|
}
|
|
|
|
if (exp instanceof ConstantList) {
|
|
return getConstantList(exp);
|
|
}
|
|
|
|
// TypedColumnReference.class,
|
|
if (exp instanceof ColumnReferencePlaceholder) {
|
|
return getColumnReferencePlaceholder(exp);
|
|
}
|
|
|
|
// TDTypeValue
|
|
if (exp instanceof TDBoolean) {
|
|
return getExpressionValue((TDBoolean) exp);
|
|
}
|
|
|
|
if (exp instanceof TDDate) {
|
|
return getExpressionValue((TDDate) exp);
|
|
}
|
|
|
|
if (exp instanceof TDInteger) {
|
|
return getExpressionValue((TDInteger) exp);
|
|
}
|
|
|
|
if (exp instanceof TDNumeric) {
|
|
return getExpressionValue((TDNumeric) exp);
|
|
}
|
|
|
|
if (exp instanceof TDText) {
|
|
return getExpressionValue((TDText) exp);
|
|
}
|
|
|
|
if (exp instanceof TDGeometry) {
|
|
return getExpressionValue((TDGeometry) exp);
|
|
}
|
|
|
|
if (exp instanceof Cast) {
|
|
return getCast(exp);
|
|
}
|
|
|
|
// Aggregation
|
|
if (exp instanceof Avg) {
|
|
return getAvg(exp);
|
|
}
|
|
|
|
if (exp instanceof Count) {
|
|
return getCount(exp);
|
|
}
|
|
|
|
if (exp instanceof Max) {
|
|
return getMax(exp);
|
|
}
|
|
|
|
if (exp instanceof Min) {
|
|
return getMin(exp);
|
|
}
|
|
|
|
if (exp instanceof Sum) {
|
|
return getSum(exp);
|
|
}
|
|
|
|
if (exp instanceof ST_Extent) {
|
|
return getSTExtent(exp);
|
|
}
|
|
|
|
ex = new C_Expression();
|
|
|
|
return ex;
|
|
|
|
}
|
|
|
|
public C_MultivaluedExpression parseMultivalued(Expression exp) throws ExpressionParserException {
|
|
|
|
if (exp instanceof ConstantList) {
|
|
return getConstantList((ConstantList) exp);
|
|
}
|
|
|
|
if (exp instanceof ExternalReferenceExpression) {
|
|
return null;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private C_Expression getValueIsIn(Expression exp) throws ExpressionParserException {
|
|
ValueIsIn v = (ValueIsIn) exp;
|
|
C_MultivaluedExpression multivalued = parseMultivalued(v.getRightArgument());
|
|
C_ValueIsIn valueIsIn = new C_ValueIsIn(parse(v.getLeftArgument()), multivalued);
|
|
return valueIsIn;
|
|
}
|
|
|
|
private C_Expression getOr(Expression exp) throws ExpressionParserException {
|
|
Or o = (Or) exp;
|
|
List<Expression> listExp = o.getArguments();
|
|
List<C_Expression> listCExp = new ArrayList<C_Expression>();
|
|
C_Expression ex;
|
|
for (Expression serviceExp : listExp) {
|
|
ex = parse(serviceExp);
|
|
listCExp.add(ex);
|
|
}
|
|
C_Or or = new C_Or(listCExp);
|
|
return or;
|
|
}
|
|
|
|
private C_Expression getNot(Expression exp) throws ExpressionParserException {
|
|
Not n = (Not) exp;
|
|
C_Not not = new C_Not(parse(n.getArgument()));
|
|
return not;
|
|
}
|
|
|
|
private C_Expression getIsNull(Expression exp) throws ExpressionParserException {
|
|
IsNull nullIs = (IsNull) exp;
|
|
C_IsNull isNull = new C_IsNull(parse(nullIs.getArgument()));
|
|
return isNull;
|
|
}
|
|
|
|
private C_Expression getIsNotNull(Expression exp) throws ExpressionParserException {
|
|
IsNotNull nullNotIs = (IsNotNull) exp;
|
|
C_IsNotNull isNotNull = new C_IsNotNull(parse(nullNotIs.getArgument()));
|
|
return isNotNull;
|
|
}
|
|
|
|
private C_Expression getBetween(Expression exp) throws ExpressionParserException {
|
|
Between bet = (Between) exp;
|
|
C_Between between = new C_Between(parse(bet.getLeftArgument()), parse(bet.getMinRangeArgument()),
|
|
parse(bet.getMaxRangeArgument()));
|
|
return between;
|
|
}
|
|
|
|
private C_Expression getAnd(Expression exp) throws ExpressionParserException {
|
|
And o = (And) exp;
|
|
List<Expression> listExp = o.getArguments();
|
|
List<C_Expression> listCExp = new ArrayList<C_Expression>();
|
|
C_Expression ex;
|
|
for (Expression serviceExp : listExp) {
|
|
ex = parse(serviceExp);
|
|
listCExp.add(ex);
|
|
}
|
|
C_And and = new C_And(listCExp);
|
|
return and;
|
|
}
|
|
|
|
private C_Expression getTextMatchSQLRegexp(Expression exp) throws ExpressionParserException {
|
|
TextMatchSQLRegexp reg = (TextMatchSQLRegexp) exp;
|
|
C_TextMatchSQLRegexp regExp = new C_TextMatchSQLRegexp(parse(reg.getLeftArgument()),
|
|
parse(reg.getRightArgument()));
|
|
return regExp;
|
|
|
|
}
|
|
|
|
private C_Expression getTextEndWith(Expression exp) throws ExpressionParserException {
|
|
TextEndsWith textEnd = (TextEndsWith) exp;
|
|
C_TextEndsWith textEndWith = new C_TextEndsWith(parse(textEnd.getLeftArgument()),
|
|
parse(textEnd.getRightArgument()));
|
|
return textEndWith;
|
|
}
|
|
|
|
private C_Expression getTextContains(Expression exp) throws ExpressionParserException {
|
|
TextContains textContains = (TextContains) exp;
|
|
C_TextContains textCont = new C_TextContains(parse(textContains.getLeftArgument()),
|
|
parse(textContains.getRightArgument()));
|
|
return textCont;
|
|
}
|
|
|
|
private C_Expression getTextBeginWith(Expression exp) throws ExpressionParserException {
|
|
TextBeginsWith textB = (TextBeginsWith) exp;
|
|
C_TextBeginsWith textBegins = new C_TextBeginsWith(parse(textB.getLeftArgument()),
|
|
parse(textB.getRightArgument()));
|
|
return textBegins;
|
|
}
|
|
|
|
private C_Expression getNotLess(Expression exp) throws ExpressionParserException {
|
|
NotLess notL = (NotLess) exp;
|
|
C_NotLess notLess = new C_NotLess(parse(notL.getLeftArgument()), parse(notL.getRightArgument()));
|
|
return notLess;
|
|
}
|
|
|
|
private C_Expression getNotGreater(Expression exp) throws ExpressionParserException {
|
|
NotGreater notG = (NotGreater) exp;
|
|
C_NotGreater notGreater = new C_NotGreater(parse(notG.getLeftArgument()), parse(notG.getRightArgument()));
|
|
return notGreater;
|
|
}
|
|
|
|
private C_Expression getNotEquals(Expression exp) throws ExpressionParserException {
|
|
NotEquals notE = (NotEquals) exp;
|
|
C_NotEquals notEquals = new C_NotEquals(parse(notE.getLeftArgument()), parse(notE.getRightArgument()));
|
|
return notEquals;
|
|
}
|
|
|
|
private C_Expression getLessThan(Expression exp) throws ExpressionParserException {
|
|
LessThan lessT = (LessThan) exp;
|
|
C_LessThan lessThan = new C_LessThan(parse(lessT.getLeftArgument()), parse(lessT.getRightArgument()));
|
|
return lessThan;
|
|
}
|
|
|
|
private C_Expression getLessOrEquals(Expression exp) throws ExpressionParserException {
|
|
LessOrEquals lessOrE = (LessOrEquals) exp;
|
|
C_LessOrEquals lessOrEquals = new C_LessOrEquals(parse(lessOrE.getLeftArgument()),
|
|
parse(lessOrE.getRightArgument()));
|
|
return lessOrEquals;
|
|
}
|
|
|
|
private C_Expression getGreaterThan(Expression exp) throws ExpressionParserException {
|
|
GreaterThan greaterThan = (GreaterThan) exp;
|
|
C_GreaterThan greater = new C_GreaterThan(parse(greaterThan.getLeftArgument()),
|
|
parse(greaterThan.getRightArgument()));
|
|
return greater;
|
|
|
|
}
|
|
|
|
private C_Expression getGreaterOrEquals(Expression exp) throws ExpressionParserException {
|
|
GreaterOrEquals greaterOrEq = (GreaterOrEquals) exp;
|
|
C_GreaterOrEquals greaterOrEquals = new C_GreaterOrEquals(parse(greaterOrEq.getLeftArgument()),
|
|
parse(greaterOrEq.getRightArgument()));
|
|
return greaterOrEquals;
|
|
|
|
}
|
|
|
|
private TD_Value getExpressionValue(TDTypeValue value) throws ExpressionParserException {
|
|
try {
|
|
if (value instanceof TDBoolean) {
|
|
TDBoolean tdboolean = (TDBoolean) value;
|
|
return new TD_Value(ColumnDataType.Boolean, String.valueOf(tdboolean.getValue()));
|
|
}
|
|
|
|
if (value instanceof TDDate) {
|
|
TDDate tddate = (TDDate) value;
|
|
return new TD_Value(ColumnDataType.Date, sdf.format(tddate.getValue()));
|
|
}
|
|
|
|
if (value instanceof TDGeometry) {
|
|
TDGeometry tdgeometry = (TDGeometry) value;
|
|
return new TD_Value(ColumnDataType.Geometry, tdgeometry.getValue());
|
|
}
|
|
|
|
if (value instanceof TDInteger) {
|
|
TDInteger tdinteger = (TDInteger) value;
|
|
return new TD_Value(ColumnDataType.Integer, String.valueOf(tdinteger.getValue()));
|
|
}
|
|
|
|
if (value instanceof TDNumeric) {
|
|
TDNumeric tdnumeric = (TDNumeric) value;
|
|
return new TD_Value(ColumnDataType.Numeric, String.valueOf(tdnumeric.getValue()));
|
|
}
|
|
|
|
if (value instanceof TDText) {
|
|
TDText tdtext = (TDText) value;
|
|
return new TD_Value(ColumnDataType.Text, String.valueOf(tdtext.getValue()));
|
|
}
|
|
|
|
} catch (Throwable e) {
|
|
logger.error("type error parsing value " + value + " " + e.getLocalizedMessage());
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private ColumnDataType mapColumnDataType(DataType columnDataType) {
|
|
if (columnDataType instanceof IntegerType) {
|
|
return ColumnDataType.Integer;
|
|
} else {
|
|
if (columnDataType instanceof NumericType) {
|
|
return ColumnDataType.Numeric;
|
|
} else {
|
|
if (columnDataType instanceof BooleanType) {
|
|
return ColumnDataType.Boolean;
|
|
} else {
|
|
if (columnDataType instanceof GeometryType) {
|
|
return ColumnDataType.Geometry;
|
|
} else {
|
|
if (columnDataType instanceof TextType) {
|
|
return ColumnDataType.Text;
|
|
} else {
|
|
if (columnDataType instanceof DateType) {
|
|
return ColumnDataType.Date;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private C_Expression getConstantList(Expression exp) throws ExpressionParserException {
|
|
List<TD_Value> l = new ArrayList<TD_Value>();
|
|
ConstantList c = (ConstantList) exp;
|
|
List<TDTypeValue> arguments = c.getArguments();
|
|
TD_Value tdv;
|
|
for (TDTypeValue value : arguments) {
|
|
tdv = getExpressionValue(value);
|
|
l.add(tdv);
|
|
}
|
|
C_ConstantList constList = new C_ConstantList(l);
|
|
return constList;
|
|
}
|
|
|
|
private C_MultivaluedExpression getConstantList(ConstantList c) throws ExpressionParserException {
|
|
List<TD_Value> l = new ArrayList<TD_Value>();
|
|
List<TDTypeValue> arguments = c.getArguments();
|
|
TD_Value tdv;
|
|
for (TDTypeValue value : arguments) {
|
|
tdv = getExpressionValue(value);
|
|
l.add(tdv);
|
|
}
|
|
C_ConstantList constList = new C_ConstantList(l);
|
|
return constList;
|
|
}
|
|
|
|
private C_Expression getColumnReferencePlaceholder(Expression exp) {
|
|
ColumnReferencePlaceholder c = (ColumnReferencePlaceholder) exp;
|
|
C_ColumnReferencePlaceholder col = new C_ColumnReferencePlaceholder(mapColumnDataType(c.getDatatype()),
|
|
c.getId(), c.getLabel());
|
|
|
|
return col;
|
|
}
|
|
|
|
private C_Expression getColumnReference(Expression exp) {
|
|
ColumnReference c = (ColumnReference) exp;
|
|
String tableId = String.valueOf(c.getTableId().getValue());
|
|
String columnId = c.getColumnId().getValue();
|
|
ColumnDataType columnDataType = mapColumnDataType(c.getType());
|
|
TRId trId = new TRId();
|
|
trId.setTableId(tableId);
|
|
trId.setViewTable(false);
|
|
ColumnData column = new ColumnData();
|
|
column.setId(columnId);
|
|
column.setColumnId(columnId);
|
|
column.setTrId(trId);
|
|
column.setDataTypeName(columnDataType.toString());
|
|
column.setLabel("Unknow");
|
|
C_ColumnReference ref = new C_ColumnReference(column);
|
|
return ref;
|
|
}
|
|
|
|
private C_Expression getUpper(Expression exp) throws ExpressionParserException {
|
|
Upper e = (Upper) exp;
|
|
C_Expression arg = parse(e.getArgument());
|
|
C_Upper upper = new C_Upper(arg);
|
|
return upper;
|
|
}
|
|
|
|
private C_Expression getLower(Expression exp) throws ExpressionParserException {
|
|
Lower e = (Lower) exp;
|
|
C_Expression arg = parse(e.getArgument());
|
|
C_Lower lower = new C_Lower(arg);
|
|
return lower;
|
|
}
|
|
|
|
private C_Expression getTrim(Expression exp) throws ExpressionParserException {
|
|
Trim e = (Trim) exp;
|
|
C_Expression arg = parse(e.getArgument());
|
|
C_Trim trim = new C_Trim(arg);
|
|
return trim;
|
|
}
|
|
|
|
private C_Expression getMD5(Expression exp) throws ExpressionParserException {
|
|
MD5 e = (MD5) exp;
|
|
C_Expression arg = parse(e.getArgument());
|
|
C_MD5 md5 = new C_MD5(arg);
|
|
return md5;
|
|
}
|
|
|
|
private C_Expression getSoundex(Expression exp) throws ExpressionParserException {
|
|
Soundex e = (Soundex) exp;
|
|
C_Expression arg = parse(e.getArgument());
|
|
C_Soundex soundex = new C_Soundex(arg);
|
|
return soundex;
|
|
}
|
|
|
|
private C_Expression getLevenshtein(Expression exp) throws ExpressionParserException {
|
|
Levenshtein e = (Levenshtein) exp;
|
|
C_Expression left = parse(e.getLeftArgument());
|
|
C_Expression right = parse(e.getRightArgument());
|
|
|
|
C_Levenshtein levenshtein = new C_Levenshtein(left, right);
|
|
return levenshtein;
|
|
}
|
|
|
|
private C_Expression getSimilarity(Expression exp) throws ExpressionParserException {
|
|
Similarity e = (Similarity) exp;
|
|
C_Expression left = parse(e.getLeftArgument());
|
|
C_Expression right = parse(e.getRightArgument());
|
|
|
|
C_Similarity similarity = new C_Similarity(left, right);
|
|
return similarity;
|
|
}
|
|
|
|
private C_Expression getEquals(Expression exp) throws ExpressionParserException {
|
|
Equals e = (Equals) exp;
|
|
C_Expression left = parse(e.getLeftArgument());
|
|
C_Expression right = parse(e.getRightArgument());
|
|
C_Equals eq = new C_Equals(left, right);
|
|
return eq;
|
|
}
|
|
|
|
private C_Expression getConcat(Expression exp) throws ExpressionParserException {
|
|
Concat concat = (Concat) exp;
|
|
C_Concat conc = new C_Concat(parse(concat.getLeftArgument()), parse(concat.getRightArgument()));
|
|
return conc;
|
|
}
|
|
|
|
private C_Expression getSubstringByIndex(Expression exp) throws ExpressionParserException {
|
|
SubstringByIndex subByIndex = (SubstringByIndex) exp;
|
|
C_SubstringByIndex sByIndex = new C_SubstringByIndex(parse(subByIndex.getSourceString()),
|
|
parse(subByIndex.getFromIndex()), parse(subByIndex.getToIndex()));
|
|
return sByIndex;
|
|
}
|
|
|
|
private C_Expression getSubstringByRegex(Expression exp) throws ExpressionParserException {
|
|
SubstringByRegex subByRegex = (SubstringByRegex) exp;
|
|
C_SubstringByRegex sByRegex = new C_SubstringByRegex(parse(subByRegex.getLeftArgument()),
|
|
parse(subByRegex.getRightArgument()));
|
|
return sByRegex;
|
|
}
|
|
|
|
private C_Expression getSubstringPosition(Expression exp) throws ExpressionParserException {
|
|
SubstringPosition subPosition = (SubstringPosition) exp;
|
|
C_SubstringPosition sPosition = new C_SubstringPosition(parse(subPosition.getLeftArgument()),
|
|
parse(subPosition.getRightArgument()));
|
|
return sPosition;
|
|
}
|
|
|
|
private C_Expression getTextReplaceMatchingRegex(Expression exp) throws ExpressionParserException {
|
|
TextReplaceMatchingRegex textReplaceMatchingRegex = (TextReplaceMatchingRegex) exp;
|
|
TD_Value replacing = getExpressionValue(textReplaceMatchingRegex.getReplacingValue());
|
|
TD_Value regexp = getExpressionValue(textReplaceMatchingRegex.getRegexp());
|
|
C_Expression toCheckText = parse(textReplaceMatchingRegex.getToCheckText());
|
|
|
|
C_TextReplaceMatchingRegex textRepRegex = new C_TextReplaceMatchingRegex(toCheckText, regexp, replacing);
|
|
return textRepRegex;
|
|
}
|
|
|
|
private C_Expression getAvg(Expression exp) throws ExpressionParserException {
|
|
Avg avg = (Avg) exp;
|
|
C_Avg av = new C_Avg(parse(avg.getArgument()));
|
|
return av;
|
|
}
|
|
|
|
private C_Expression getCount(Expression exp) throws ExpressionParserException {
|
|
Count count = (Count) exp;
|
|
C_Count cnt = new C_Count(parse(count.getArgument()));
|
|
return cnt;
|
|
}
|
|
|
|
private C_Expression getMax(Expression exp) throws ExpressionParserException {
|
|
Max max = (Max) exp;
|
|
C_Max ma = new C_Max(parse(max.getArgument()));
|
|
return ma;
|
|
}
|
|
|
|
private C_Expression getMin(Expression exp) throws ExpressionParserException {
|
|
Min min = (Min) exp;
|
|
C_Min mi = new C_Min(parse(min.getArgument()));
|
|
return mi;
|
|
}
|
|
|
|
private C_Expression getSTExtent(Expression exp) throws ExpressionParserException {
|
|
ST_Extent stExtent = (ST_Extent) exp;
|
|
C_ST_Extent stEx = new C_ST_Extent(parse(stExtent.getArgument()));
|
|
return stEx;
|
|
}
|
|
|
|
private C_Expression getSum(Expression exp) throws ExpressionParserException {
|
|
Sum sum = (Sum) exp;
|
|
C_Sum sm = new C_Sum(parse(sum.getArgument()));
|
|
return sm;
|
|
}
|
|
|
|
private C_Expression getCast(Expression exp) throws ExpressionParserException {
|
|
Cast castExp = (Cast) exp;
|
|
C_Cast sm = new C_Cast(parse(castExp.getArgument()), mapColumnDataType(castExp.getCastToType()));
|
|
return sm;
|
|
}
|
|
|
|
private C_Expression getAddition(Expression exp) throws ExpressionParserException {
|
|
Addition addition = (Addition) exp;
|
|
C_Addition add = new C_Addition(parse(addition.getLeftArgument()), parse(addition.getRightArgument()));
|
|
return add;
|
|
}
|
|
|
|
private C_Expression getSubtraction(Expression exp) throws ExpressionParserException {
|
|
Subtraction subtraction = (Subtraction) exp;
|
|
C_Subtraction sub = new C_Subtraction(parse(subtraction.getLeftArgument()),
|
|
parse(subtraction.getRightArgument()));
|
|
return sub;
|
|
}
|
|
|
|
private C_Expression getModulus(Expression exp) throws ExpressionParserException {
|
|
Modulus modulus = (Modulus) exp;
|
|
C_Modulus modu = new C_Modulus(parse(modulus.getLeftArgument()), parse(modulus.getRightArgument()));
|
|
return modu;
|
|
}
|
|
|
|
private C_Expression getMultiplication(Expression exp) throws ExpressionParserException {
|
|
Multiplication multiplication = (Multiplication) exp;
|
|
C_Multiplication multi = new C_Multiplication(parse(multiplication.getLeftArgument()),
|
|
parse(multiplication.getRightArgument()));
|
|
return multi;
|
|
}
|
|
|
|
private C_Expression getDivision(Expression exp) throws ExpressionParserException {
|
|
Division division = (Division) exp;
|
|
C_Division divi = new C_Division(parse(division.getLeftArgument()), parse(division.getRightArgument()));
|
|
return divi;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param exp
|
|
* Client expression
|
|
* @return Expression
|
|
* @throws ExpressionParserException
|
|
* Exception
|
|
*/
|
|
public Expression parse(C_Expression exp) throws ExpressionParserException {
|
|
logger.debug("Parse: " + exp);
|
|
Expression ex = null;
|
|
|
|
switch (exp.getId()) {
|
|
case "ColumnReferencePlaceholder":
|
|
ex = getColumnReferencePlaceholder(exp);
|
|
break;
|
|
case "ConstantList":
|
|
ex = getConstantlist(exp);
|
|
break;
|
|
case "ColumnReference":
|
|
ex = getColumnReference(exp);
|
|
break;
|
|
case "TD_Value":
|
|
TD_Value value = (TD_Value) exp;
|
|
ex = getExpressionValue(value);
|
|
break;
|
|
case "Equals":
|
|
ex = getEquals(exp);
|
|
break;
|
|
case "GreaterOrEquals":
|
|
ex = getGreaterOrEquals(exp);
|
|
break;
|
|
case "GreaterThan":
|
|
ex = getGreaterThan(exp);
|
|
break;
|
|
case "LessOrEquals":
|
|
ex = getLessOrEquals(exp);
|
|
break;
|
|
case "LessThan":
|
|
ex = getLessThan(exp);
|
|
break;
|
|
case "NotEquals":
|
|
ex = getNotEquals(exp);
|
|
break;
|
|
case "NotGreater":
|
|
ex = getNotGreater(exp);
|
|
break;
|
|
case "NotLess":
|
|
ex = getNotLess(exp);
|
|
break;
|
|
case "TextBeginsWith":
|
|
ex = getTextBeginWith(exp);
|
|
break;
|
|
case "TextContains":
|
|
ex = getTextContains(exp);
|
|
break;
|
|
case "TextEndsWith":
|
|
ex = getTextEndWith(exp);
|
|
break;
|
|
case "TextMatchSQLRegexp":
|
|
ex = getTextMatchSQLRegexp(exp);
|
|
break;
|
|
case "And":
|
|
ex = getAnd(exp);
|
|
break;
|
|
case "Between":
|
|
ex = getBetween(exp);
|
|
break;
|
|
case "IsNotNull":
|
|
ex = getIsNotNull(exp);
|
|
break;
|
|
case "IsNull":
|
|
ex = getIsNull(exp);
|
|
break;
|
|
case "Not":
|
|
ex = getNot(exp);
|
|
break;
|
|
case "Or":
|
|
ex = getOr(exp);
|
|
break;
|
|
case "ValueIsIn":
|
|
ex = getValueIsIn(exp);
|
|
break;
|
|
case "Concat":
|
|
ex = getConcat(exp);
|
|
break;
|
|
case "SubstringByIndex":
|
|
ex = getSubstringByIndex(exp);
|
|
break;
|
|
case "SubstringByRegex":
|
|
ex = getSubstringByRegex(exp);
|
|
break;
|
|
case "SubstringPosition":
|
|
ex = getSubstringPosition(exp);
|
|
break;
|
|
case "TextReplaceMatchingRegex":
|
|
ex = getTextReplaceMatchingRegex(exp);
|
|
break;
|
|
case "Avg":
|
|
ex = getAvg(exp);
|
|
break;
|
|
case "Count":
|
|
ex = getCount(exp);
|
|
break;
|
|
case "Max":
|
|
ex = getMax(exp);
|
|
break;
|
|
case "Min":
|
|
ex = getMin(exp);
|
|
break;
|
|
case "Sum":
|
|
ex = getSum(exp);
|
|
break;
|
|
case "ST_Extent":
|
|
ex = getSTExtent(exp);
|
|
break;
|
|
case "Cast":
|
|
ex = getCast(exp);
|
|
break;
|
|
case "Addition":
|
|
ex = getAddition(exp);
|
|
break;
|
|
case "Subtraction":
|
|
ex = getSubtraction(exp);
|
|
break;
|
|
case "Modulus":
|
|
ex = getModulus(exp);
|
|
break;
|
|
case "Multiplication":
|
|
ex = getMultiplication(exp);
|
|
break;
|
|
case "Division":
|
|
ex = getDivision(exp);
|
|
break;
|
|
case "Upper":
|
|
ex = getUpper(exp);
|
|
break;
|
|
case "Lower":
|
|
ex = getLower(exp);
|
|
break;
|
|
case "Trim":
|
|
ex = getTrim(exp);
|
|
break;
|
|
case "MD5":
|
|
ex = getMD5(exp);
|
|
break;
|
|
case "Soundex":
|
|
ex = getSoundex(exp);
|
|
break;
|
|
case "Levenshtein":
|
|
ex = getLevenshtein(exp);
|
|
break;
|
|
case "Similarity":
|
|
ex = getSimilarity(exp);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ex;
|
|
}
|
|
|
|
public MultivaluedExpression parseMultivalued(C_MultivaluedExpression exp) throws ExpressionParserException {
|
|
MultivaluedExpression ex = null;
|
|
switch (exp.getIdMulti()) {
|
|
case "ConstantList":
|
|
ex = getConstantlist(exp);
|
|
break;
|
|
case "ExternalReferenceExpression":
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return ex;
|
|
}
|
|
|
|
private Expression getValueIsIn(C_Expression exp) throws ExpressionParserException {
|
|
C_ValueIsIn v = (C_ValueIsIn) exp;
|
|
MultivaluedExpression multivalued = parseMultivalued(v.getRightArgument());
|
|
ValueIsIn valueIsIn = new ValueIsIn(parse(v.getLeftArgument()), multivalued);
|
|
return valueIsIn;
|
|
}
|
|
|
|
private Expression getOr(C_Expression exp) throws ExpressionParserException {
|
|
C_Or o = (C_Or) exp;
|
|
List<C_Expression> listCExp = o.getArguments();
|
|
List<Expression> listExp = new ArrayList<Expression>();
|
|
Expression ex;
|
|
for (C_Expression cexp : listCExp) {
|
|
ex = parse(cexp);
|
|
listExp.add(ex);
|
|
}
|
|
Or or = new Or(listExp);
|
|
return or;
|
|
}
|
|
|
|
private Expression getNot(C_Expression exp) throws ExpressionParserException {
|
|
C_Not n = (C_Not) exp;
|
|
Not not = new Not(parse(n.getArgument()));
|
|
return not;
|
|
}
|
|
|
|
private Expression getIsNull(C_Expression exp) throws ExpressionParserException {
|
|
C_IsNull nullIs = (C_IsNull) exp;
|
|
IsNull isNull = new IsNull(parse(nullIs.getArgument()));
|
|
return isNull;
|
|
}
|
|
|
|
private Expression getIsNotNull(C_Expression exp) throws ExpressionParserException {
|
|
C_IsNotNull nullNotIs = (C_IsNotNull) exp;
|
|
IsNotNull isNotNull = new IsNotNull(parse(nullNotIs.getArgument()));
|
|
return isNotNull;
|
|
}
|
|
|
|
private Expression getBetween(C_Expression exp) throws ExpressionParserException {
|
|
C_Between bet = (C_Between) exp;
|
|
Between between = new Between(parse(bet.getLeftArgument()), parse(bet.getMinRangeArgument()),
|
|
parse(bet.getMaxRangeArgument()));
|
|
|
|
return between;
|
|
}
|
|
|
|
private Expression getAnd(C_Expression exp) throws ExpressionParserException {
|
|
C_And o = (C_And) exp;
|
|
List<C_Expression> listCExp = o.getArguments();
|
|
List<Expression> listExp = new ArrayList<Expression>();
|
|
Expression ex;
|
|
for (C_Expression cexp : listCExp) {
|
|
ex = parse(cexp);
|
|
listExp.add(ex);
|
|
}
|
|
And and = new And(listExp);
|
|
return and;
|
|
}
|
|
|
|
private Expression getTextMatchSQLRegexp(C_Expression exp) throws ExpressionParserException {
|
|
C_TextMatchSQLRegexp reg = (C_TextMatchSQLRegexp) exp;
|
|
TextMatchSQLRegexp regExp = new TextMatchSQLRegexp(parse(reg.getLeftArgument()), parse(reg.getRightArgument()));
|
|
return regExp;
|
|
|
|
}
|
|
|
|
private Expression getTextEndWith(C_Expression exp) throws ExpressionParserException {
|
|
C_TextEndsWith textEnd = (C_TextEndsWith) exp;
|
|
TextEndsWith textEndWith = new TextEndsWith(parse(textEnd.getLeftArgument()),
|
|
parse(textEnd.getRightArgument()));
|
|
return textEndWith;
|
|
}
|
|
|
|
private Expression getTextContains(C_Expression exp) throws ExpressionParserException {
|
|
C_TextContains textContains = (C_TextContains) exp;
|
|
TextContains textCont = new TextContains(parse(textContains.getLeftArgument()),
|
|
parse(textContains.getRightArgument()));
|
|
return textCont;
|
|
}
|
|
|
|
private Expression getTextBeginWith(C_Expression exp) throws ExpressionParserException {
|
|
C_TextBeginsWith textB = (C_TextBeginsWith) exp;
|
|
TextBeginsWith textBegins = new TextBeginsWith(parse(textB.getLeftArgument()), parse(textB.getRightArgument()));
|
|
return textBegins;
|
|
}
|
|
|
|
private Expression getNotLess(C_Expression exp) throws ExpressionParserException {
|
|
C_NotLess notL = (C_NotLess) exp;
|
|
NotLess notLess = new NotLess(parse(notL.getLeftArgument()), parse(notL.getRightArgument()));
|
|
return notLess;
|
|
}
|
|
|
|
private Expression getNotGreater(C_Expression exp) throws ExpressionParserException {
|
|
C_NotGreater notG = (C_NotGreater) exp;
|
|
NotGreater notGreater = new NotGreater(parse(notG.getLeftArgument()), parse(notG.getRightArgument()));
|
|
return notGreater;
|
|
}
|
|
|
|
private Expression getNotEquals(C_Expression exp) throws ExpressionParserException {
|
|
C_NotEquals notE = (C_NotEquals) exp;
|
|
NotEquals notEquals = new NotEquals(parse(notE.getLeftArgument()), parse(notE.getRightArgument()));
|
|
return notEquals;
|
|
}
|
|
|
|
private Expression getLessThan(C_Expression exp) throws ExpressionParserException {
|
|
C_LessThan lessT = (C_LessThan) exp;
|
|
LessThan lessThan = new LessThan(parse(lessT.getLeftArgument()), parse(lessT.getRightArgument()));
|
|
return lessThan;
|
|
}
|
|
|
|
private Expression getLessOrEquals(C_Expression exp) throws ExpressionParserException {
|
|
C_LessOrEquals lessOrE = (C_LessOrEquals) exp;
|
|
LessOrEquals lessOrEquals = new LessOrEquals(parse(lessOrE.getLeftArgument()),
|
|
parse(lessOrE.getRightArgument()));
|
|
return lessOrEquals;
|
|
}
|
|
|
|
private Expression getGreaterThan(C_Expression exp) throws ExpressionParserException {
|
|
C_GreaterThan greaterThan = (C_GreaterThan) exp;
|
|
GreaterThan greater = new GreaterThan(parse(greaterThan.getLeftArgument()),
|
|
parse(greaterThan.getRightArgument()));
|
|
return greater;
|
|
|
|
}
|
|
|
|
private Expression getGreaterOrEquals(C_Expression exp) throws ExpressionParserException {
|
|
C_GreaterOrEquals greaterOrEq = (C_GreaterOrEquals) exp;
|
|
GreaterOrEquals greaterOrEquals = new GreaterOrEquals(parse(greaterOrEq.getLeftArgument()),
|
|
parse(greaterOrEq.getRightArgument()));
|
|
return greaterOrEquals;
|
|
|
|
}
|
|
|
|
private TDTypeValue getExpressionValue(TD_Value value) throws ExpressionParserException {
|
|
|
|
TDTypeValue ex = null;
|
|
try {
|
|
switch (value.getValueType()) {
|
|
case Boolean:
|
|
ex = new TDBoolean(Boolean.valueOf(value.getValue()));
|
|
break;
|
|
case Date:
|
|
Date d = null;
|
|
try {
|
|
d = sdf.parse(value.getValue());
|
|
} catch (ParseException e) {
|
|
logger.error("Unparseable using " + sdf);
|
|
throw new ExpressionParserException(value.getValue() + " is not valid Date type");
|
|
}
|
|
ex = new TDDate(d);
|
|
break;
|
|
case Geometry:
|
|
if (TDGeometry.validateGeometry(value.getValue())) {
|
|
ex = new TDGeometry(value.getValue());
|
|
} else {
|
|
throw new ExpressionParserException(value.getValue() + " is not valid Geometry type");
|
|
}
|
|
break;
|
|
case Integer:
|
|
Integer vInteger;
|
|
try {
|
|
vInteger = Integer.valueOf(value.getValue());
|
|
} catch (NumberFormatException e) {
|
|
throw new ExpressionParserException(value.getValue() + " is not valid Integer type");
|
|
}
|
|
ex = new TDInteger(vInteger);
|
|
break;
|
|
case Numeric:
|
|
Double vNumeric;
|
|
try {
|
|
vNumeric = Double.valueOf(value.getValue());
|
|
} catch (NumberFormatException e) {
|
|
throw new ExpressionParserException(value.getValue() + " is not valid Double type");
|
|
}
|
|
ex = new TDNumeric(vNumeric);
|
|
break;
|
|
case Text:
|
|
if (value.getValue() == null) {
|
|
ex = new TDText("");
|
|
} else {
|
|
ex = new TDText(value.getValue());
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} catch (Throwable e) {
|
|
logger.error("type error parsing value " + value + " " + e.getLocalizedMessage());
|
|
}
|
|
return ex;
|
|
}
|
|
|
|
private DataType mapColumnDataType(ColumnDataType columnDataType) {
|
|
if (columnDataType == ColumnDataType.Integer) {
|
|
return new IntegerType();
|
|
} else {
|
|
if (columnDataType == ColumnDataType.Numeric) {
|
|
return new NumericType();
|
|
} else {
|
|
if (columnDataType == ColumnDataType.Boolean) {
|
|
return new BooleanType();
|
|
} else {
|
|
if (columnDataType == ColumnDataType.Geometry) {
|
|
return new GeometryType();
|
|
} else {
|
|
if (columnDataType == ColumnDataType.Text) {
|
|
return new TextType();
|
|
} else {
|
|
if (columnDataType == ColumnDataType.Date) {
|
|
return new DateType();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private Expression getConstantlist(C_Expression exp) throws ExpressionParserException {
|
|
List<TDTypeValue> l = new ArrayList<TDTypeValue>();
|
|
C_ConstantList c = (C_ConstantList) exp;
|
|
List<TD_Value> arguments = c.getArguments();
|
|
TDTypeValue tdv;
|
|
for (TD_Value value : arguments) {
|
|
tdv = getExpressionValue(value);
|
|
l.add(tdv);
|
|
}
|
|
ConstantList constList = new ConstantList(l);
|
|
return constList;
|
|
}
|
|
|
|
private MultivaluedExpression getConstantlist(C_MultivaluedExpression exp) throws ExpressionParserException {
|
|
List<TDTypeValue> l = new ArrayList<TDTypeValue>();
|
|
C_ConstantList c = (C_ConstantList) exp;
|
|
List<TD_Value> arguments = c.getArguments();
|
|
TDTypeValue tdv;
|
|
for (TD_Value value : arguments) {
|
|
tdv = getExpressionValue(value);
|
|
l.add(tdv);
|
|
}
|
|
ConstantList constList = new ConstantList(l);
|
|
return constList;
|
|
}
|
|
|
|
private Expression getColumnReferencePlaceholder(C_Expression exp) {
|
|
C_ColumnReferencePlaceholder c = (C_ColumnReferencePlaceholder) exp;
|
|
ColumnReferencePlaceholder col = new ColumnReferencePlaceholder(mapColumnDataType(c.getDataType()),
|
|
c.getColumnId(), c.getLabel());
|
|
return col;
|
|
}
|
|
|
|
private Expression getColumnReference(C_Expression exp) {
|
|
C_ColumnReference c = (C_ColumnReference) exp;
|
|
String tableIdS = null;
|
|
if (c.getColumn().getTrId().isViewTable()) {
|
|
tableIdS = c.getColumn().getTrId().getReferenceTargetTableId();
|
|
} else {
|
|
tableIdS = c.getColumn().getTrId().getTableId();
|
|
}
|
|
TableId tableId = new TableId(Long.valueOf(tableIdS));
|
|
ColumnLocalId columnId = new ColumnLocalId(c.getColumn().getColumnId());
|
|
|
|
ColumnReference ref = new ColumnReference(tableId, columnId,
|
|
mapColumnDataType(ColumnDataType.getColumnDataTypeFromId(c.getColumn().getDataTypeName())));
|
|
return ref;
|
|
}
|
|
|
|
private Expression getUpper(C_Expression exp) throws ExpressionParserException {
|
|
C_Upper e = (C_Upper) exp;
|
|
Expression arg = parse(e.getArgument());
|
|
Upper upper = new Upper(arg);
|
|
return upper;
|
|
}
|
|
|
|
private Expression getLower(C_Expression exp) throws ExpressionParserException {
|
|
C_Lower e = (C_Lower) exp;
|
|
Expression arg = parse(e.getArgument());
|
|
Lower lower = new Lower(arg);
|
|
return lower;
|
|
}
|
|
|
|
private Expression getTrim(C_Expression exp) throws ExpressionParserException {
|
|
C_Trim e = (C_Trim) exp;
|
|
Expression arg = parse(e.getArgument());
|
|
Trim trim = new Trim(arg);
|
|
return trim;
|
|
}
|
|
|
|
private Expression getMD5(C_Expression exp) throws ExpressionParserException {
|
|
C_MD5 e = (C_MD5) exp;
|
|
Expression arg = parse(e.getArgument());
|
|
MD5 md5 = new MD5(arg);
|
|
return md5;
|
|
}
|
|
|
|
private Expression getSoundex(C_Expression exp) throws ExpressionParserException {
|
|
C_Soundex e = (C_Soundex) exp;
|
|
Expression arg = parse(e.getArgument());
|
|
Soundex soundex = new Soundex(arg);
|
|
return soundex;
|
|
}
|
|
|
|
private Expression getLevenshtein(C_Expression exp) throws ExpressionParserException {
|
|
C_Levenshtein e = (C_Levenshtein) exp;
|
|
Expression left = parse(e.getLeftArgument());
|
|
Expression right = parse(e.getRightArgument());
|
|
|
|
Levenshtein levenshtein = new Levenshtein(left, right);
|
|
return levenshtein;
|
|
}
|
|
|
|
private Expression getSimilarity(C_Expression exp) throws ExpressionParserException {
|
|
C_Similarity e = (C_Similarity) exp;
|
|
Expression left = parse(e.getLeftArgument());
|
|
Expression right = parse(e.getRightArgument());
|
|
|
|
Similarity similarity = new Similarity(left, right);
|
|
return similarity;
|
|
}
|
|
|
|
private Expression getEquals(C_Expression exp) throws ExpressionParserException {
|
|
C_Equals e = (C_Equals) exp;
|
|
Expression left = parse(e.getLeftArgument());
|
|
Expression right = parse(e.getRightArgument());
|
|
Equals eq = new Equals(left, right);
|
|
return eq;
|
|
}
|
|
|
|
private Expression getConcat(C_Expression exp) throws ExpressionParserException {
|
|
C_Concat concat = (C_Concat) exp;
|
|
Concat conc = new Concat(parse(concat.getLeftArgument()), parse(concat.getRightArgument()));
|
|
return conc;
|
|
}
|
|
|
|
private Expression getSubstringByIndex(C_Expression exp) throws ExpressionParserException {
|
|
C_SubstringByIndex subByIndex = (C_SubstringByIndex) exp;
|
|
SubstringByIndex sByIndex = new SubstringByIndex(parse(subByIndex.getSourceString()),
|
|
parse(subByIndex.getFromIndex()), parse(subByIndex.getToIndex()));
|
|
return sByIndex;
|
|
}
|
|
|
|
private Expression getSubstringByRegex(C_Expression exp) throws ExpressionParserException {
|
|
C_SubstringByRegex subByRegex = (C_SubstringByRegex) exp;
|
|
SubstringByRegex sByRegex = new SubstringByRegex(parse(subByRegex.getSourceString()),
|
|
parse(subByRegex.getRegex()));
|
|
return sByRegex;
|
|
}
|
|
|
|
private Expression getSubstringPosition(C_Expression exp) throws ExpressionParserException {
|
|
C_SubstringPosition subPosition = (C_SubstringPosition) exp;
|
|
SubstringPosition sPosition = new SubstringPosition(parse(subPosition.getLeftArgument()),
|
|
parse(subPosition.getRightArgument()));
|
|
return sPosition;
|
|
}
|
|
|
|
private Expression getTextReplaceMatchingRegex(C_Expression exp) throws ExpressionParserException {
|
|
C_TextReplaceMatchingRegex textReplaceMatchingRegex = (C_TextReplaceMatchingRegex) exp;
|
|
TDText tdRegexp = new TDText(textReplaceMatchingRegex.getRegexp().getValue());
|
|
|
|
String replacement = textReplaceMatchingRegex.getReplacing().getValue();
|
|
if (replacement == null) {
|
|
replacement = "";
|
|
}
|
|
TDText tdReplacing = new TDText(replacement);
|
|
|
|
TextReplaceMatchingRegex textRepRegex = new TextReplaceMatchingRegex(
|
|
parse(textReplaceMatchingRegex.getToCheckText()), tdRegexp, tdReplacing);
|
|
return textRepRegex;
|
|
}
|
|
|
|
private Expression getAvg(C_Expression exp) throws ExpressionParserException {
|
|
C_Avg avg = (C_Avg) exp;
|
|
Avg av = new Avg(parse(avg.getArgument()));
|
|
return av;
|
|
}
|
|
|
|
private Expression getCount(C_Expression exp) throws ExpressionParserException {
|
|
C_Count count = (C_Count) exp;
|
|
Count cnt = new Count(parse(count.getArgument()));
|
|
return cnt;
|
|
}
|
|
|
|
private Expression getMax(C_Expression exp) throws ExpressionParserException {
|
|
C_Max max = (C_Max) exp;
|
|
Max ma = new Max(parse(max.getArgument()));
|
|
return ma;
|
|
}
|
|
|
|
private Expression getMin(C_Expression exp) throws ExpressionParserException {
|
|
C_Min min = (C_Min) exp;
|
|
Min mi = new Min(parse(min.getArgument()));
|
|
return mi;
|
|
}
|
|
|
|
private Expression getSTExtent(C_Expression exp) throws ExpressionParserException {
|
|
C_ST_Extent stExtent = (C_ST_Extent) exp;
|
|
ST_Extent stEx = new ST_Extent(parse(stExtent.getArgument()));
|
|
return stEx;
|
|
}
|
|
|
|
private Expression getSum(C_Expression exp) throws ExpressionParserException {
|
|
C_Sum sum = (C_Sum) exp;
|
|
Sum sm = new Sum(parse(sum.getArgument()));
|
|
return sm;
|
|
}
|
|
|
|
private Expression getCast(C_Expression exp) throws ExpressionParserException {
|
|
C_Cast castExp = (C_Cast) exp;
|
|
Cast sm = new Cast(parse(castExp.getLeftArgument()), mapColumnDataType(castExp.getRightArgument()));
|
|
return sm;
|
|
}
|
|
|
|
private Expression getAddition(C_Expression exp) throws ExpressionParserException {
|
|
C_Addition addition = (C_Addition) exp;
|
|
Addition add = new Addition(parse(addition.getLeftArgument()), parse(addition.getRightArgument()));
|
|
return add;
|
|
}
|
|
|
|
private Expression getSubtraction(C_Expression exp) throws ExpressionParserException {
|
|
C_Subtraction subtraction = (C_Subtraction) exp;
|
|
Subtraction sub = new Subtraction(parse(subtraction.getLeftArgument()), parse(subtraction.getRightArgument()));
|
|
return sub;
|
|
}
|
|
|
|
private Expression getModulus(C_Expression exp) throws ExpressionParserException {
|
|
C_Modulus modulus = (C_Modulus) exp;
|
|
Modulus modu = new Modulus(parse(modulus.getLeftArgument()), parse(modulus.getRightArgument()));
|
|
return modu;
|
|
}
|
|
|
|
private Expression getMultiplication(C_Expression exp) throws ExpressionParserException {
|
|
C_Multiplication multiplication = (C_Multiplication) exp;
|
|
Multiplication multi = new Multiplication(parse(multiplication.getLeftArgument()),
|
|
parse(multiplication.getRightArgument()));
|
|
return multi;
|
|
}
|
|
|
|
private Expression getDivision(C_Expression exp) throws ExpressionParserException {
|
|
C_Division division = (C_Division) exp;
|
|
Division divi = new Division(parse(division.getLeftArgument()), parse(division.getRightArgument()));
|
|
return divi;
|
|
}
|
|
|
|
}
|