KickJava   Java API By Example, From Geeks To Geeks.

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


1 /**
2  * Sequoia: Database clustering technology.
3  * Copyright (C) 2005 AmicoSoft, Inc. dba Emic Networks
4  * Contact: sequoia@continuent.org
5  *
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  *
18  * Initial developer(s): Emmanuel Cecchet.
19  * Contributor(s): ______________________.
20  */
21
22 package org.continuent.sequoia.controller.requests;
23
24 import java.util.regex.Pattern JavaDoc;
25
26 /**
27  * This class defines the regular expressions to be used with generic ANSI SQL
28  * requests.
29  *
30  * @author <a HREF="mailto:emmanuel.cecchet@continuent.com">Emmanuel Cecchet</a>
31  * @version 1.0
32  */
33 public final class SequoiaRequestRegExp implements RequestRegExp
34 {
35   private static final String JavaDoc ALTER_REQUEST_PATTERN_STRING = "^alter.*";
36   private static final String JavaDoc CREATE_REQUEST_PATTERN_STRING = "^(create|select\\s.+\\sinto\\s).*";
37   private static final String JavaDoc DELETE_REQUEST_PATTERN_STRING = "^(delete|truncate).*";
38   private static final String JavaDoc DROP_REQUEST_PATTERN_STRING = "^drop.*";
39   private static final String JavaDoc INSERT_REQUEST_PATTERN_STRING = "^insert.*";
40   private static final String JavaDoc SELECT_REQUEST_PATTERN_STRING = "^(\\s|\\()*select.*";
41   private static final String JavaDoc SELECT_FOR_UPDATE_PATTERN_STRING = ".*select.*\\s+for\\s+update\\s*.*";
42   private static final String JavaDoc STORED_PROCEDURE_PATTERN_STRING = "^\\{(\\s*\\?\\s*=)?\\s*call.*";
43   private static final String JavaDoc UPDATE_REQUEST_PATTERN_STRING = "^update.*";
44   private static final String JavaDoc UNKNOWN_READ_REQUEST_PATTERN_STRING = "^show.*";
45   private static final String JavaDoc UNKNOWN_WRITE_REQUEST_PATTERN_STRING = "^(grant|lock|revoke|set).*";
46   private static final String JavaDoc STATEMENT_EXECUTE_REQUEST_PATTERN_STRING = "^(explain\\s+analyze).*";
47   private static final String JavaDoc UNAUTHORIZED_REQUEST_PATTERN_STRING = "^(shutdown|kill).*";
48
49   // Note that we use Patterns and not Matchers because these objects are
50 // potentially accessed concurrently and parsing could occur in parallel. This
51 // way, each caller will have to call Pattern.matcher() that will allocate a
52 // matcher for its own use in a thread-safe way.
53
54   private static final Pattern JavaDoc ALTER_REQUEST_PATTERN = Pattern
55                                                                             .compile(
56                                                                                 ALTER_REQUEST_PATTERN_STRING,
57                                                                                 Pattern.CASE_INSENSITIVE
58                                                                                     | Pattern.DOTALL);
59
60   private static final Pattern JavaDoc CREATE_REQUEST_PATTERN = Pattern
61                                                                             .compile(
62                                                                                 CREATE_REQUEST_PATTERN_STRING,
63                                                                                 Pattern.CASE_INSENSITIVE
64                                                                                     | Pattern.DOTALL);
65
66   private static final Pattern JavaDoc DELETE_REQUEST_PATTERN = Pattern
67                                                                             .compile(
68                                                                                 DELETE_REQUEST_PATTERN_STRING,
69                                                                                 Pattern.CASE_INSENSITIVE
70                                                                                     | Pattern.DOTALL);
71   private static final Pattern JavaDoc DROP_REQUEST_PATTERN = Pattern
72                                                                             .compile(
73                                                                                 DROP_REQUEST_PATTERN_STRING,
74                                                                                 Pattern.CASE_INSENSITIVE
75                                                                                     | Pattern.DOTALL);
76
77   private static final Pattern JavaDoc INSERT_REQUEST_PATTERN = Pattern
78                                                                             .compile(
79                                                                                 INSERT_REQUEST_PATTERN_STRING,
80                                                                                 Pattern.CASE_INSENSITIVE
81                                                                                     | Pattern.DOTALL);
82
83   private static final Pattern JavaDoc SELECT_REQUEST_PATTERN = Pattern
84                                                                             .compile(
85                                                                                 SELECT_REQUEST_PATTERN_STRING,
86                                                                                 Pattern.CASE_INSENSITIVE
87                                                                                     | Pattern.DOTALL);
88   private static final Pattern JavaDoc SELECT_FOR_UPDATE_PATTERN = Pattern
89                                                                             .compile(
90                                                                                 SELECT_FOR_UPDATE_PATTERN_STRING,
91                                                                                 Pattern.CASE_INSENSITIVE
92                                                                                     | Pattern.DOTALL);
93
94   private static final Pattern JavaDoc STORED_PROCEDURE_PATTERN = Pattern
95                                                                             .compile(
96                                                                                 STORED_PROCEDURE_PATTERN_STRING,
97                                                                                 Pattern.CASE_INSENSITIVE
98                                                                                     | Pattern.DOTALL);
99
100   private static final Pattern JavaDoc UPDATE_REQUEST_PATTERN = Pattern
101                                                                             .compile(
102                                                                                 UPDATE_REQUEST_PATTERN_STRING,
103                                                                                 Pattern.CASE_INSENSITIVE
104                                                                                     | Pattern.DOTALL);
105
106   private static final Pattern JavaDoc UNKNOWN_READ_REQUEST_PATTERN = Pattern
107                                                                             .compile(
108                                                                                 UNKNOWN_READ_REQUEST_PATTERN_STRING,
109                                                                                 Pattern.CASE_INSENSITIVE
110                                                                                     | Pattern.DOTALL);
111
112   private static final Pattern JavaDoc UNKNOWN_WRITE_REQUEST_PATTERN = Pattern
113                                                                             .compile(
114                                                                                 UNKNOWN_WRITE_REQUEST_PATTERN_STRING,
115                                                                                 Pattern.CASE_INSENSITIVE
116                                                                                     | Pattern.DOTALL);
117
118   private static final Pattern JavaDoc STATEMENT_EXECUTE_REQUEST_PATTERN = Pattern
119                                                                             .compile(
120                                                                                 STATEMENT_EXECUTE_REQUEST_PATTERN_STRING,
121                                                                                 Pattern.CASE_INSENSITIVE
122                                                                                     | Pattern.DOTALL);
123
124   private static final Pattern JavaDoc UNAUTHORIZED_REQUEST_PATTERN = Pattern
125                                                                             .compile(
126                                                                                 UNAUTHORIZED_REQUEST_PATTERN_STRING,
127                                                                                 Pattern.CASE_INSENSITIVE
128                                                                                     | Pattern.DOTALL);
129
130   /**
131    * @see org.continuent.sequoia.controller.requests.RequestRegExp#getAlterRequestPattern()
132    */
133   public Pattern JavaDoc getAlterRequestPattern()
134   {
135     return ALTER_REQUEST_PATTERN;
136   }
137
138   /**
139    * @see org.continuent.sequoia.controller.requests.RequestRegExp#getCreateRequestPattern()
140    */
141   public Pattern JavaDoc getCreateRequestPattern()
142   {
143     return CREATE_REQUEST_PATTERN;
144   }
145
146   /**
147    * @see org.continuent.sequoia.controller.requests.RequestRegExp#getDeleteRequestPattern()
148    */
149   public Pattern JavaDoc getDeleteRequestPattern()
150   {
151     return DELETE_REQUEST_PATTERN;
152   }
153
154   /**
155    * @see org.continuent.sequoia.controller.requests.RequestRegExp#getDropRequestPattern()
156    */
157   public Pattern JavaDoc getDropRequestPattern()
158   {
159     return DROP_REQUEST_PATTERN;
160   }
161
162   /**
163    * @see org.continuent.sequoia.controller.requests.RequestRegExp#getInsertQueryPattern()
164    */
165   public Pattern JavaDoc getInsertQueryPattern()
166   {
167     return INSERT_REQUEST_PATTERN;
168   }
169
170   /**
171    * @see org.continuent.sequoia.controller.requests.RequestRegExp#getSelectForUpdatePattern()
172    */
173   public Pattern JavaDoc getSelectForUpdatePattern()
174   {
175     return SELECT_FOR_UPDATE_PATTERN;
176   }
177
178   /**
179    * @see org.continuent.sequoia.controller.requests.RequestRegExp#getSelectRequestPattern()
180    */
181   public Pattern JavaDoc getSelectRequestPattern()
182   {
183     return SELECT_REQUEST_PATTERN;
184   }
185
186   /**
187    * @see org.continuent.sequoia.controller.requests.RequestRegExp#getStoredProcedurePattern()
188    */
189   public Pattern JavaDoc getStoredProcedurePattern()
190   {
191     return STORED_PROCEDURE_PATTERN;
192   }
193
194   /**
195    * @see org.continuent.sequoia.controller.requests.RequestRegExp#getUnknownReadRequestPattern()
196    */
197   public Pattern JavaDoc getUnknownReadRequestPattern()
198   {
199     return UNKNOWN_READ_REQUEST_PATTERN;
200   }
201
202   /**
203    * @see org.continuent.sequoia.controller.requests.RequestRegExp#getUnknownWriteRequestPattern()
204    */
205   public Pattern JavaDoc getUnknownWriteRequestPattern()
206   {
207     return UNKNOWN_WRITE_REQUEST_PATTERN;
208   }
209
210   /**
211    * @see org.continuent.sequoia.controller.requests.RequestRegExp#getUpdateRequestPattern()
212    */
213   public Pattern JavaDoc getUpdateRequestPattern()
214   {
215     return UPDATE_REQUEST_PATTERN;
216   }
217
218   /**
219    * @see org.continuent.sequoia.controller.requests.RequestRegExp#getStatementExecuteRequestPattern()
220    */
221   public Pattern JavaDoc getStatementExecuteRequestPattern()
222   {
223     return STATEMENT_EXECUTE_REQUEST_PATTERN;
224   }
225
226   /**
227    * @see org.continuent.sequoia.controller.requests.RequestRegExp#getUnauthorizedRequestsPattern()
228    */
229   public Pattern JavaDoc getUnauthorizedRequestsPattern()
230   {
231     return UNAUTHORIZED_REQUEST_PATTERN;
232   }
233
234 }
235
Popular Tags