MySQL 5.6.14 Source Code Document
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
NullValuesTest.java
1 /*
2  Copyright 2010 Sun Microsystems, Inc.
3  All rights reserved. Use is subject to license terms.
4 
5  This program is free software; you can redistribute it and/or modify
6  it under the terms of the GNU General Public License as published by
7  the Free Software Foundation; version 2 of the License.
8 
9  This program is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  GNU General Public License for more details.
13 
14  You should have received a copy of the GNU General Public License
15  along with this program; if not, write to the Free Software
16  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18 
19 package testsuite.clusterj;
20 
21 import com.mysql.clusterj.ClusterJDatastoreException;
22 import com.mysql.clusterj.ClusterJUserException;
23 import testsuite.clusterj.model.NullValues;
24 
25 public class NullValuesTest extends AbstractClusterJModelTest {
26 
27  protected static final String tablename = "nullvalues";
28  protected static final int numberOfPropertyTypes = 7;
29  protected static final int numberOfFieldsPerProperty = 12;
30 
34  protected static final int DATABASE_NOT_NULL = 0; // if the column is defined as not nullable
35  protected static final int DATABASE_NULL = 1; // if the column is defined as nullable
36  protected static final String[] databaseNull =
37  new String[] {"DATABASE_NOT_NULL", "DATABASE_NULL"};
38  protected static final int DATABASE_NO_DEFAULT = 0; // if the column has no default value in the database schema
39  protected static final int DATABASE_DEFAULT = 2; // if the column has a default value in the database schema
40  protected static final String[] databaseDefault =
41  new String[] {"DATABASE_NO_DEFAULT", "DATABASE_DEFAULT"};
42  protected static final int NULLVALUE_NONE = 0; // if the property is NullValue.NONE
43  protected static final int NULLVALUE_EXCEPTION = 4; // if the property is NullValue.EXCEPTION
44  protected static final int NULLVALUE_DEFAULT = 8; // if the property is NullValue.DEFAULT
45  protected static final String[] nullValue =
46  new String[] {"NULL_VALUE_NONE", "NULL_VALUE_EXCEPTION", "NULL_VALUE_DEFAULT"};
47 
48  protected static final String[] propertyTypes = new String[] {
49  "Integer", "Long", "Short", "Byte", "String", "Float", "Double"};
50 
51  @Override
52  public void localSetUp() {
53  createSessionFactory();
54  session = sessionFactory.getSession();
55  session.deletePersistentAll(NullValues.class);
56  addTearDownClasses(NullValues.class);
57  }
58 
73  public void test() {
74 
75  tx = session.currentTransaction();
76  // make sure we can commit a legal instance.
77  if (true) {
78  tx.begin();
79  NullValues instance = createValidInstance();
80  int id = 0;
81  instance.setId(id);
82  session.makePersistent(instance);
83  tx.commit();
84  tx.begin();
85  instance = session.find(NullValues.class, id);
86  session.deletePersistent(instance);
87  tx.commit();
88  }
89  // iterate all property and field types and set the value of the
90  // field to null and then commit.
91  for (int propertyType = 0; propertyType < numberOfPropertyTypes; ++propertyType) {
92  for (int fieldIndex = 0; fieldIndex < numberOfFieldsPerProperty; ++fieldIndex) {
93  NullValues instance = createValidInstance();
94  int id = propertyType * numberOfFieldsPerProperty + fieldIndex;
95  //System.out.println("id: " + id);
96  instance.setId(id);
97  try {
98  tx.begin();
99  // set one property to null value
100  setValue(instance, propertyType, fieldIndex, true);
101  // and see what happens
102  session.makePersistent(instance);
103  tx.commit();
104  //System.out.println("no exception for: " + id + " " + decodeValues(id));
105  if (expectedException(id, null)) {
106  error("Expected exception not thrown for case " +
107  decodeType(propertyType) + ": " + decodeValues(id));
108  }
109  } catch (Exception e) {
110  // see if this is an expected exception
111  //System.out.println("exception for: " + id + " " + decodeValues(id));
112  if (!expectedException(id, e)) {
113  error("Unexpected exception from commit for case " +
114  decodeType(propertyType) + ": " + decodeValues(id)
115  + " " + e.toString());
116  e.printStackTrace();
117  }
118  continue; // if an exception was caught, don't try to verify the instance
119  } finally {
120  if (tx.isActive()) {
121  tx.rollback();
122  }
123  }
124  try {
125  tx.begin();
126  instance = session.find(NullValues.class, id);
127  verifyNullValues(propertyType, fieldIndex, id, instance);
128  tx.commit();
129  } catch (Exception e) {
130  error("Unexpected exception from find for case" +
131  decodeType(propertyType) + ": " + decodeValues(id)
132  + " " + e.toString());
133  e.printStackTrace();
134  }
135  }
136  }
137  failOnError();
138  }
139 
140  protected NullValues createValidInstance() {
141  NullValues instance = session.newInstance(NullValues.class);
142  for (int propertyType = 0; propertyType < numberOfPropertyTypes; ++propertyType) {
143  for (int fieldIndex = 0; fieldIndex < numberOfFieldsPerProperty; ++fieldIndex) {
144  // set all properties to non-null values
145  setValue(instance, propertyType, fieldIndex, false);
146  }
147  }
148  return instance;
149  }
150 
151  protected int whatDatabaseDefault(int id) {
152  return ((id % numberOfFieldsPerProperty) & 2) >> 1;
153  }
154 
155  protected int whatDatabaseNull(int id) {
156  return (id % numberOfFieldsPerProperty) & 1;
157  }
158 
159  protected int whatNullValue(int id) {
160  return ((id % numberOfFieldsPerProperty) & 12) >> 2;
161  }
162 
163  private String decodeValues(int id) {
164 // protected static final int DATABASE_NOT_NULL = 0; // if the column is defined as not nullable
165 // protected static final int DATABASE_NULL = 1; // if the column is defined as nullable
166  String databaseNullResult = databaseNull[whatDatabaseNull(id)];
167 // protected static final int DATABASE_NO_DEFAULT = 0; // if the column has no default value in the database schema
168 // protected static final int DATABASE_DEFAULT = 2; // if the column has a default value in the database schema
169  String databaseDefaultResult = databaseDefault[whatDatabaseDefault(id)];
170 // protected static final int NULLVALUE_NONE = 0; // if the property is NullValue.NONE
171 // protected static final int NULLVALUE_EXCEPTION = 4; // if the property is NullValue.EXCEPTION
172 // protected static final int NULLVALUE_DEFAULT = 8; // if the property is NullValue.DEFAULT
173  String nullValueResult = nullValue[whatNullValue(id)];
174  return databaseNullResult + " " +
175  databaseDefaultResult + " " +
176  nullValueResult;
177  }
178 
179  private String decodeType(int type) {
180  return propertyTypes[type];
181  }
182 
183  private boolean expectedException(int id, Exception e) {
184  // if DATABASE_NOT_NULL and NULL_VALUE_NONE => ClusterJDatastoreException
185  // the database exception might have been wrapped
186  Throwable t = e==null?null:e.getCause();
187  if (whatDatabaseNull(id) == 0 &&
188  (whatNullValue(id) == 0)) {
189  if (e != null &&
190  e instanceof ClusterJDatastoreException) {
191  return true;
192  } else if (t instanceof Exception) {
193  return expectedException(id, (Exception)t);
194  } else {
195  return false;
196  }
197  }
198  // if NULL_VALUE_EXCEPTION => ClusterJUserException
199  if (whatNullValue(id) == 1) {
200  if (e != null &&
201  e instanceof ClusterJUserException) {
202  return true;
203  } else {
204  return false;
205  }
206  }
207  // else no exception is expected
208  return false;
209  }
210 
211  private void verifyNullValues(int propertyType, int fieldIndex, int id, NullValues instance) {
212  Object value = getValue(instance, propertyType, fieldIndex);
213  if (whatDatabaseNull(id) == DATABASE_NULL
214  && (whatDatabaseDefault(id) == DATABASE_NO_DEFAULT)
215  && (whatNullValue(id) == NULLVALUE_NONE)
216  ) {
217  // should store a null in the database for this case
218  errorIfNotEqual("For id " + id + " propertyType " + propertyType + " fieldIndex " + fieldIndex + " instance was " + (instance==null?"null":instance.toString() + " value was " + ((value==null)?"null ":value + " of type " + value.getClass().getName() + " " ) + decodeValues(id)), null, value);
219  }
220  }
221 
229  private void setValue(NullValues instance, int propertyType, int fieldIndex, boolean nullValue) {
230  switch(propertyType) {
231  case 0: // Integer
232  switch(fieldIndex) {
233  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
234  instance.setIntNotNullNoDefaultNullValueNone(nullValue?null:0); break;
235  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
236  instance.setIntNullNoDefaultNullValueNone(nullValue?null:0); break;
237  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
238  instance.setIntNotNullDefaultNullValueNone(nullValue?null:0); break;
239  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
240  instance.setIntNullDefaultNullValueNone(nullValue?null:0); break;
241  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
242  instance.setIntNotNullNoDefaultNullValueException(nullValue?null:0); break;
243  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
244  instance.setIntNullNoDefaultNullValueException(nullValue?null:0); break;
245  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
246  instance.setIntNotNullDefaultNullValueException(nullValue?null:0); break;
247  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
248  instance.setIntNullDefaultNullValueException(nullValue?null:0); break;
249  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
250  instance.setIntNotNullNoDefaultNullValueDefault(nullValue?null:0); break;
251  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
252  instance.setIntNullNoDefaultNullValueDefault(nullValue?null:0); break;
253  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
254  instance.setIntNotNullDefaultNullValueDefault(nullValue?null:0); break;
255  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
256  instance.setIntNullDefaultNullValueDefault(nullValue?null:0); break;
257  default:
258  throw new IllegalArgumentException("Illegal field index " + fieldIndex);
259  }
260  break;
261  case 1: // Long
262  switch(fieldIndex) {
263  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
264  instance.setLongNotNullNoDefaultNullValueNone(nullValue?null:0L); break;
265  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
266  instance.setLongNullNoDefaultNullValueNone(nullValue?null:0L); break;
267  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
268  instance.setLongNotNullDefaultNullValueNone(nullValue?null:0L); break;
269  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
270  instance.setLongNullDefaultNullValueNone(nullValue?null:0L); break;
271  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
272  instance.setLongNotNullNoDefaultNullValueException(nullValue?null:0L); break;
273  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
274  instance.setLongNullNoDefaultNullValueException(nullValue?null:0L); break;
275  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
276  instance.setLongNotNullDefaultNullValueException(nullValue?null:0L); break;
277  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
278  instance.setLongNullDefaultNullValueException(nullValue?null:0L); break;
279  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
280  instance.setLongNotNullNoDefaultNullValueDefault(nullValue?null:0L); break;
281  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
282  instance.setLongNullNoDefaultNullValueDefault(nullValue?null:0L); break;
283  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
284  instance.setLongNotNullDefaultNullValueDefault(nullValue?null:0L); break;
285  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
286  instance.setLongNullDefaultNullValueDefault(nullValue?null:0L); break;
287  default:
288  throw new IllegalArgumentException("Illegal field index " + fieldIndex);
289  }
290  case 2: // Short
291  switch(fieldIndex) {
292  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
293  instance.setShortNotNullNoDefaultNullValueNone(nullValue?null:(short)0); break;
294  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
295  instance.setShortNullNoDefaultNullValueNone(nullValue?null:(short)0); break;
296  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
297  instance.setShortNotNullDefaultNullValueNone(nullValue?null:(short)0); break;
298  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
299  instance.setShortNullDefaultNullValueNone(nullValue?null:(short)0); break;
300  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
301  instance.setShortNotNullNoDefaultNullValueException(nullValue?null:(short)0); break;
302  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
303  instance.setShortNullNoDefaultNullValueException(nullValue?null:(short)0); break;
304  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
305  instance.setShortNotNullDefaultNullValueException(nullValue?null:(short)0); break;
306  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
307  instance.setShortNullDefaultNullValueException(nullValue?null:(short)0); break;
308  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
309  instance.setShortNotNullNoDefaultNullValueDefault(nullValue?null:(short)0); break;
310  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
311  instance.setShortNullNoDefaultNullValueDefault(nullValue?null:(short)0); break;
312  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
313  instance.setShortNotNullDefaultNullValueDefault(nullValue?null:(short)0); break;
314  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
315  instance.setShortNullDefaultNullValueDefault(nullValue?null:(short)0); break;
316  default:
317  throw new IllegalArgumentException("Illegal field index " + fieldIndex);
318  }
319  case 3: // Byte
320  switch(fieldIndex) {
321  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
322  instance.setByteNotNullNoDefaultNullValueNone(nullValue?null:(byte)0); break;
323  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
324  instance.setByteNullNoDefaultNullValueNone(nullValue?null:(byte)0); break;
325  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
326  instance.setByteNotNullDefaultNullValueNone(nullValue?null:(byte)0); break;
327  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
328  instance.setByteNullDefaultNullValueNone(nullValue?null:(byte)0); break;
329  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
330  instance.setByteNotNullNoDefaultNullValueException(nullValue?null:(byte)0); break;
331  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
332  instance.setByteNullNoDefaultNullValueException(nullValue?null:(byte)0); break;
333  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
334  instance.setByteNotNullDefaultNullValueException(nullValue?null:(byte)0); break;
335  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
336  instance.setByteNullDefaultNullValueException(nullValue?null:(byte)0); break;
337  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
338  instance.setByteNotNullNoDefaultNullValueDefault(nullValue?null:(byte)0); break;
339  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
340  instance.setByteNullNoDefaultNullValueDefault(nullValue?null:(byte)0); break;
341  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
342  instance.setByteNotNullDefaultNullValueDefault(nullValue?null:(byte)0); break;
343  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
344  instance.setByteNullDefaultNullValueDefault(nullValue?null:(byte)0); break;
345  default:
346  throw new IllegalArgumentException("Illegal field index " + fieldIndex);
347  }
348  case 4: // String
349  switch(fieldIndex) {
350  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
351  instance.setStringNotNullNoDefaultNullValueNone(nullValue?null:"0"); break;
352  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
353  instance.setStringNullNoDefaultNullValueNone(nullValue?null:"0"); break;
354  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
355  instance.setStringNotNullDefaultNullValueNone(nullValue?null:"0"); break;
356  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
357  instance.setStringNullDefaultNullValueNone(nullValue?null:"0"); break;
358  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
359  instance.setStringNotNullNoDefaultNullValueException(nullValue?null:"0"); break;
360  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
361  instance.setStringNullNoDefaultNullValueException(nullValue?null:"0"); break;
362  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
363  instance.setStringNotNullDefaultNullValueException(nullValue?null:"0"); break;
364  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
365  instance.setStringNullDefaultNullValueException(nullValue?null:"0"); break;
366  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
367  instance.setStringNotNullNoDefaultNullValueDefault(nullValue?null:"0"); break;
368  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
369  instance.setStringNullNoDefaultNullValueDefault(nullValue?null:"0"); break;
370  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
371  instance.setStringNotNullDefaultNullValueDefault(nullValue?null:"0"); break;
372  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
373  instance.setStringNullDefaultNullValueDefault(nullValue?null:"0"); break;
374  default:
375  throw new IllegalArgumentException("Illegal field index " + fieldIndex);
376  }
377  break;
378  case 5: // Float
379  switch(fieldIndex) {
380  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
381  instance.setFloatNotNullNoDefaultNullValueNone(nullValue?null:0.0F); break;
382  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
383  instance.setFloatNullNoDefaultNullValueNone(nullValue?null:0.0F); break;
384  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
385  instance.setFloatNotNullDefaultNullValueNone(nullValue?null:0.0F); break;
386  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
387  instance.setFloatNullDefaultNullValueNone(nullValue?null:0.0F); break;
388  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
389  instance.setFloatNotNullNoDefaultNullValueException(nullValue?null:0.0F); break;
390  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
391  instance.setFloatNullNoDefaultNullValueException(nullValue?null:0.0F); break;
392  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
393  instance.setFloatNotNullDefaultNullValueException(nullValue?null:0.0F); break;
394  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
395  instance.setFloatNullDefaultNullValueException(nullValue?null:0.0F); break;
396  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
397  instance.setFloatNotNullNoDefaultNullValueDefault(nullValue?null:0.0F); break;
398  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
399  instance.setFloatNullNoDefaultNullValueDefault(nullValue?null:0.0F); break;
400  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
401  instance.setFloatNotNullDefaultNullValueDefault(nullValue?null:0.0F); break;
402  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
403  instance.setFloatNullDefaultNullValueDefault(nullValue?null:0.0F); break;
404  default:
405  throw new IllegalArgumentException("Illegal field index " + fieldIndex);
406  }
407  break;
408  case 6: // Double
409  switch(fieldIndex) {
410  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
411  instance.setDoubleNotNullNoDefaultNullValueNone(nullValue?null:0.0D); break;
412  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
413  instance.setDoubleNullNoDefaultNullValueNone(nullValue?null:0.0D); break;
414  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
415  instance.setDoubleNotNullDefaultNullValueNone(nullValue?null:0.0D); break;
416  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
417  instance.setDoubleNullDefaultNullValueNone(nullValue?null:0.0D); break;
418  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
419  instance.setDoubleNotNullNoDefaultNullValueException(nullValue?null:0.0D); break;
420  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
421  instance.setDoubleNullNoDefaultNullValueException(nullValue?null:0.0D); break;
422  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
423  instance.setDoubleNotNullDefaultNullValueException(nullValue?null:0.0D); break;
424  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
425  instance.setDoubleNullDefaultNullValueException(nullValue?null:0.0D); break;
426  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
427  instance.setDoubleNotNullNoDefaultNullValueDefault(nullValue?null:0.0D); break;
428  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
429  instance.setDoubleNullNoDefaultNullValueDefault(nullValue?null:0.0D); break;
430  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
431  instance.setDoubleNotNullDefaultNullValueDefault(nullValue?null:0.0D); break;
432  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
433  instance.setDoubleNullDefaultNullValueDefault(nullValue?null:0.0D); break;
434  default:
435  throw new IllegalArgumentException("Illegal field index " + fieldIndex);
436  }
437  break;
438  default:
439  throw new IllegalArgumentException("Illegal property type " + propertyType);
440  }
441  }
442 
449  private Object getValue(NullValues instance, int propertyType, int fieldIndex) {
450  if (instance == null)
451  return null;
452  switch(propertyType) {
453  case 0: // Integer
454  switch(fieldIndex) {
455  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
456  return instance.getIntNotNullNoDefaultNullValueNone();
457  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
458  return instance.getIntNullNoDefaultNullValueNone();
459  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
460  return instance.getIntNotNullDefaultNullValueNone();
461  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
462  return instance.getIntNullDefaultNullValueNone();
463  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
464  return instance.getIntNotNullNoDefaultNullValueException();
465  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
466  return instance.getIntNullNoDefaultNullValueException();
467  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
468  return instance.getIntNotNullDefaultNullValueException();
469  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
470  return instance.getIntNullDefaultNullValueException();
471  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
472  return instance.getIntNotNullNoDefaultNullValueDefault();
473  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
474  return instance.getIntNullNoDefaultNullValueDefault();
475  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
476  return instance.getIntNotNullDefaultNullValueDefault();
477  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
478  return instance.getIntNullDefaultNullValueDefault();
479  default:
480  throw new IllegalArgumentException("Illegal field index " + fieldIndex);
481  }
482 
483  case 1: // Long
484  switch(fieldIndex) {
485  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
486  return instance.getLongNotNullNoDefaultNullValueNone();
487  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
488  return instance.getLongNullNoDefaultNullValueNone();
489  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
490  return instance.getLongNotNullDefaultNullValueNone();
491  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
492  return instance.getLongNullDefaultNullValueNone();
493  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
494  return instance.getLongNotNullNoDefaultNullValueException();
495  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
496  return instance.getLongNullNoDefaultNullValueException();
497  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
498  return instance.getLongNotNullDefaultNullValueException();
499  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
500  return instance.getLongNullDefaultNullValueException();
501  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
502  return instance.getLongNotNullNoDefaultNullValueDefault();
503  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
504  return instance.getLongNullNoDefaultNullValueDefault();
505  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
506  return instance.getLongNotNullDefaultNullValueDefault();
507  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
508  return instance.getLongNullDefaultNullValueDefault();
509  default:
510  throw new IllegalArgumentException("Illegal field index " + fieldIndex);
511  }
512  case 2: // Short
513  switch(fieldIndex) {
514  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
515  return instance.getShortNotNullNoDefaultNullValueNone();
516  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
517  return instance.getShortNullNoDefaultNullValueNone();
518  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
519  return instance.getShortNotNullDefaultNullValueNone();
520  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
521  return instance.getShortNullDefaultNullValueNone();
522  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
523  return instance.getShortNotNullNoDefaultNullValueException();
524  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
525  return instance.getShortNullNoDefaultNullValueException();
526  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
527  return instance.getShortNotNullDefaultNullValueException();
528  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
529  return instance.getShortNullDefaultNullValueException();
530  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
531  return instance.getShortNotNullNoDefaultNullValueDefault();
532  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
533  return instance.getShortNullNoDefaultNullValueDefault();
534  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
535  return instance.getShortNotNullDefaultNullValueDefault();
536  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
537  return instance.getShortNullDefaultNullValueDefault();
538  default:
539  throw new IllegalArgumentException("Illegal field index " + fieldIndex);
540  }
541  case 3: // Byte
542  switch(fieldIndex) {
543  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
544  return instance.getByteNotNullNoDefaultNullValueNone();
545  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
546  return instance.getByteNullNoDefaultNullValueNone();
547  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
548  return instance.getByteNotNullDefaultNullValueNone();
549  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
550  return instance.getByteNullDefaultNullValueNone();
551  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
552  return instance.getByteNotNullNoDefaultNullValueException();
553  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
554  return instance.getByteNullNoDefaultNullValueException();
555  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
556  return instance.getByteNotNullDefaultNullValueException();
557  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
558  return instance.getByteNullDefaultNullValueException();
559  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
560  return instance.getByteNotNullNoDefaultNullValueDefault();
561  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
562  return instance.getByteNullNoDefaultNullValueDefault();
563  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
564  return instance.getByteNotNullDefaultNullValueDefault();
565  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
566  return instance.getByteNullDefaultNullValueDefault();
567  default:
568  throw new IllegalArgumentException("Illegal field index " + fieldIndex);
569  }
570  case 4: // String
571  switch(fieldIndex) {
572  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
573  return instance.getStringNotNullNoDefaultNullValueNone();
574  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
575  return instance.getStringNullNoDefaultNullValueNone();
576  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
577  return instance.getStringNotNullDefaultNullValueNone();
578  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
579  return instance.getStringNullDefaultNullValueNone();
580  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
581  return instance.getStringNotNullNoDefaultNullValueException();
582  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
583  return instance.getStringNullNoDefaultNullValueException();
584  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
585  return instance.getStringNotNullDefaultNullValueException();
586  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
587  return instance.getStringNullDefaultNullValueException();
588  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
589  return instance.getStringNotNullNoDefaultNullValueDefault();
590  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
591  return instance.getStringNullNoDefaultNullValueDefault();
592  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
593  return instance.getStringNotNullDefaultNullValueDefault();
594  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
595  return instance.getStringNullDefaultNullValueDefault();
596  default:
597  throw new IllegalArgumentException("Illegal field index " + fieldIndex);
598  }
599 
600  case 5: // Float
601  switch(fieldIndex) {
602  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
603  return instance.getFloatNotNullNoDefaultNullValueNone();
604  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
605  return instance.getFloatNullNoDefaultNullValueNone();
606  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
607  return instance.getFloatNotNullDefaultNullValueNone();
608  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
609  return instance.getFloatNullDefaultNullValueNone();
610  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
611  return instance.getFloatNotNullNoDefaultNullValueException();
612  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
613  return instance.getFloatNullNoDefaultNullValueException();
614  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
615  return instance.getFloatNotNullDefaultNullValueException();
616  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
617  return instance.getFloatNullDefaultNullValueException();
618  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
619  return instance.getFloatNotNullNoDefaultNullValueDefault();
620  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
621  return instance.getFloatNullNoDefaultNullValueDefault();
622  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
623  return instance.getFloatNotNullDefaultNullValueDefault();
624  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
625  return instance.getFloatNullDefaultNullValueDefault();
626  default:
627  throw new IllegalArgumentException("Illegal field index " + fieldIndex);
628  }
629 
630  case 6: // Double
631  switch(fieldIndex) {
632  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
633  return instance.getDoubleNotNullNoDefaultNullValueNone();
634  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_NONE:
635  return instance.getDoubleNullNoDefaultNullValueNone();
636  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
637  return instance.getDoubleNotNullDefaultNullValueNone();
638  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_NONE:
639  return instance.getDoubleNullDefaultNullValueNone();
640  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
641  return instance.getDoubleNotNullNoDefaultNullValueException();
642  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_EXCEPTION:
643  return instance.getDoubleNullNoDefaultNullValueException();
644  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
645  return instance.getDoubleNotNullDefaultNullValueException();
646  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_EXCEPTION:
647  return instance.getDoubleNullDefaultNullValueException();
648  case DATABASE_NOT_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
649  return instance.getDoubleNotNullNoDefaultNullValueDefault();
650  case DATABASE_NULL + DATABASE_NO_DEFAULT + NULLVALUE_DEFAULT:
651  return instance.getDoubleNullNoDefaultNullValueDefault();
652  case DATABASE_NOT_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
653  return instance.getDoubleNotNullDefaultNullValueDefault();
654  case DATABASE_NULL + DATABASE_DEFAULT + NULLVALUE_DEFAULT:
655  return instance.getDoubleNullDefaultNullValueDefault();
656  default:
657  throw new IllegalArgumentException("Illegal field index " + fieldIndex);
658  }
659 
660  default:
661  throw new IllegalArgumentException("Illegal property type " + propertyType);
662  }
663  }
664 
665 }