/** * INTERNAL: * Rebuild myself against the base, with the values of parameters supplied by the context * expression. This is used for transforming a standalone expression (e.g. the join criteria of a mapping) * into part of some larger expression. You normally would not call this directly, instead calling twist * See the comment there for more details" */ public Expression twistedForBaseAndContext(Expression newBase, Expression context) { Expression twistedBase = getBaseExpression().twistedForBaseAndContext(newBase, context); return twistedBase.getField(getField()); }
/** * INTERNAL: * This expression is built on a different base than the one we want. Rebuild it and * return the root of the new tree */ public Expression rebuildOn(Expression newBase) { FieldExpression expression = new FieldExpression(getField(), getBaseExpression().rebuildOn(newBase)); expression.setSelectIfOrderedBy(selectIfOrderedBy()); return expression; }
/** * INTERNAL: * Print SQL onto the stream, using the ExpressionPrinter for context */ public void printSQL(ExpressionSQLPrinter printer) { // to support custom types, print expressions derived from field expressions and direct query keys with their aliases // Note: This is also necessary for TableExpressions, but they are taken care of by their associated FieldExpression. if (getBaseExpression() != null && getBaseExpression().isFieldExpression() || (getBaseExpression().isQueryKeyExpression() && ((QueryKeyExpression)getBaseExpression()).isAttribute())){ getBaseExpression().printSQL(printer); printer.printString("."); } printer.printField(getAliasedField()); }
/** * INTERNAL: called from SQLSelectStatement.writeFieldsFromExpression(...) */ @Override public void writeFields(ExpressionSQLPrinter printer, Vector newFields, SQLSelectStatement statement) { DatabaseField field = getField(); if (field != null) { newFields.addElement(field); writeField(printer, field, statement); } }
/** * INTERNAL: * Return all the fields */ public Vector getFields() { Vector result = new Vector(1); result.addElement(getField()); return result; }
/** * INTERNAL: * Alias the database field for our current environment */ private void initializeAliasedField() { DatabaseField tempField = (DatabaseField)getField().clone(); DatabaseTable aliasedTable = getAliasedTable(); // Put in a special check here so that if the aliasing does nothing we don't cache the // result because it's invalid. This saves us from caching premature data if e.g. debugging // causes us to print too early" // if (aliasedTable.equals(getField().getTable())) { // return; // } else { aliasedField = tempField; aliasedField.setTable(aliasedTable); // } }
/** * INTERNAL: * Normalize the expression into a printable structure. */ public Expression normalize(ExpressionNormalizer normalizer) { Expression expression = super.normalize(normalizer); // to support custom types, print expressions derived from field expressions, table expressions and direct query keys with their aliases if (getBaseExpression() != null && getBaseExpression().isFieldExpression() || getBaseExpression().isTableExpression() || (getBaseExpression().isQueryKeyExpression() && ((QueryKeyExpression)getBaseExpression()).isAttribute())){ getBuilder().getStatement().setRequiresAliases(true); } return expression; }
/** * INTERNAL: */ public Expression newDerivedField(DatabaseField field) { FieldExpression result = new FieldExpression(field, this); addDerivedField(result); return result; }
protected void writeField(ExpressionSQLPrinter printer, DatabaseField field, SQLSelectStatement statement) { if (this.field == field){ //print ", " before each selected field except the first one if (printer.isFirstElementPrinted()) { printer.printString(", "); } else { printer.setIsFirstElementPrinted(true); } printSQL(printer); addFieldAliasIfNeeded(printer, field, statement); } else { super.writeField(printer, field, statement); } }
/** * INTERNAL: * Return the field appropriately aliased */ public DatabaseField getAliasedField() { if (aliasedField == null) { initializeAliasedField(); } return aliasedField; }
/** * INTERNAL: * Normalize the expression into a printable structure. */ @Override public Expression normalize(ExpressionNormalizer normalizer) { // IndexExpression always has base QueryKeyExpression. // Base expression should be normalized first: it sets the field, // and may changes base expression // from the original base QueryKeyExpression to TableExpression. // That's why the base expression may be normalized again in super.normalize. getBaseExpression().normalize(normalizer); return super.normalize(normalizer); } }
/** * INTERNAL: * Returns collection of aliases of the tables to be locked. * Only used by platforms that lock tables individually in FROM clause * (platform.shouldPrintLockingClauseAfterWhereClause()==false) * like SQLServer */ public Collection getAliasesOfTablesToBeLocked(SQLSelectStatement statement) { int expected = statement.getTableAliases().size(); HashSet aliases = new HashSet(expected); ExpressionBuilder clonedBuilder = statement.getBuilder(); Iterator<Expression> iterator = getLockedExpressions().iterator(); while (iterator.hasNext() && aliases.size() < expected) { Expression next = iterator.next(); // Necessary as this was determined in query framework. next = next.rebuildOn(clonedBuilder); // next is either ObjectExpression or FieldExpression if(next.isFieldExpression()) { next = ((FieldExpression)next).getBaseExpression(); } DatabaseTable[] expAliases = next.getTableAliases().keys(); for (int i=0; i<expAliases.length; i++) { aliases.add(expAliases[i]); } } return aliases; } }
protected void writeField(ExpressionSQLPrinter printer, DatabaseField field, SQLSelectStatement statement) { if (this.field == field){ //print ", " before each selected field except the first one if (printer.isFirstElementPrinted()) { printer.printString(", "); } else { printer.setIsFirstElementPrinted(true); } printSQL(printer); } else { super.writeField(printer, field, statement); } }
/** * INTERNAL: * Return all the fields */ public Vector getFields() { Vector result = new Vector(1); result.addElement(getField()); return result; }
/** * INTERNAL: called from SQLSelectStatement.writeFieldsFromExpression(...) */ @Override public void writeFields(ExpressionSQLPrinter printer, Vector newFields, SQLSelectStatement statement) { DatabaseField field = getField(); if (field != null) { newFields.addElement(field); writeField(printer, field, statement); } }
/** * INTERNAL: * Alias the database field for our current environment */ private void initializeAliasedField() { DatabaseField tempField = getField().clone(); DatabaseTable aliasedTable = getAliasedTable(); // Put in a special check here so that if the aliasing does nothing we don't cache the // result because it's invalid. This saves us from caching premature data if e.g. debugging // causes us to print too early" // if (aliasedTable.equals(getField().getTable())) { // return; // } else { aliasedField = tempField; aliasedField.setTable(aliasedTable); // } }
/** * INTERNAL: * Normalize the expression into a printable structure. */ public Expression normalize(ExpressionNormalizer normalizer) { if (this.hasBeenNormalized) { return this; } Expression expression = super.normalize(normalizer); // to support custom types, print expressions derived from field expressions, table expressions and direct query keys with their aliases if (getBaseExpression() != null && getBaseExpression().isFieldExpression() || getBaseExpression().isTableExpression() || (getBaseExpression().isQueryKeyExpression() && ((QueryKeyExpression)getBaseExpression()).isAttribute())){ getBuilder().getStatement().setRequiresAliases(true); } return expression; }
/** * INTERNAL: */ public Expression newDerivedField(DatabaseField field) { FieldExpression result = new FieldExpression(field, this); addDerivedField(result); return result; }
/** * INTERNAL: * Return the field appropriately aliased */ public DatabaseField getAliasedField() { if (aliasedField == null) { initializeAliasedField(); } return aliasedField; }
/** * INTERNAL: * Normalize the expression into a printable structure. */ public Expression normalize(ExpressionNormalizer normalizer) { // IndexExpression always has base QueryKeyExpression. // Base expression should be normalized first: it sets the field, // and may changes base expression // from the original base QueryKeyExpression to TableExpression. // That's why the base expression may be normalized again in super.normalize. getBaseExpression().normalize(normalizer); return super.normalize(normalizer); } }