KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > derbyTesting > functionTests > tests > lang > WiscVTI


1 /*
2
3    Derby - Class org.apache.derbyTesting.functionTests.tests.lang.WiscVTI
4
5    Licensed to the Apache Software Foundation (ASF) under one or more
6    contributor license agreements. See the NOTICE file distributed with
7    this work for additional information regarding copyright ownership.
8    The ASF licenses this file to You under the Apache License, Version 2.0
9    (the "License"); you may not use this file except in compliance with
10    the License. You may obtain a copy of the License at
11
12       http://www.apache.org/licenses/LICENSE-2.0
13
14    Unless required by applicable law or agreed to in writing, software
15    distributed under the License is distributed on an "AS IS" BASIS,
16    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17    See the License for the specific language governing permissions and
18    limitations under the License.
19
20  */

21
22 package org.apache.derbyTesting.functionTests.tests.lang;
23
24 import org.apache.derby.vti.VTITemplate;
25
26 import java.sql.SQLException JavaDoc;
27 import java.sql.ResultSetMetaData JavaDoc;
28 import java.sql.DriverManager JavaDoc;
29 import java.sql.Connection JavaDoc;
30
31 /**
32  * This class is a VTI for loading data into the Wisconsin benchmark schema.
33  * See The Benchmark Handbook, Second Edition (edited by Jim Gray).
34  */

35 public class WiscVTI extends VTITemplate {
36
37     int numrows;
38     int prime;
39     int generator;
40     int rowsReturned = 0;
41
42     int unique1;
43     int unique2;
44     int two;
45     int four;
46     int ten;
47     int twenty;
48     int onePercent;
49     int tenPercent;
50     int twentyPercent;
51     int fiftyPercent;
52     int unique3;
53     int evenOnePercent;
54     int oddOnePercent;
55     String JavaDoc stringu1;
56     String JavaDoc stringu2;
57     String JavaDoc string4;
58
59     int seed;
60     static final String JavaDoc[] cyclicStrings = {
61         "AAAAxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
62         "HHHHxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
63         "OOOOxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
64         "VVVVxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
65         };
66
67     boolean closed = false;
68
69     static final WiscMetaData metaData = new WiscMetaData();
70
71     public WiscVTI(int numrows) throws SQLException JavaDoc {
72         this.numrows = numrows;
73
74         /* Choose prime and generator values for the desired table size */
75         if (numrows <= 1000) {
76             generator = 279;
77             prime = 1009;
78         } else if (numrows <= 10000) {
79             generator = 2969;
80             prime = 10007;
81         } else if (numrows <= 100000) {
82             generator = 21395;
83             prime = 100003;
84         } else if (numrows <= 1000000) {
85             generator = 2107;
86             prime = 1000003;
87         } else if (numrows <= 10000000) {
88             generator = 211;
89             prime = 10000019;
90         } else if (numrows <= 100000000) {
91             generator = 21;
92             prime = 100000007;
93         } else {
94             throw new SQLException JavaDoc("Too many rows - maximum is 100000000, " +
95                                     numrows + " requested.");
96         }
97
98         seed = generator;
99     }
100
101     public ResultSetMetaData JavaDoc getMetaData() {
102         return metaData;
103     }
104
105     public boolean next() throws SQLException JavaDoc {
106         if (closed) {
107             throw new SQLException JavaDoc("next() call on a closed result set");
108         }
109
110         if (rowsReturned >= numrows)
111             return false;
112
113         seed = rand(seed, numrows);
114
115         unique1 = seed - 1;
116         unique2 = rowsReturned;
117         two = unique1 % 2;
118         four = unique1 % 4;
119         ten = unique1 % 10;
120         twenty = unique1 % 20;
121         onePercent = unique1 % 100;
122         tenPercent = unique1 % 10;
123         twentyPercent = unique1 % 5;
124         fiftyPercent = unique1 % 2;
125         unique3 = unique1;
126         evenOnePercent = onePercent * 2;
127         oddOnePercent = evenOnePercent + 1;
128         stringu1 = uniqueString(unique1);
129         stringu2 = uniqueString(unique2);
130         string4 = cyclicStrings[rowsReturned % cyclicStrings.length];
131
132         rowsReturned++;
133
134         return true;
135     }
136
137     public int getInt(int columnIndex) throws SQLException JavaDoc {
138         if (closed) {
139             throw new SQLException JavaDoc("getInt() call on a closed result set");
140         }
141
142         switch (columnIndex) {
143           case 1:
144             return unique1;
145
146           case 2:
147             return unique2;
148
149           case 3:
150             return two;
151
152           case 4:
153             return four;
154
155           case 5:
156             return ten;
157
158           case 6:
159             return twenty;
160
161           case 7:
162             return onePercent;
163
164           case 8:
165             return tenPercent;
166
167           case 9:
168             return twentyPercent;
169
170           case 10:
171             return fiftyPercent;
172
173           case 11:
174             return unique3;
175
176           case 12:
177             return evenOnePercent;
178
179           case 13:
180             return oddOnePercent;
181
182           default:
183             throw new SQLException JavaDoc("getInt() invalid for column " + columnIndex);
184         }
185     }
186
187     public String JavaDoc getString(int columnIndex) throws SQLException JavaDoc {
188         if (closed) {
189             throw new SQLException JavaDoc("getString() call on a closed result set");
190         }
191
192         switch (columnIndex) {
193           case 14:
194             return stringu1;
195
196           case 15:
197             return stringu2;
198
199           case 16:
200             return string4;
201
202           default:
203             throw new SQLException JavaDoc("getString() invalid for column " +
204                                                                 columnIndex);
205         }
206     }
207
208     public void close() {
209         closed = true;
210     }
211
212     private int rand(int seed, int limit) {
213         do {
214             seed = (generator * seed) % prime;
215         } while (seed > limit);
216
217         return seed;
218     }
219
220     private static final char[] chars = {
221         'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
222         'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
223     };
224  
225     private String JavaDoc uniqueString(int unique) {
226         int i;
227         int rem;
228         char[] retval = new char[52];
229
230         // First set result string to
231
// "AAAAAAA "
232
for (i = 0; i < 7; i++) {
233             retval[i] = 'A';
234         }
235         for (i = 7; i < retval.length; i++) {
236             retval[i] = 'x';
237         }
238
239         // Convert unique value from right to left into an alphabetic string
240
i = 6;
241         while (unique > 0) {
242             rem = unique % 26;
243             retval[i] = chars[rem];
244             unique /= 26;
245             i--;
246         }
247
248         return new String JavaDoc(retval);
249     }
250
251     public static void WISCInsertWOConnection(int numrows, String JavaDoc tableName) throws SQLException JavaDoc {
252     
253         Connection JavaDoc conn = DriverManager.getConnection("jdbc:default:connection");
254         WISCInsert wi = new WISCInsert();
255         wi.doWISCInsert(numrows, tableName, conn);
256     }
257
258 }
259
Popular Tags