|
1 package com.daffodilwoods.daffodildb.server.sql99.ddl.utility;
2
3 import java.util.*;
4
5 import com.daffodilwoods.daffodildb.server.datadictionarysystem.*;
6 import com.daffodilwoods.daffodildb.server.serversystem.*;
7 import com.daffodilwoods.daffodildb.server.sql99.*;
8 import com.daffodilwoods.daffodildb.server.sql99.common.*;
9 import com.daffodilwoods.daffodildb.server.sql99.ddl.descriptors.*;
10 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator.*;
11 import com.daffodilwoods.daffodildb.server.sql99.expression.booleanvalueexpression.*;
12 import com.daffodilwoods.daffodildb.utils.*;
13 import com.daffodilwoods.database.general.*;
14 import com.daffodilwoods.database.resource.*;
15 import in.co.daffodil.db.general.*;
16
17 public class GeneralUtility {
18
19 public static void checkValidDataTypeForAutoIncrement(int type) throws
20 DException {
21 if (! (type == Datatypes.BIGINT ||
22 type == Datatypes.BYTE ||
23 type == Datatypes.INT ||
24 type == Datatypes.INTEGER ||
25 type == Datatypes.LONG ||
26 type == Datatypes.SHORT ||
27 type == Datatypes.SMALLINT ||
28 type == Datatypes.TINYINT ||
29 type == Datatypes.DOUBLE ||
30 type == Datatypes.DOUBLEPRECISION ||
31 type == Datatypes.FLOAT ||
32 type == Datatypes.REAL ||
33 type == Datatypes.DEC ||
34 type == Datatypes.DECIMAL ||
35 type == Datatypes.NUMERIC)) {
36 throw new DException("DSE5007", null);
37 }
38 }
39
40
41 public static boolean areComparable(int dataType1, int dataType2) {
42 switch (dataType1) {
43 case Datatypes.CHAR:
44 case Datatypes.VARCHAR:
45 case Datatypes.CHARACTERVARYING:
46 case Datatypes.CHARVARYING:
47 case Datatypes.CHARACTER:
48 return dataType2 == Datatypes.CHAR ||
49 dataType2 == Datatypes.VARCHAR ||
50 dataType2 == Datatypes.CHARACTERVARYING ||
51 dataType2 == Datatypes.CHARVARYING ||
52 dataType2 == Datatypes.CHARACTER;
53
54 case Datatypes.INT:
55 case Datatypes.INTEGER:
56 case Datatypes.BIGINT:
57 case Datatypes.LONG:
58 case Datatypes.SMALLINT:
59 case Datatypes.SHORT:
60 case Datatypes.REAL:
61 case Datatypes.FLOAT:
62 case Datatypes.DOUBLEPRECISION:
63 case Datatypes.DOUBLE:
64 case Datatypes.NUMERIC:
65 case Datatypes.DECIMAL:
66 case Datatypes.DEC:
67 case Datatypes.BIGDECIMAL:
68 case Datatypes.TINYINT:
69 case Datatypes.BYTE:
70 return dataType2 == Datatypes.INT ||
71 dataType2 == Datatypes.INTEGER ||
72 dataType2 == Datatypes.BIGINT ||
73 dataType2 == Datatypes.LONG ||
74 dataType2 == Datatypes.SMALLINT ||
75 dataType2 == Datatypes.SHORT ||
76 dataType2 == Datatypes.REAL ||
77 dataType2 == Datatypes.FLOAT ||
78 dataType2 == Datatypes.DOUBLEPRECISION ||
79 dataType2 == Datatypes.DOUBLE ||
80 dataType2 == Datatypes.NUMERIC ||
81 dataType2 == Datatypes.DECIMAL ||
82 dataType2 == Datatypes.DEC ||
83 dataType2 == Datatypes.BIGDECIMAL ||
84 dataType2 == Datatypes.TINYINT ||
85 dataType2 == Datatypes.BYTE;
86
87 case Datatypes.DATE:
88 return dataType2 == Datatypes.DATE;
89
90 case Datatypes.TIME:
91 return dataType2 == Datatypes.TIME;
92
93 case Datatypes.TIMESTAMP:
94 return dataType2 == Datatypes.TIMESTAMP;
95
96 case Datatypes.BIT:
97 case Datatypes.BITVARYING:
98 return dataType2 == Datatypes.BIT ||
99 dataType2 == Datatypes.BITVARYING;
100 case Datatypes.BOOLEAN:
101 return dataType2 == Datatypes.BOOLEAN;
102 }
103 return false;
104 }
105
106 public static Class  getJavaDataType(String nameOfDatatype) throws DException {
107 Class retValue;
108 nameOfDatatype = nameOfDatatype.trim();
109 if (nameOfDatatype.equalsIgnoreCase("STRING")) {
110 retValue = String .class;
111 } else if (nameOfDatatype.equalsIgnoreCase("CHAR") ||
112 nameOfDatatype.equalsIgnoreCase("CHARACTER")||
113 nameOfDatatype.equalsIgnoreCase("VARCHAR")||
114 nameOfDatatype.equalsIgnoreCase("VARCHAR2")) {
115 retValue = char.class;
116 } else if (nameOfDatatype.equalsIgnoreCase("CLOB")) {
117 retValue = java.sql.Clob .class;
118 } else if (nameOfDatatype.equalsIgnoreCase("BLOB")) {
119 retValue = java.sql.Blob .class;
120 } else if (nameOfDatatype.equalsIgnoreCase("DECIMAL") ||
121 nameOfDatatype.equalsIgnoreCase("NUMERIC")) {
122 retValue = java.math.BigDecimal .class;
123 } else if (nameOfDatatype.equalsIgnoreCase("NULL")) {
124 throw new DException("DSE8125", null);
125 } else if (nameOfDatatype.equalsIgnoreCase("BIGINT")) {
126 retValue = Long .class;
127 } else if (nameOfDatatype.equalsIgnoreCase("BIT") ||
128 nameOfDatatype.equalsIgnoreCase("BOOLEAN")) {
129 retValue = Boolean .class;
130 } else if (nameOfDatatype.equalsIgnoreCase("INTEGER") ||
131 nameOfDatatype.equalsIgnoreCase("INT") ||
132 nameOfDatatype.equalsIgnoreCase("SMALLINT")) {
133 retValue = Integer .class;
134 } else if (nameOfDatatype.equalsIgnoreCase("BINARY") ||
135 nameOfDatatype.equalsIgnoreCase("TINYINT") ||
136 nameOfDatatype.equalsIgnoreCase("VARBINARY")) {
137 retValue = Byte .class;
138 } else if (nameOfDatatype.equalsIgnoreCase("TIMESTAMP")) {
139 retValue = java.sql.Timestamp .class;
140 } else if (nameOfDatatype.equalsIgnoreCase("TIME")) {
141 retValue = java.sql.Time .class;
142 } else if (nameOfDatatype.equalsIgnoreCase("DATE")) {
143 retValue = java.sql.Date .class;
144 } else if (nameOfDatatype.equalsIgnoreCase("FLOAT") ||
145 nameOfDatatype.equalsIgnoreCase("DOUBLE")) {
146 retValue = Double .class;
147 } else if (nameOfDatatype.equalsIgnoreCase("REAL")) {
148 retValue = Float .class;
149 } else if (nameOfDatatype.equalsIgnoreCase("JAVAPARAMETER")) {
150 retValue = javaParameter.class;
151 } else {
152 throw new DException("DSE8125", null);
153 }
154 return retValue;
155 }
156
157 public static void checkUnsupportedDataTypes(datatype _datatype) throws
158 DException {
159 }
160
161 public static boolean checkForDatabaseLength(int databaseNameLength, String databaseName) throws
162 DException {
163 if (! (databaseNameLength <= SystemTablesCreator.SQLIdentifierSize.intValue()))
164 throw new DException("DSE8117", new Object [] {databaseName, new Integer (SystemTablesCreator.SQLIdentifierSize.intValue())});
165 return true;
166 }
167
168 public static boolean checkForUserNameLength(int userNameLength, String userName) throws
169 DException {
170 if (! (userNameLength <= SystemTablesCreator.SQLIdentifierSize.intValue()))
171 throw new DException("DSE8117", new Object [] {userName, new Integer (SystemTablesCreator.SQLIdentifierSize.intValue())});
172 return true;
173 }
174
175 public static boolean checkForPassworNameLength(int passwordNameLength, String passwordName) throws
176 DException {
177 if (! (passwordNameLength <= SystemTablesCreator.SQLIdentifierSize.intValue()))
178 throw new DException("DSE8117", new Object [] {passwordName, new Integer (SystemTablesCreator.SQLIdentifierSize.intValue())});
179 return true;
180 }
181
182 public static boolean checkAllColumnGrantableRights(_ServerSession
183 currentSession, String user, int privilgeType, ArrayList columnsList) throws
184 DException {
185 _DataDictionary dictionary = currentSession.getDataDictionary();
186 _PrivilegeCharacteristics pc = dictionary.getPrivilegeCharacteristics(user, _PrivilegeCharacteristics.AUTHORIZATION_ROLE);
187 for (int i = 0, size = columnsList.size(); i < size; i++) {
188 String [] qualifiedColumnName = (String []) columnsList.get(i);
189 QualifiedIdentifier tableName = new QualifiedIdentifier(
190 qualifiedColumnName[0], qualifiedColumnName[1], qualifiedColumnName[2]);
191 _PrivilegeTable pt = pc.getPrivilegeTable(tableName);
192 _ColumnCharacteristics cc = dictionary.getColumnCharacteristics(tableName, true);
193 if (pt.hasColumnPrivilegesWithGrantOption(cc.getColumnIndex(
194 qualifiedColumnName[3]), privilgeType)) {
195 return false;
196 }
197 }
198 return true;
199 }
200
201 public static void setDataTypeProperties(int size,
202 DataTypeDescriptor dataTypeDes,
203 int type, int scale) throws DException {
204 dataTypeDes.data_Type = com.daffodilwoods.database.utility.TypeConverter.
205 getDataBaseTypeName(type);
206 switch (type) {
207 case Datatypes.INT:
208 case Datatypes.INTEGER:
209 case Datatypes.BIGINT:
210 case Datatypes.LONG:
211 case Datatypes.SHORT:
212 case Datatypes.SMALLINT:
213 case Datatypes.TINYINT:
214 case Datatypes.BYTE:
215 dataTypeDes.numeric_precision = new Integer (size);
216 dataTypeDes.numeric_precision_radix = new Integer (10);
217 dataTypeDes.numeric_scal = new Integer (0);
218 break;
219
220 case Datatypes.DEC:
221 case Datatypes.DECIMAL:
222 case Datatypes.BIGDECIMAL:
223
225 case Datatypes.NUMERIC:
226 dataTypeDes.numeric_precision = new Integer (size);
227 dataTypeDes.numeric_precision_radix = new Integer (10);
228
230 if (scale != -1) {
231 dataTypeDes.numeric_scal = new Integer (scale);
232 } else {
233 dataTypeDes.numeric_scal = new Integer (5);
234 }
235 break;
236
237 case Datatypes.REAL:
238 case Datatypes.FLOAT:
239 case Datatypes.DOUBLE:
240 case Datatypes.DOUBLEPRECISION:
241 dataTypeDes.numeric_precision = new Integer (size);
242 dataTypeDes.numeric_precision_radix = new Integer (2);
243 dataTypeDes.numeric_scal = null;
244 break;
245
246 case Datatypes.DATE:
247 case Datatypes.TIME:
248 case Datatypes.TIMESTAMP:
249 dataTypeDes.datatime_precision = new Integer (size);
250 break;
251
252 case Datatypes.BINARY:
253 case Datatypes.VARBINARY:
254 case Datatypes.CHARACTER:
255 case Datatypes.CHAR:
256 case Datatypes.CHARACTERVARYING:
257 case Datatypes.CHARVARYING:
258 case Datatypes.VARCHAR:
259 case Datatypes.BIT:
260 case Datatypes.BITVARYING:
261 case Datatypes.LONGVARBINARY:
262 case Datatypes.LONGVARCHAR:
263 case Datatypes.BLOB:
264 case Datatypes.CLOB:
265 case Datatypes.CHARLARGEOBJECT:
266 case Datatypes.CHARACTERLARGEOBJECT:
267 case Datatypes.BINARYLARGEOBJECT:
268 dataTypeDes.character_maximum_length = new Integer (size);
269 dataTypeDes.character_octet_length = new Integer (0);
270 }
271 }
272
273 public static ArrayList removeRedundentTables(String catalogName,
274 String schemaName,
275 ArrayList tablesIncluded) {
276 int size = tablesIncluded.size();
277 ArrayList tablesList = new ArrayList(size);
278 TreeSet tablesSet = new TreeSet(new StringArrayComparator());
279 for (int i = 0; i < size; i++) {
280 String [] tableNamepresent = (String []) tablesIncluded.get(i);
281 String [] tableName = new String [3];
282 int tableLen = tableNamepresent.length;
283 if (tableLen == 3) {
284 tableName = tableNamepresent;
285 } else {
286 tableName[0] = catalogName;
287 tableName[1] = tableLen < 2 ? schemaName : tableNamepresent[0];
288 tableName[2] = tableLen == 1 ? tableNamepresent[0] : tableNamepresent[1];
289 }
290 if (!tablesSet.contains(tableName)) {
291 tablesSet.add(tableName);
292 }
293 }
294 tablesList.addAll(tablesSet);
295 return tablesList;
296 }
297
298 public static ArrayList removeRedundentColumns(String catalogName,
299 String schemaName,
300 String objectName,
301 ArrayList columnsIncluded) {
302 int size = columnsIncluded.size();
303 TreeSet columnsSet = new TreeSet(new StringArrayComparator());
304 ArrayList columnsList = new ArrayList(size);
305 for (int i = 0; i < size; i++) {
306 String [] columnNamepresent = (String []) columnsIncluded.get(i);
307 String [] columnName = new String [4];
308 int columnLen = columnNamepresent.length;
309 if (columnLen == 4) {
310 columnName = columnNamepresent;
311 } else {
312 columnName[0] = catalogName;
313 columnName[1] = columnLen < 3 ? schemaName : columnNamepresent[0];
314 columnName[2] = objectName != null && columnLen < 2 ? objectName :
315 columnNamepresent[columnLen - 2];
316 columnName[3] = columnNamepresent[columnLen - 1];
317 }
318 if (!columnsSet.contains(columnName)) {
319 columnsSet.add(columnName);
320 }
321 }
322 columnsList.addAll(columnsSet);
323 return columnsList;
324 }
325
326 public static void validateUserRights(String schemOwner,
327 _ServerSession currentSession) throws
328 DException {
329 if (!currentSession.isEnabledAuthorizationIdentifier(schemOwner, true)) {
330 throw new DException("DSE12", null);
331 }
332 }
333
334 public static String getSchemaOwner(String catalogName, String schemaName,
335 _ServerSession currentSession) throws
336 DException {
337 SchemaDescriptor schDes = new SchemaDescriptor();
338 schDes.catalog_name = catalogName;
339 schDes.schema_name = schemaName;
340 schDes.load(currentSession);
341 return schDes.schema_owner;
342 }
343
344 public static int getBytesCount(int type, int size) throws DException {
345 switch (type) {
346 case Datatypes.INT:
347 case Datatypes.INTEGER:
348 return Datatypes.INTSIZE;
349 case Datatypes.REAL:
350 return Datatypes.REALSIZE;
351 case Datatypes.DATE:
352 return Datatypes.DATESIZE;
353 case Datatypes.BIGINT:
354 case Datatypes.LONG:
355 case Datatypes.FLOAT:
356 case Datatypes.DOUBLE:
357 case Datatypes.DOUBLEPRECISION:
358 return Datatypes.DOUBLESIZE;
359 case Datatypes.SHORT:
360 case Datatypes.SMALLINT:
361 return Datatypes.SHORTSIZE;
362 case Datatypes.BOOLEAN:
363 return Datatypes.BOOLEANSIZE;
364 case Datatypes.TINYINT:
365 case Datatypes.BYTE:
366 return Datatypes.BYTESIZE;
367 case Datatypes.TIME:
368 return Datatypes.TIMESIZE;
369 case Datatypes.TIMESTAMP:
370 return Datatypes.TIMESTAMPSIZE;
371 case Datatypes.BINARY:
372 case Datatypes.VARBINARY:
373 return size;
374
375 case Datatypes.CHARACTER:
376 case Datatypes.CHAR:
377 case Datatypes.CHARACTERVARYING:
378 case Datatypes.CHARVARYING:
379 case Datatypes.VARCHAR:
380
381 return size;
382 case Datatypes.BIT:
383 case Datatypes.BITVARYING:
384 return size;
385 case Datatypes.DEC:
386 case Datatypes.DECIMAL:
387 case Datatypes.NUMERIC:
388 case Datatypes.BIGDECIMAL:
389
390 return size;
391
392 case Datatypes.LONGVARBINARY:
393 case Datatypes.LONGVARCHAR:
394 case Datatypes.BLOB:
395 case Datatypes.CLOB:
396 case Datatypes.CHARLARGEOBJECT:
397 case Datatypes.CHARACTERLARGEOBJECT:
398 case Datatypes.BINARYLARGEOBJECT:
399 return 6; }
401 return -1;
402 }
403
404 public static int getPrecision(int charLength, int numPrecision,
405 int datePrecision, int intervalPrecision) {
406 return charLength != 0 ? charLength
407 : numPrecision != 0 ? numPrecision
408 : datePrecision != 0 ? datePrecision
409 : intervalPrecision;
410 }
411
412 public static TreeMap getApplicableRolesForUser(_ServerSession serverSession, String grantee) throws DException {
413 TreeMap map = new TreeMap(String.CASE_INSENSITIVE_ORDER);
414 _SelectQueryIterator iterWithPublic = SqlSchemaConstants.getIterator(
415 serverSession, QueryMaker.getAllRoleAuthorizationsforGranteeAndPublic(),
416 new Object [] {grantee});
417 if (!iterWithPublic.first()) {
418 return map;
419 }
420 do {
421 RoleAuthorizationDescriptor roleAuthDes = new RoleAuthorizationDescriptor();
422 roleAuthDes.loadDataFromRecord(iterWithPublic);
423 map.put(roleAuthDes.role_name, roleAuthDes);
424 } while (iterWithPublic.next());
425 return map;
426 }
427
428 public static TreeMap getApplicableRoles(_ServerSession serverSession, String grantee) throws DException {
429 TreeMap map = new TreeMap(String.CASE_INSENSITIVE_ORDER);
430 _SelectQueryIterator iterWithPublic = SqlSchemaConstants.getIterator(serverSession, QueryMaker.getAllRoleAuthorizationsforGranteeAndPublic(), new Object [] {grantee});
431 _Executer executer = SqlSchemaConstants.getExecuter(serverSession, QueryMaker.getAllRoleAuthorizationsforGranteeOnly());
432 getApplicableRoles(map, executer, iterWithPublic);
433 return map;
434 }
435
436 private static void getApplicableRoles(TreeMap applicableRolesMap, _Executer executer, _SelectQueryIterator iterator) throws DException {
437 if (!iterator.first()) {
438 return;
439 }
440 do {
441 RoleAuthorizationDescriptor roleAuthDes = new RoleAuthorizationDescriptor();
442 roleAuthDes.loadDataFromRecord(iterator);
443 if (applicableRolesMap.containsKey(roleAuthDes.role_name)) {
444 if (roleAuthDes.role_name.equalsIgnoreCase(SqlSchemaConstants.YES)) {
445 applicableRolesMap.put(roleAuthDes.role_name, roleAuthDes);
446 }
447 } else {
448 applicableRolesMap.put(roleAuthDes.role_name, roleAuthDes);
449 }
450 _SelectQueryIterator iter = (_SelectQueryIterator) executer.executeForFresh(new Object [] {roleAuthDes.role_name});
451 getApplicableRoles(applicableRolesMap, executer, iter);
452 } while (iterator.next());
453 }
454
455 public static String [] getApplicableRoleNames(PreparedStatementGetter prepareStatementGetter, String grantee) throws DException {
456 TreeSet set = new TreeSet(String.CASE_INSENSITIVE_ORDER);
457 _SelectQueryIterator iterWithPublic = (_SelectQueryIterator) prepareStatementGetter.getAllRoleAuthorizationsExecuterforGranteeAndPublic().execute(new Object [] {grantee});
458 _Executer executer = prepareStatementGetter.getAllRoleAuthorizationsExecuterforGranteeOnly();
459 getApplicableRolesNames(set, executer, iterWithPublic);
460 return (String []) set.toArray(new String [0]);
461 }
462
463 private static void getApplicableRolesNames(TreeSet applicableRolesSet, _Executer executer, _SelectQueryIterator iterator) throws DException {
464 if (!iterator.first()) {
465 return;
466 }
467 do {
468 RoleAuthorizationDescriptor roleAuthDes = new RoleAuthorizationDescriptor();
469 roleAuthDes.loadDataFromRecord(iterator);
470 if (!applicableRolesSet.contains(roleAuthDes.role_name)) {
471 applicableRolesSet.add(roleAuthDes.role_name);
472 }
473 _SelectQueryIterator iter = (_SelectQueryIterator) executer.executeForFresh(new Object [] {roleAuthDes.role_name});
474 getApplicableRolesNames(applicableRolesSet, executer, iter);
475 } while (iterator.next());
476 }
477
478 public static String getReplacedCheckClause(String columnName,
479 String domainCheckClause) {
480 StringBuffer newCheckClause = new StringBuffer ();
481 int index = domainCheckClause.indexOf("value");
482 while (index != -1) {
483 newCheckClause.append(domainCheckClause.substring(0, index))
484 .append(" ")
485 .append(QuotedUtility.getUserIdentifier(columnName));
486 domainCheckClause = domainCheckClause.substring(index + 6);
487 index = domainCheckClause.indexOf("value");
488 }
489 newCheckClause.append(domainCheckClause);
490 return newCheckClause.toString();
491 }
492 }
493 |
Popular Tags |
Java API By Example, From Geeks To Geeks.