FileDocCategorySizeDatePackage
SQLDeleteAllStatement.javaAPI DocGlassfish v2 API11360Tue May 22 16:54:32 BST 2007oracle.toplink.essentials.internal.expressions

SQLDeleteAllStatement

public class SQLDeleteAllStatement extends SQLDeleteStatement

Purpose: Print DELETE statement with non trivial WHERE clause

Responsibilities:

  • Print DELETE statement.
author
Andrei Ilitchev
since
TOPLink 10.1.3

Fields Summary
protected Expression
inheritanceExpression
protected SQLCall
selectCallForExist
protected String
tableAliasInSelectCallForExist
protected SQLCall
selectCallForNotExist
protected String
tableAliasInSelectCallForNotExist
protected Vector
aliasedFields
protected Vector
originalFields
protected boolean
shouldExtractWhereClauseFromSelectCallForExist
Constructors Summary
Methods Summary
public oracle.toplink.essentials.internal.databaseaccess.DatabaseCallbuildCall(oracle.toplink.essentials.internal.sessions.AbstractSession session)
Return SQL call for the statement, through generating the SQL string.

        SQLCall call = (SQLCall)super.buildCall(session);

        Writer writer = new CharArrayWriter(100);
        try {
            // because where clause is null, 
            // call.sqlString == "DELETE FROM getTable().getQualifiedName()"
            writer.write(call.getSQLString());

            boolean whereWasPrinted = true;
            if(selectCallForExist != null) {
                if(shouldExtractWhereClauseFromSelectCallForExist) {
                    // Should get here only in case selectCallForExist doesn't have aliases and 
                    // targets the same table as the statement.
                    // Instead of making selectCallForExist part of " WHERE EXIST("
                    // just extract its where clause.
                    // Example: selectCallForExist.sqlString:
                    // "SELECT PROJ_ID FROM PROJECT WHERE (LEADER_ID IS NULL)
                    whereWasPrinted = writeWhere(writer, selectCallForExist, call);
                    // The result is:
                    // "WHERE (LEADER_ID IS NULL)"
                } else {
                    writer.write(" WHERE EXISTS(");
                    // EXIST Example: selectCallForExist.sqlString:
                    // "SELECT t0.EMP_ID FROM EMPLOYEE t0, SALARY t1 WHERE (((t0.F_NAME LIKE 'a') AND (t1.SALARY = 0)) AND (t1.EMP_ID = t0.EMP_ID))"
                    writeSelect(writer, selectCallForExist, tableAliasInSelectCallForExist, call);
                    // closing bracket for EXISTS
                    writer.write(")");
                    // The result is (target table is SALARY):
                    // "WHERE EXISTS(SELECT t0.EMP_ID FROM EMPLOYEE t0, SALARY t1 WHERE (((t0.F_NAME LIKE 'a') AND (t1.SALARY = 0)) AND (t1.EMP_ID = t0.EMP_ID)) AND t1.EMP_ID = SALARY.EMP_ID)"
                }
            } else if (inheritanceExpression != null) {
                writer.write(" WHERE ");
                // Example: (PROJ_TYPE = 'L')
                ExpressionSQLPrinter printer = new ExpressionSQLPrinter(session, getTranslationRow(), call, false);
                printer.setWriter(writer);
                printer.printExpression(inheritanceExpression);
                // The result is:
                // "(PROJ_TYPE = 'L')"
            } else {
                whereWasPrinted = false;
            }

            if(selectCallForNotExist != null) {
                if(whereWasPrinted) {
                    writer.write(" AND");
                } else {
                    writer.write(" WHERE");
                }
                writer.write(" NOT EXISTS(");
                // NOT EXIST Example: selectCall.sqlString:
                // "SELECT t0.EMP_ID FROM EMPLOYEE t0, SALARY t1 WHERE (t1.EMP_ID = t0.EMP_ID)"
                writeSelect(writer, selectCallForNotExist, tableAliasInSelectCallForNotExist, call);
                // closing bracket for EXISTS
                writer.write(")");
                // The result is (target table is EMPLOYEE):
                // "WHERE NOT EXISTS(SELECT t0.EMP_ID FROM EMPLOYEE t0, SALARY t1 WHERE ((t1.EMP_ID = t0.EMP_ID)) AND t0.EMP_ID = EMPLOYEE.EMP_ID)"
            }            

            call.setSQLString(writer.toString());
            
        } catch (IOException exception) {
            throw ValidationException.fileError(exception);
        }
                
        return call;
    
public java.util.VectorgetAliasedFieldsForExpression()

        return aliasedFields;
    
public oracle.toplink.essentials.expressions.ExpressiongetInheritanceExpression()

        return inheritanceExpression;
    
public java.util.VectorgetOriginalFieldsForJoin()

        return originalFields;
    
public oracle.toplink.essentials.queryframework.SQLCallgetSelectCallForExist()

        return selectCallForExist;
    
public oracle.toplink.essentials.queryframework.SQLCallgetSelectCallForNotExist()

        return selectCallForNotExist;
    
public java.lang.StringgetTableAliasInSelectCallForExist()

        return tableAliasInSelectCallForExist;
    
public java.lang.StringgetTableAliasInSelectCallForNotExist()

        return tableAliasInSelectCallForNotExist;
    
public voidsetAliasedFieldsForJoin(java.util.Vector aliasedFields)

        this.aliasedFields = aliasedFields;
    
public voidsetInheritanceExpression(oracle.toplink.essentials.expressions.Expression inheritanceExpression)

        this.inheritanceExpression = inheritanceExpression;
    
public voidsetOriginalFieldsForJoin(java.util.Vector originalFields)

        this.originalFields = originalFields;
    
public voidsetPrimaryKeyFieldsForAutoJoin(java.util.Collection primaryKeyFields)

        if(primaryKeyFields != null) {
            if(primaryKeyFields instanceof Vector) {
                setOriginalFieldsForJoin((Vector)primaryKeyFields);
            } else {
                setOriginalFieldsForJoin(new Vector(primaryKeyFields));
            }
            setAliasedFieldsForJoin((Vector)getOriginalFieldsForJoin().clone());
        } else {
            setOriginalFieldsForJoin(null);
            setAliasedFieldsForJoin(null);
        }
    
public voidsetSelectCallForExist(oracle.toplink.essentials.queryframework.SQLCall selectCallForExist)

        this.selectCallForExist = selectCallForExist;
    
public voidsetSelectCallForNotExist(oracle.toplink.essentials.queryframework.SQLCall selectCallForNotExist)

        this.selectCallForNotExist = selectCallForNotExist;
    
public voidsetShouldExtractWhereClauseFromSelectCallForExist(boolean shouldExtractWhereClauseFromSelectCallForExist)

        this.shouldExtractWhereClauseFromSelectCallForExist = shouldExtractWhereClauseFromSelectCallForExist;
    
public voidsetTableAliasInSelectCallForExist(java.lang.String tableAliasInSelectCallForExist)

        this.tableAliasInSelectCallForExist = tableAliasInSelectCallForExist;
    
public voidsetTableAliasInSelectCallForNotExist(java.lang.String tableAliasInSelectCallForNotExist)

        this.tableAliasInSelectCallForNotExist = tableAliasInSelectCallForNotExist;
    
public booleanshouldExtractWhereClauseFromSelectCallForExist()

        return shouldExtractWhereClauseFromSelectCallForExist;
    
protected voidwriteSelect(java.io.Writer writer, oracle.toplink.essentials.queryframework.SQLCall selectCall, java.lang.String tableAliasInSelectCall, oracle.toplink.essentials.queryframework.SQLCall call)

        String str = selectCall.getSQLString();
        writer.write(str);
        
        boolean hasWhereClause = str.toUpperCase().indexOf(" WHERE ") >= 0;

        // join aliased fields to original fields                                               
        // Examples:
        //   table aliase provided: AND t0.EMP_ID = EMPLOYEE.EMP_ID
        //   table aliase not provided: AND EMP_ID = EMPLOYEE.EMP_ID
        for(int i=0; i < originalFields.size(); i++) {
            if(i==0 && !hasWhereClause) {
            // there is no where clause - should print WHERE
                writer.write(" WHERE ");
            } else {
                writer.write(" AND ");
            }
            if(tableAliasInSelectCall != null) {
                writer.write(tableAliasInSelectCall);
                writer.write('.");
            }
            writer.write(((DatabaseField)aliasedFields.elementAt(i)).getName());
            writer.write(" = ");
            writer.write(table.getQualifiedName());
            writer.write('.");
            writer.write(((DatabaseField)originalFields.elementAt(i)).getName());
        }

        // add parameters
        call.getParameters().addAll(selectCall.getParameters());
        call.getParameterTypes().addAll(selectCall.getParameterTypes());            
    
protected booleanwriteWhere(java.io.Writer writer, oracle.toplink.essentials.queryframework.SQLCall selectCall, oracle.toplink.essentials.queryframework.SQLCall call)

        String selectStr = selectCallForExist.getSQLString();

        int index = selectStr.toUpperCase().indexOf(" WHERE ");
        if(index < 0) {
            // no where clause - nothing to do
            return false;
        }

        // print the where clause
        String str = selectStr.substring(index);
        writer.write(str);

        // add parameters
        call.getParameters().addAll(selectCall.getParameters());
        call.getParameterTypes().addAll(selectCall.getParameterTypes());            

        return true;