C-JDBC: org.objectweb.cjdbc.common.sql.DeleteRequest Class Reference

Parses the SQL request and extracts the selected columns and tables given the DatabaseSchema of the database targeted by this request.

An exception is thrown when the parsing fails. Warning, this method does not check the validity of the request. In particular, invalid request could be parsed without throwing an exception. However, valid SQL request should never throw an exception.

00144   {
00145     if (granularity == ParsingGranularities.NO_PARSING)
00146     {
00147       isParsed = true;
00148       return;
00149     }
00150 
00151     // Sanity check
00152     if (schema == null)
00153       throw new SQLException(
00154           "Unable to parse request with an undefined database schema");
00155 
00156     String originalSQL = this.trimCarriageReturn();
00157     String sql = originalSQL.toLowerCase();
00158 
00159     int fromIdx = sql.indexOf("from ");
00160     if (fromIdx == -1)
00161     {
00162       // For queries like: DELETE t WHERE ... used by Oracle
00163       fromIdx = 6; // 6 = "delete".length()
00164     }
00165     else
00166     {
00167       // Syntax is usually DELETE FROM t WHERE ... but it can be
00168       // DELETE t1 FROM t1,t2,.... WHERE ...
00169       // If there is something between DELETE and FROM, tableName will use this
00170       // name but the FROM clause will have all tables.
00171       String tableBetweenDeleteAndFrom;
00172       if (isCaseSensitive)
00173         tableBetweenDeleteAndFrom = originalSQL.substring(6, fromIdx).trim();
00174       else
00175         tableBetweenDeleteAndFrom = sql.substring(6, fromIdx).trim();
00176       if (tableBetweenDeleteAndFrom.length() == 0)
00177         tableName = null;
00178       else
00179         tableName = tableBetweenDeleteAndFrom;
00180       fromIdx += 5; // 5 = "from".length()
00181     }
00182 
00183     sql = sql.substring(fromIdx).trim();
00184 
00185     // Look for the WHERE clause
00186     int whereIdx = sql.indexOf("where ");
00187 
00188     if (isCaseSensitive)
00189       sql = originalSQL.substring(originalSQL.length() - sql.length());
00190     if (tableName == null)
00191     { // It was not a DELETE t1 FROM xxx type of query
00192       if (whereIdx == -1)
00193         tableName = sql;
00194       else
00195         tableName = sql.substring(0, whereIdx).trim();
00196     }
00197 
00198     // Get the table on which DELETE occurs
00199     DatabaseTable t = schema.getTable(tableName, isCaseSensitive);
00200     if (t == null)
00201       throw new SQLException("Unknown table '" + tableName
00202           + "' in this DELETE statement: " + sqlQuery + "'");
00203 
00204     try
00205     {
00206       switch (granularity)
00207       {
00208         case ParsingGranularities.NO_PARSING :
00209           return;
00210         case ParsingGranularities.TABLE :
00211           break;
00212         case ParsingGranularities.COLUMN :
00213           from = getFromTables(tableName, schema);
00214           columns = getWhereColumns(sql.substring(whereIdx + 6).trim(), from);
00215 
00216           if (from != null)
00217           {
00218             // Convert 'from' to an ArrayList of String objects instead of
00219             // AliasedTables objects
00220             int size = from.size();
00221             ArrayList unaliased = new ArrayList(size);
00222             for (int i = 0; i < size; i++)
00223               unaliased.add(((AliasedDatabaseTable) from.get(i)).getTable()
00224                   .getName());
00225             from = unaliased;
00226           }
00227           break;
00228         case ParsingGranularities.COLUMN_UNIQUE :
00229           from = getFromTables(tableName, schema);
00230           columns = getWhereColumns(sql.substring(whereIdx + 6).trim(), from);
00231 
00232           if (from != null)
00233           {
00234             // Convert 'from' to an ArrayList of String objects instead of
00235             // AliasedTables objects
00236             int size = from.size();
00237             ArrayList unaliased = new ArrayList(size);
00238             for (int i = 0; i < size; i++)
00239               unaliased.add(((AliasedDatabaseTable) from.get(i)).getTable()
00240                   .getName());
00241             from = unaliased;
00242           }
00243           break;
00244         default :
00245           throw new SQLException("Unsupported parsing granularity: '"
00246               + granularity + "'");
00247       }
00248     }
00249     catch (SQLException e)
00250     {
00251       from = null;
00252       columns = null;
00253       whereValues = null;
00254       throw e;
00255     }
00256 
00257     isParsed = true;
00258   }


Public Member Functions
	DeleteRequest (String sqlQuery, boolean escapeProcessing, int timeout, String lineSeparator, DatabaseSchema schema, int granularity, boolean isCaseSensitive) throws SQLException
	DeleteRequest (String sqlQuery, boolean escapeProcessing, int timeout, String lineSeparator)
void	parse (DatabaseSchema schema, int granularity, boolean isCaseSensitive) throws SQLException
void	cloneParsing (AbstractRequest request)
ArrayList	getValues ()
boolean	isUnique ()
boolean	isInsert ()
boolean	isUpdate ()
boolean	isDelete ()
boolean	isCreate ()
boolean	isDrop ()
void	debug ()
boolean	isAlter ()
Protected Attributes
ArrayList	whereValues

org.objectweb.cjdbc.common.sql.DeleteRequest Class Reference

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation