use of org.datanucleus.store.rdbms.sql.expression.CharacterExpression in project datanucleus-rdbms by datanucleus.
the class StringIndexOf3Method method getExpression.
/* (non-Javadoc)
* @see org.datanucleus.store.rdbms.sql.method.SQLMethod#getExpression(org.datanucleus.store.rdbms.sql.expression.SQLExpression, java.util.List)
*/
public SQLExpression getExpression(SQLStatement stmt, SQLExpression expr, List<SQLExpression> args) {
if (args == null || args.size() == 0 || args.size() > 2) {
throw new NucleusException(Localiser.msg("060003", "indexOf", "StringExpression", 0, "StringExpression/CharacterExpression/ParameterLiteral"));
}
// {stringExpr}.indexOf(strExpr1 [,numExpr2])
SQLExpression one = ExpressionUtils.getLiteralForOne(stmt);
ArrayList funcArgs = new ArrayList();
funcArgs.add(expr);
List funcArgs2 = new ArrayList();
SQLExpression substrExpr = args.get(0);
if (!(substrExpr instanceof StringExpression) && !(substrExpr instanceof CharacterExpression) && !(substrExpr instanceof ParameterLiteral)) {
throw new NucleusException(Localiser.msg("060003", "indexOf", "StringExpression", 0, "StringExpression/CharacterExpression/ParameterLiteral"));
}
funcArgs2.add(substrExpr);
List types = new ArrayList();
// max 4000 according DB2 docs
types.add("VARCHAR(4000)");
funcArgs.add(new StringExpression(stmt, stmt.getSQLExpressionFactory().getMappingForType(String.class, true), "CAST", funcArgs2, types));
if (args.size() == 2) {
SQLExpression fromExpr = args.get(1);
if (!(fromExpr instanceof NumericExpression)) {
throw new NucleusException(Localiser.msg("060003", "indexOf", "StringExpression", 1, "NumericExpression"));
}
types = new ArrayList();
types.add("BIGINT");
List funcArgs3 = new ArrayList();
funcArgs3.add(new NumericExpression(fromExpr, Expression.OP_ADD, one));
// Add 1 to the passed in value so that it is of origin 1 to be compatible with LOCATE
// Make sure argument is typed as BIGINT
funcArgs.add(new NumericExpression(stmt, stmt.getSQLExpressionFactory().getMappingForType(int.class, true), "CAST", funcArgs3, types));
}
NumericExpression locateExpr = new NumericExpression(stmt, stmt.getSQLExpressionFactory().getMappingForType(int.class, true), "LOCATE", funcArgs);
// Subtract 1 from the result of LOCATE to be consistent with Java strings
return new NumericExpression(locateExpr, Expression.OP_SUB, one).encloseInParentheses();
}
use of org.datanucleus.store.rdbms.sql.expression.CharacterExpression in project datanucleus-rdbms by datanucleus.
the class MapContainsValueMethod method getExpression.
/* (non-Javadoc)
* @see org.datanucleus.store.rdbms.sql.method.SQLMethod#getExpression(org.datanucleus.store.rdbms.sql.expression.SQLExpression, java.util.List)
*/
public SQLExpression getExpression(SQLStatement stmt, SQLExpression expr, List<SQLExpression> args) {
if (args == null || args.size() == 0 || args.size() > 1) {
throw new NucleusException(Localiser.msg("060016", "containsValue", "MapExpression", 1));
}
MapExpression mapExpr = (MapExpression) expr;
SQLExpression valExpr = args.get(0);
if (valExpr.isParameter()) {
// Value is a parameter so make sure its type is set
AbstractMemberMetaData mmd = mapExpr.getJavaTypeMapping().getMemberMetaData();
if (mmd != null && mmd.getMap() != null) {
Class valCls = stmt.getQueryGenerator().getClassLoaderResolver().classForName(mmd.getMap().getValueType());
stmt.getQueryGenerator().bindParameter(valExpr.getParameterName(), valCls);
}
}
ClassLoaderResolver clr = stmt.getQueryGenerator().getClassLoaderResolver();
SQLExpressionFactory exprFactory = stmt.getSQLExpressionFactory();
if (mapExpr instanceof MapLiteral) {
MapLiteral lit = (MapLiteral) mapExpr;
Map map = (Map) lit.getValue();
JavaTypeMapping m = exprFactory.getMappingForType(boolean.class, true);
if (map == null || map.size() == 0) {
return exprFactory.newLiteral(stmt, m, true).eq(exprFactory.newLiteral(stmt, m, false));
}
boolean useInExpression = false;
List<SQLExpression> mapValExprs = lit.getValueLiteral().getValueExpressions();
if (mapValExprs != null && !mapValExprs.isEmpty()) {
// Make sure the the map key(s) are compatible with the keyExpr
boolean incompatible = true;
Class elemtype = clr.classForName(valExpr.getJavaTypeMapping().getType());
Iterator<SQLExpression> mapKeyExprIter = mapValExprs.iterator();
while (mapKeyExprIter.hasNext()) {
SQLExpression mapKeyExpr = mapKeyExprIter.next();
Class mapKeyType = clr.classForName(mapKeyExpr.getJavaTypeMapping().getType());
if (valueTypeCompatible(elemtype, mapKeyType)) {
incompatible = false;
break;
}
}
if (incompatible) {
// The provided element type isn't assignable to any of the input collection elements!
return exprFactory.newLiteral(stmt, m, true).eq(exprFactory.newLiteral(stmt, m, false));
}
// Check if we should compare using an "IN (...)" expression
SQLExpression mapKeyExpr = mapValExprs.get(0);
if (mapKeyExpr instanceof StringExpression || mapKeyExpr instanceof NumericExpression || mapKeyExpr instanceof TemporalExpression || mapKeyExpr instanceof CharacterExpression || mapKeyExpr instanceof EnumExpression) {
useInExpression = true;
}
}
if (useInExpression) {
// Return "key IN (val1, val2, ...)"
SQLExpression[] exprs = (mapValExprs != null ? mapValExprs.toArray(new SQLExpression[mapValExprs.size()]) : null);
return new InExpression(valExpr, exprs);
}
// TODO If valExpr is a parameter and mapExpr is derived from a parameter ?
MapValueLiteral mapValueLiteral = lit.getValueLiteral();
BooleanExpression bExpr = null;
List<SQLExpression> elementExprs = mapValueLiteral.getValueExpressions();
for (int i = 0; i < elementExprs.size(); i++) {
if (bExpr == null) {
bExpr = (elementExprs.get(i)).eq(valExpr);
} else {
bExpr = bExpr.ior((elementExprs.get(i)).eq(valExpr));
}
}
if (bExpr != null) {
bExpr.encloseInParentheses();
}
return bExpr;
}
if (stmt.getQueryGenerator().getCompilationComponent() == CompilationComponent.FILTER) {
boolean useSubquery = getNeedsSubquery(stmt);
JoinType joinType = JoinType.INNER_JOIN;
if (valExpr instanceof UnboundExpression) {
// See if the user has defined what should be used
String varName = ((UnboundExpression) valExpr).getVariableName();
String extensionName = "datanucleus.query.jdoql." + varName + ".join";
String extensionValue = (String) stmt.getQueryGenerator().getValueForExtension(extensionName);
if (extensionValue != null) {
if (extensionValue.equalsIgnoreCase("SUBQUERY")) {
useSubquery = true;
} else if (extensionValue.equalsIgnoreCase("INNERJOIN")) {
useSubquery = false;
} else if (extensionValue.equalsIgnoreCase("LEFTOUTERJOIN")) {
joinType = JoinType.LEFT_OUTER_JOIN;
}
}
}
// TODO Check if *this* "containsValue" is negated, not any of them (and remove above check)
if (useSubquery) {
return containsAsSubquery(stmt, mapExpr, valExpr);
}
return containsAsJoin(stmt, mapExpr, valExpr, joinType);
}
return containsAsSubquery(stmt, mapExpr, valExpr);
}
use of org.datanucleus.store.rdbms.sql.expression.CharacterExpression in project datanucleus-rdbms by datanucleus.
the class StringIndexOf4Method method getExpression.
/* (non-Javadoc)
* @see org.datanucleus.store.rdbms.sql.method.SQLMethod#getExpression(org.datanucleus.store.rdbms.sql.expression.SQLExpression, java.util.List)
*/
public SQLExpression getExpression(SQLStatement stmt, SQLExpression expr, List<SQLExpression> args) {
if (args == null || args.size() == 0 || args.size() > 2) {
throw new NucleusException(Localiser.msg("060003", "indexOf", "StringExpression", 0, "StringExpression/CharacterExpression/ParameterLiteral"));
}
// {stringExpr}.indexOf(strExpr1 [,numExpr2])
SQLExpression one = ExpressionUtils.getLiteralForOne(stmt);
ArrayList funcArgs = new ArrayList();
SQLExpression substrExpr = args.get(0);
if (!(substrExpr instanceof StringExpression) && !(substrExpr instanceof CharacterExpression) && !(substrExpr instanceof ParameterLiteral)) {
throw new NucleusException(Localiser.msg("060003", "indexOf", "StringExpression", 0, "StringExpression/CharacterExpression/ParameterLiteral"));
}
funcArgs.add(substrExpr);
funcArgs.add(expr);
if (args.size() == 2) {
SQLExpression fromExpr = args.get(1);
if (!(fromExpr instanceof NumericExpression)) {
throw new NucleusException(Localiser.msg("060003", "indexOf", "StringExpression", 1, "NumericExpression"));
}
// Add 1 to the passed in value so that it is of origin 1 to be compatible with CHARINDEX
funcArgs.add(new NumericExpression(fromExpr, Expression.OP_ADD, one));
}
// Subtract 1 from the result of CHARINDEX to be consistent with Java strings
NumericExpression locateExpr = new NumericExpression(stmt, stmt.getSQLExpressionFactory().getMappingForType(int.class, true), "CHARINDEX", funcArgs);
return new NumericExpression(locateExpr, Expression.OP_SUB, one).encloseInParentheses();
}
use of org.datanucleus.store.rdbms.sql.expression.CharacterExpression in project datanucleus-rdbms by datanucleus.
the class StringMatchesMethod method getExpression.
/* (non-Javadoc)
* @see org.datanucleus.store.rdbms.sql.method.SQLMethod#getExpression(org.datanucleus.store.rdbms.sql.expression.SQLExpression, java.util.List)
*/
public SQLExpression getExpression(SQLStatement stmt, SQLExpression expr, List<SQLExpression> args) {
if (args == null || args.size() > 2) {
throw new NucleusException("Incorrect arguments for String.matches(StringExpression)");
} else if (!(args.get(0) instanceof StringExpression) && !(args.get(0) instanceof ParameterLiteral)) {
throw new NucleusException("Incorrect arguments for String.matches(StringExpression)");
}
SQLExpression likeExpr = args.get(0);
if (!(likeExpr instanceof StringExpression) && !(likeExpr instanceof CharacterExpression) && !(likeExpr instanceof ParameterLiteral)) {
throw new NucleusException(Localiser.msg("060003", "like/matches", "StringExpression", 0, "StringExpression/CharacterExpression/ParameterLiteral"));
}
SQLExpression escapeExpr = null;
if (args.size() > 1) {
escapeExpr = args.get(1);
}
if ((likeExpr instanceof StringLiteral || likeExpr instanceof ParameterLiteral) && likeExpr.isParameter()) {
// Argument as parameter needs translation to use SQL "LIKE" syntax, so has to be embedded as literal
stmt.getQueryGenerator().useParameterExpressionAsLiteral((SQLLiteral) likeExpr);
}
SQLExpressionFactory exprFactory = stmt.getSQLExpressionFactory();
if (expr instanceof StringLiteral && likeExpr instanceof StringLiteral) {
// String.matches(String) so evaluate in-memory
String primary = (String) ((StringLiteral) expr).getValue();
String pattern = (String) ((StringLiteral) likeExpr).getValue();
return new BooleanLiteral(stmt, exprFactory.getMappingForType(boolean.class, false), primary.matches(pattern));
} else if (expr instanceof StringLiteral) {
return getBooleanLikeExpression(stmt, expr, likeExpr, escapeExpr);
} else if (expr instanceof StringExpression && likeExpr instanceof StringLiteral) {
// Convert the pattern to use the regex constructs suitable for the datastore
String pattern = (String) ((StringLiteral) likeExpr).getValue();
if (stmt.getQueryGenerator().getQueryLanguage().equalsIgnoreCase(Query.LANGUAGE_JDOQL)) {
// JDOQL input is in java.lang.String regular expression format, so convert to SQL like
boolean caseSensitive = false;
if (pattern.startsWith("(?i)")) {
caseSensitive = true;
pattern = pattern.substring(4);
}
DatastoreAdapter dba = stmt.getDatastoreAdapter();
RegularExpressionConverter converter = new RegularExpressionConverter(dba.getPatternExpressionZeroMoreCharacters().charAt(0), dba.getPatternExpressionAnyCharacter().charAt(0), dba.getEscapeCharacter().charAt(0));
if (caseSensitive) {
SQLExpression patternExpr = exprFactory.newLiteral(stmt, likeExpr.getJavaTypeMapping(), converter.convert(pattern).toLowerCase());
return getBooleanLikeExpression(stmt, expr.invoke("toLowerCase", null), patternExpr, escapeExpr);
}
SQLExpression patternExpr = exprFactory.newLiteral(stmt, likeExpr.getJavaTypeMapping(), converter.convert(pattern));
return getBooleanLikeExpression(stmt, expr, patternExpr, escapeExpr);
}
SQLExpression patternExpr = exprFactory.newLiteral(stmt, likeExpr.getJavaTypeMapping(), pattern);
return getBooleanLikeExpression(stmt, expr, patternExpr, escapeExpr);
} else if (expr instanceof StringExpression) {
return getExpressionForStringExpressionInput(stmt, expr, likeExpr, escapeExpr);
} else {
throw new NucleusException(Localiser.msg("060001", "matches", expr));
}
}
use of org.datanucleus.store.rdbms.sql.expression.CharacterExpression in project datanucleus-rdbms by datanucleus.
the class StringReplaceAllMethod method getExpression.
/* (non-Javadoc)
* @see org.datanucleus.store.rdbms.sql.method.SQLMethod#getExpression(org.datanucleus.store.rdbms.sql.expression.SQLExpression, java.util.List)
*/
public SQLExpression getExpression(SQLStatement stmt, SQLExpression expr, List<SQLExpression> args) {
if (args == null || args.size() != 2) {
throw new NucleusException(Localiser.msg("060003", "replaceAll", "StringExpression", 2, "StringExpression/CharacterExpression"));
}
// {strExpr}.translate(strExpr1, strExpr2)
SQLExpression strExpr1 = args.get(0);
SQLExpression strExpr2 = args.get(1);
if (!(strExpr1 instanceof StringExpression) && !(strExpr1 instanceof CharacterExpression)) {
throw new NucleusException(Localiser.msg("060003", "replaceAll", "StringExpression", 1, "StringExpression/CharacterExpression"));
}
if (!(strExpr2 instanceof StringExpression) && !(strExpr2 instanceof CharacterExpression)) {
throw new NucleusException(Localiser.msg("060003", "replaceAll", "StringExpression", 2, "StringExpression/CharacterExpression"));
}
// Invoke substring(startExpr, endExpr)
List<SQLExpression> newArgs = new ArrayList<>(3);
newArgs.add(expr);
newArgs.add(strExpr1);
newArgs.add(strExpr2);
SQLExpressionFactory exprFactory = stmt.getSQLExpressionFactory();
JavaTypeMapping mapping = exprFactory.getMappingForType(String.class, false);
return new StringExpression(stmt, mapping, "replace", newArgs);
}
Aggregations