Java > Open Source Codes > smallsql > database > SQLTokenizer


1 /* =============================================================
2  * SmallSQL : a free Java DBMS library for the Java(tm) platform
3  * =============================================================
4  *
5  * (C) Copyright 2004-2006, by Volker Berlin.
6  *
7  * Project Info: http://www.smallsql.de/
8  *
9  * This library is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU Lesser General Public License as published by
11  * the Free Software Foundation; either version 2.1 of the License, or
12  * (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful, but
15  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
17  * License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
22  * USA.
23  *
24  * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
25  * in the United States and other countries.]
26  *
27  * ---------------
28  * SQLTokenizer.java
29  * ---------------
30  * Author: Volker Berlin
31  *
32  */
33 package smallsql.database;
34
35 import java.util.*;
36 import java.sql.Types ;
37
38 public class SQLTokenizer {
39
40     public static List parseSQL( char[] sql ){
41         SearchNode node = searchTree;
42         ArrayList tokens = new ArrayList();
43         int value = 0;
44         int tokenStart = 0;
45         boolean wasWhiteSpace = true;
46         char quote = 0;
47         StringBuffer quoteBuffer = new StringBuffer ();
48
49         for(int i=0; i<sql.length; i++){
50             char c = sql[i];
51             switch(c){
52                 case '\"':
53                 case '\'':
54                             if(quote == 0){
55                                 quote = c;
56                             }else if(quote == c){
57                                 // prüfen auf escaped quote
58 if(i+1<sql.length && sql[i+1] == quote){
59                                     quoteBuffer.append(quote);
60                                     i++;
61                                 }else{
62                                     tokens.add( new SQLToken( quoteBuffer.toString(), (quote == '\'') ? STRING : IDENTIFER, tokenStart, i+1) );
63                                     quoteBuffer.setLength(0);
64                                     quote = 0;
65                                     tokenStart = i+1;
66                                     wasWhiteSpace = true;
67                                 }
68                             }else quoteBuffer.append(c);
69                             break;
70                 case '.':
71                             if(quote == 0){
72                                 // there are follow cases with a point
73 // "abc"."abc" --> identifer --> multiple tokens
74 // "5"."3" --> identifer --> multiple tokens
75 // 5.3 --> number --> one token
76 // 5.e3 --> number --> one token
77 // .3 --> number --> one token
78 // .e3 --> identifer --> multiple tokens
79 int k=tokenStart;
80                                 if(k == i){ // point is first charcter
81 if(sql.length> k+1){
82                                         char cc = sql[k+1];
83                                         if((cc >= '0') && cc <= '9') break; // is a number --> break
84 }
85                                 }else{
86                                     for(; k<i; k++){
87                                         char cc = sql[k];
88                                         if((cc != '-' && cc != '$' && cc < '0') || cc > '9') break; // is identifer --> break
89 }
90                                     if(k>=i) break; // vorhergehende token sind nur Ziffern, also kein Bezeichner sonder FLießkommazahl
91 }
92                             }
93                             // Zeichen vorher ist keine Zahl, also Bezeichner
94 // kein break;
95 case '-':
96                             if(quote == 0 && !wasWhiteSpace){
97                                 char c1 = sql[tokenStart];
98                                 char cx = sql[i-1];
99                                 if(((c1 >= '0' && c1 <= '9') || c1 == '.') && (cx == 'e' || cx == 'E'))
100                                     //negative exponential number
101 break;
102                                 if(c1 == '$' && tokenStart+1 == i)
103                                     // money number
104 break;
105                             }
106                 case ' ':
107                 case '\t':
108                 case '\n':
109                 case '\r':
110                 case ',':
111                 case '(':
112                 case ')':
113                 case '{':
114                 case '}':
115                 case '*':
116                 case '+':
117                 case '/':
118                 case '%':
119                 case '&':
120                 case '|':
121                 case '=':
122                 case '<':
123                 case '>':
124                 case '?':
125                 case '^':
126                 case '~':
127                             if(quote == 0){
128                                 if(!wasWhiteSpace){
129                                    tokens.add( new SQLToken( value, tokenStart, i) );
130                                    value = 0;
131                                 }
132                                 switch(c){
133                                     case ' ':
134                                     case '\t':
135                                     case '\n':
136                                     case '\r':
137                                         // skipp this characters, this are not tokens, this are only source formater
138 break;
139                                     case '<':
140                                         if((i+1 < sql.length) && (sql[i+1] == '>')){
141                                             tokens.add( new SQLToken( UNEQUALS, i, i+2) );
142                                             i++;
143                                             break;
144                                         }
145                                     case '>':
146                                         if((i+1 < sql.length) && (sql[i+1] == '=')){
147                                             tokens.add( new SQLToken( 100 + c, i, i+2) );
148                                             i++;
149                                             break;
150                                         }
151                                     default:
152                                         tokens.add( new SQLToken( c, i, i+1) );
153                                 }
154                                 wasWhiteSpace = true;
155                                 tokenStart = i+1;
156                             }else{
157                                 quoteBuffer.append(c);
158                             }
159                             break;
160                 default:
161                             if(quote == 0){
162                                 if(wasWhiteSpace){
163                                      node = searchTree;
164                                 }else{
165                                     if(node == null){
166                                         value = 0;
167                                         wasWhiteSpace = false;
168                                         break;
169                                     }
170                                 }
171                                 c |= 0x20; // case insensitiv
172 while(node != null && node.letter != c) node = node.nextEntry;
173                                 if(node != null){
174                                     value = node.value;
175                                     node = node.nextLetter;
176                                 }else{
177                                     value = 0;
178                                     node = null;
179                                 }
180                             }else{
181                                 quoteBuffer.append(c);
182                             }
183                             wasWhiteSpace = false;
184                             break;
185             }
186         }
187         if(!wasWhiteSpace){
188            tokens.add( new SQLToken( value, tokenStart, sql.length) );
189         }
190         return tokens;
191     }
192
193     static private void addKeyWord( String keyword, int value){
194         keywords.put( Utils.getInteger( value), keyword );
195
196         char[] letters = keyword.toCharArray();
197         if(searchTree == null){
198             searchTree = new SearchNode();
199             searchTree.letter = (char)(letters[0] | 0x20);
200         }
201         SearchNode prev = null;
202         SearchNode node = searchTree;
203         boolean wasNextEntry = true; // of node nextEntry oder nextLetter von prev ist
204 for(int i=0; i<letters.length; i++){
205             char c = (char)(letters[i] | 0x20);
206             while(node != null && node.letter != c) {
207                 prev = node;
208                 node = node.nextEntry;
209                 wasNextEntry = true;
210             }
211             if(node == null){
212                 node = new SearchNode();
213                 node.letter = c;
214                 if(wasNextEntry)
215                      prev.nextEntry = node;
216                 else prev.nextLetter = node;
217                 wasNextEntry = false;
218                 prev = node;
219                 node = null;
220             }else{
221                 prev = node;
222                 node = node.nextLetter;
223                 wasNextEntry = false;
224             }
225         }
226         prev.value = value;
227     }
228
229     static final String getKeyWord(int key){
230         return (String )keywords.get( Utils.getInteger(key) );
231     }
232     
233     static final int getSQLDataType(int type){
234         // on change of this map the order from getTypeInfo need to be change
235 switch(type){
236             case SQLTokenizer.BIT:
237                         return Types.BIT;
238             case SQLTokenizer.BOOLEAN:
239                         return Types.BOOLEAN;
240             case SQLTokenizer.BINARY:
241                         return Types.BINARY;
242             case SQLTokenizer.VARBINARY:
243                         return Types.VARBINARY;
244             case SQLTokenizer.LONGVARBINARY:
245                         return Types.LONGVARBINARY;
246             case SQLTokenizer.BLOB:
247                         return Types.BLOB;
248             case SQLTokenizer.TINYINT:
249                         return Types.TINYINT;
250             case SQLTokenizer.SMALLINT:
251                         return Types.SMALLINT;
252             case SQLTokenizer.INT:
253                         return Types.INTEGER;
254             case SQLTokenizer.BIGINT:
255                         return Types.BIGINT;
256             case SQLTokenizer.SMALLMONEY:
257             case SQLTokenizer.MONEY:
258             case SQLTokenizer.DECIMAL:
259                         return Types.DECIMAL;
260             case SQLTokenizer.NUMERIC:
261                         return Types.NUMERIC;
262             case SQLTokenizer.REAL:
263                         return Types.REAL;
264             case SQLTokenizer.FLOAT:
265                         return Types.FLOAT;
266             case SQLTokenizer.DOUBLE:
267                         return Types.DOUBLE;
268             case SQLTokenizer.DATE:
269                         return Types.DATE;
270             case SQLTokenizer.TIME:
271                         return Types.TIME;
272             case SQLTokenizer.TIMESTAMP:
273             case SQLTokenizer.SMALLDATETIME:
274                         return Types.TIMESTAMP;
275             case SQLTokenizer.CHAR:
276             case SQLTokenizer.NCHAR:
277                         return Types.CHAR;
278             case SQLTokenizer.VARCHAR:
279             case SQLTokenizer.NVARCHAR:
280                         return Types.VARCHAR;
281             case SQLTokenizer.LONGNVARCHAR:
282             case SQLTokenizer.LONGVARCHAR:
283                         return Types.LONGVARCHAR;
284             case SQLTokenizer.CLOB:
285             case SQLTokenizer.NCLOB:
286                         return Types.CLOB;
287             case SQLTokenizer.JAVA_OBJECT:
288                         return Types.JAVA_OBJECT;
289             case SQLTokenizer.UNIQUEIDENTIFIER:
290                         return -11;
291             case SQLTokenizer.NULL:
292                         return Types.NULL;
293             default: throw new Error ("DataType:"+type);
294         }
295     }
296     
297     static SearchNode searchTree;
298
299     static Hashtable keywords = new Hashtable(337);
300     static final int VALUE = 0;
301     static final int STRING = 3;
302     static final int IDENTIFER = 4;
303     static final int NUMBERVALUE= 5;
304     static{
305         // for Error messages
306 keywords.put( new Integer (VALUE), "<expression>" );
307         keywords.put( new Integer (IDENTIFER), "<identifer>" );
308         keywords.put( new Integer (NUMBERVALUE), "<number>" );
309     }
310
311     static final int PERCENT = '%'; // 37
312 static final int BIT_AND = '&'; // 38
313 static final int PARENTHESIS_L = '('; // 40
314 static final int PARENTHESIS_R = ')'; // 41
315 static final int ASTERISK = '*'; // 42
316 static final int PLUS = '+'; // 43
317 static final int COMMA = ','; // 44
318 static final int MINUS = '-'; // 45
319 static final int POINT = '.'; // 46
320 static final int SLACH = '/'; // 47
321 static final int LESSER = '<'; // 60
322 static final int EQUALS = '='; // 61
323 static final int GREATER = '>'; // 62
324 static final int QUESTION = '?'; // 63
325 static final int BIT_XOR = '^'; // 94
326 static final int ESCAPE_L = '{'; // 123
327 static final int BIT_OR = '|'; // 124
328 static final int ESCAPE_R = '}'; // 125
329 static final int TILDE = '~'; // 126
330
331     static final int LESSER_EQU = 100 + LESSER; // <=
332 static final int UNEQUALS = 100 + EQUALS; // <>
333 static final int GREATER_EQU = 100 + GREATER; // >=
334
335     static{
336         // für Fehlermeldungen
337 keywords.put( new Integer (LESSER_EQU), "<=" );
338         keywords.put( new Integer (UNEQUALS), "<>" );
339         keywords.put( new Integer (GREATER_EQU), ">=" );
340     }
341     static final int SELECT = 200;
342     static final int DELETE = 201;
343     //static final int INSERT = 202;
344 static final int INTO = 203;
345     static final int UPDATE = 204;
346     static final int CREATE = 205;
347     static final int DROP = 206;
348     static final int ALTER = 207;
349     static final int SET = 208;
350     static final int EXECUTE = 209;
351     static final int FROM = 210;
352     static final int WHERE = 211;
353     static final int GROUP = 212;
354     static final int BY = 213;
355     static final int HAVING = 214;
356     static final int ORDER = 215;
357     static final int ASC = 216;
358     static final int DESC = 217;
359     static final int VALUES = 218;
360     static final int AS = 219;
361     static final int DEFAULT = 220;
362     static final int IDENTITY = 221;
363     static final int INNER = 222;
364     static final int JOIN = 223;
365     static final int ON = 224;
366     static final int OUTER = 225;
367     static final int FULL = 226;
368     static final int CROSS = 227;
369     static final int USE = 228;
370     static final int TOP = 229;
371
372     static final int DATABASE = 230;
373     static final int TABLE = 231;
374     static final int VIEW = 232;
375     static final int INDEX = 233;
376     static final int PROCEDURE = 234;
377
378     static final int TRANSACTION= 240;
379     static final int ISOLATION = 241;
380     static final int LEVEL = 242;
381     static final int READ = 243;
382     static final int COMMITTED = 244;
383     static final int UNCOMMITTED= 245;
384     static final int REPEATABLE = 246;
385     static final int SERIALIZABLE= 247;
386     
387     static final int CONSTRAINT = 250;
388     static final int PRIMARY = 251;
389     static final int FOREIGN = 252;
390     static final int KEY = 253;
391     static final int UNIQUE = 254;
392     static final int CLUSTERED = 255;
393     static final int NONCLUSTERED=256;
394     static final int REFERENCES = 257;
395
396     static final int UNION = 260;
397     static final int ALL = 261;
398     static final int DISTINCT = 262;
399     static final int CASE = 263;
400     static final int WHEN = 264;
401     static final int THEN = 265;
402     static final int ELSE = 266;
403     static final int END = 267;
404     static final int SWITCH = 268;
405     
406     static final String DESC_STR = "DESC";
407     static{
408         addKeyWord( "SELECT", SELECT);
409         addKeyWord( "DELETE", DELETE);
410 // addKeyWord( "INSERT", INSERT);
411 addKeyWord( "INTO", INTO);
412         addKeyWord( "UPDATE", UPDATE);
413         addKeyWord( "CREATE", CREATE);
414         addKeyWord( "DROP", DROP);
415         addKeyWord( "ALTER", ALTER);
416         addKeyWord( "SET", SET);
417         addKeyWord( "EXEC", EXECUTE); // alias für EXECUTE; alias zuerst setzten, damit in Hashtable
418 addKeyWord( "EXECUTE", EXECUTE);
419         addKeyWord( "FROM", FROM);
420         addKeyWord( "WHERE", WHERE);
421         addKeyWord( "GROUP", GROUP);
422         addKeyWord( "BY", BY);
423         addKeyWord( "HAVING", HAVING);
424         addKeyWord( "ORDER", ORDER);
425         addKeyWord( "ASC", ASC);
426         addKeyWord( DESC_STR, DESC);
427         addKeyWord( "VALUES", VALUES);
428         addKeyWord( "AS", AS);
429         addKeyWord( "DEFAULT", DEFAULT);
430         addKeyWord( "IDENTITY", IDENTITY);
431         addKeyWord( "INNER", INNER);
432         addKeyWord( "JOIN", JOIN);
433         addKeyWord( "ON", ON);
434         addKeyWord( "OUTER", OUTER);
435         addKeyWord( "FULL", FULL);
436         addKeyWord( "CROSS", CROSS);
437         addKeyWord( "USE", USE);
438         addKeyWord( "TOP", TOP);
439
440         addKeyWord( "DATABASE", DATABASE);
441         addKeyWord( "TABLE", TABLE);
442         addKeyWord( "VIEW", VIEW);
443         addKeyWord( "INDEX", INDEX);
444         addKeyWord( "PROCEDURE",PROCEDURE);
445
446         addKeyWord( "TRANSACTION", TRANSACTION);
447         addKeyWord( "ISOLATION", ISOLATION);
448         addKeyWord( "LEVEL", LEVEL);
449         addKeyWord( "READ", READ);
450         addKeyWord( "COMMITTED", COMMITTED);
451         addKeyWord( "UNCOMMITTED", UNCOMMITTED);
452         addKeyWord( "REPEATABLE", REPEATABLE);
453         addKeyWord( "SERIALIZABLE", SERIALIZABLE);
454         
455         addKeyWord( "CONSTRAINT", CONSTRAINT);
456         addKeyWord( "PRIMARY", PRIMARY);
457         addKeyWord( "FOREIGN", FOREIGN);
458         addKeyWord( "KEY", KEY);
459         addKeyWord( "UNIQUE", UNIQUE);
460         addKeyWord( "CLUSTERED", CLUSTERED);
461         addKeyWord( "NONCLUSTERED", NONCLUSTERED);
462         addKeyWord( "REFERENCES", REFERENCES);
463
464         addKeyWord( "UNION", UNION);
465         addKeyWord( "ALL", ALL);
466         addKeyWord( "DISTINCT", DISTINCT);
467         addKeyWord( "CASE", CASE);
468         addKeyWord( "WHEN", WHEN);
469         addKeyWord( "THEN", THEN);
470         addKeyWord( "ELSE", ELSE);
471         addKeyWord( "END", END);
472         addKeyWord( "SWITCH", SWITCH);
473     }
474
475
476     //data types
477 static final int BIT = 300;
478     static final int BOOLEAN = 301;
479     static final int BINARY = 310;
480     static final int VARBINARY = 311;
481     static final int RAW = 312;
482     static final int LONGVARBINARY = 313;
483     static final int BLOB = 316;
484     static final int TINYINT = 321;
485     static final int SMALLINT = 322;
486     static final int INT = 323;
487     static final int COUNTER = 324; //alias für INT IDENTITY, wird von ACCESS verwendet
488 static final int BIGINT = 325;
489     static final int SMALLMONEY = 330;
490     static final int MONEY = 331;
491     static final int DECIMAL = 332;
492     static final int NUMERIC = 333;
493     static final int REAL = 336;
494     static final int FLOAT = 337;
495     static final int DOUBLE = 338;
496     static final int DATE = 340;
497     static final int TIME = 341;
498     static final int TIMESTAMP = 342;
499     static final int SMALLDATETIME = 343;
500     static final int CHAR = 350;
501     static final int NCHAR = 352;
502     static final int VARCHAR = 353;
503     static final int NVARCHAR = 355;
504     static final int SYSNAME = 357;
505     static final int LONGVARCHAR = 359;
506     static final int LONGNVARCHAR = 360;
507     static final int LONG = 361;
508     static final int CLOB = 362;
509     static final int NCLOB = 363;
510     static final int UNIQUEIDENTIFIER= 370;
511     static final int JAVA_OBJECT = 371;
512
513     static{
514         addKeyWord( "BIT", BIT);
515         addKeyWord( "BOOLEAN", BOOLEAN);
516         addKeyWord( "BINARY", BINARY);
517         addKeyWord( "VARBINARY", VARBINARY);
518         addKeyWord( "RAW", RAW); // alias for Oracle RAW and LONG RAW
519 addKeyWord( "IMAGE", LONGVARBINARY); // alias for MS SQL Server data type IMAGE
520 addKeyWord( "LONGVARBINARY",LONGVARBINARY);
521         addKeyWord( "BLOB", BLOB);
522         addKeyWord( "BYTE", TINYINT);
523         addKeyWord( "TINYINT", TINYINT);
524         addKeyWord( "SMALLINT", SMALLINT);
525         addKeyWord( "INTEGER", INT);
526         addKeyWord( "INT", INT);
527         addKeyWord( "COUNTER", COUNTER);
528         addKeyWord( "BIGINT", BIGINT);
529         addKeyWord( "SMALLMONEY", SMALLMONEY);
530         addKeyWord( "MONEY", MONEY);
531         addKeyWord( "NUMBER", DECIMAL);
532         addKeyWord( "VARNUM", DECIMAL);
533         addKeyWord( "DECIMAL", DECIMAL);
534         addKeyWord( "NUMERIC", NUMERIC);
535         addKeyWord( "REAL", REAL);
536         addKeyWord( "FLOAT", FLOAT);
537         addKeyWord( "DOUBLE", DOUBLE);
538         addKeyWord( "DATE", DATE);
539         addKeyWord( "TIME", TIME);
540         addKeyWord( "DATETIME", TIMESTAMP); // alias for MS SQL Server data type DATETIME
541 addKeyWord( "TIMESTAMP", TIMESTAMP);
542         addKeyWord( "SMALLDATETIME",SMALLDATETIME);
543         addKeyWord( "CHARACTER", CHAR); // alias for CHAR
544 addKeyWord( "CHAR", CHAR);
545         addKeyWord( "NCHAR", NCHAR);
546         addKeyWord( "VARCHAR2", VARCHAR); // alias for Oracle VARCHAR2
547 addKeyWord( "VARCHAR", VARCHAR);
548         addKeyWord( "NVARCHAR2", NVARCHAR); // alias for Oracle VARCHAR2
549 addKeyWord( "NVARCHAR", NVARCHAR);
550         addKeyWord( "SYSNAME", SYSNAME);
551         addKeyWord( "TEXT", LONGVARCHAR);
552         addKeyWord( "LONGVARCHAR", LONGVARCHAR);
553         addKeyWord( "NTEXT", LONGNVARCHAR);
554         addKeyWord( "LONGNVARCHAR", LONGNVARCHAR);
555         addKeyWord( "LONG", LONG); // alias for Oracle LONG and LONG RAW
556 addKeyWord( "CLOB", CLOB);
557         addKeyWord( "NCLOB", NCLOB);
558         addKeyWord( "UNIQUEIDENTIFIER",UNIQUEIDENTIFIER);
559         addKeyWord( "SQL_VARIANT", JAVA_OBJECT); // alias for MS SQL Server data type SQL_VARIANT
560 addKeyWord( "JAVA_OBJECT", JAVA_OBJECT);
561     }
562
563     //escape commands
564 static final int D = 400;
565     static final int T = 401;
566     static final int TS = 402;
567     static final int FN = 403;
568     static final int CALL = 404;
569     static final int OJ = 405;
570     static{
571         addKeyWord( "D", D);
572         addKeyWord( "T", T);
573         addKeyWord( "TS", TS);
574         addKeyWord( "FN", FN);
575         addKeyWord( "CALL", CALL);
576         addKeyWord( "OJ", OJ);
577     }
578
579
580     static final int OR = 500;
581     static final int AND = 501;
582     static final int IS = 502;
583     static final int NOT = 503;
584     static final int NULL = 504;
585     static final int TRUE = 505;
586     static final int FALSE = 506;
587     static final int BETWEEN= 507;
588     static final int LIKE = 508;
589     static final int IN = 509;
590     static{
591         addKeyWord( "OR", OR);
592         addKeyWord( "AND", AND);
593         addKeyWord( "IS", IS);
594         addKeyWord( "NOT", NOT);
595         addKeyWord( "NULL", NULL);
596         addKeyWord( "YES", TRUE); //alias for TRUE
597 addKeyWord( "TRUE", TRUE);
598         addKeyWord( "NO", FALSE); //alias for FALSE
599 addKeyWord( "FALSE", FALSE);
600         addKeyWord( "BETWEEN", BETWEEN);
601         addKeyWord( "LIKE", LIKE);
602         addKeyWord( "IN", IN);
603     }
604
605
606     //NUMERIC FUNCTIONS
607 static final int ABS = 1000; //first numeric function --> see SSDatabaseMetaData.getNumericFunctions
608 static final int ACOS = 1001;
609     static final int ASIN = 1002;
610     static final int ATAN = 1003;
611     static final int ATAN2 = 1004;
612     static final int CEILING = 1005;
613     static final int COS = 1006;
614     static final int COT = 1007;
615     static final int DEGREES = 1008;
616     static final int EXP = 1009;
617     static final int FLOOR = 1010;
618     static final int LOG = 1011;
619     static final int LOG10 = 1012;
620     static final int MOD = 1013;
621     static final int PI = 1014;
622     static final int POWER = 1015;
623     static final int RADIANS = 1016;
624     static final int RAND = 1017;
625     static final int ROUND = 1018;
626     static final int SIGN = 1019;
627     static final int SIN = 1020;
628     static final int SQRT = 1021;
629     static final int TAN = 1022;
630     static final int TRUNCATE = 1023; //last numeric function --> see SSDatabaseMetaData.getNumericFunctions
631 static{
632         addKeyWord( "ABS", ABS);
633         addKeyWord( "ACOS", ACOS);
634         addKeyWord( "ASIN", ASIN);
635         addKeyWord( "ATAN", ATAN);
636         addKeyWord( "ATN2", ATAN2); //alias for MS SQL Server
637 addKeyWord( "ATAN2", ATAN2);
638         addKeyWord( "CEILING", CEILING);
639         addKeyWord( "COS", COS);
640         addKeyWord( "COT", COT);
641         addKeyWord( "DEGREES", DEGREES);
642         addKeyWord( "EXP", EXP);
643         addKeyWord( "FLOOR", FLOOR);
644         addKeyWord( "LOG", LOG);
645         addKeyWord( "LOG10", LOG10);
646         addKeyWord( "MOD", MOD);
647         addKeyWord( "PI", PI);
648         addKeyWord( "POWER", POWER);
649         addKeyWord( "RADIANS", RADIANS);
650         addKeyWord( "RAND", RAND);
651         addKeyWord( "ROUND", ROUND);
652         addKeyWord( "SIGN", SIGN);
653         addKeyWord( "SIN", SIN);
654         addKeyWord( "SQRT", SQRT);
655         addKeyWord( "TAN", TAN);
656         addKeyWord( "TRUNCATE", TRUNCATE);
657     }
658
659     //String Functionens
660 static final int ASCII = 1100; //first string function --> see SSDatabaseMetaData.getStringFunctions
661 static final int _CHAR = 1101;
662     static final int CONCAT = 1102;
663     static final int DIFFERENCE = 1103;
664     static final int INSERT = 1104;
665     static final int LCASE = 1105;
666     static final int LEFT = 1106;
667     static final int LENGTH = 1107;
668     static final int LOCATE = 1108;
669     static final int LTRIM = 1109;
670     static final int REPEAT = 1110;
671     static final int REPLACE = 1111;
672     static final int RIGHT = 1112;
673     static final int RTRIM = 1113;
674     static final int SOUNDEX = 1114;
675     static final int SPACE = 1115;
676     static final int SUBSTRING = 1116;
677     static final int TRIM = 1117;
678     static final int UCASE = 1118; //last string function --> see SSDatabaseMetaData.getStringFunctions
679 static{
680         addKeyWord( "ASCII", ASCII);
681         keywords.put( new Integer (_CHAR), "CHAR" ); // needed for metadata functions
682 addKeyWord( "CONCAT", CONCAT);
683         addKeyWord( "DIFFERENCE",DIFFERENCE);
684         addKeyWord( "INSERT", INSERT);
685         addKeyWord( "LCASE", LCASE);
686         addKeyWord( "LEFT", LEFT);
687         addKeyWord( "DATALENGTH",LENGTH); //alias for MS SQL Server
688 addKeyWord( "LEN", LENGTH); //alias for MS SQL Server
689 addKeyWord( "LENGTH", LENGTH);
690         addKeyWord( "CHARINDEX",LOCATE); //alias for MS SQL Server
691 addKeyWord( "LOCATE", LOCATE);
692         addKeyWord( "LTRIM", LTRIM);
693         addKeyWord( "REPEAT", REPEAT);
694         addKeyWord( "REPLACE", REPLACE);
695         addKeyWord( "RIGHT", RIGHT);
696         addKeyWord( "RTRIM", RTRIM);
697         addKeyWord( "SOUNDEX", SOUNDEX);
698         addKeyWord( "SPACE", SPACE);
699         addKeyWord( "SUBSTRING",SUBSTRING);
700         addKeyWord( "TRIM", TRIM);
701         addKeyWord( "UCASE", UCASE);
702     }
703
704     //TIME and DATE FUNCTIONS
705 static final int CURDATE = 1200; //first time date function --> see SSDatabaseMetaData.getTimeDateFunctions
706 static final int CURTIME = 1201;
707     static final int DAYNAME = 1202;
708     static final int DAYOFMONTH = 1203;
709     static final int DAYOFWEEK = 1204;
710     static final int DAYOFYEAR = 1205;
711     static final int DAY = 1206;
712     static final int HOUR = 1207;
713     static final int MILLISECOND= 1208;
714     static final int MINUTE = 1209;
715     static final int MONTH = 1210;
716     static final int MONTHNAME = 1211;
717     static final int NOW = 1212;
718     static final int QUARTER = 1213;
719     static final int SECOND = 1214;
720     static final int TIMESTAMPADD=1215;
721     static final int TIMESTAMPDIFF=1216;
722     static final int WEEK = 1217;
723     static final int YEAR = 1218; //last time date function --> see SSDatabaseMetaData.getTimeDateFunctions
724 static{
725         addKeyWord( "CURDATE", CURDATE);
726         addKeyWord( "CURTIME", CURTIME);
727         addKeyWord( "DAYNAME", DAYNAME);
728         addKeyWord( "DAYOFMONTH", DAYOFMONTH);
729         addKeyWord( "DAYOFWEEK", DAYOFWEEK);
730         addKeyWord( "DAYOFYEAR", DAYOFYEAR);
731         addKeyWord( "DAY", DAY);
732         addKeyWord( "HOUR", HOUR);
733         addKeyWord( "MILLISECOND", MILLISECOND);
734         addKeyWord( "MINUTE", MINUTE);
735         addKeyWord( "MONTH", MONTH);
736         addKeyWord( "MONTHNAME", MONTHNAME);
737         addKeyWord( "GETDATE", NOW); //alias for MS SQL Server
738 addKeyWord( "NOW", NOW);
739         addKeyWord( "QUARTER", QUARTER);
740         addKeyWord( "SECOND", SECOND);
741         addKeyWord( "DATEADD", TIMESTAMPADD); //alias for MS SQL Server
742 addKeyWord( "TIMESTAMPADD", TIMESTAMPADD);
743         addKeyWord( "DATEDIFF", TIMESTAMPDIFF); //alias for MS SQL Server
744 addKeyWord( "TIMESTAMPDIFF",TIMESTAMPDIFF);
745         addKeyWord( "WEEK", WEEK);
746         addKeyWord( "YEAR", YEAR);
747     }
748     
749     // Time intervals
750 static final int SQL_TSI_FRAC_SECOND= 1250;
751     static final int SQL_TSI_SECOND = 1251;
752     static final int SQL_TSI_MINUTE = 1252;
753     static final int SQL_TSI_HOUR = 1253;
754     static final int SQL_TSI_DAY = 1254;
755     static final int SQL_TSI_WEEK = 1255;
756     static final int SQL_TSI_MONTH = 1256;
757     static final int SQL_TSI_QUARTER = 1257;
758     static final int SQL_TSI_YEAR = 1258;
759     static{
760         addKeyWord( "MS", SQL_TSI_FRAC_SECOND);
761         addKeyWord( "SQL_TSI_FRAC_SECOND", SQL_TSI_FRAC_SECOND);
762         addKeyWord( "S", SQL_TSI_SECOND);
763         addKeyWord( "SS", SQL_TSI_SECOND);
764         addKeyWord( "SQL_TSI_SECOND", SQL_TSI_SECOND);
765         addKeyWord( "MI", SQL_TSI_MINUTE);
766         addKeyWord( "N", SQL_TSI_MINUTE);
767         addKeyWord( "SQL_TSI_MINUTE", SQL_TSI_MINUTE);
768         addKeyWord( "HH", SQL_TSI_HOUR);
769         addKeyWord( "SQL_TSI_HOUR", SQL_TSI_HOUR);
770         //addKeyWord( "D", SQL_TSI_DAY);
771 addKeyWord( "DD", SQL_TSI_DAY);
772         addKeyWord( "SQL_TSI_DAY", SQL_TSI_DAY);
773         addKeyWord( "WK", SQL_TSI_WEEK);
774         addKeyWord( "WW", SQL_TSI_WEEK);
775         addKeyWord( "SQL_TSI_WEEK", SQL_TSI_WEEK);
776         addKeyWord( "M", SQL_TSI_MONTH);
777         addKeyWord( "MM", SQL_TSI_MONTH);
778         addKeyWord( "SQL_TSI_MONTH", SQL_TSI_MONTH);
779         addKeyWord( "Q", SQL_TSI_QUARTER);
780         addKeyWord( "QQ", SQL_TSI_QUARTER);
781         addKeyWord( "SQL_TSI_QUARTER", SQL_TSI_QUARTER);
782         addKeyWord( "YY", SQL_TSI_YEAR);
783         addKeyWord( "YYYY", SQL_TSI_YEAR);
784         addKeyWord( "SQL_TSI_YEAR", SQL_TSI_YEAR);
785     }
786     
787     //SYSTEM FUNCTIONS
788 //static final int DATABASE = 1300;
789 static final int IFNULL = 1301; //first system function --> see SSDatabaseMetaData.getSystemFunctions
790 static final int USER = 1302;
791     static final int CONVERT = 1303;
792     static final int CAST = 1304;
793     static final int IIF = 1305; //last system function --> see SSDatabaseMetaData.getSystemFunctions
794 static{
795         addKeyWord( "ISNULL", IFNULL); //alias for IFNULL, used from MS SQL Server with 2 parameter, from MS Access with 1 parameter
796 addKeyWord( "IFNULL", IFNULL);
797         addKeyWord( "USER", USER);
798         addKeyWord( "CONVERT", CONVERT);
799         addKeyWord( "CAST", CAST);
800         addKeyWord( "IIF", IIF);
801     }
802     
803     // data types for ecape function CONVERT
804 static final int SQL_BIGINT = 1350;
805     static final int SQL_BINARY = 1351;
806     static final int SQL_BIT = 1352;
807     static final int SQL_CHAR = 1353;
808     static final int SQL_DATE = 1354;
809     static final int SQL_DECIMAL = 1355;
810     static final int SQL_DOUBLE = 1356;
811     static final int SQL_FLOAT = 1357;
812     static final int SQL_INTEGER = 1358;
813     static final int SQL_LONGVARBINARY = 1359;
814     static final int SQL_LONGVARCHAR = 1360;
815     static final int SQL_REAL = 1361;
816     static final int SQL_SMALLINT = 1362;
817     static final int SQL_TIME = 1363;
818     static final int SQL_TIMESTAMP = 1364;
819     static final int SQL_TINYINT = 1365;
820     static final int SQL_VARBINARY = 1366;
821     static final int SQL_VARCHAR = 1367;
822     static{
823         addKeyWord( "SQL_BIGINT", SQL_BIGINT);
824         addKeyWord( "SQL_BINARY", SQL_BINARY);
825         addKeyWord( "SQL_BIT", SQL_BIT);
826         addKeyWord( "SQL_CHAR", SQL_CHAR);
827         addKeyWord( "SQL_DATE", SQL_DATE);
828         addKeyWord( "SQL_DECIMAL", SQL_DECIMAL);
829         addKeyWord( "SQL_DOUBLE", SQL_DOUBLE);
830         addKeyWord( "SQL_FLOAT", SQL_FLOAT);
831         addKeyWord( "SQL_INTEGER", SQL_INTEGER);
832         addKeyWord( "SQL_LONGVARBINARY",SQL_LONGVARBINARY);
833         addKeyWord( "SQL_LONGVARCHAR", SQL_LONGVARCHAR);
834         addKeyWord( "SQL_REAL", SQL_REAL);
835         addKeyWord( "SQL_SMALLINT", SQL_SMALLINT);
836         addKeyWord( "SQL_TIME", SQL_TIME);
837         addKeyWord( "SQL_TIMESTAMP", SQL_TIMESTAMP);
838         addKeyWord( "SQL_TINYINT", SQL_TINYINT);
839         addKeyWord( "SQL_VARBINARY", SQL_VARBINARY);
840         addKeyWord( "SQL_VARCHAR", SQL_VARCHAR);
841     }
842     
843     
844     //Aggregate Function
845 static final int COUNT = 1400;
846     static final int MIN = 1401;
847     static final int MAX = 1402;
848     static final int SUM = 1403;
849     static final int FIRST = 1404;
850     static final int LAST = 1405;
851     static final int AVG = 1406;
852     static{
853         addKeyWord( "COUNT", COUNT);
854         addKeyWord( "MIN", MIN);
855         addKeyWord( "MAX", MAX);
856         addKeyWord( "SUM", SUM);
857         addKeyWord( "FIRST", FIRST);
858         addKeyWord( "LAST", LAST);
859         addKeyWord( "AVG", AVG);
860     }
861
862 }
863
864 class SearchNode{
865     int value;
866     char letter;
867     SearchNode nextLetter; // nächste Buchstabe eines Keywortes
868 SearchNode nextEntry; // nächte Eintrag eines Buchstabens, der die gleich Startsequenz hat
869 }
870
871
872

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags