* This class is used to generate SQL. *
* The final generation (prepare...) is triggered by the EOAdaptorChannel when * it is asked to perform an adaptor operation. It turns the EOAdaptorOperation * into a straight method call (eg selectAttributes) which in turn uses the * SQLExpressionFactory to create and prepare an expression. * *
* If the 'EOCustomQueryExpressionHintKey' is set, the value of this key is * processed as a keyvalue-format pattern to produce the SQL. EOSQLExpression * will still prepare and provide the parts of the SQL (eg qualifiers, sorts) * but the assembly will be done using the SQL pattern. *
* Example:
* SELECT COUNT(*) FROM %(tables)s WHERE %(where)s %(limit)s* * Keys:
* select eg SELECT or SELECT DISTINCT * columns eg BASE.lastname, BASE.firstname * tables eg BASE.customer * basetable eg customer * qualifier eg lastname LIKE 'Duck%' * orderings eg lastname ASC, firstname DESC * limit eg OFFSET 0 LIMIT 1 * lock eg FOR UPDATE * joins* Compound: *
* where eg WHERE lastname LIKE 'Duck%' * andQualifier eg AND lastname LIKE 'Duck%' (nothing w/o qualifier) * orQualifier eg OR lastname LIKE 'Duck%' (nothing w/o qualifier)* * *
* The main methods are the four prepare.. methods, * prepareSelectExpressionWithAttributes(), prepareUpdateExpressionWith.. etc. * Those methods are usually called by the SQLExpressionFactory, which first * allocates the EOSQLExpression subclass (as provided by the specific database * adaptor) and calls the prepare... method. *
* * * * *
* This object is not synchronized.
*/
public class EOSQLExpression extends NSObject {
// TODO: document
// TODO: document that adaptors SUBCLASS this to achive proper quoting etc
// TODO: document handling of EOSQLQualifier
/*
* Note: its quite inefficient from a String concat perspective. Should use
* a StringBuilder, but well, as long as it doesn't hurt ;-)
*/
protected static final Log log = LogFactory.getLog("EOSQLExpression");
protected static final boolean isDebugOn = log.isDebugEnabled();
public static final String EOCustomQueryExpressionHintKey =
"EOCustomQueryExpressionHintKey";
public static final String BaseEntityPath = "";
public static final String BaseEntityAlias = "BASE";
protected EOEntity entity;
protected String statement; /* direct SQL */
protected StringBuilder listString;
protected StringBuilder valueList;
protected List
* The result is stored in the 'this.statement' ivar.
*
* @param _row - the keys/values to INSERT
*/
public void prepareInsertExpressionWithRow(final Map
* In PostgreSQL this is available with 8.2.x, the syntax is:
* What this method does:
*
* @param _attrs - the attributes to fetch, or null to fetch all
* @param _lock - whether the rows/table should be locked in the database
* @param _fspec - the EOFetchSpecification containing the qualifier, etc
*/
public void prepareSelectExpressionWithAttributes
(EOAttribute[] _attrs, boolean _lock, EOFetchSpecification _fspec)
{
/* check for custom statements */
String customSQL = null;
if (_fspec.hints() != null)
customSQL = (String)_fspec.hints().get(EOCustomQueryExpressionHintKey);
if (isDebugOn) log.debug("generating SELECT expression ..");
this.useAliases = true;
this.qualifier = _fspec.qualifier();
/* apply restricting qualifier */
EOQualifier q =
this.entity != null ? this.entity.restrictingQualifier() : null;
if (q != null) {
if (this.qualifier != null) {
this.qualifier =
new EOAndQualifier(new EOQualifier[] { this.qualifier, q });
}
else
this.qualifier = q;
}
if (isDebugOn) log.debug(" qualifier: " + this.qualifier);
/* check for distinct */
String select = _fspec.usesDistinct() ? "SELECT DISTINCT" : "SELECT";
/* prepare columns to select */
// TBD: Some database require that values used in the qualifiers and/or
// sort orderings are part of the SELECT. Support that.
String columns;
if (_attrs != null && _attrs.length > 0) {
this.listString = new StringBuilder(128);
for (int i = 0; i < _attrs.length; i++)
this.addSelectListAttribute(_attrs[i]);
columns = this.listString.toString();
this.listString.setLength(0);
}
else
columns = "*";
if (isDebugOn) log.debug(" columns: " + columns);
/* prepare where clause (has side effects for joins etc) */
String where = this.whereClauseString();
if (isDebugOn) log.debug(" where: " + where);
/* prepare order bys */
EOSortOrdering[] fetchOrder = _fspec.sortOrderings();
String orderBy = null;
if (fetchOrder != null && fetchOrder.length > 0) {
if (this.listString == null)
this.listString = new StringBuilder(64);
else
this.listString.setLength(0);
for (int i = 0; i < fetchOrder.length; i++)
this.addOrderByAttributeOrdering(fetchOrder[i]);
orderBy = this.listString.toString();
}
if (isDebugOn) log.debug(" order: " + orderBy);
/* joins, must be done before the tablelist is generated! */
final boolean inlineJoins = this.doesIncludeJoinsInFromClause();
this.joinExpression();
String joinClause = inlineJoins
? null /* will be processed in tableListAndJoinsWithRootEntity() */
: this.joinClauseString();
if (isDebugOn) log.debug(" join: " + joinClause);
/* table list */
final String tables = inlineJoins
? this.tableListAndJoinsWithRootEntity(this.entity)
: this.tableListWithRootEntity(this.entity);
if (isDebugOn) log.debug(" tables: " + tables);
/* lock */
final String lockClause = _lock ? this.lockClause() : null;
/* limits */
final String limitClause = (_fspec != null)
? this.limitClause(_fspec.fetchOffset(), _fspec.fetchLimit())
: null;
// TODO: GROUP BY expression [, ...]
// TODO: HAVING condition [, ...]
/* we are done, assemble */
if (customSQL != null) {
this.statement = assembleCustomSelectStatementWithAttributes
(_attrs, _lock, q, fetchOrder,
customSQL,
select, columns, tables, where, joinClause, orderBy,
limitClause, lockClause);
}
else {
this.statement = assembleSelectStatementWithAttributes
(_attrs, _lock, q, fetchOrder,
select, columns, tables, where, joinClause, orderBy,
limitClause, lockClause);
}
if (isDebugOn) log.debug("result: " + this.statement);
}
public String assembleSelectStatementWithAttributes
(final EOAttribute[] _attrs, boolean _lock, final EOQualifier _qualifier,
final EOSortOrdering[] _fetchOrder,
final String _select, final String _cols, final String _tables,
String _where, String _joinClause, final String _orderBy,
final String _limit,
final String _lockClause)
{
/* 128 was too small, SQL seems to be ~512 */
StringBuilder sb = new StringBuilder(1024);
sb.append(_select == null ? "SELECT " : _select);
sb.append(' ');
sb.append(_cols);
if (_tables != null) {
sb.append(" FROM ");
sb.append(_tables);
}
if (_where != null && _where.length() == 0) _where = null;
if (_joinClause != null && _joinClause.length() == 0) _joinClause = null;
if (_where != null || _joinClause != null) {
sb.append(" WHERE ");
if (_where != null)
sb.append(_where);
if (_where != null && _joinClause != null)
sb.append(" AND ");
if (_joinClause != null)
sb.append(_joinClause);
}
if (_orderBy != null && _orderBy.length() > 0) {
sb.append(" ORDER BY ");
sb.append(_orderBy);
}
if (_limit != null) {
sb.append(' ');
sb.append(_limit);
}
if (_lockClause != null) {
sb.append(' ');
sb.append(_lockClause);
}
return sb.toString();
}
protected static final void putValueOrEmptyString
(final Map
* The result of this is added the the 'this.listString' using
* appendItemToListString().
*
* The method is called by prepareSelectExpressionWithAttributes() to build
* the list of attributes used in the SELECT.
*/
public void addSelectListAttribute(final EOAttribute _attribute) {
if (_attribute == null) return;
String s = this.sqlStringForAttribute(_attribute);
s = this.formatSQLString(s, _attribute.readFormat());
this.appendItemToListString(s, this.listString);
}
public void addUpdateListAttribute(EOAttribute _attribute, Object _value) {
if (_attribute == null)
return;
/* key */
String a = this.sqlStringForAttribute(_attribute);
/* value */
// TODO: why not call sqlStringForValue()?
boolean useBind;
if (_value != null) {
if (_value instanceof EOQualifierVariable)
useBind = true;
else if (_value instanceof EORawSQLValue)
useBind = false;
else
useBind = this.shouldUseBindVariableForAttribute(_attribute);
}
else
useBind = this.shouldUseBindVariableForAttribute(_attribute);
String v;
if (useBind) {
Map
* Builds the JOIN parts of the FROM statement, eg:
* It just adds the joins from left to right, since I don't know yet
* how to properly put the parenthesis around them :-)
*
* We currently ALWAYS build LEFT JOINs. Which is wrong, but unless we
* can order the JOINs, no option.
*
* @param _entity - root entity to use ("" alias)
* @return the list of tables, eg "person AS BASE INNER JOIN address AS T0"
*/
public String tableListAndJoinsWithRootEntity(EOEntity _entity) {
if (_entity == null)
return null;
StringBuilder sb = new StringBuilder(128);
/* the base entity */
sb.append(this.sqlStringForSchemaObjectName(_entity.externalName()));
sb.append(" AS ");
sb.append(this.relationshipPathToAlias.get(""));
/* Sort the aliases by the number of components in their pathes. I
* think later we need to consider their prefixes and collect them
* in proper parenthesis
*/
List
* It constructs stuff like T1.person_id = T2.company_id. The actual joins
* are added using the addJoinClause method, which builds the expression
* (in the this.joinClauseString ivar).
*/
public void joinExpression() {
final Map
* The semantics trigger the proper operation, eg '=', '*=', '=*' or '*=*'.
*
* @param _left - left side join expression
* @param _right - right side join expression
* @param _semantic - semantics, as passed on to assembleJoinClause()
*/
public void addJoinClause(String _left, String _right, int _semantic) {
String jc = this.assembleJoinClause(_left, _right, _semantic);;
if (this.joinClauseString == null || this.joinClauseString.length() == 0)
this.joinClauseString = jc;
else
this.joinClauseString += " AND " + jc;
}
public String assembleJoinClause(String _left, String _right, int _semantic) {
// TODO: semantic
String op = " = ";
switch (_semantic) {
case EORelationship.InnerJoin: op = " = "; break;
case EORelationship.LeftOuterJoin: op = " *= "; break;
case EORelationship.RightOuterJoin: op = " =* "; break;
case EORelationship.FullOuterJoin: op = " *=* "; break;
}
return _left + op + _right;
}
/* basic construction */
public void appendItemToListString(String _item, StringBuilder _sb) {
if (_sb.length() > 0)
_sb.append(", ");
_sb.append(_item);
}
/* formatting */
public String formatSQLString(String _sql, String _format) {
//System.err.println("FORMAT " + _sql + " WITH " + _format);
if (_format == null)
return _sql;
if (_format.indexOf('%') == -1) /* contains no formats */
return _format; /* yes, the format replaces the value! */
// TODO: any other formats? what about %%P (escaped %)
return _format.replace("%P", _sql);
}
public String formatStringValue(String _v) {
// TODO: whats the difference to sqlStringForString?
if (_v == null)
return "NULL";
return "'" + escapeSQLString(_v) + "'";
}
public String sqlStringForString(String _v) {
if (_v == null)
return "NULL";
return "'" + escapeSQLString(_v) + "'";
}
/**
* Returns the SQL representation of a Number. For INTs this is just the
* Java value, for float/doubles/bigdecs it might be database specific.
* The current implementation just calls the numbers toString() method.
*
* @param _value - some Number object
* @return the SQL representation of the given Number (or NULL for null)
*/
public String sqlStringForNumber(Number _value) {
return (_value == null) ? "NULL" : _value.toString();
}
/**
* Returns the SQL representation of a Boolean. This returns TRUE and FALSE.
*
* @param _v - some Boolean object
* @return the SQL representation of the given Boolean (or NULL for null)
*/
public String sqlStringForBoolean(Boolean _v) {
return (_v == null) ? "NULL" : (_v.booleanValue() ? "TRUE" : "FALSE");
}
/**
* The current implementation just returns the 'toString()' of the Date.
*
* @param _v - a Date object
* @param _attr - an EOAttribute containing formatting details
* @return the SQL representation of the given Date (or NULL for null)
*/
public String formatDateValue(Date _v, EOAttribute _attr) {
// TODO: fixme. Use format specifications as denoted in the attribute
// TODO: is this called? Probably the formatting should be done using a
// binding in the JDBC adaptor
return _v != null ? _v.toString() : null;
}
/**
* Returns the SQL String representation of the given value Object.
*
* The default implementation returns false.
*
* @param _attr - EOAttribute whose value should be added
* @return whether or not binds ('?' patterns) should be used
*/
public boolean mustUseBindVariableForAttribute(final EOAttribute _attr) {
return false;
}
/**
* Checks whether binds should be used for the specified attribute. Eg this
* might be the case if its a BLOB attribute. Currently we use binds for
* almost all attributes except INTs and BOOLs.
*
* @param _attr - EOAttribute whose value should be added
* @return whether or not binds ('?' patterns) should be used
*/
public boolean shouldUseBindVariableForAttribute(final EOAttribute _attr) {
if (this.mustUseBindVariableForAttribute(_attr))
return true;
if (_attr == null)
return true; /* Hm */
/* Hm, any reasons NOT to use binds? Actually yes, prepared statements are
* slower if the query is used just once. However, its quite likely that
* model based fetches reuse the same kind of query a LOT. So using binds
* and caching the prepared statements makes quite some sense.
*
* Further, for JDBC this ensures that our basetypes are properly escaped,
* we don't need to take care of that (eg handling the various Date types).
*
* Hm, lets avoid binding numbers and booleans.
*/
final String exttype = _attr.externalType();
if (exttype != null) {
if (exttype.startsWith("INT")) return false;
if (exttype.startsWith("BOOL")) return false;
}
return true;
}
public Map
* If the qualifier implements EOQualifierSQLGeneration, its directly asked
* for the SQL representation.
* Otherwise we call the appropriate methods for known types of qualifiers.
*
* @param _q - the qualifier to be converted
* @return a String representing the qualifier, or null on error
*/
public String sqlStringForQualifier(final EOQualifier _q) {
if (_q == null) return null;
/* first support custom SQL qualifiers */
if (_q instanceof EOQualifierSQLGeneration)
return ((EOQualifierSQLGeneration)_q).sqlStringForSQLExpression(this);
/* next check builtin qualifiers */
if (_q instanceof EONotQualifier) {
return this.sqlStringForNegatedQualifier
(((EONotQualifier)_q).qualifier());
}
if (_q instanceof EOKeyValueQualifier)
return this.sqlStringForKeyValueQualifier((EOKeyValueQualifier)_q);
if (_q instanceof EOKeyComparisonQualifier) {
return this.sqlStringForKeyComparisonQualifier
((EOKeyComparisonQualifier)_q);
}
if (_q instanceof EOAndQualifier) {
return this.sqlStringForConjoinedQualifiers
(((EOCompoundQualifier)_q).qualifiers());
}
if (_q instanceof EOOrQualifier) {
return this.sqlStringForDisjoinedQualifiers
(((EOCompoundQualifier)_q).qualifiers());
}
if (_q instanceof EOSQLQualifier)
return this.sqlStringForRawQualifier((EOSQLQualifier)_q);
if (_q instanceof EOBooleanQualifier)
return this.sqlStringForBooleanQualifier((EOBooleanQualifier)_q);
log.error("could not convert qualifier to SQL: " + _q);
return null;
}
public String sqlStringForBooleanQualifier(EOBooleanQualifier _q) {
// TBD: we could return an empty qualifier for true?
return (_q == EOBooleanQualifier.falseQualifier)
? "1 = 2" : "1 = 1";
}
/**
* This returns the SQL for a raw qualifier (EOSQLQualifier). The SQL still
* needs to be generated because a SQL qualifier is composed of plain strings
* as well as 'dynamic' parts.
*
* EOQualifierVariables must be evaluated before this method is called.
*
* @param _q - the EOSQLQualifier to be converted
* @return the SQL for the qualifier, or null on error
*/
public String sqlStringForRawQualifier(EOSQLQualifier _q) {
if (_q == null) return null;
// TODO: Do something inside the parts? Pattern replacement?
final Object[] parts = _q.parts();
if (parts == null) return null;
if (parts.length == 0) return "";
final StringBuilder sb = new StringBuilder(256);
for (int i = 0; i < parts.length; i++) {
if (parts[i] == null) {
log.warn("SQL qualifier contains a null part ...");
continue;
}
if (parts[i] instanceof EOQualifierVariable)
log.warn("SQL qualifier contains a variable: " + parts[i]);
// TBD: Whats correct here? Should we escape parts or not? For now we
// assume that values are just that and need to be escaped. Which
// implies that bindings cannot contain dynamic SQL.
// Note that 'raw' sections of the qualifier will be EOSQLRawValue
// objects.
String fv = this.formatValue(parts[i]);
if (fv != null)
sb.append(fv);
else
log.warn("got no SQL for value: " + parts[i]);
}
return sb.toString();
}
public String sqlStringForNegatedQualifier(EOQualifier _q) {
final String qs = this.sqlStringForQualifier(_q);
if (qs == null || qs.length() == 0) return null;
return "NOT ( " + qs + " )";
}
/**
* Generates the SQL for an EOKeyValueQualifier. This qualifier compares a
* column against some constant value using some operator.
*
* @param _q - the EOKeyValueQualifier
* @return the SQL or null if the SQL could not be generated
*/
public String sqlStringForKeyValueQualifier(EOKeyValueQualifier _q) {
if (_q == null) return null;
String k = _q.key();
EOAttribute a = this.entity != null ? this.entity.attributeNamed(k) : null;
Object v = _q.value();
String sqlCol;
/* generate lhs */
if ((sqlCol = this.sqlStringForAttributeNamed(k)) == null) {
log.warn("got no SQL string for attribute of LHS " + k + ": " + _q);
return null;
}
if (a != null) sqlCol = this.formatSQLString(sqlCol, a.readFormat());
if (sqlCol == null) {
log.warn("formatting attribute with read format returned null: "+a);
return null;
}
// TODO: unless the DB supports a specific case-search LIKE, we need
// to perform an upper
/* generate operator */
// TODO: do something about caseInsensitiveLike (TO_UPPER?), though in
// PostgreSQL and MySQL this is already covered by special operators
EOQualifier.ComparisonOperation opsel = _q.operation();
String op = this.sqlStringForSelector(opsel, v, true);
if (op == null) {
log.error("got no operation for qualifier: " + _q);
return null;
}
StringBuilder sb = new StringBuilder(64);
sb.append(sqlCol);
sb.append(" ");
sb.append(op);
sb.append(" ");
/* generate value */
if (op.startsWith("IS") && v == null) {
/* IS NULL or IS NOT NULL */
sb.append("NULL");
}
else if (op.equals("IN")) {
if (v instanceof EOQualifierVariable) {
log.error(
"detected unresolved qualifier variable in IN qualifier:\n " +
_q + "\n variable: " + v);
return null;
}
// we might need to add casting support, eg:
// varcharcolumn IN ( 1, 2, 3, 4 )
// does NOT work with PostgreSQL. We need to do:
// varcharcolumn::int IN ( 1, 2, 3, 4 )
// which is also suboptimal if the varcharcolumn does contain strings,
// or:
// varcharcolumn IN ( 1::varchar, 2::varchar, 3::varchar, 4::varchar )
// which might be counter productive since it might get longer than:
// varcharcolumn = 1 OR varcharcolumn = 2 etc
if (v.getClass().isArray())
v = UList.asList(v);
if (v instanceof Collection) {
// TBD: can't we move all this to sqlStringForValue? This has similiar
// stuff already
Collection c = (Collection)v;
int len = c.size();
if (len == 0) {
/* An 'IN ()' does NOT work in PostgreSQL, weird. We treat such a
* qualifier as always false. */
sb = new StringBuilder("1 = 2");
}
else {
sb.append(" (");
boolean isFirst = true;
for (Object subvalue: c) {
if (isFirst) isFirst = false;
else sb.append(", ");
sb.append(this.sqlStringForValue(subvalue, k));
}
sb.append(")");
}
}
else {
/* Note: 'IN ( NULL )' at least works in PostgreSQL */
log.warn("value of IN qualifier was no list: " + v);
sb.append(" (");
sb.append(this.sqlStringForValue(v, k));
sb.append(")");
}
}
else {
/* a regular value */
if (v != null) {
if (opsel == EOQualifier.ComparisonOperation.LIKE ||
opsel == EOQualifier.ComparisonOperation.CASE_INSENSITIVE_LIKE) {
// TODO: unless the DB supports a specific case-search LIKE, we need
// to perform an upper
v = this.sqlPatternFromShellPattern(v.toString());
}
}
sb.append(this.sqlStringForValue(v, k));
}
return sb.toString();
}
/**
* Generates the SQL for an EOKeyComparisonQualifier, eg:
* Note that we do not add empty qualifiers (such which returned an empty
* String as their SQL representation).
*
* @param _qs - set of qualifiers
* @param _op - operation to use, including spaces, eg " AND "
* @return String containing the SQL for all qualifiers
*/
public String sqlStringForJoinedQualifiers(EOQualifier[] _qs, String _op) {
if (_qs == null || _qs.length == 0) return null;
if (_qs.length == 1) return this.sqlStringForQualifier(_qs[0]);
final StringBuilder sb = new StringBuilder(256);
for (int i = 0; i < _qs.length; i++) {
String s = this.sqlStringForQualifier(_qs[i]);
if (s == null || s.length() == 0)
continue; /* do not add empty qualifiers as per doc */ // TBD: explain
if (sb.length() > 0) sb.append(_op);
sb.append("( ");
sb.append(s);
sb.append(" )");
}
return sb.toString();
}
/**
* Calls sqlStringForJoinedQualifiers with the " AND " operator.
*
* @param _qs - qualifiers to conjoin
* @return SQL representation of the qualifiers
*/
public String sqlStringForConjoinedQualifiers(EOQualifier[] _qs) {
return this.sqlStringForJoinedQualifiers(_qs, " AND ");
}
/**
* Calls sqlStringForJoinedQualifiers with the " OR " operator.
*
* @param _qs - qualifiers to disjoin
* @return SQL representation of the qualifiers
*/
public String sqlStringForDisjoinedQualifiers(EOQualifier[] _qs) {
return this.sqlStringForJoinedQualifiers(_qs, " OR ");
}
/**
* Converts the shell patterns used in EOQualifiers into SQL % patterns.
* Example:
* Eg the EOAttribute takes its columnName() and calls
* sqlStringForSchemaObjectName() with it on the given EOSQLExpression.
*/
public static interface SQLValue {
/**
* Called by sqlStringForAttribute() and other methods to convert an
* object to a SQL expression.
*
* @param _context - the EOSQLExpression object which is building the SQL
* @return the String to be used for 'this' object
*/
public String valueForSQLExpression(EOSQLExpression _context);
}
/* constants */
public static final String BindVariableAttributeKey =
"BindVariableAttributeKey";
public static final String BindVariablePlaceHolderKey =
"BindVariablePlaceHolderKey";
public static final String BindVariableColumnKey = "BindVariableColumnKey";
public static final String BindVariableNameKey = "BindVariableNameKey";
public static final String BindVariableValueKey = "BindVariableValueKey";
/* description */
@Override
public void appendAttributesToDescription(final StringBuilder _d) {
super.appendAttributesToDescription(_d);
if (this.entity != null) {
_d.append(" entity=");
_d.append(this.entity);
}
}
/* escaping */
/**
* This function escapes single quotes and backslashes with itself. Eg:
* INSERT INTO Log ( a, b) VALUES (1,2), (3,4), (5,6);
*
* @param _rows - list of rows to insert
* @param _tableList - SQL table reference (eg 'address')
* @param _columnList - SQL list of columns (eg 'firstname, lastname')
* @param _valueLists - SQL list of values
* @return assembles SQL, or null if there where no values
*/
public String assembleInsertStatementWithRows
(final Map
*
* The result of the method is stored in the 'this.statement' ivar.
*
*
* person AS BASE
* LEFT JOIN address AS T0 ON ( T0.person_id = BASE.person_id )
* LEFT JOIN company AS T1 ON ( T1.owner_id = BASE.owner_id)
*
*
* When an EOQualifierVariable is encountered an error is logged and null is
* returned.
* For unknown objects the string representation is rendered.
*
* @param _v - some value to be formatted for inclusion in the SQL
* @return a String representing the value
*/
protected String formatValue(Object _v) {
// own method for basic stuff
if (_v == null)
return "NULL";
if (_v instanceof String)
return this.formatStringValue((String)_v);
if (_v instanceof Number)
return this.sqlStringForNumber((Number)_v);
if (_v instanceof Boolean)
return this.sqlStringForBoolean((Boolean)_v);
if (_v instanceof Date)
return this.formatDateValue((Date)_v, null /* attribute */);
if (_v instanceof EORawSQLValue)
return _v.toString();
/* process lists */
Class itemClazz = _v.getClass().getComponentType();
if (itemClazz != null) { /* array */
if (itemClazz == java.lang.Integer.TYPE) {
int[] nums = (int[])_v;
if (nums.length <= 0)
return "( )"; /* empty list */
StringBuilder sql = new StringBuilder(256);
sql.append("( ");
boolean isFirst = true;
for (int o: nums) {
if (isFirst) isFirst = false;
else sql.append(", ");
sql.append(o);
}
sql.append(" )");
return sql.toString();
}
_v = Arrays.asList((Object[])_v);
}
if (_v instanceof Collection) {
Collection c = (Collection)_v;
if (c.size() <= 0)
return "( )"; /* empty list */
StringBuilder sql = new StringBuilder(256);
sql.append("( ");
boolean isFirst = true;
for (Object o: c) {
if (isFirst) isFirst = false;
else sql.append(", ");
sql.append(this.formatValue(o));
}
sql.append(" )");
return sql.toString();
}
if (_v instanceof EOKeyGlobalID) {
Object[] vals = ((EOKeyGlobalID)_v).keyValues();
if (vals == null || vals.length == 0) {
log.error("got EOKeyGlobalID w/o values: " + _v);
return null;
}
if (vals.length > 1) {
log.error("cannot format EOKeyGlobalID with more than one value: "+_v);
return null;
}
return this.formatValue(vals[0]);
}
/* warn about qualifier variables */
if (_v instanceof EOQualifierVariable) {
log.error("detected unresolved qualifier variable: " + _v);
return null;
}
/* fallback to string representation */
log.warn("unexpected SQL value, rendering as string: " + _v);
return this.formatStringValue(_v.toString());
}
/**
* This method finally calls formatValue() but does some type coercion when
* an EOAttribute is provided.
*
* @param _value - some value which should be formatted for a SQL string
* @param _attr - an optional EOAttribute containing formatting info
* @return a String suitable for use in a SQL string (or null on error)
*/
public String formatValueForAttribute(Object _value, EOAttribute _attr) {
if (_attr == null)
return this.formatValue(_value);
if (_value instanceof Boolean) {
/* convert Boolean values for integer columns */
// somewhat hackish
if (_attr.externalType().startsWith("INT"))
_value = ((Boolean)_value).booleanValue() ? 1 : 0;
}
else if (_value instanceof Date) {
/* catch this here because formatValue() does not have the attribute */
return this.formatDateValue((Date)_value, _attr);
}
// TODO: do something with the attribute ...
// Note: read formats are applied later on
return this.formatValue(_value);
}
/**
* This is called by sqlStringForKeyValueQualifier().
*
* @param _value
* @param _keyPath
* @return
*/
public String sqlStringForValue(Object _value, String _keyPath) {
if (_value instanceof EORawSQLValue)
return _value.toString();
EOAttribute attribute = (this.entity != null)
? this.entity.attributeNamed(_keyPath) : null;
boolean useBind = false;
if (_value instanceof EOQualifierVariable)
useBind = true;
else if ((_value != null && _value.getClass().isArray()) ||
_value instanceof Collection) {
/* Not sure whether this should really override the attribute? Its for
* IN queries.
*/
useBind = false;
}
else if (attribute != null)
useBind = this.shouldUseBindVariableForAttribute(attribute);
else {
/* no model to base our decision on */
if (_value != null) { /* we don't need a bind for NULL */
/* we dont bind bools and numbers, no risk of SQL attacks? */
useBind = !(_value instanceof Number || _value instanceof Boolean);
}
}
if (useBind) {
Map
* ship.city = bill.city
* T1.city = T2.city
*
* @param _q - EOKeyComparisonQualifier to build
* @return the SQL for the qualifier
*/
public String sqlStringForKeyComparisonQualifier(EOKeyComparisonQualifier _q){
if (_q == null) return null;
final StringBuilder sb = new StringBuilder(64);
final String lhs = _q.leftKey();
final String rhs = _q.rightKey();
EOAttribute a;
String s;
/* generate lhs */
s = this.sqlStringForAttributeNamed(lhs);
a = this.entity != null ? this.entity.attributeNamed(lhs) : null;
if (a != null) s = this.formatSQLString(s, a.readFormat());
sb.append(s);
sb.append(" ");
/* generate operator */
// TODO: do something about caseInsensitiveLike (TO_UPPER?)
sb.append(this.sqlStringForSelector(_q.operation(), null, false));
/* generate rhs */
sb.append(" ");
s = this.sqlStringForAttributeNamed(rhs);
a = this.entity != null ? this.entity.attributeNamed(rhs) : null;
if (a != null) s = this.formatSQLString(s, a.readFormat());
sb.append(s);
return sb.toString();
}
/**
* Calls sqlStringForQualifier() on each of the given qualifiers and joins
* the results using the given _op (either " AND " or " OR ").
*
* name LIKE '?ello*World*'
* name LIKE '_ello%World%'
*
* @param _pattern
* @return
*/
public String sqlPatternFromShellPattern(String _pattern) {
if (_pattern == null) return null;
// System.err.println("FIXUP PATTERN: " + _pattern);
String s = _pattern.replace("%", "\\%"); // hm, should we escape as %%?
s = s.replace("*", "%");
s = s.replace("_", "\\_");
s = s.replace("?", "_");
// System.err.println("DID: " + s);
return s;
}
/* aliases */
public Map
* Hello 'World'
* Hello ''World''
* @param _value - String to escape
* @return escaped String
*/
public static String escapeSQLString(final String _value) {
if (_value == null)
return null;
if (_value.length() == 0)
return "";
final StringBuilder buffer = new StringBuilder(_value.length() + 8);
final StringCharacterIterator localParser =
new StringCharacterIterator(_value);
// slow
for (char c = localParser.current();
c != CharacterIterator.DONE;
c = localParser.next())
{
if (c == '\'') { // replace ' with ''
buffer.append('\'');
buffer.append('\'');
}
else if (c == '\\') { // replace \ with \\
buffer.append('\\');
buffer.append('\\');
}
else
buffer.append(c);
}
return buffer.toString();
}
/* sorting alias pathes */
static class CompareNumberOfDots implements Comparator