|
1 package com.daffodilwoods.daffodildb.utils;
2
3 import com.daffodilwoods.database.resource.*;
4 import com.daffodilwoods.daffodildb.server.datadictionarysystem.*;
5 import com.daffodilwoods.database.utility.P;
6 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.*;
7 import com.daffodilwoods.daffodildb.server.datasystem.utility.RecordVersion;
8
9 public class ColumnCharacteristicsUtilities implements Datatype {
10
11 public static int[] getColumnsType(int[] columns, _ColumnCharacteristics cc) throws DException {
12 int[] columnsType = new int[columns.length];
13 for (int i = 0; i < columns.length; i++) {
14 columnsType[i] = cc.getColumnType(columns[i]);
15 }
16 return columnsType;
17 }
18
19 public static int[] getColumnsSize(int[] columns, _ColumnCharacteristics cc) throws DException {
20 int[] columnsType = new int[columns.length];
21 for (int i = 0; i < columns.length; i++)
22 columnsType[i] = cc.getPrecision(columns[i]);
23 return columnsType;
24 }
25
26 public static boolean isFixed(int type) throws DException {
27 return! (type == ARRAY || type == BIGDECIMAL || type == VARCHAR ||
28 type == NUMERIC || type == DECIMAL || type == DEC ||
29 type == CHARACTERVARYING || type == CHARVARYING ||
30 type == BITVARYING || type == SUM ||
31 type == VARBINARY || type == REF || type == STRUCT);
32 }
33
34 public static boolean isFixedTable(_ColumnCharacteristics columnCharacteristics) throws DException {
35 for (int i = 0, columnCount = columnCharacteristics.getColumnCount(); i < columnCount; i++)
36 if (!isFixed(columnCharacteristics.getColumnType(i)))
37 return false;
38 return true;
39 }
40
41 public static Object  [] getObjectOfRespectiveType(Object [] objects, int[] dataType, int[] size) throws DException {
42 if (objects == null)
43 return null;
44 Object [] objectToReturn = new Object [objects.length];
45 for (int i = 0; i < objects.length; i++) {
46 if (objects[i] != null) {
47 objectToReturn[i] = com.daffodilwoods.database.general.TypeConverter.ConvertObjectToDatabaseType(objects[i], dataType[i], size[i]);
48 }
49 }
50 return objectToReturn;
51 }
52
53 public static int getPrecision(int type, int byteSize) throws DException {
54 switch (type) {
55 case INT:
56 case INTEGER:
57 return INT_PRECISION;
58 case DATE:
59 return DATE_PRECISION;
60 case BIGINT:
61 case LONG:
62 return LONG_PRECISION;
63 case FLOAT:
64 case DOUBLE:
65 case DOUBLEPRECISION:
66 return DOUBLE_PRECISION;
67 case REAL:
68 return REAL_PRECISION;
69 case SHORT:
70 case SMALLINT:
71 return SHORT_PRECISION;
72 case BOOLEAN:
73 return BOOLEAN_PRECISION;
74 case TINYINT:
75 case BYTE:
76 return BYTE_PRECISION;
77 case TIME:
78 return TIME_PRECISION;
79 case TIMESTAMP:
80 return TIMESTAMP_PRECISION;
81 case DEC:
82 case DECIMAL:
83 case BIGDECIMAL:
84 return BIGDECIMAL_PRECISION;
85 }
86 return byteSize;
87 }
88
89 public static int getMemoryUsage(int[] indexes, Object [] values, _ColumnCharacteristics cc) throws DException {
90 int memoryUsage = 0;
91 if (indexes.length == values.length)
92 for (int i = 0; i < indexes.length; i++)
93 memoryUsage += getMemoryUsage(cc.getColumnType(indexes[i]), values[i]);
94 else
95 for (int i = 0; i < indexes.length; i++)
96 memoryUsage += getMemoryUsage(cc.getColumnType(indexes[i]), values[indexes[i]]);
97 return memoryUsage;
98 }
99
100
102 public static int getMemoryUsage(Object [] values, _ColumnCharacteristics cc) throws DException {
103 int memoryUsage = 0;
104 for (int i = 0; i < values.length; i++)
105 memoryUsage += getMemoryUsage(cc.getColumnType(i), values[i]);
106 return memoryUsage;
107 }
108
109
110 private static int getMemoryUsage(int columnType, Object value) throws DException {
111 int referenceMemory = 8;
112 if (value == null)
113 return referenceMemory;
114 try {
115 switch (columnType) {
116 case BINARY:
117 case VARBINARY:
118 case CHAR:
119 case CHARVARYING:
120 case CHARACTERVARYING:
121 case CHARACTER:
122 case VARCHAR:
123
124 String str = value.toString();
125 return str.length() + referenceMemory;
126 case BIT:
127 case BITVARYING:
128 String binaryValue = (String ) value;
129 return binaryValue.length() + referenceMemory;
130
131 case INT:
132 case INTEGER:
133 return Datatype.INTSIZE + referenceMemory;
134 case BIGINT:
135 case LONG:
136 return Datatype.LONGSIZE + referenceMemory;
137 case SMALLINT:
138 case SHORT:
139 return Datatype.SHORTSIZE + referenceMemory;
140 case BOOLEAN:
141 return Datatype.BOOLEANSIZE + referenceMemory;
142 case FLOAT:
143 return Datatype.FLOATSIZE + referenceMemory;
144 case DOUBLEPRECISION:
145 case DOUBLE:
146 return Datatype.DOUBLESIZE + referenceMemory;
147 case DATE:
148 return 16 + referenceMemory;
149 case MODULE:
150 return MODULESIZE + referenceMemory;
151 case SUM:
152 return 16 + referenceMemory;
153 case ARRAY:
154 return referenceMemory;
155 case RECORD:
156 return 8 + referenceMemory;
157 case RECORDSET:
158 return referenceMemory;
159 case DECIMAL:
160 case DEC:
161 case NUMERIC:
162 case BIGDECIMAL:
163 return 32 + 8 + referenceMemory; case REAL:
165 return REALSIZE + referenceMemory;
166 case TIME:
167 return 16 + referenceMemory;
168 case TIMESTAMP:
169 return 24 + referenceMemory;
170 case TINYINT:
171 case BYTE:
172 return 1 + referenceMemory;
173 case LONGVARBINARY:
174 case BINARYLARGEOBJECT:
175 case BLOB:
176 return (int) ( (java.sql.Blob ) value).length() + referenceMemory;
177 case LONGVARCHAR:
178 case CHARACTERLARGEOBJECT:
179 case CHARLARGEOBJECT:
180 case CLOB:
181 return (int) ( (java.sql.Clob ) value).length() + referenceMemory;
182 case REF:
183 return referenceMemory;
184 case STRUCT:
185 return referenceMemory;
186 }
187 } catch (Exception ex) {
188 }
189 throw new DException("DSE1018", new Object [] {new Integer (columnType)});
190 }
191
192 public static boolean isStringType(int type) {
193 return type == CHAR || type == CHARACTER || type == CHARACTERVARYING ||
194 type == CHARVARYING || type == VARCHAR;
195 }
196
197 public static Object [] getAutoIncrementColumnIndexes(_ColumnCharacteristics cc, int[] columnindexes, RecordVersion recordVersion) throws DException {
198 int count = cc.getColumnCount();
199 int[] autoIncrementColumnIndexes = new int[count];
200 Object [] autoIncrementColumnValues = new Object [count];
201 int counter = 0;
202 int vcounter = 0;
203 for (int i = 0; i < count; i++) {
204 if (cc.isAutoIncrement(i)) {
205 autoIncrementColumnIndexes[counter] = i;
206 if (P.indexOf( (columnindexes), i) == -1) {
207 autoIncrementColumnValues[counter] = recordVersion.getCurrentRecord().
208 getObject(i);
209 vcounter++;
210 }
211 counter++;
212 }
213 }
214 if (counter > 0) {
215 int[] temp = new int[counter];
216 Object [] values = null;
217 System.arraycopy(autoIncrementColumnIndexes, 0, temp, 0, counter);
218 if (vcounter > 0) {
219 values = new Object [counter];
220 System.arraycopy(autoIncrementColumnValues, 0, values, 0, counter);
221 }
222 return new Object [] {temp, values};
223 } else {
224 int[] temp = new int[0];
225 Object [] values = new Object [0];
226 return new Object [] {temp, values};
227 }
228 }
229
230 public static int[] getColumnsScale(int[] columns, _ColumnCharacteristics cc) throws DException {
231 int[] columnsType = new int[columns.length];
232 for (int i = 0; i < columns.length; i++) {
233 columnsType[i] = cc.getScale(columns[i]);
234 }
235 return columnsType;
236 }
237 }
238 |
Popular Tags |
Java API By Example, From Geeks To Geeks.