KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > continuent > sequoia > controller > requests > AlterRequest


1 /**
2  * Sequoia: Database clustering technology.
3  * Copyright (C) 2002-2004 French National Institute For Research In Computer
4  * Science And Control (INRIA).
5  * Copyright (C) 2005-2006 Continuent, Inc.
6  * Contact: sequoia@continuent.org
7  *
8  * Licensed under the Apache License, Version 2.0 (the "License");
9  * you may not use this file except in compliance with the License.
10  * You may obtain a copy of the License at
11  *
12  * http://www.apache.org/licenses/LICENSE-2.0
13  *
14  * Unless required by applicable law or agreed to in writing, software
15  * distributed under the License is distributed on an "AS IS" BASIS,
16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17  * See the License for the specific language governing permissions and
18  * limitations under the License.
19  *
20  * Initial developer(s): Nicolas Modrzyk.
21  * Contributor(s): ______________________.
22  */
23
24 package org.continuent.sequoia.controller.requests;
25
26 import java.sql.SQLException JavaDoc;
27 import java.util.ArrayList JavaDoc;
28 import java.util.TreeSet JavaDoc;
29
30 import org.continuent.sequoia.common.i18n.Translate;
31 import org.continuent.sequoia.controller.semantic.SemanticBehavior;
32 import org.continuent.sequoia.controller.sql.schema.DatabaseColumn;
33 import org.continuent.sequoia.controller.sql.schema.DatabaseSchema;
34 import org.continuent.sequoia.controller.sql.schema.DatabaseTable;
35 import org.continuent.sequoia.controller.sql.schema.TableColumn;
36
37 /**
38  * This class defines a AlterRequest
39  *
40  * @author <a HREF="mailto:Nicolas.Modrzyk@inrialpes.fr">Nicolas Modrzyk </a>
41  * @version 1.0
42  */
43 public class AlterRequest extends AbstractWriteRequest
44 {
45   private static final long serialVersionUID = 8386732943389593826L;
46
47   /** The table to alter. */
48   protected transient DatabaseTable table = null;
49
50   /** The column altered */
51   protected transient DatabaseColumn column = null;
52
53   protected transient boolean isDrop = false;
54   protected transient boolean isAdd = false;
55
56   // Be conservative, if we cannot parse the query, assumes it invalidates
57 // everything
58 protected boolean altersAggregateList = true;
59   protected boolean altersDatabaseCatalog = true;
60   protected boolean altersDatabaseSchema = true;
61   protected boolean altersMetadataCache = true;
62   protected boolean altersQueryResultCache = true;
63   protected boolean altersSomething = true;
64   protected boolean altersStoredProcedureList = true;
65   protected boolean altersUserDefinedTypes = true;
66   protected boolean altersUsers = true;
67
68   /**
69    * Creates a new <code>AlterRequest</code> instance. The caller must give an
70    * SQL request, without any leading or trailing spaces and beginning with
71    * 'alter table '
72    * <p>
73    * The request is not parsed but it can be done later by a call to
74    * {@link #parse(DatabaseSchema, int, boolean)}.
75    *
76    * @param sqlQuery the SQL request
77    * @param escapeProcessing should the driver to escape processing before
78    * sending to the database ?
79    * @param timeout an <code>int</code> value
80    * @param lineSeparator the line separator used in the query
81    * @see #parse
82    */
83   public AlterRequest(String JavaDoc sqlQuery, boolean escapeProcessing, int timeout,
84       String JavaDoc lineSeparator)
85   {
86     super(sqlQuery, escapeProcessing, timeout, lineSeparator, RequestType.ALTER);
87     setMacrosAreProcessed(true); // no macro processing needed
88 }
89
90   /**
91    * @see org.continuent.sequoia.controller.requests.AbstractRequest#altersAggregateList()
92    */
93   public boolean altersAggregateList()
94   {
95     return altersAggregateList;
96   }
97
98   /**
99    * @see org.continuent.sequoia.controller.requests.AbstractRequest#altersDatabaseCatalog()
100    */
101   public boolean altersDatabaseCatalog()
102   {
103     return altersDatabaseCatalog;
104   }
105
106   /**
107    * @see org.continuent.sequoia.controller.requests.AbstractRequest#altersDatabaseSchema()
108    */
109   public boolean altersDatabaseSchema()
110   {
111     return altersDatabaseSchema;
112   }
113
114   /**
115    * @see org.continuent.sequoia.controller.requests.AbstractRequest#altersMetadataCache()
116    */
117   public boolean altersMetadataCache()
118   {
119     return altersMetadataCache;
120   }
121
122   /**
123    * @see org.continuent.sequoia.controller.requests.AbstractRequest#altersQueryResultCache()
124    */
125   public boolean altersQueryResultCache()
126   {
127     return altersQueryResultCache;
128   }
129
130   /**
131    * @see org.continuent.sequoia.controller.requests.AbstractRequest#altersSomething()
132    */
133   public boolean altersSomething()
134   {
135     return altersSomething;
136   }
137
138   /**
139    * @see org.continuent.sequoia.controller.requests.AbstractRequest#altersStoredProcedureList()
140    */
141   public boolean altersStoredProcedureList()
142   {
143     return altersStoredProcedureList;
144   }
145
146   /**
147    * @see org.continuent.sequoia.controller.requests.AbstractRequest#altersUserDefinedTypes()
148    */
149   public boolean altersUserDefinedTypes()
150   {
151     return altersUserDefinedTypes;
152   }
153
154   /**
155    * @see org.continuent.sequoia.controller.requests.AbstractRequest#altersUsers()
156    */
157   public boolean altersUsers()
158   {
159     return altersUsers;
160   }
161
162   /**
163    * @see org.continuent.sequoia.controller.requests.AbstractRequest#cloneParsing(org.continuent.sequoia.controller.requests.AbstractRequest)
164    */
165   public void cloneParsing(AbstractRequest request)
166   {
167     if (!request.isParsed())
168       return;
169     cloneParsingCommons(request);
170     AlterRequest alterRequest = (AlterRequest) request;
171     cloneTableNameAndColumns(alterRequest);
172     table = alterRequest.getDatabaseTable();
173     column = alterRequest.getColumn();
174     isParsed = true;
175   }
176
177   /**
178    * Returns the column value.
179    *
180    * @return Returns the column.
181    */
182   public DatabaseColumn getColumn()
183   {
184     return column;
185   }
186
187   /**
188    * Returns the table value.
189    *
190    * @return Returns the table.
191    */
192   public DatabaseTable getDatabaseTable()
193   {
194     return table;
195   }
196
197   /**
198    * Returns the isAdd value.
199    *
200    * @return Returns the isAdd.
201    */
202   public boolean isAdd()
203   {
204     return isAdd;
205   }
206
207   /**
208    * @see org.continuent.sequoia.controller.requests.AbstractRequest#needsMacroProcessing()
209    */
210   public boolean needsMacroProcessing()
211   {
212     return false;
213   }
214
215   /**
216    * @see org.continuent.sequoia.controller.requests.AbstractRequest#parse(org.continuent.sequoia.controller.sql.schema.DatabaseSchema,
217    * int, boolean)
218    */
219   public void parse(DatabaseSchema schema, int granularity,
220       boolean isCaseSensitive) throws SQLException JavaDoc
221   {
222     /*
223      * Example Alter statement: ALTER TABLE table_name ADD column_name datatype
224      * ALTER TABLE table_name DROP COLUMN column_name
225      */
226
227     if (granularity == ParsingGranularities.NO_PARSING)
228     {
229       isParsed = true;
230       return;
231     }
232
233     String JavaDoc originalSQL = this.trimCarriageReturnAndTabs();
234     String JavaDoc sql = originalSQL.toLowerCase();
235
236     // Strip 'alter table '
237 int tableIdx = sql.indexOf("table");
238     if (tableIdx == -1)
239       throw new SQLException JavaDoc(
240           "Malformed Alter Request. Should start with [ALTER TABLE]");
241     sql = sql.substring(tableIdx + 5).trim();
242
243     int index = 0;
244     // Does the query contain a add?
245 int addIdx = sql.indexOf(" add ");
246     if (addIdx != -1)
247     {
248       isAdd = true;
249       index = addIdx;
250     }
251     else
252     {
253       // Does the query contain a drop?
254 int dropIdx = sql.indexOf(" drop ");
255       if (dropIdx != -1)
256       {
257         isDrop = true;
258         index = dropIdx;
259       }
260     }
261
262     if (isAdd || isDrop)
263     { // Extract table information
264 if (isCaseSensitive) // Reverse to the original case
265 sql = originalSQL.substring(originalSQL.length() - sql.length());
266
267       tableName = sql.substring(0, index).trim();
268       table = new DatabaseTable(tableName);
269       writeLockedTables = new TreeSet JavaDoc();
270       writeLockedTables.add(tableName);
271       addDependingTables(schema, writeLockedTables);
272
273       if ((schema != null) && (granularity > ParsingGranularities.TABLE))
274       {
275         int subsIndex = index + 6 + 2; // index + column.length() + space
276 if (isAdd)
277           subsIndex += 3;
278         else
279           // Drop
280 subsIndex += 4;
281
282         columns = new ArrayList JavaDoc();
283         sql = sql.substring(subsIndex).trim();
284
285         if (isAdd)
286         {
287           int colIndex = sql.indexOf(' ');
288           String JavaDoc colName = sql.substring(0, colIndex);
289
290           int uniqueIndex = sql.toLowerCase().indexOf("unique");
291           int primary = sql.toLowerCase().indexOf("primary");
292           if (uniqueIndex != -1 || primary != -1)
293             column = new DatabaseColumn(colName, true);
294           else
295             column = new DatabaseColumn(colName, false);
296           columns.add(new TableColumn(tableName, colName));
297         }
298         else if (isDrop)
299         {
300           String JavaDoc colName = sql.trim();
301           column = schema.getTable(tableName).getColumn(colName);
302           columns.add(new TableColumn(tableName, colName));
303         }
304       }
305     }
306     // else other forms of ALTER TABLE just use default semantic
307 setSemantic(new SemanticBehavior(null, writeLockedTables, null,
308         altersDatabaseSchema, altersMetadataCache, altersQueryResultCache,
309         altersUsers, isReadOnly, needsMacroProcessing(),
310         SemanticBehavior.SERIALIZABLE_ORDER, requiresConnectionPoolFlush
311             ? SemanticBehavior.FLUSH_ALL_USERS
312             : SemanticBehavior.FLUSH_NONE));
313     isParsed = true;
314   }
315
316   /**
317    * Does this request returns a ResultSet?
318    *
319    * @return false
320    */
321   public boolean returnsResultSet()
322   {
323     return false;
324   }
325
326   /**
327    * @see org.continuent.sequoia.controller.requests.AbstractRequest#getParsingResultsAsString()
328    */
329   public String JavaDoc getParsingResultsAsString()
330   {
331     StringBuffer JavaDoc sb = new StringBuffer JavaDoc(super.getParsingResultsAsString());
332     sb.append(Translate.get("request.alter.table", table));
333     sb.append(Translate.get("request.alter.column", column));
334     sb.append(Translate.get("request.alter.is.drop", isDrop));
335     sb.append(Translate.get("request.alter.is.add", isAdd));
336     sb.append(Translate.get("request.alters",
337         new String JavaDoc[]{String.valueOf(altersAggregateList()),
338             String.valueOf(altersDatabaseCatalog()),
339             String.valueOf(altersDatabaseSchema()),
340             String.valueOf(altersMetadataCache()),
341             String.valueOf(altersQueryResultCache()),
342             String.valueOf(altersSomething()),
343             String.valueOf(altersStoredProcedureList()),
344             String.valueOf(altersUserDefinedTypes()),
345             String.valueOf(altersUsers())}));
346
347     return sb.toString();
348   }
349 }
Popular Tags