KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > continuent > sequoia > controller > backend > rewriting > PatternRewritingRule


1 /**
2  * Sequoia: Database clustering technology.
3  * Copyright (C) 2002-2004 French National Institute For Research In Computer
4  * Science And Control (INRIA).
5  * Contact: sequoia@continuent.org
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  * Initial developer(s): Emmanuel Cecchet.
20  * Contributor(s): ______________________.
21  */
22
23 package org.continuent.sequoia.controller.backend.rewriting;
24
25 import java.util.Hashtable JavaDoc;
26 import java.util.StringTokenizer JavaDoc;
27
28 /**
29  * This class defines a PatternRewritingRule
30  *
31  * @author <a HREF="mailto:Emmanuel.Cecchet@inria.fr">Emmanuel Cecchet </a>
32  * @version 1.0
33  */
34 public class PatternRewritingRule extends AbstractRewritingRule
35 {
36   private char tokenDelimiter = '?';
37   private String JavaDoc[] patternArray;
38   private String JavaDoc[] rewriteArray;
39
40   /**
41    * Creates a new <code>PatternRewritingRule.java</code> object
42    *
43    * @param queryPattern SQL pattern to match
44    * @param rewrite rewritten SQL query
45    * @param caseSensitive true if matching is case sensitive
46    * @param stopOnMatch true if rewriting must stop after this rule if it
47    * matches.
48    */
49   public PatternRewritingRule(String JavaDoc queryPattern, String JavaDoc rewrite,
50       boolean caseSensitive, boolean stopOnMatch)
51   {
52     super(queryPattern, rewrite, caseSensitive, stopOnMatch);
53
54     // Parse queryPattern and rewrite to extract the parameters ?1 ?2 ...
55 StringTokenizer JavaDoc patternTokenizer = new StringTokenizer JavaDoc(queryPattern, String
56         .valueOf(tokenDelimiter), true);
57     patternArray = new String JavaDoc[patternTokenizer.countTokens()];
58     int i = 0;
59     try
60     {
61       do
62       {
63         patternArray[i] = patternTokenizer.nextToken();
64         if (patternArray[i].charAt(0) == tokenDelimiter)
65         { // We found a delimiter (?)
66 String JavaDoc nextToken = patternTokenizer.nextToken();
67           // Add the parameter number (only works with 1 digit parameters)
68 //For example ?124 will be recognized as ?1
69 patternArray[i] += nextToken.charAt(0);
70           i++;
71           if (nextToken.length() > 1)
72             // This is the next token
73 patternArray[i] = nextToken.substring(1);
74         }
75         i++;
76       }
77       while (patternTokenizer.hasMoreTokens());
78     }
79     catch (RuntimeException JavaDoc e)
80     {
81       throw new RuntimeException JavaDoc("Malformed query pattern: " + queryPattern);
82     }
83     StringTokenizer JavaDoc rewriteTokenizer = new StringTokenizer JavaDoc(rewrite, String
84         .valueOf(tokenDelimiter), true);
85     rewriteArray = new String JavaDoc[rewriteTokenizer.countTokens()];
86     i = 0;
87     try
88     {
89       do
90       {
91         rewriteArray[i] = rewriteTokenizer.nextToken();
92         if (rewriteArray[i].charAt(0) == tokenDelimiter)
93         { // We found a delimiter (?)
94 String JavaDoc nextToken = rewriteTokenizer.nextToken();
95           // Add the parameter number (only works with 1 digit parameters)
96 //For example ?124 will be recognized as ?1
97 rewriteArray[i] += nextToken.charAt(0);
98           i++;
99           if (nextToken.length() > 1)
100             // This is the next token
101 rewriteArray[i] = nextToken.substring(1);
102         }
103         i++;
104       }
105       while (rewriteTokenizer.hasMoreTokens());
106     }
107     catch (RuntimeException JavaDoc e1)
108     {
109       throw new RuntimeException JavaDoc("Malformed rewrite element: " + rewrite);
110     }
111   }
112
113   /**
114    * @see org.continuent.sequoia.controller.backend.rewriting.AbstractRewritingRule#rewrite(java.lang.String)
115    */
116   public String JavaDoc rewrite(String JavaDoc sqlQuery)
117   {
118     Hashtable JavaDoc tokens = null; // Parameters value in the query
119 String JavaDoc lastParameter = null;
120     String JavaDoc currentToken;
121     int oldIndex = 0;
122     int newIndex = 0;
123
124     // Check for match and collect parameters into tokens
125 for (int i = 0; i < patternArray.length; i++)
126     {
127       currentToken = patternArray[i];
128       if (currentToken == null)
129         break; // Last token was a parameter
130 if (currentToken.charAt(0) == tokenDelimiter)
131       { // A new parameter is expected
132 lastParameter = currentToken;
133         continue;
134       }
135       // Here is the value of the parameter
136 newIndex = sqlQuery.indexOf(currentToken, oldIndex);
137       if (newIndex == -1)
138       { // No match
139 hasMatched = false;
140         return sqlQuery;
141       }
142
143       if (lastParameter != null)
144       { // Add the parameter value
145 if (tokens == null)
146           tokens = new Hashtable JavaDoc();
147         tokens.put(lastParameter, sqlQuery.substring(oldIndex, newIndex));
148       }
149       oldIndex = newIndex + currentToken.length();
150     }
151     // Last parameter
152 if (newIndex < sqlQuery.length())
153     {
154       if (tokens != null)
155       {
156         if (tokens.containsKey(lastParameter))
157         { // No match on the end of the pattern
158 hasMatched = false;
159           return sqlQuery;
160         }
161         else
162           tokens.put(lastParameter, sqlQuery.substring(oldIndex));
163       }
164       // Here, we probably had a match without parameters. What's the point?
165 }
166
167     hasMatched = true;
168
169     StringBuffer JavaDoc rewrittenQuery = new StringBuffer JavaDoc();
170     for (int i = 0; i < rewriteArray.length; i++)
171     {
172       currentToken = rewriteArray[i];
173       if (currentToken == null)
174         break; // Last token was a parameter
175 if (currentToken.charAt(0) != tokenDelimiter)
176         rewrittenQuery.append(currentToken);
177       else
178         rewrittenQuery.append(tokens.get(currentToken));
179     }
180     return rewrittenQuery.toString();
181   }
182 }
Popular Tags