src/org/objectweb/cjdbc/common/sql/UpdateRequest.java

説明を見る。

package org.objectweb.cjdbc.common.sql;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.StringTokenizer;

import org.objectweb.cjdbc.common.sql.schema.DatabaseColumn;
import org.objectweb.cjdbc.common.sql.schema.DatabaseSchema;
import org.objectweb.cjdbc.common.sql.schema.DatabaseTable;
import org.objectweb.cjdbc.common.sql.schema.TableColumn;

public class UpdateRequest extends AbstractWriteRequest implements Serializable
{
  private transient boolean isUnique;

  private transient HashMap updatedValues = null;

  public UpdateRequest(String sqlQuery, boolean escapeProcessing, int timeout,
      String lineSeparator, DatabaseSchema schema, int granularity,
      boolean isCaseSensitive) throws SQLException
  {
    this(sqlQuery, escapeProcessing, timeout, lineSeparator);
    parse(schema, granularity, isCaseSensitive);
  }

  public UpdateRequest(String sqlQuery, boolean escapeProcessing, int timeout,
      String lineSeparator)
  {
    super(sqlQuery, escapeProcessing, timeout, lineSeparator);
    cacheable = RequestType.UNCACHEABLE;
    isParsed = false;
    isUnique = false;
  }

  public void parse(DatabaseSchema schema, int granularity,
      boolean isCaseSensitive) throws SQLException
  {
    if (granularity == ParsingGranularities.NO_PARSING)
    {
      isParsed = true;
      return;
    }

    // Sanity check
    if (schema == null)
      throw new SQLException(
          "Unable to parse request with an undefined database schema");

    String whereClause = null;
    isUnique = true;

    String originalSQL = this.trimCarriageReturn();
    String sql = originalSQL.toLowerCase();

    // Strip 'update '
    sql = sql.substring(7).trim();

    // Look for the SET or WHERE clause
    int setIdx = sql.indexOf("set ");
    int whereIdx = sql.indexOf("where ");
    if (setIdx == -1)
      throw new SQLException(
          "Unable to find the SET keyword in this UPDATE statement: '"
              + sqlQuery + "'");

    if (isCaseSensitive)
      sql = originalSQL.substring(7).trim();

    if (whereIdx == -1)
    {
      whereIdx = sql.length();
      isUnique = false;
    }
    else
    {
      whereClause = sql.substring(whereIdx + 5);
      // 5 = "where".length(), do not trim or remove anything after
      // else the following code will no more work
      sql = sql.substring(0, whereIdx + 1).trim();
    }

    // Get the table on which UPDATE occurs
    DatabaseTable t = schema.getTable(sql.substring(0, setIdx).trim(),
        isCaseSensitive);
    if (t == null)
      throw new SQLException("Unknown table '" + tableName
          + "' in this UPDATE statement: '" + sqlQuery + "'");
    else
      // Get the real name here (resolves case sentivity problems)
      tableName = t.getName();

    if (granularity > ParsingGranularities.TABLE)
    {
      // We have to get the affected columns
      // Column names are separated by comas and are before a '=' symbol
      StringTokenizer columnTokens = new StringTokenizer(sql.substring(
          setIdx + 4, whereIdx), ",");
      // 4=length("SET ")
      columns = new ArrayList();
      DatabaseColumn col = null;
      while (columnTokens.hasMoreTokens())
      {
        String token = columnTokens.nextToken();
        int eq = token.indexOf("=");
        if (eq == -1)
          continue;
        token = token.substring(0, eq).trim();
        col = t.getColumn(token, isCaseSensitive);
        if (col == null)
        {
          tableName = null;
          columns = null;
          throw new SQLException("Unknown column name '" + token
              + "' in this UPDATE statement: '" + sqlQuery + "'");
        }
        else
          columns.add(new TableColumn(tableName, col.getName()));
      }
    }

    isParsed = true;
    if (!isUnique)
      return;
    else
      isUnique = false;

    if (granularity < ParsingGranularities.COLUMN_UNIQUE)
      return;

    // Prepare hashtable for updated values
    updatedValues = new HashMap(columns.size());

    // Check whether this update affects a single row or not
    // Instead of parsing the clause, we use a brutal force technique
    // and we try to directly identify every column name of the table.
    DatabaseColumn col = null;
    ArrayList cols = t.getColumns();
    int size = cols.size();
    for (int j = 0; j < size; j++)
    {
      col = (DatabaseColumn) cols.get(j);
      String colName = col.getName();
      // if pattern found and column not already in result, it's a dependency !
      int matchIdx = whereClause.indexOf(colName);
      while (matchIdx > 0)
      {
        // Try to check that we got the full pattern and not a sub-pattern
        char beforePattern = whereClause.charAt(matchIdx - 1);
        if (((beforePattern >= 'a') && (beforePattern <= 'z'))
            || ((beforePattern >= 'A') && (beforePattern <= 'Z'))
            || (beforePattern == '_'))
          matchIdx = whereClause.indexOf(colName, matchIdx + 1);
        else
        { // Ok it's a good one, check if it is UNIQUE
          isUnique = col.isUnique();
          if (!isUnique)
            return;
          // Check if this UNIQUE columns stands in the left part of an
          // equality
          int eq = whereClause.indexOf("=", matchIdx);
          if ((eq == -1)
              || (whereClause.substring(matchIdx + colName.length(), eq).trim()
                  .length() > 0))
          {
            isUnique = false;
            return;
          }
          do
          {
            eq++; // Skip spaces
          }
          while (whereClause.charAt(eq) == ' ');

          // Check if we have "..." or '...'
          char startChar = whereClause.charAt(eq);
          int end;
          if ((startChar == '\'') || (startChar == '"'))
          {
            eq++;
            do
            { // Look for the end of the quote and take care of \' or \"
              end = whereClause.indexOf(startChar, eq);
            }
            while (whereClause.charAt(end - 1) == '\\');
          }
          else
          {
            // It's a regular value just find the next comma
            end = whereClause.indexOf(",", eq);
            if (end == -1)
              end = whereClause.length();
          }
          pkValue = whereClause.substring(eq, end);

          matchIdx = whereClause.indexOf(colName, matchIdx + 1);
        }
      }
    }

    cacheable = RequestType.UNIQUE_CACHEABLE;

    // Now get the values for each updated field
    sql = originalSQL.substring(7).substring(0, whereIdx).trim();
    if(!isCaseSensitive)
      sql.toLowerCase();
    int set = sql.toLowerCase().indexOf("set");
    sql = sql.substring(set+3).trim();
    
    for (int j = 0; j < cols.size(); j++)
    {
      col = (DatabaseColumn) cols.get(j);
      // if pattern found and column not already in result, it's a dependency !
      String colName = (isCaseSensitive) ? col.getName() : col.getName().toLowerCase();
      int matchIdx = sql.indexOf(colName);

      while (matchIdx >= 0)
      {
        char afterPattern = sql.charAt(matchIdx + colName.length());
        if ((afterPattern != '=') && (afterPattern != ' '))
        {
          matchIdx = sql.indexOf(colName, matchIdx + colName.length());
          continue;
        }

        // Try to check that we got the full pattern and not a sub-pattern
        char beforePattern = Character.CONTROL;
        try
        {
          beforePattern = sql.charAt(matchIdx - 1);
        }
        catch (RuntimeException e)
        {
          // nothing
        }
        if (((beforePattern >= 'a') && (beforePattern <= 'z')) // Everything
            // should be
            // lowercase here
            || (beforePattern == '_'))
          matchIdx = sql.indexOf(colName, matchIdx + 1);
        else
        { // Ok, it's good, get the value on the right part of the equality
          int eq = sql.indexOf("=", matchIdx);
          do
          {
            eq++; // Skip spaces
          }
          while (sql.charAt(eq) == ' ');

          // Check if we have "..." or '...'
          char startChar = sql.charAt(eq);
          int end;
          if ((startChar == '\'') || (startChar == '"'))
          {
            eq++;
            do
            { // Look for the end of the quote and take care of \' or \"
              end = sql.indexOf(startChar, eq);
            }
            while (sql.charAt(end - 1) == '\\');
          }
          else
          {
            // It's a regular value just find the next comma
            end = sql.indexOf(",", eq);
            if (end == -1)
              end = sql.length();
          }
          updatedValues.put(col.getName(), sql.substring(eq, end).trim());
          break;
        }
      }
    }
  }

  public HashMap getUpdatedValues()
  {
    return updatedValues;
  }

  public void cloneParsing(AbstractRequest request)
  {
    if (!request.isParsed())
      return;
    cloneTableNameAndColumns((AbstractWriteRequest) request);
    updatedValues = ((UpdateRequest) request).getUpdatedValues();
    isParsed = true;
  }

  public boolean isInsert()
  {
    return false;
  }

  public boolean isUpdate()
  {
    return true;
  }

  public boolean isDelete()
  {
    return false;
  }

  public boolean isCreate()
  {
    return false;
  }

  public boolean isDrop()
  {
    return false;
  }

  public boolean isUnique()
  {
    return isUnique;
  }

  public void debug()
  {
    super.debug();
    if (tableName != null)
      System.out.println("Updated table: " + tableName);
    else
      System.out.println("No information about updated table");

    if (columns != null)
    {
      System.out.println("Updated columns:");
      for (int i = 0; i < columns.size(); i++)
        System.out.println("  "
            + ((TableColumn) columns.get(i)).getColumnName());
    }
    else
      System.out.println("No information about updated columns");

    System.out.println("Unique update: " + isUnique);

    System.out.println("");
  }
  public boolean isAlter()
  {
    return false;
  }
}

---