summaryrefslogtreecommitdiff
path: root/projects/net.wotonomy.persistence/src/main/java/net/wotonomy/access/EOSQLExpression.java
diff options
context:
space:
mode:
Diffstat (limited to 'projects/net.wotonomy.persistence/src/main/java/net/wotonomy/access/EOSQLExpression.java')
-rw-r--r--projects/net.wotonomy.persistence/src/main/java/net/wotonomy/access/EOSQLExpression.java697
1 files changed, 697 insertions, 0 deletions
diff --git a/projects/net.wotonomy.persistence/src/main/java/net/wotonomy/access/EOSQLExpression.java b/projects/net.wotonomy.persistence/src/main/java/net/wotonomy/access/EOSQLExpression.java
new file mode 100644
index 0000000..4cb15e5
--- /dev/null
+++ b/projects/net.wotonomy.persistence/src/main/java/net/wotonomy/access/EOSQLExpression.java
@@ -0,0 +1,697 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Michael Powers
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+package net.wotonomy.access;
+
+import java.util.Enumeration;
+
+import net.wotonomy.control.EOAndQualifier;
+import net.wotonomy.control.EOFetchSpecification;
+import net.wotonomy.control.EOKeyComparisonQualifier;
+import net.wotonomy.control.EOKeyValueQualifier;
+import net.wotonomy.control.EOOrQualifier;
+import net.wotonomy.control.EOQualifier;
+import net.wotonomy.control.EOSortOrdering;
+import net.wotonomy.foundation.NSArray;
+import net.wotonomy.foundation.NSData;
+import net.wotonomy.foundation.NSDictionary;
+import net.wotonomy.foundation.NSKeyValueCoding;
+import net.wotonomy.foundation.NSMutableArray;
+import net.wotonomy.foundation.NSMutableDictionary;
+import net.wotonomy.foundation.NSSelector;
+import net.wotonomy.foundation.NSTimestamp;
+import net.wotonomy.foundation.NSTimestampFormatter;
+
+/**
+* @author ezamudio@nasoft.com
+* @author $Author: cgruber $
+* @version $Revision: 894 $
+*/
+public abstract class EOSQLExpression {
+
+ public static final String BindVariableAttributeKey = "BindVariableAttribute";
+ public static final String BindVariableColumnKey = "BindVariableColumn";
+ public static final String BindVariableNameKey = "BindVariableName";
+ public static final String BindVariablePlaceHolderKey = "BindVariablePlaceholder";
+ public static final String BindVariableValueKey = "BindVariableValue";
+ private static int UseBindings;
+ private static final int _DefaultFormatSQLStringLength = 64;
+ private static final int _DefaultListStringLength = 256;
+ private static final int _DefaultOrderByStringLength = 128;
+ private static final int _DefaultPathLength = 128;
+ private static final int _DefaultTableListLength = 128;
+ protected static final char[] _hexChars = new char[]{
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
+ };
+ private static final int _ValueLengthLimit = 40;
+ protected NSMutableDictionary _aliasesByRelationshipPath;
+ protected NSMutableDictionary _aliasesByEntityName;
+ protected NSMutableArray _bindings;
+ protected NSMutableArray _contextStack;
+ protected static NSTimestampFormatter _defaultDateFormatter;
+ protected EOEntity _entity;
+ protected StringBuffer _joinClauseString;
+ protected StringBuffer _listString;
+ protected StringBuffer _orderByString;
+ protected String _statement;
+ protected String _upperFunctionName;
+ protected boolean _useAliases = true;
+ protected static boolean _quoteExternalNames;
+ protected StringBuffer _valueListString;
+ protected String _whereClauseString;
+
+ private EOSQLExpression() {
+ super();
+ }
+
+ public EOSQLExpression(EOEntity entity) {
+ super();
+ _entity = entity;
+ }
+
+ public String _aliasForRelatedAttributeRelationshipPath(EOAttribute a, String path) {
+ return null;
+ }
+
+ public String _aliasForRelationshipPath(String path) {
+ return (String)_aliasesByRelationshipPath.objectForKey(path);
+ }
+
+ protected NSTimestampFormatter _defaultDateFormatter() {
+ return _defaultDateFormatter;
+ }
+
+ protected StringBuffer _listString() {
+ if (_listString == null)
+ _listString = new StringBuffer();
+ return _listString;
+ }
+
+ protected StringBuffer _orderByString() {
+ if (_orderByString == null)
+ _orderByString = new StringBuffer();
+ return _orderByString;
+ }
+
+ public EOEntity _rootEntityForExpression() {
+ return _entity;
+ }
+
+ public void _setEntity(EOEntity value) {
+ _entity = value;
+ }
+
+ public String _sqlStringForJoinSemanticMatchSemantic(int semantic,int match) {
+ return null;
+ }
+
+ protected String _stringForDate(NSTimestamp timestamp) {
+ return null;
+ }
+
+ protected StringBuffer _valueList() {
+ if (_valueListString == null)
+ _valueListString = new StringBuffer();
+ return _valueListString;
+ }
+
+ public void addBindVariableDictionary( NSDictionary dict ) {
+ }
+
+ /** Adds the SQL to create the attribute to the attribute list.
+ * The appended text is of the form attr_name attr_type allow_null
+ * @param attr The attribute to create the SQL for.
+ */
+ public void addCreateClauseForAttribute(EOAttribute attr) {
+ StringBuffer buf = new StringBuffer(attr.columnName());
+ buf.append(' ');
+ buf.append(columnTypeStringForAttribute(attr));
+ buf.append(allowsNullClauseForConstraint(attr.allowsNull()));
+ appendItemToListString(buf.toString(), _listString());
+ }
+
+ public void addInsertListAttribute(EOAttribute attr, Object o) {
+ }
+
+ public void addJoinClause(String left, String right, int semantic) {
+ String s = assembleJoinClause(left, right, semantic);
+ if (_joinClauseString == null)
+ _joinClauseString = new StringBuffer();
+ if (_joinClauseString.length() > 0)
+ _joinClauseString.append(" AND ");
+ _joinClauseString.append(s);
+ }
+
+ public void addOrderByAttributeOrdering(EOSortOrdering order) {
+ String sql = sqlStringForAttributeNamed(order.key());
+ if (order.selector().equals(EOSortOrdering.CompareCaseInsensitiveAscending) || order.selector().equals(EOSortOrdering.CompareCaseInsensitiveDescending))
+ sql = "UPPER(" + sql + ")";
+ if (order.selector().equals(EOSortOrdering.CompareCaseInsensitiveAscending) || order.selector().equals(EOSortOrdering.CompareAscending))
+ sql += " ASC";
+ else
+ sql += " DESC";
+ appendItemToListString(sql, _orderByString());
+ }
+
+ public void addSelectListAttribute(EOAttribute attr) {
+ appendItemToListString(formatSQLString(sqlStringForAttribute(attr), attr.readFormat()), _listString());
+ }
+
+ public void addUpdateListAttribute(EOAttribute attr, Object o) {
+ StringBuffer buf = new StringBuffer(attr.columnName());
+ buf.append('=');
+ buf.append(formatSQLString(formatValueForAttribute(o, attr), attr.writeFormat()));
+ appendItemToListString(buf.toString(), _listString());
+ }
+
+ public NSMutableDictionary aliasesByRelationshipPath() {
+ if (_aliasesByRelationshipPath == null) {
+ _aliasesByRelationshipPath = new NSMutableDictionary();
+ if (!_useAliases)
+ return _aliasesByRelationshipPath;
+ _aliasesByRelationshipPath.setObjectForKey("t0", "");
+ }
+ return _aliasesByRelationshipPath;
+ }
+
+ public String allowsNullClauseForConstraint(boolean flag) {
+ return flag ? "" : " NOT NULL";
+ }
+
+ public void appendItemToListString(String item, StringBuffer list) {
+ if (list.length() > 0)
+ list.append(", ");
+ list.append(item);
+ }
+
+ public String assembleDeleteStatementWithQualifier(EOQualifier q, String tableList, String whereClause) {
+ String s = "DELETE FROM " + tableList;
+ if (whereClause != null && whereClause.length() > 0)
+ s += " WHERE " + whereClause;
+ return s;
+ }
+
+ public String assembleInsertStatementWithRow(NSDictionary row,
+ String tableList, String columnList, String valueList) {
+ String sql = "INSERT INTO " + tableList;
+ if (columnList != null)
+ sql += " (" + columnList + ")";
+ sql += " VALUES " + valueList;
+ return sql;
+ }
+
+ public String assembleJoinClause(String leftName, String rightName, int semantic) {
+ String op = "=";
+ if (semantic == EORelationship.LeftOuterJoin)
+ op = "*=";
+ else if (semantic == EORelationship.RightOuterJoin)
+ op = "=*";
+ return leftName + op + rightName;
+ }
+
+ public String assembleSelectStatementWithAttributes(NSArray attributes,
+ boolean lock, EOQualifier q, NSArray fetchOrder, String selectString, String columnList,
+ String tableList, String whereClause, String joinClause, String orderByClause, String lockClause) {
+ String sql = selectString + " " + columnList + " FROM " + tableList;
+ if (lockClause != null)
+ sql += " " + lockClause;
+ if (whereClause != null || joinClause != null)
+ sql += " WHERE ";
+ if (whereClause != null)
+ sql += whereClause;
+ if (whereClause != null && joinClause != null)
+ sql += " AND ";
+ if (joinClause != null)
+ sql += joinClause;
+ if (orderByClause != null)
+ sql += " ORDER BY " + orderByClause;
+ return sql;
+ }
+
+ public String assembleUpdateStatementWithRow(NSDictionary row, EOQualifier q, String tableList, String updateList, String whereClause) {
+ String s = "UPDATE " + tableList + " SET " + updateList;
+ if (whereClause != null && whereClause.length() > 0)
+ s += " WHERE " + whereClause;
+ return s;
+ }
+
+ public NSArray bindVariableDictionaries() {
+ return null;
+ }
+
+ public abstract NSMutableDictionary bindVariableDictionaryForAttribute(EOAttribute attr, Object o);
+
+ public String columnTypeStringForAttribute(EOAttribute attr) {
+ String x = attr.externalType();
+ if (attr.precision() > 0) {
+ x += " (" + attr.precision() + "," + attr.scale() + ")";
+ } else if (attr.width() > 0) {
+ x += " (" + attr.width() + ")";
+ }
+ return x;
+ }
+
+ public EOEntity entity() {
+ return _entity;
+ }
+
+ public String externalNameQuoteCharacter() {
+ return "\"";
+ }
+
+ public String formatSQLString(String value, String format) {
+ if (format == null)
+ return value;
+ return value;
+ }
+
+ /**
+ * Returns the received string wrapped in single quotes,
+ * with any quotes or escape chars found inside it
+ * properly escaped.
+ * @param s The string to format.
+ */
+ public String formatStringValue(String s) {
+ StringBuffer buf = new StringBuffer(s);
+ for (int i = buf.length()-1; i >= 0; i--) {
+ if (buf.charAt(i) == sqlEscapeChar()) {
+ buf.insert(i, sqlEscapeChar());
+ i++;
+ }
+ if (buf.charAt(i) == '\'') {
+ buf.insert(i, sqlEscapeChar());
+ i++;
+ }
+ }
+ buf.append('\'');
+ buf.insert(0, '\'');
+ return buf.toString();
+ }
+
+ public String formatValueForAttribute(Object value, EOAttribute attr) {
+ if (value == null || value == NSKeyValueCoding.NullValue)
+ return "NULL";
+ if (value instanceof String)
+ return formatStringValue((String)value);
+ if (value instanceof Number)
+ return sqlStringForNumber((Number)value);
+ //TODO: format timestamps
+ return value.toString();
+ }
+
+ public String joinClauseString() {
+ if (_joinClauseString == null)
+ return null;
+ return _joinClauseString.toString();
+ }
+
+ public void joinExpression() {
+ _joinClauseString = null;
+ if (_aliasesByEntityName.count() > 1) {
+ }
+ }
+
+ public String listString() {
+ return _listString().toString();
+ }
+
+ public String lockClause() {
+ return "";
+ }
+
+ public boolean mustUseBindVariableForAttribute(EOAttribute attr) {
+ return false;
+ }
+
+ public String orderByString() {
+ if (_orderByString == null)
+ return null;
+ return _orderByString.toString();
+ }
+
+ public void prepareConstraintStatementForRelationship(EORelationship rel, NSArray arr1, NSArray arr2) {
+ }
+
+ public void prepareDeleteExpressionForQualifier(EOQualifier q) {
+ String where = null;
+ setStatement(assembleDeleteStatementWithQualifier(q, _entity.externalName(), where));
+ }
+
+ public void prepareInsertExpressionWithRow(NSDictionary row) {
+ StringBuffer cols = new StringBuffer("(");
+ StringBuffer values = new StringBuffer("(");
+ Enumeration enumeration = row.keyEnumerator();
+ while (enumeration.hasMoreElements()) {
+ String key = (String)enumeration.nextElement();
+ EOAttribute a = _entity.attributeNamed(key);
+ cols.append(a.columnName());
+ values.append(formatValueForAttribute(row.objectForKey(key), a));
+ if (enumeration.hasMoreElements()) {
+ cols.append(", ");
+ values.append(", ");
+ }
+ }
+ cols.append(")");
+ cols.append(")");
+ setStatement(assembleInsertStatementWithRow(row, _entity.externalName(), cols.toString(), values.toString()));
+ }
+
+ public void prepareSelectExpressionWithAttributes(NSArray atts, boolean lock, EOFetchSpecification fspec) {
+ _aliasesByRelationshipPath = new NSMutableDictionary();
+ _aliasesByEntityName = new NSMutableDictionary();
+ EOQualifier q = null;
+ NSArray order = null;
+ if (fspec != null) {
+ q = fspec.qualifier();
+ order = fspec.sortOrderings();
+ }
+ //Assemble the column list (this yields the alias list)
+ for (int i = 0; i < atts.count(); i++)
+ addSelectListAttribute((EOAttribute)atts.objectAtIndex(i));
+ //assemble the where string
+ if (q != null) {
+ if (q instanceof EOQualifierSQLGeneration)
+ setWhereClauseString(sqlStringForQualifier((EOQualifierSQLGeneration)q));
+ else {
+ EOQualifierSQLGeneration.Support sup = EOQualifierSQLGeneration.Support.supportForClass(q.getClass());
+ setWhereClauseString(sup.sqlStringForSQLExpression(q, this));
+ }
+ }
+ //assemble the join string
+ joinExpression();
+ //assemble the order by string
+ if (order != null && order.count() > 0) {
+ for (int i = 0; i < order.count(); i++) {
+ EOSortOrdering so = (EOSortOrdering)order.objectAtIndex(i);
+ addOrderByAttributeOrdering(so);
+ }
+ }
+ //create the statement
+ setStatement(assembleSelectStatementWithAttributes(atts, lock, q, order, "SELECT", listString(),
+ tableListWithRootEntity(_entity), whereClauseString(), joinClauseString(), orderByString(), lockClause()));
+ }
+
+ /** Build an UPDATE statement with the given information. */
+ public void prepareUpdateExpressionWithRow(NSDictionary row, EOQualifier q) {
+ StringBuffer buf = new StringBuffer();
+ Enumeration enumeration = row.keyEnumerator();
+ while (enumeration.hasMoreElements()) {
+ String key = (String)enumeration.nextElement();
+ EOAttribute a = _entity.attributeNamed(key);
+ if (a == null)
+ throw new EOGeneralAdaptorException("Cannot find attribute named " + key + " in entity " + _entity.name());
+ buf.append(a.columnName());
+ buf.append('=');
+ buf.append(formatValueForAttribute(row.objectForKey(key), a));
+ if (enumeration.hasMoreElements())
+ buf.append(", ");
+ }
+ if (q != null) {
+ setWhereClauseString(sqlStringForQualifier(null));
+ }
+ setStatement(assembleUpdateStatementWithRow(row, q, _entity.externalName(), buf.toString(), whereClauseString()));
+ }
+
+ public void setStatement(String statement) {
+ _statement = statement;
+ }
+
+ public String statement() {
+ return _statement;
+ }
+
+ public void setUseAliases(boolean flag) {
+ _useAliases = flag;
+ }
+
+ public boolean useAliases() {
+ return _useAliases;
+ }
+
+ public void setUseBindVariables(boolean flag) {
+ }
+
+ public boolean useBindVariables() {
+ return System.getProperty("EOAdaptorUseBindVariables", "false").equals("true");
+ }
+
+ /** @deprecated Check externalNameQuoteCharacter instead. */
+ public static void setUseQuotedExternalNames(boolean flag) {
+ _quoteExternalNames = flag;
+ }
+ /** @deprecated Use the instance method externalNameQuoteCharacter instead. */
+ public static boolean useQuotedExternalNames() {
+ return _quoteExternalNames;
+ }
+
+ public void setWhereClauseString(String clause) {
+ _whereClauseString = clause;
+ }
+
+ public String whereClauseString() {
+ return _whereClauseString;
+ }
+
+ public boolean shouldUseBindVariableForAttribute(EOAttribute attr) {
+ return false;
+ }
+
+ public char sqlEscapeChar() {
+ return '\\';
+ }
+
+ public String sqlPatternFromShellPattern(String pattern) {
+ return sqlPatternFromShellPatternWithEscapeCharacter(pattern, sqlEscapeChar());
+ }
+
+ public String sqlPatternFromShellPatternWithEscapeCharacter(String pattern, char escape) {
+ StringBuffer buf = new StringBuffer(pattern);
+ int idx = 0;
+ //escape all '%'
+ do {
+ idx = buf.indexOf("%");
+ if (idx == 0)
+ buf.insert(escape, 0);
+ else if (idx > 0 && buf.charAt(idx-1) != escape)
+ buf.insert(escape, idx);
+ } while (idx >= 0);
+ //escape all '_'
+ do {
+ idx = buf.indexOf("_");
+ if (idx == 0)
+ buf.insert(escape, 0);
+ else if (idx > 0 && buf.charAt(idx-1) != escape)
+ buf.insert(escape, idx);
+ } while (idx >= 0);
+ //substitute all '*'
+ do {
+ idx = buf.indexOf("*");
+ if (idx >= 0)
+ buf.replace(idx, idx+1, "%");
+ } while (idx >= 0);
+ //substitute all '?'
+ do {
+ idx = buf.indexOf("?");
+ if (idx >= 0)
+ buf.replace(idx, idx+1, "_");
+ } while (idx >= 0);
+ return buf.toString();
+ }
+
+ public String sqlStringForAttribute(EOAttribute attr) {
+ if (_aliasesByEntityName == null)
+ _aliasesByEntityName = new NSMutableDictionary();
+ String alias = (String)_aliasesByEntityName.objectForKey(attr.entity().name());
+ if (alias == null) {
+ alias = "t" + (_aliasesByEntityName.count() + 1);
+ _aliasesByEntityName.setObjectForKey(alias, attr.entity().name());
+ }
+ if (useAliases())
+ return alias + "." + attr.columnName();
+ else
+ return attr.entity().externalName() + "." + attr.columnName();
+ }
+
+ public String sqlStringForAttributeNamed(String name) {
+ if (name.indexOf('.') > 0) {
+ return sqlStringForAttribute(_entity._attributeForPath(name));
+ }
+ return sqlStringForAttribute(_entity.attributeNamed(name));
+
+ }
+
+ /**
+ * Returns a string representing the path from the first
+ * relationship in the array to the last one.
+ * @param path An array of EORelationship objects.
+ * @return A string consisting of the names of the relationships
+ * separated by dots.
+ */
+ public String sqlStringForAttributePath(NSArray path) {
+ StringBuffer buf = new StringBuffer();
+ for (int i = 0; i < path.count(); i++) {
+ EORelationship rel = (EORelationship)path.objectAtIndex(i);
+ if (i > 0)
+ buf.append('.');
+ buf.append(rel.name());
+ }
+ return buf.toString();
+ }
+
+ public String sqlStringForCaseInsensitiveLike(String key, String value) {
+ return "LOWER(" + key + ") LIKE LOWER(" + sqlPatternFromShellPattern(value) + ")";
+ }
+
+ public String sqlStringForConjoinedQualifiers(NSArray qualifiers) {
+ EOAndQualifier q = new EOAndQualifier(qualifiers);
+ return EOQualifierSQLGeneration.Support.supportForClass(EOAndQualifier.class).sqlStringForSQLExpression(q, this);
+ }
+
+ public String sqlStringForData(NSData data) {
+ byte[] b = data.bytes();
+ char[] c = new char[b.length * 2];
+ int pos = 0;
+ for (int i = 0; i < b.length; i++) {
+ int x = (b[i] & 0xf0) >> 4;
+ c[pos++] = _hexChars[x];
+ x = (b[i] & 0x0f);
+ c[pos++] = _hexChars[x];
+ }
+ return new String(c);
+ }
+
+ public String sqlStringForDisjoinedQualifiers(NSArray qualifiers) {
+ EOOrQualifier q = new EOOrQualifier(qualifiers);
+ return EOQualifierSQLGeneration.Support.supportForClass(EOOrQualifier.class).sqlStringForSQLExpression(q, this);
+ }
+
+ public String sqlStringForKeyComparisonQualifier(EOKeyComparisonQualifier q) {
+ return EOQualifierSQLGeneration.Support.supportForClass(EOKeyComparisonQualifier.class).sqlStringForSQLExpression(q, this);
+ }
+
+ public String sqlStringForKeyValueQualifier(EOKeyValueQualifier q) {
+ return EOQualifierSQLGeneration.Support.supportForClass(EOKeyValueQualifier.class).sqlStringForSQLExpression(q, this);
+ }
+
+ public String sqlStringForNegatedQualifier(EOQualifier q) {
+ EOQualifierSQLGeneration.Support sup = EOQualifierSQLGeneration.Support.supportForClass(q.getClass());
+ String sql = sup.sqlStringForSQLExpression(q, this);
+ return "NOT (" + sql + ")";
+ }
+
+ public static String sqlStringForNumber(Number number) {
+ return number.toString();
+ }
+
+ public String sqlStringForQualifier(EOQualifierSQLGeneration sql) {
+ return sql.sqlStringForSQLExpression(this);
+ }
+
+ public String sqlStringForSchemaObjectName(String name) {
+ return name;
+ }
+
+ public String sqlStringForSelector(NSSelector sel, Object value) {
+ if (sel == EOQualifier.QualifierOperatorEqual) {
+ if (value == NSKeyValueCoding.NullValue)
+ return " is ";
+ return "=";
+ } else if (sel == EOQualifier.QualifierOperatorNotEqual) {
+ if (value == NSKeyValueCoding.NullValue)
+ return " is not ";
+ return "<>";
+ } else if (sel == EOQualifier.QualifierOperatorLessThan) {
+ return "<";
+ } else if (sel == EOQualifier.QualifierOperatorGreaterThan) {
+ return ">";
+ } else if (sel == EOQualifier.QualifierOperatorLessThanOrEqualTo) {
+ return "<=";
+ } else if (sel == EOQualifier.QualifierOperatorGreaterThanOrEqualTo) {
+ return ">=";
+ } else if (sel == EOQualifier.QualifierOperatorLike || sel == EOQualifier.QualifierOperatorCaseInsensitiveLike) {
+ return " like ";
+ }
+ return sel.name();
+ }
+
+ public static String sqlStringForString(String s) {
+ return s;
+ }
+
+ public String sqlStringForValue(Object value, String keyPath) {
+ EOAttribute a = _entity._attributeForPath(keyPath);
+ return formatValueForAttribute(value, a);
+ }
+
+ public String tableListWithRootEntity(EOEntity root) {
+ StringBuffer buf = new StringBuffer(root.externalName());
+ if (useAliases()) {
+ buf.append(" ");
+ buf.append(_aliasesByEntityName.objectForKey(root.name()));
+ }
+ if (_aliasesByEntityName.count() > 0) {
+ Enumeration enumeration = _aliasesByEntityName.keyEnumerator();
+ while (enumeration.hasMoreElements()) {
+ String key = (String)enumeration.nextElement();
+ if (!key.equals(root.name())) {
+ buf.append(", ");
+ buf.append(key);
+ if (useAliases())
+ buf.append(_aliasesByEntityName.objectForKey(key));
+ }
+ }
+ }
+ return buf.toString();
+ }
+
+ public String toString() {
+ return "<" + getClass().getName() + "> " + statement();
+ }
+
+ public String valueList() {
+ return _valueList().toString();
+ }
+
+}
+/*
+ * $Log$
+ * Revision 1.2 2006/02/16 16:47:14 cgruber
+ * Move some classes in to "internal" packages and re-work imports, etc.
+ *
+ * Also use UnsupportedOperationExceptions where appropriate, instead of WotonomyExceptions.
+ *
+ * Revision 1.1 2006/02/16 13:19:57 cgruber
+ * Check in all sources in eclipse-friendly maven-enabled packages.
+ *
+ * Revision 1.5 2005/05/11 15:21:53 cgruber
+ * Change enum to enumeration, since enum is now a keyword as of Java 5.0
+ *
+ * A few other comments in the code.
+ *
+ * Revision 1.4 2003/08/29 21:14:18 chochos
+ * fix the algorithm in formatStringValue.
+ *
+ * Revision 1.3 2003/08/14 02:12:32 chochos
+ * implemented use of (simple) qualifiers
+ *
+ * Revision 1.2 2003/08/13 22:59:39 chochos
+ * Can now generate simple one-entity select statements.
+ *
+ * Revision 1.1 2003/08/13 01:04:32 chochos
+ * the SQL generation classes. EOSQLExpression still needs a lot of work, but the factory is pretty much done.
+ *
+ */ \ No newline at end of file
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-10 01:29:21 +0000