/* BasicExpressionBuilder.java */
package org.enhydra.shark;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import org.enhydra.shark.api.client.wfmc.wapi.WMFilter;
import org.enhydra.shark.api.client.wfmc.wapi.WMSessionHandle;
import org.enhydra.shark.api.client.wfservice.NotConnected;
import org.enhydra.shark.api.common.ActivityFilterBuilder;
import org.enhydra.shark.api.common.AssignmentFilterBuilder;
import org.enhydra.shark.api.common.EventAuditFilterBuilder;
import org.enhydra.shark.api.common.FilterBuilder;
import org.enhydra.shark.api.common.ProcessFilterBuilder;
import org.enhydra.shark.api.common.ProcessMgrFilterBuilder;
import org.enhydra.shark.api.common.ResourceFilterBuilder;
import org.enhydra.shark.api.internal.security.SecurityManager;
/**
* BasicExpressionBuilder implements core expression builder functionality.
*
* @author V.Puskas
* @version 0.21
*/
public abstract class BasicFilterBuilder {
protected static char delimiter = '\'';
protected static boolean usingStandardVariableModel;
protected static boolean usingUppercaseStringQueries;
protected static String objectid_column_name = " oid ";
public static final String PARAM_NAME_STRING_DELIMITER = "ExpressionBuilder.StringDelimiter";
public static final String PARAM_NAME_OBJECTID_COLUMN_NAME = "DatabaseManager.ObjectIdColumnName";
public static final String PARAM_NAME_VARIABLE_MODEL = "DODSPersistentManager.useStandardVariableDataModel";
public static final String PARAM_NAME_USE_UPERCASE_STRING_QUERIES = "FilterBuilder.useUppercaseStringQueries";
/**
* There are several parameters needed for expression building to work properly.
* Constructor parameter may contain: <tt>ExpressionBuilder.StringDelimiter</tt> and
* <tt>DatabaseManager.ObjectIdColumnName</tt>.
*
* @param p property object: probably <code>Shark.getInstance().getProperties()</code>,
* but we're nop picky :-) it could even be null in which case we'll use
* hardcoded defaults for configurable parameters
*/
protected BasicFilterBuilder(Properties p) {
if (null != p) {
BasicFilterBuilder.objectid_column_name = " "
+ p.getProperty(PARAM_NAME_OBJECTID_COLUMN_NAME,
"oid") + " ";
BasicFilterBuilder.usingStandardVariableModel = Boolean.valueOf(p.getProperty(PARAM_NAME_VARIABLE_MODEL,
"true"))
.booleanValue();
BasicFilterBuilder.usingUppercaseStringQueries = Boolean.valueOf(p.getProperty(PARAM_NAME_USE_UPERCASE_STRING_QUERIES,
"false"))
.booleanValue();
BasicFilterBuilder.delimiter = p.getProperty(PARAM_NAME_STRING_DELIMITER, "'")
.charAt(0);
}
}
/**
* Some database vendors are peculiar about string(CHAR) delimiters, thus need for its
* indirect usage.
*
* @return currently configured delimiter
*/
protected char getDelimiter() {
return delimiter;
}
public WMFilter and(WMSessionHandle shandle, WMFilter f1, WMFilter f2)
throws Exception {
long tStamp = SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodStart(shandle, "BasicFilterBuilder.and");
try {
if (!SharkUtilities.checkSession(shandle)) {
throw new NotConnected("The session handle is not valid!");
}
checkSecurity(shandle, "and", null);
return _and(new WMFilter[] {
f1, f2
});
} finally {
SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodEnd(shandle, tStamp, "BasicFilterBuilder.and", this);
}
}
public WMFilter andForArray(WMSessionHandle shandle, WMFilter[] fs) throws Exception {
long tStamp = SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodStart(shandle, "BasicFilterBuilder.and");
try {
if (!SharkUtilities.checkSession(shandle)) {
throw new NotConnected("The session handle is not valid!");
}
checkSecurity(shandle, "and", null);
return _and(fs);
} finally {
SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodEnd(shandle, tStamp, "BasicFilterBuilder.and", this);
}
}
protected WMFilter _and(WMFilter[] fs) {
WMFilter fret = new WMFilter();
String sqlExp = "(";
String bshExp = "(";
List pus = new ArrayList();
List pvus = new ArrayList();
boolean isSqlComplete = true;
int startAt = 0;
int limit = 0;
for (int i = 0; i < fs.length; i++) {
sqlExp += fs[i].getSQLWhereExpression();
bshExp += fs[i].getBshExpression();
if (i != fs.length - 1) {
sqlExp += " AND ";
bshExp += " && ";
}
pus.addAll(Arrays.asList(fs[i].getPropertiesUsed()));
pvus.addAll(Arrays.asList(fs[i].getPropertyValuesUsed()));
isSqlComplete = isSqlComplete && fs[i].isSqlWhereComplete();
if (fs[i].getStartPosition() > startAt) {
startAt = fs[i].getStartPosition();
}
if (fs[i].getLimit() > limit) {
limit = fs[i].getLimit();
}
}
sqlExp += ")";
bshExp += ")";
fret.setSQLWhereExpression(sqlExp);
fret.setBshExpression(bshExp);
fret.setStartPosition(startAt);
fret.setLimit(limit);
String[] pu = new String[pus.size()];
pus.toArray(pu);
String[] pvu = new String[pvus.size()];
pvus.toArray(pvu);
fret.setPropertiesUsed(pu);
fret.setPropertyValuesUsed(pvu);
fret.setSqlWhereComplete(isSqlComplete);
fret.setFilterType(fs[0].getFilterType());
return fret;
}
public WMFilter or(WMSessionHandle shandle, WMFilter f1, WMFilter f2) throws Exception {
long tStamp = SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodStart(shandle, "BasicFilterBuilder.or");
try {
if (!SharkUtilities.checkSession(shandle)) {
throw new NotConnected("The session handle is not valid!");
}
checkSecurity(shandle, "or", null);
return _or(new WMFilter[] {
f1, f2
});
} finally {
SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodEnd(shandle, tStamp, "BasicFilterBuilder.or", this);
}
}
public WMFilter orForArray(WMSessionHandle shandle, WMFilter[] fs) throws Exception {
long tStamp = SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodStart(shandle, "BasicFilterBuilder.or");
try {
if (!SharkUtilities.checkSession(shandle)) {
throw new NotConnected("The session handle is not valid!");
}
checkSecurity(shandle, "or", null);
return _or(fs);
} finally {
SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodEnd(shandle, tStamp, "BasicFilterBuilder.or", this);
}
}
protected WMFilter _or(WMFilter[] fs) {
WMFilter fret = new WMFilter();
String sqlExp = "(";
String bshExp = "(";
List pus = new ArrayList();
List pvus = new ArrayList();
boolean isSqlComplete = true;
int startAt = 0;
int limit = 0;
for (int i = 0; i < fs.length; i++) {
sqlExp += fs[i].getSQLWhereExpression();
bshExp += fs[i].getBshExpression();
if (i != fs.length - 1) {
sqlExp += " OR ";
bshExp += " || ";
}
pus.addAll(Arrays.asList(fs[i].getPropertiesUsed()));
isSqlComplete = isSqlComplete & fs[i].isSqlWhereComplete();
if (fs[i].getStartPosition() > startAt) {
startAt = fs[i].getStartPosition();
}
if (fs[i].getLimit() > limit) {
limit = fs[i].getLimit();
}
}
sqlExp += ")";
bshExp += ")";
fret.setSQLWhereExpression(sqlExp);
fret.setBshExpression(bshExp);
fret.setStartPosition(startAt);
fret.setLimit(limit);
String[] pu = new String[pus.size()];
pus.toArray(pu);
String[] pvu = new String[pvus.size()];
pvus.toArray(pvu);
fret.setPropertiesUsed(pu);
fret.setPropertyValuesUsed(pvu);
fret.setSqlWhereComplete(isSqlComplete);
fret.setFilterType(fs[0].getFilterType());
return fret;
}
public WMFilter not(WMSessionHandle shandle, WMFilter f) throws Exception {
long tStamp = SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodStart(shandle, "BasicFilterBuilder.not");
try {
if (!SharkUtilities.checkSession(shandle)) {
throw new NotConnected("The session handle is not valid!");
}
checkSecurity(shandle, "not", null);
WMFilter fret = new WMFilter();
String sqlExp = " NOT (" + f.getSQLWhereExpression() + ")";
String bshExp = "!(" + f.getBshExpression() + ")";
fret.setSQLWhereExpression(sqlExp);
fret.setBshExpression(bshExp);
fret.setPropertiesUsed(f.getPropertiesUsed());
fret.setPropertyValuesUsed(f.getPropertyValuesUsed());
fret.setSqlWhereComplete(f.isSqlWhereComplete());
fret.setFilterType(f.getFilterType());
fret.setStartPosition(f.getStartPosition());
fret.setLimit(f.getLimit());
return fret;
} finally {
SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodEnd(shandle, tStamp, "BasicFilterBuilder.not", this);
}
}
public WMFilter setStartPosition(WMSessionHandle shandle, WMFilter f, int startAt)
throws Exception {
long tStamp = SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodStart(shandle, "BasicFilterBuilder.setStartPosition");
try {
if (!SharkUtilities.checkSession(shandle)) {
throw new NotConnected("The session handle is not valid!");
}
checkSecurity(shandle, "setStartPosition", null);
f.setStartPosition(startAt);
return f;
} finally {
SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodEnd(shandle, tStamp, "BasicFilterBuilder.setStartPosition", this);
}
}
public WMFilter setLimit(WMSessionHandle shandle, WMFilter f, int limit)
throws Exception {
long tStamp = SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodStart(shandle, "BasicFilterBuilder.setLimit");
try {
if (!SharkUtilities.checkSession(shandle)) {
throw new NotConnected("The session handle is not valid!");
}
checkSecurity(shandle, "setLimit", null);
f.setLimit(limit);
return f;
} finally {
SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodEnd(shandle, tStamp, "BasicFilterBuilder.setLimit", this);
}
}
protected String getSQLUpperCaseIfNeccessary (String field) {
if (BasicFilterBuilder.usingUppercaseStringQueries) {
return " UPPER("+field+") ";
}
return field;
}
protected String getUpperCaseIfNeccessary (String value) {
if (value==null) return value;
if (BasicFilterBuilder.usingUppercaseStringQueries) {
return value.toUpperCase();
}
return value;
}
protected String getEqualityOperation () {
if (BasicFilterBuilder.usingUppercaseStringQueries) {
return "equalsIgnoreCase";
}
return "equals";
}
protected WMFilter addEquals(int filterType,
String java_name,
String sql_name,
String value) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(getSQLUpperCaseIfNeccessary(sql_name)
+ " = " + getDelimiter() + getUpperCaseIfNeccessary(value) + getDelimiter());
fret.setBshExpression(java_name + "."+getEqualityOperation()+"(\"" + getUpperCaseIfNeccessary(value) + "\")");
addNewPropertyUsed(fret, java_name, value);
return fret;
}
protected WMFilter addEquals(int filterType,
String java_name,
String sql_name,
long value) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name + " = " + value);
fret.setBshExpression(java_name + ".longValue()" + " == " + value);
addNewPropertyUsed(fret, java_name, String.valueOf(value));
return fret;
}
protected WMFilter addGreaterThan(int filterType,
String java_name,
String sql_name,
long value) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name + " > " + value);
fret.setBshExpression(java_name + ".longValue()" + " > " + value);
addNewPropertyUsed(fret, java_name, String.valueOf(value));
return fret;
}
protected WMFilter addLessThan(int filterType,
String java_name,
String sql_name,
long value) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name + " < " + value);
fret.setBshExpression(java_name + ".longValue()" + " < " + value);
addNewPropertyUsed(fret, java_name, String.valueOf(value));
return fret;
}
protected WMFilter addGreaterThanWithSubQuery(int filterType,
String java_name,
String sql_name,
String sqlInPart,
long value,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name + sqlInPart + " > " + value + sqlEndPart);
fret.setBshExpression(java_name + ".longValue()" + " > " + value);
addNewPropertyUsed(fret, java_name, String.valueOf(value));
return fret;
}
protected WMFilter addGreaterThanWithSubQueryForVariables(int filterType,
String java_name,
String sql_name,
String sqlInPart1,
String sqlInPart2,
String vName,
long vValue,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name
+ sqlInPart1 + getDelimiter() + vName + getDelimiter()
+ sqlInPart2 + " > " + vValue + sqlEndPart);
fret.setBshExpression(java_name + ".longValue()" + " > " + vValue);
addNewPropertyUsed(fret, java_name, String.valueOf(vValue));
return fret;
}
protected WMFilter addLessThanWithSubQuery(int filterType,
String java_name,
String sql_name,
String sqlInPart,
long value,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name + sqlInPart + " < " + value + sqlEndPart);
fret.setBshExpression(java_name + ".longValue()" + " < " + value);
addNewPropertyUsed(fret, java_name, String.valueOf(value));
return fret;
}
protected WMFilter addLessThanWithSubQueryForVariables(int filterType,
String java_name,
String sql_name,
String sqlInPart1,
String sqlInPart2,
String vName,
long vValue,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name
+ sqlInPart1 + getDelimiter() + vName + getDelimiter()
+ sqlInPart2 + " < " + vValue + sqlEndPart);
fret.setBshExpression(java_name + ".longValue()" + " < " + vValue);
addNewPropertyUsed(fret, java_name, String.valueOf(vValue));
return fret;
}
protected WMFilter addEqualsWithSubQuery(int filterType,
String java_name,
String sql_name,
String sqlInPart,
long value,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name + sqlInPart + value + sqlEndPart);
fret.setBshExpression(java_name + ".longValue()" + " == " + value);
addNewPropertyUsed(fret, java_name, String.valueOf(value));
return fret;
}
protected WMFilter addEqualsWithSubQueryForVariables(int filterType,
String java_name,
String sql_name,
String sqlInPart1,
String sqlInPart2,
String vName,
long vValue,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name
+ sqlInPart1 + getDelimiter() + vName + getDelimiter()
+ sqlInPart2 + vValue + sqlEndPart);
fret.setBshExpression(java_name + ".longValue()" + " == " + vValue);
addNewPropertyUsed(fret, java_name, String.valueOf(vValue));
return fret;
}
protected WMFilter addGreaterThanWithSubQuery(int filterType,
String java_name,
String sql_name,
String sqlInPart,
double value,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name + sqlInPart + " > " + value + sqlEndPart);
fret.setBshExpression(java_name + ".longValue()" + " > " + value);
addNewPropertyUsed(fret, java_name, String.valueOf(value));
return fret;
}
protected WMFilter addGreaterThanWithSubQueryForVariables(int filterType,
String java_name,
String sql_name,
String sqlInPart1,
String sqlInPart2,
String vName,
double vValue,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name
+ sqlInPart1 + getDelimiter() + vName + getDelimiter()
+ sqlInPart2 + " > " + vValue + sqlEndPart);
fret.setBshExpression(java_name + ".longValue()" + " > " + vValue);
addNewPropertyUsed(fret, java_name, String.valueOf(vValue));
return fret;
}
protected WMFilter addLessThanWithSubQuery(int filterType,
String java_name,
String sql_name,
String sqlInPart,
double value,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name + sqlInPart + " < " + value + sqlEndPart);
fret.setBshExpression(java_name + ".doubleValue()" + " < " + value);
addNewPropertyUsed(fret, java_name, String.valueOf(value));
return fret;
}
protected WMFilter addLessThanWithSubQueryForVariables(int filterType,
String java_name,
String sql_name,
String sqlInPart1,
String sqlInPart2,
String vName,
double vValue,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name
+ sqlInPart1 + getDelimiter() + vName + getDelimiter()
+ sqlInPart2 + " < " + vValue + sqlEndPart);
fret.setBshExpression(java_name + ".doubleValue()" + " < " + vValue);
addNewPropertyUsed(fret, java_name, String.valueOf(vValue));
return fret;
}
protected WMFilter addEqualsWithSubQuery(int filterType,
String java_name,
String sql_name,
String sqlInPart,
double value,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name + sqlInPart + value + sqlEndPart);
fret.setBshExpression(java_name + ".doubleValue()" + " == " + value);
addNewPropertyUsed(fret, java_name, String.valueOf(value));
return fret;
}
protected WMFilter addEqualsWithSubQueryForVariables(int filterType,
String java_name,
String sql_name,
String sqlInPart1,
String sqlInPart2,
String vName,
double vValue,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name
+ sqlInPart1 + getDelimiter() + vName + getDelimiter()
+ sqlInPart2 + vValue + sqlEndPart);
fret.setBshExpression(java_name + ".doubleValue()" + " == " + vValue);
addNewPropertyUsed(fret, java_name, String.valueOf(vValue));
return fret;
}
protected WMFilter addEqualsWithSubQuery(int filterType,
String java_name,
String sql_name,
String sqlInPart,
String value,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name
+ sqlInPart + getDelimiter() + getUpperCaseIfNeccessary(value) + getDelimiter()
+ sqlEndPart);
fret.setBshExpression(java_name + getEqualityOperation()+".(\"" + getUpperCaseIfNeccessary(value) + "\")");
addNewPropertyUsed(fret, java_name, value);
return fret;
}
protected WMFilter addEqualsWithSubQueryForVariables(int filterType,
String java_name,
String sql_name,
String sqlInPart1,
String sqlInPart2,
String vName,
String vValue,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name
+ sqlInPart1 + getDelimiter() + getUpperCaseIfNeccessary(vName) + getDelimiter()
+ sqlInPart2 + getDelimiter() + getUpperCaseIfNeccessary(vValue) + getDelimiter()
+ sqlEndPart);
fret.setBshExpression(java_name + getEqualityOperation()+"(\"" + getUpperCaseIfNeccessary(vValue) + "\")");
addNewPropertyUsed(fret, java_name, vValue);
return fret;
}
protected WMFilter addEqualsWithSubQueryTwice(int filterType,
String java_name,
String sql_name,
String sqlInPart,
String value,
String sqlMiddlePart,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name
+ sqlInPart + getDelimiter() + getUpperCaseIfNeccessary(value) + getDelimiter()
+ sqlMiddlePart + getDelimiter() + getUpperCaseIfNeccessary(value)
+ getDelimiter() + sqlEndPart);
fret.setBshExpression(java_name + getEqualityOperation()+"(\"" + getUpperCaseIfNeccessary(value) + "\")");
addNewPropertyUsed(fret, java_name, value);
return fret;
}
protected WMFilter addStartsWithSubQuery(int filterType,
String java_name,
String sql_name,
String sqlInPart,
String value,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name
+ sqlInPart + getDelimiter() + getUpperCaseIfNeccessary(value) + "%"
+ getDelimiter() + sqlEndPart);
fret.setBshExpression(java_name + ".startsWith(\"" + getUpperCaseIfNeccessary(value) + "\")");
addNewPropertyUsed(fret, java_name, value);
return fret;
}
protected WMFilter addContainsWithSubQuery(int filterType,
String java_name,
String sql_name,
String sqlInPart,
String value,
String sqlEndPart) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(sql_name
+ sqlInPart + " LIKE " + getDelimiter() + "%" + getUpperCaseIfNeccessary(value)
+ "%" + getDelimiter() + sqlEndPart);
fret.setBshExpression(java_name + ".indexOf(\"" + getUpperCaseIfNeccessary(value) + "\") != -1");
addNewPropertyUsed(fret, java_name, value);
return fret;
}
protected WMFilter addContains(int filterType,
String java_name,
String sql_name,
String value) {
WMFilter fret = new WMFilter(filterType);
fret.setSQLWhereExpression(getSQLUpperCaseIfNeccessary(sql_name)
+ " LIKE " + getDelimiter() + "%" + getUpperCaseIfNeccessary(value) + "%"
+ getDelimiter());
fret.setBshExpression(java_name + ".indexOf(\"" + getUpperCaseIfNeccessary(value) + "\") != -1");
addNewPropertyUsed(fret, java_name, value);
return fret;
}
/**
* Appends arbitrary condition
* <p>
* Here you may specify any script compatible expression, but <b>beware complete
* expression will be evaluated inside Java VM </b>, not on DB.
*
* @param bshExpr condition to add
* @return itself
*/
public WMFilter addBshExpression(WMSessionHandle shandle,
WMFilter filter,
String bshExpr) throws Exception {
long tStamp = SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodStart(shandle, "BasicFilterBuilder.addBshExpression");
try {
if (!SharkUtilities.checkSession(shandle)) {
throw new NotConnected("The session handle is not valid!");
}
checkSecurity(shandle, "addBshExpression", null);
if (filter.getBshExpression() == null) {
filter.setBshExpression(bshExpr);
} else {
filter.setSQLWhereExpression(filter.getBshExpression()
+ " && (" + bshExpr + ")");
}
String sqlExp = "1 = 1";
if (filter.getSQLWhereExpression() == null) {
filter.setSQLWhereExpression(sqlExp);
} else {
filter.setSQLWhereExpression(filter.getSQLWhereExpression()
+ " AND (" + sqlExp + ")");
}
filter.setSqlWhereComplete(false);
return filter;
} finally {
SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodEnd(shandle, tStamp, "BasicFilterBuilder.addBshExpression", this);
}
}
protected WMFilter setOrderBy(WMFilter filter, String column, boolean ascending) {
String ordBy = filter.getOrderBy();
if (ordBy.indexOf("ORDER BY") == -1) {
ordBy += " ORDER BY ";
} else {
ordBy += ", ";
}
ordBy += column + (ascending ? " ASC" : " DESC");
filter.setOrderBy(ordBy);
return filter;
}
public WMFilter createEmptyFilter(WMSessionHandle shandle) throws Exception {
long tStamp = SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodStart(shandle, "BasicFilterBuilder.createEmptyFilter");
try {
if (!SharkUtilities.checkSession(shandle)) {
throw new NotConnected("The session handle is not valid!");
}
checkSecurity(shandle, "createEmptyFilter", null);
int filterType = -1;
if (this instanceof ProcessMgrFilterBuilder) {
filterType = FilterBuilder.SQL_TYPE_MANAGER;
} else if (this instanceof ProcessFilterBuilder) {
filterType = FilterBuilder.SQL_TYPE_PROCESS;
} else if (this instanceof ResourceFilterBuilder) {
filterType = FilterBuilder.SQL_TYPE_RESOURCE;
} else if (this instanceof ActivityFilterBuilder) {
filterType = FilterBuilder.SQL_TYPE_ACTIVITY;
} else if (this instanceof AssignmentFilterBuilder) {
filterType = FilterBuilder.SQL_TYPE_ASSIGNMENT;
} else if (this instanceof EventAuditFilterBuilder) {
filterType = FilterBuilder.SQL_TYPE_EVENT_AUDIT;
}
WMFilter filter = new WMFilter(filterType);
filter.setSQLWhereExpression("1 = 1");
return filter;
} finally {
SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodEnd(shandle, tStamp, "BasicFilterBuilder.createEmptyFilter", this);
}
}
public String toIteratorExpression(WMSessionHandle shandle, WMFilter filter)
throws Exception {
long tStamp = SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodStart(shandle, "BasicFilterBuilder.toIteratorExpression");
try {
if (!SharkUtilities.checkSession(shandle)) {
throw new NotConnected("The session handle is not valid!");
}
checkSecurity(shandle, "toIteratorExpression", null);
StringBuffer ret = new StringBuffer();
if (!filter.isSqlWhereComplete()) {
ret.append("/*FORCE*/\n");
}
if (filter.getPropertiesUsed() != null && 0 < filter.getPropertiesUsed().length) {
ret.append("/*used ").append(whatsUsed(filter)).append(" used*/\n");
}
if (filter.getBshExpression() == null) {
filter.setBshExpression("");
}
ret.append(filter.getBshExpression());
if (filter.getSQLWhereExpression() == null) {
filter.setSQLWhereExpression("1 = 1");
}
ret.append("\n/*sql ")
.append(filter.getSQLWhereExpression())
.append(filter.getOrderBy())
.append(" sql*/");
ret.append(" \n/*startAt " + filter.getStartPosition() + " startAt*/");
ret.append(" \n/*limit " + filter.getLimit() + " limit*/");
return ret.toString();
} finally {
SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodEnd(shandle, tStamp, "BasicFilterBuilder.toIteratorExpression", this);
}
}
public String getIteratorEmptyExpression(WMSessionHandle shandle) throws Exception {
long tStamp = SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodStart(shandle, "BasicFilterBuilder.getIteratorEmptyExpression");
try {
if (!SharkUtilities.checkSession(shandle)) {
throw new NotConnected("The session handle is not valid!");
}
checkSecurity(shandle, "getIteratorEmptyExpression", null);
return "\n/*sql 1 = 1 sql*/";
} finally {
SharkEngineManager.getInstance()
.getCallbackUtilities()
.methodEnd(shandle,
tStamp,
"BasicFilterBuilder.getIteratorEmptyExpression",
this);
}
}
protected void addNewPropertyUsed(WMFilter filter, String prop, String propVal) {
String[] pu = filter.getPropertiesUsed();
String[] pvu = filter.getPropertyValuesUsed();
String[] pun = new String[pu.length + 1];
String[] pvun = new String[pvu.length + 1];
System.arraycopy(pu, 0, pun, 0, pu.length);
pun[pu.length] = prop;
System.arraycopy(pvu, 0, pvun, 0, pvu.length);
pvun[pvu.length] = propVal;
filter.setPropertiesUsed(pun);
filter.setPropertyValuesUsed(pvun);
}
protected String whatsUsed(WMFilter filter) {
StringBuffer ret = new StringBuffer();
for (int i = 0; i < filter.getPropertiesUsed().length; i++) {
ret.append(filter.getPropertiesUsed()[i]).append(" ");
}
return ret.toString();
}
protected void checkSecurity(WMSessionHandle shandle, String methodName, Map d)
throws Exception {
SecurityManager sm = SharkEngineManager.getInstance().getSecurityManager();
if (sm != null) {
sm.check_security(shandle, this.getClass(), methodName, d);
}
}
}
|