review.fuel-infra Code Review - packages/trusty/mysql-wsrep-5.6.git/blob

   1 /*
   2    Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; version 2 of the License.
   7
   8    This program is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11    GNU General Public License for more details.
  12
  13    You should have received a copy of the GNU General Public License
  14    along with this program; if not, write to the Free Software
  15    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
  16 */
  17
  18 package com.mysql.clusterj.core.metadata;
  19
  20 import com.mysql.clusterj.ClusterJDatastoreException;
  21 import com.mysql.clusterj.ClusterJFatalInternalException;
  22 import com.mysql.clusterj.ClusterJUserException;
  23 import com.mysql.clusterj.ColumnMetadata;
  24 import com.mysql.clusterj.ColumnType;
  25 import com.mysql.clusterj.core.spi.QueryExecutionContext;
  26 import com.mysql.clusterj.core.spi.ValueHandler;
  27 import com.mysql.clusterj.core.spi.DomainTypeHandler;
  28 import com.mysql.clusterj.core.query.CandidateIndexImpl;
  29 import com.mysql.clusterj.core.query.InPredicateImpl;
  30 import com.mysql.clusterj.core.query.PredicateImpl;
  31 import com.mysql.clusterj.core.spi.DomainFieldHandler;
  32 import com.mysql.clusterj.core.store.Blob;
  33 import com.mysql.clusterj.core.store.IndexScanOperation;
  34 import com.mysql.clusterj.core.store.Operation;
  35 import com.mysql.clusterj.core.store.PartitionKey;
  36 import com.mysql.clusterj.core.store.ResultData;
  37 import com.mysql.clusterj.core.store.ScanFilter;
  38 import com.mysql.clusterj.core.util.I18NHelper;
  39 import com.mysql.clusterj.core.util.Logger;
  40 import com.mysql.clusterj.core.util.LoggerFactoryService;
  41 import java.lang.reflect.Proxy;
  42 import java.math.BigDecimal;
  43 import java.math.BigInteger;
  44 import java.sql.Date;
  45 import java.sql.Time;
  46 import java.sql.Timestamp;
  47 import java.text.ParseException;
  48 import java.text.SimpleDateFormat;
  49 import java.util.HashSet;
  50 import java.util.Set;
  51
  52 /**
  53  *
  54  */
  55 public abstract class AbstractDomainFieldHandlerImpl implements DomainFieldHandler, ColumnMetadata {
  56
  57     public AbstractDomainFieldHandlerImpl() {}
  58
  59     /** Empty byte[] to set the initial value of the byte array before execute. */
  60     public static final byte[] emptyByteArray = new byte[0];
  61     static final I18NHelper local = I18NHelper.getInstance(AbstractDomainFieldHandlerImpl.class);
  62     static final Logger logger = LoggerFactoryService.getFactory().getInstance(AbstractDomainFieldHandlerImpl.class);
  63
  64     /** The domain type handler for this field */
  65     protected DomainTypeHandler<?> domainTypeHandler;
  66
  67     /** true if the mapped column allows null values */
  68     protected boolean nullable;
  69
  70     /** The default value for the column if the field is null */
  71     protected String columnDefaultValue = null;
  72
  73     /** The column name if only one column for this field */
  74     protected String columnName = "";
  75
  76     /** The Column metadata for the database column. */
  77     protected com.mysql.clusterj.core.store.Column storeColumn;
  78
  79     /** The Charset name for the column. */
  80     protected String charsetName = null;
  81
  82     /** The precision of the column in the database */
  83     protected int precision;
  84
  85     /** The scale of the column in the database */
  86     protected int scale;
  87
  88     /** The length of the column in the database */
  89     protected int maximumLength;
  90
  91     /** true if the column is part of the partition key */
  92     protected boolean partitionKey;
  93
  94     /** The Store Type for the column. */
  95     protected ColumnType storeColumnType = null;
  96
  97     /** Column names in the case of a field mapped to multiple columns, e.g. foreign keys */
  98     protected String[] columnNames;
  99
 100     /** The default value for this field */
 101     protected Object defaultValue;
 102
 103     /** Error messages while constructing the field */
 104     protected StringBuffer errorMessages;
 105
 106     /** The number of the field. This is the index into many arrays in the implementation,
 107      * in particular the array of fields in the domain type handler, and the array of
 108      * values in the InvocationHandler. */
 109     protected int fieldNumber;
 110
 111     /** index names for this field */
 112     protected Set<String> indexNames = new HashSet<String>();
 113     /** The index handlers in which this field participates.
 114      * The first dimension indexes the index handlers in the DomainTypeHandler;
 115      * the second dimension indexes the IndexHandler fields array.
 116      * For example, a value of {{1,2}, {2,3}} means that this field is
 117      * at position 2 of the IndexHandler at position 1 and
 118      * at position 3 of the IndexHandler at position 2 in the
 119      * DomainTypeHandler.
 120      */
 121     protected int[][] indices = new int[0][0];
 122
 123     /** The name of the field (property). */
 124     protected String name;
 125
 126     /** The type of the field (property). */
 127     protected Class<?> type;
 128
 129     /** If there is an ordered index on this field */
 130     protected boolean orderedIndex = false;
 131
 132     /** If there is a unique index on this field */
 133     protected boolean uniqueIndex = false;
 134
 135     /** If this is a primary key column */
 136     protected boolean primaryKey = false;
 137
 138     /** The composite domain field handlers */
 139     public AbstractDomainFieldHandlerImpl[] compositeDomainFieldHandlers = null;
 140
 141     /**
 142      * The type-specific anonymous class with methods
 143      * to set a value into an Operation or a managed Object.
 144      */
 145     protected ObjectOperationHandler objectOperationHandlerDelegate;
 146
 147     /** Provide a reason for a field not being able to be persistent. The reason
 148      * is added to the existing list of reasons.
 149      * @param message the reason
 150      */
 151     protected void error(String message) {
 152         if (errorMessages == null) {
 153             errorMessages = new StringBuffer(local.message("ERR_Field_Not_Valid", domainTypeHandler.getName(), name));
 154         }
 155         errorMessages.append(message);
 156         errorMessages.append('\n');
 157     }
 158
 159     public void filterCompareValue(Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
 160         if (value == null) {
 161             if (ScanFilter.BinaryCondition.COND_EQ.equals(condition)) {
 162                 filter.isNull(storeColumn);
 163                 return;
 164             } else {
 165                 throw new ClusterJUserException(
 166                         local.message("ERR_Null_Values_Can_Only_Be_Filtered_Equal",
 167                                 domainTypeHandler.getName(), name, condition));
 168             }
 169         }
 170         try {
 171             objectOperationHandlerDelegate.filterCompareValue(this, value, condition, filter);
 172         } catch (Exception ex) {
 173             throw new ClusterJDatastoreException(local.message("ERR_Filter_Value", name, columnName, objectOperationHandlerDelegate.handler(), value), ex);
 174         }
 175     }
 176
 177     public String getColumnName() {
 178         return columnName;
 179     }
 180
 181     public String[] getColumnNames() {
 182         return columnNames;
 183     }
 184
 185     public int getFieldNumber() {
 186         return fieldNumber;
 187     }
 188
 189     public Class<?> getType() {
 190         return type;
 191     }
 192
 193     public String getTypeName() {
 194         return (type==null)?"unknown":printableName(type);
 195     }
 196
 197     protected String printableName(Class<?> cls) {
 198         if (cls.isArray()) {
 199             return printableName(cls.getComponentType()) + "[] ";
 200         } else {
 201             return cls.getName();
 202         }
 203     }
 204
 205     public String getName() {
 206         return name;
 207     }
 208
 209     public boolean includedInIndex(String index) {
 210         return indexNames.contains(index);
 211     }
 212
 213     public boolean isPrimitive() {
 214         return objectOperationHandlerDelegate.isPrimitive();
 215     }
 216
 217     public boolean isPrimaryKey() {
 218         return primaryKey;
 219     }
 220
 221     public com.mysql.clusterj.core.store.Column getStoreColumn() {
 222         return storeColumn;
 223     }
 224
 225     public void markEqualBounds(CandidateIndexImpl[] candidateIndexImpls, PredicateImpl predicate) {
 226         for (int[] indexBounds : indices) {
 227             candidateIndexImpls[indexBounds[0]].markEqualBound(indexBounds[1], predicate);
 228         }
 229     }
 230
 231     public void markInBounds(CandidateIndexImpl[] candidateIndexImpls, InPredicateImpl predicate) {
 232         for (int[] indexBounds : indices) {
 233             candidateIndexImpls[indexBounds[0]].markInBound(indexBounds[1], predicate);
 234         }
 235     }
 236
 237     public void markLowerBounds(CandidateIndexImpl[] candidateIndexImpls, PredicateImpl predicate, boolean strict) {
 238         for (int[] indexBounds : indices) {
 239             candidateIndexImpls[indexBounds[0]].markLowerBound(indexBounds[1], predicate, strict);
 240         }
 241     }
 242
 243     public void markUpperBounds(CandidateIndexImpl[] candidateIndexImpls, PredicateImpl predicate, boolean strict) {
 244         for (int[] indexBounds : indices) {
 245             candidateIndexImpls[indexBounds[0]].markUpperBound(indexBounds[1], predicate, strict);
 246         }
 247     }
 248
 249     public Object getValue(QueryExecutionContext context, String index) {
 250         return objectOperationHandlerDelegate.getValue(context, index);
 251     }
 252
 253     void objectSetDefaultValue(ValueHandler handler) {
 254         objectOperationHandlerDelegate.objectInitializeJavaDefaultValue(this, handler);
 255     }
 256
 257     public void objectSetKeyValue(Object key, ValueHandler handler) {
 258         if (logger.isDetailEnabled()) {
 259             logger.detail("Setting value " + key + ".");
 260         }
 261         handler.setObject(fieldNumber, key);
 262     }
 263
 264     public void objectSetValue(ResultData rs, ValueHandler handler) {
 265         try {
 266             objectOperationHandlerDelegate.objectSetValue(this, rs, handler);
 267         } catch (Exception ex) {
 268             throw new ClusterJDatastoreException(local.message("ERR_Value_Delegate", name, columnName, objectOperationHandlerDelegate.handler(), "objectSetValue"), ex);
 269         }
 270     }
 271
 272     public void objectSetValueExceptIndex(ResultData rs, ValueHandler handler, String indexName) {
 273         try {
 274             if (!includedInIndex(indexName)) {
 275                 objectOperationHandlerDelegate.objectSetValue(this, rs, handler);
 276             }
 277         } catch (Exception ex) {
 278             throw new ClusterJDatastoreException(local.message("ERR_Value_Delegate", name, columnName, objectOperationHandlerDelegate.handler(), "objectSetValueExcept"), ex);
 279         }
 280     }
 281
 282     public void objectSetValueFor(Object value, Object row, String indexName) {
 283         if (includedInIndex(indexName)) {
 284             ValueHandler handler = (ValueHandler) Proxy.getInvocationHandler(row);
 285             handler.setObject(fieldNumber, value);
 286         }
 287     }
 288
 289     public void operationEqual(Object value, Operation op) {
 290         try {
 291             objectOperationHandlerDelegate.operationEqual(this, value, op);
 292         } catch (Exception ex) {
 293             ex.printStackTrace();
 294             throw new ClusterJDatastoreException(local.message("ERR_Value_Delegate", name, columnName, objectOperationHandlerDelegate.handler(), "operationEqual"), ex);
 295         }
 296     }
 297
 298     public void operationEqualForIndex(Object parameterValue, Operation op, String indexName) {
 299         throw new UnsupportedOperationException("Not yet implemented");
 300     }
 301
 302     public void operationGetValue(Operation op) {
 303         if (logger.isDetailEnabled()) {
 304             logger.detail("Column " + columnName + ".");
 305         }
 306         try {
 307             objectOperationHandlerDelegate.operationGetValue(this, op);
 308         } catch (Exception ex) {
 309             throw new ClusterJDatastoreException(local.message("ERR_Value_Delegate", name, columnName, objectOperationHandlerDelegate.handler(), "operationGetValue"), ex);
 310         }
 311     }
 312
 313     public void operationSetBounds(Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
 314         if (logger.isDetailEnabled()) {
 315             logger.detail("Column: " + columnName + " type: " + type + " value: " + value);
 316         }
 317         try {
 318             objectOperationHandlerDelegate.operationSetBounds(this, value, type, op);
 319         } catch (Exception ex) {
 320             throw new ClusterJDatastoreException(local.message("ERR_Value_Delegate", name, columnName, objectOperationHandlerDelegate.handler(), "operationSetBounds"), ex);
 321         }
 322     }
 323
 324     public void operationSetModifiedValue(ValueHandler handler, Operation op) {
 325         if (handler.isModified(fieldNumber)) {
 326             // delegate to operationSetValue to get NullValue behavior
 327             operationSetValue(handler, op);
 328         }
 329     }
 330
 331     public void operationSetValue(ValueHandler handler, Operation op) {
 332         if (logger.isDetailEnabled()) {
 333             logger.detail("Column: " + columnName + " field: " + name + " type: " + type + " delegate " + objectOperationHandlerDelegate.handler());
 334         }
 335         try {
 336             objectOperationHandlerDelegate.operationSetValue(this, handler, op);
 337         } catch (ClusterJDatastoreException ex) {
 338             throw new ClusterJDatastoreException(local.message("ERR_Value_Delegate", name, columnName, objectOperationHandlerDelegate.handler(), "operationSetValue"), ex);
 339         }
 340     }
 341
 342     public void operationSetValue(Object value, Operation op) {
 343         if (logger.isDetailEnabled()) {
 344             logger.detail("Column: " + columnName + " field: " + name + " type: " + type + " delegate " + objectOperationHandlerDelegate.handler());
 345         }
 346         try {
 347             objectOperationHandlerDelegate.operationSetValue(this, value, op);
 348         } catch (ClusterJDatastoreException ex) {
 349             throw new ClusterJDatastoreException(local.message("ERR_Value_Delegate", name, columnName, objectOperationHandlerDelegate.handler(), "operationSetValue"), ex);
 350         }
 351     }
 352
 353     protected void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
 354         try {
 355             objectOperationHandlerDelegate.operationSetValue(fmd, value, op);
 356         } catch (Exception ex) {
 357             throw new ClusterJDatastoreException(local.message("ERR_Value_Delegate", name, columnName, objectOperationHandlerDelegate.handler(), "operationSetValue"), ex);
 358         }
 359     }
 360
 361     public void partitionKeySetPart(PartitionKey result, ValueHandler handler) {
 362         try {
 363             objectOperationHandlerDelegate.partitionKeySetPart(this, result, handler);
 364         } catch (NullPointerException npe) {
 365             throw new ClusterJUserException(
 366                     local.message("ERR_Key_Must_Not_Be_Null",
 367                             domainTypeHandler.getName(), getName()));
 368         }
 369     }
 370
 371     protected static String formatBytes(int length, byte[] data) {
 372         int bytesToFormat = Math.min(length, data.length);
 373         StringBuffer buffer = new StringBuffer(":");
 374         for (int i = 0; i < bytesToFormat; ++i) {
 375             buffer.append("[");
 376             buffer.append(data[i]);
 377             buffer.append("]");
 378         }
 379         if (bytesToFormat < data.length) {
 380             buffer.append("...");
 381         }
 382         return buffer.toString();
 383     }
 384
 385     protected static java.util.Date parse(String dateString) {
 386         try {
 387             return new SimpleDateFormat().parse(dateString);
 388         } catch (ParseException ex) {
 389             throw new ClusterJUserException(local.message("ERR_Parse_Exception", dateString));
 390         }
 391     }
 392
 393     protected String printIndices() {
 394         StringBuffer buffer = new StringBuffer();
 395         buffer.append("indices[");
 396         buffer.append(indices.length);
 397         buffer.append("][]\n");
 398         for (int[] row : indices) {
 399             buffer.append(" row size ");
 400             buffer.append(row == null ? "null" : row.length);
 401             buffer.append(": ");
 402             buffer.append(row == null ? "" : row[0]);
 403             buffer.append(" ");
 404             buffer.append(row == null ? "" : row[1]);
 405             buffer.append("\n");
 406         }
 407         return buffer.toString();
 408     }
 409
 410     protected void reportErrors() {
 411         if (errorMessages != null) {
 412             throw new ClusterJUserException(errorMessages.toString());
 413         }
 414     }
 415
 416     @Override
 417     public String toString() {
 418         return name;
 419     }
 420
 421     public void validateIndexType(String indexName, boolean hash) {
 422         if (objectOperationHandlerDelegate == null || !(objectOperationHandlerDelegate.isValidIndexType(this, hash))) {
 423             error (local.message("ERR_Invalid_Index_For_Type",
 424                     domainTypeHandler.getName(), name, columnName, indexName, hash?"hash":"btree"));
 425         }
 426     }
 427
 428     protected static interface ObjectOperationHandler {
 429
 430         boolean isPrimitive();
 431
 432         Object getValue(QueryExecutionContext context, String index);
 433
 434         void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler);
 435
 436         void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op);
 437
 438         Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue);
 439
 440         void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op);
 441
 442         void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op);
 443
 444         String handler();
 445
 446         void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler);
 447
 448         void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op);
 449
 450         void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter);
 451
 452         void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op);
 453
 454         boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered);
 455
 456         void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd, PartitionKey partitionKey, ValueHandler keyValueHandler);
 457     }
 458
 459     protected static ObjectOperationHandler objectOperationHandlerByte = new ObjectOperationHandler() {
 460
 461         public boolean isPrimitive() {
 462             return true;
 463         }
 464
 465         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
 466             handler.setByte(fmd.fieldNumber, (byte) 0);
 467         }
 468
 469         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
 470             op.getValue(fmd.storeColumn);
 471         }
 472
 473         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
 474             return (Byte) (columnDefaultValue == null ? Byte.valueOf((byte)0) : Byte.valueOf(columnDefaultValue));
 475         }
 476
 477         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
 478             op.setByte(fmd.storeColumn, (Byte) value);
 479         }
 480
 481         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
 482             if (logger.isDetailEnabled()) {
 483                 logger.detail("Column " + fmd.columnName + " set to value " + handler.getByte(fmd.fieldNumber));
 484             }
 485             op.setByte(fmd.storeColumn, handler.getObjectByte(fmd.fieldNumber).byteValue());
 486         }
 487
 488         public String handler() {
 489             return "setByte";
 490         }
 491
 492         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
 493             handler.setByte(fmd.fieldNumber, rs.getByte(fmd.storeColumn));
 494         }
 495
 496         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
 497             op.setBoundByte(fmd.storeColumn, type, ((Number)value).byteValue());
 498         }
 499
 500         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
 501             filter.cmpByte(condition, fmd.storeColumn, ((Number) value).byteValue());
 502         }
 503
 504         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
 505             if (logger.isDetailEnabled()) {
 506                 logger.detail("setInt.setEqual " + fmd.columnName + " to value " + value);
 507             }
 508             op.equalByte(fmd.storeColumn, ((Number) value).byteValue());
 509         }
 510
 511         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
 512             return true;
 513         }
 514
 515         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
 516                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
 517             throw new ClusterJFatalInternalException(
 518                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
 519         }
 520
 521         public Object getValue(QueryExecutionContext context, String index) {
 522             return context.getByte(index);
 523         }
 524
 525     };
 526
 527     protected static ObjectOperationHandler objectOperationHandlerBoolean = new ObjectOperationHandler() {
 528
 529         public boolean isPrimitive() {
 530             return true;
 531         }
 532
 533         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
 534             handler.setBoolean(fmd.fieldNumber, false);
 535         }
 536
 537         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
 538             op.getValue(fmd.storeColumn);
 539         }
 540
 541         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
 542             return (Boolean) (columnDefaultValue == null ? Boolean.FALSE : Boolean.valueOf(columnDefaultValue));
 543         }
 544
 545         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
 546             op.setBoolean(fmd.storeColumn, (Boolean)value);
 547         }
 548
 549         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
 550             op.setBoolean(fmd.storeColumn, handler.getBoolean(fmd.fieldNumber));
 551         }
 552
 553         public String handler() {
 554             return "setBoolean";
 555         }
 556
 557         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
 558             handler.setBoolean(fmd.fieldNumber, rs.getBoolean(fmd.storeColumn));
 559         }
 560
 561         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
 562             throw new ClusterJFatalInternalException(local.message("ERR_NotImplemented"));
 563         }
 564
 565         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
 566             filter.cmpBoolean(condition, fmd.storeColumn, ((Boolean) value).booleanValue());
 567         }
 568
 569         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
 570             op.equalBoolean(fmd.storeColumn, ((Boolean)value).booleanValue());
 571         }
 572
 573         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
 574             return false;
 575         }
 576
 577         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
 578                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
 579             throw new ClusterJFatalInternalException(
 580                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
 581         }
 582
 583         public Object getValue(QueryExecutionContext context, String index) {
 584             return context.getBoolean(index);
 585         }
 586
 587     };
 588
 589     protected static ObjectOperationHandler objectOperationHandlerObjectBoolean = new ObjectOperationHandler() {
 590
 591         public boolean isPrimitive() {
 592             return false;
 593         }
 594
 595         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
 596             handler.setBoolean(fmd.fieldNumber, false);
 597         }
 598
 599         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
 600             op.getValue(fmd.storeColumn);
 601         }
 602
 603         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
 604             return (Boolean)(columnDefaultValue == null ? Boolean.FALSE : Boolean.valueOf(columnDefaultValue));
 605         }
 606
 607         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
 608             op.setBoolean(fmd.storeColumn, (Boolean)value);
 609         }
 610
 611         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
 612             if (handler.isNull(fmd.fieldNumber)) {
 613                 op.setNull(fmd.storeColumn);
 614             } else {
 615             op.setBoolean(fmd.storeColumn, handler.getBoolean(fmd.fieldNumber));
 616             }
 617         }
 618
 619         public String handler() {
 620             return "setObjectBoolean";
 621         }
 622
 623         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
 624             handler.setObjectBoolean(fmd.fieldNumber, rs.getObjectBoolean(fmd.storeColumn));
 625         }
 626
 627         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
 628             throw new ClusterJFatalInternalException(local.message("ERR_NotImplemented"));
 629         }
 630
 631         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
 632             filter.cmpBoolean(condition, fmd.storeColumn, ((Boolean) value).booleanValue());
 633         }
 634
 635         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
 636             op.equalBoolean(fmd.storeColumn, ((Boolean)value).booleanValue());
 637         }
 638
 639         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
 640             return false;
 641         }
 642
 643         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
 644                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
 645             throw new ClusterJFatalInternalException(
 646                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
 647         }
 648
 649         public Object getValue(QueryExecutionContext context, String index) {
 650             return context.getBoolean(index);
 651         }
 652
 653     };
 654
 655     protected static ObjectOperationHandler objectOperationHandlerBytes = new ObjectOperationHandler() {
 656
 657         public boolean isPrimitive() {
 658             return false;
 659         }
 660
 661         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
 662         }
 663
 664         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
 665             op.getValue(fmd.storeColumn);
 666         }
 667
 668         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
 669             if (columnDefaultValue == null) {
 670                 return new byte[]{};
 671             } else {
 672                 throw new UnsupportedOperationException(local.message("ERR_Convert_String_To_Value", columnDefaultValue, "byte[]"));
 673             }
 674         }
 675
 676         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
 677             if (value == null) {
 678                 op.setNull(fmd.storeColumn);
 679             } else {
 680                 op.setBytes(fmd.storeColumn, (byte[]) value);
 681             }
 682         }
 683
 684         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
 685             byte[] value = handler.getBytes(fmd.fieldNumber);
 686             if (value == null) {
 687                 op.setNull(fmd.storeColumn);
 688             } else {
 689                 op.setBytes(fmd.storeColumn, value);
 690             }
 691         }
 692
 693         public String handler() {
 694             return "setBytes";
 695         }
 696
 697         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
 698             handler.setBytes(fmd.fieldNumber, rs.getBytes(fmd.storeColumn));
 699         }
 700
 701         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
 702             op.setBoundBytes(fmd.storeColumn, type, (byte[]) value);
 703         }
 704
 705         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
 706             filter.cmpBytes(condition, fmd.storeColumn, (byte[]) value);
 707         }
 708
 709         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
 710             if (logger.isDetailEnabled()) {
 711                 logger.detail("setBytes.setEqual " + fmd.columnName + " to value " + value);
 712             }
 713             op.equalBytes(fmd.storeColumn, (byte[]) value);
 714         }
 715
 716         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
 717             return true;
 718         }
 719
 720         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
 721                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
 722             throw new ClusterJFatalInternalException(
 723                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
 724         }
 725
 726         public Object getValue(QueryExecutionContext context, String index) {
 727             return context.getBytes(index);
 728         }
 729
 730     };
 731
 732     protected static ObjectOperationHandler objectOperationHandlerKeyBytes = new ObjectOperationHandler() {
 733
 734         public boolean isPrimitive() {
 735             return false;
 736         }
 737
 738         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
 739         }
 740
 741         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
 742             op.getValue(fmd.storeColumn);
 743         }
 744
 745         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
 746             if (columnDefaultValue == null) {
 747                 return emptyByteArray;
 748             } else {
 749                 throw new UnsupportedOperationException(local.message("ERR_Convert_String_To_Value", columnDefaultValue, "byte[]"));
 750             }
 751         }
 752
 753         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
 754             op.equalBytes(fmd.storeColumn, (byte[]) value);
 755         }
 756
 757         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
 758             byte[] value = handler.getBytes(fmd.fieldNumber);
 759             op.equalBytes(fmd.storeColumn, value);
 760         }
 761
 762         public String handler() {
 763             return "setKeyBytes";
 764         }
 765
 766         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
 767             handler.setBytes(fmd.fieldNumber, rs.getBytes(fmd.storeColumn));
 768         }
 769
 770         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
 771             op.setBoundBytes(fmd.storeColumn, type, (byte[]) value);
 772         }
 773
 774         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
 775             filter.cmpBytes(condition, fmd.storeColumn, (byte[]) value);
 776         }
 777
 778         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
 779             if (logger.isDetailEnabled()) {
 780                 logger.detail("setBytes.setEqual " + fmd.columnName + " to value " + value);
 781             }
 782             op.equalBytes(fmd.storeColumn, (byte[]) value);
 783         }
 784
 785         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
 786             return true;
 787         }
 788
 789         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
 790                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
 791             partitionKey.addBytesKey(fmd.storeColumn, keyValueHandler.getBytes(fmd.fieldNumber));
 792         }
 793
 794         public Object getValue(QueryExecutionContext context, String index) {
 795             return context.getBytes(index);
 796         }
 797
 798     };
 799
 800     protected static ObjectOperationHandler objectOperationHandlerBytesLob = new ObjectOperationHandler() {
 801
 802         public boolean isPrimitive() {
 803             return false;
 804         }
 805
 806         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
 807         }
 808
 809         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
 810             op.getBlob(fmd.storeColumn);
 811         }
 812
 813         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
 814             if (columnDefaultValue == null) {
 815                 return new byte[]{};
 816             } else {
 817                 throw new UnsupportedOperationException(local.message("ERR_Convert_String_To_Value", columnDefaultValue, "byte[]"));
 818             }
 819         }
 820
 821         public void operationSetValue(final AbstractDomainFieldHandlerImpl fmd, final Object value, final Operation op) {
 822             Blob blob = op.getBlobHandle(fmd.storeColumn);
 823             if (value == null) {
 824                 blob.setNull();
 825             } else {
 826                 // set an empty blob first, and later replace it with the real value
 827                 blob.setValue(emptyByteArray);
 828                 Runnable callback = new Runnable() {
 829
 830                     public void run() {
 831                         Blob blob = op.getBlobHandle(fmd.storeColumn);
 832                         byte[] data = (byte[]) value;
 833                         int length = data.length;
 834                         if (logger.isDetailEnabled()) {
 835                             logger.detail("Value to operation set blob value for field " + fmd.name + " for column " + fmd.columnName + " wrote length " + length + formatBytes(16, data));
 836                         }
 837                         blob.writeData(data);
 838                     }
 839                 };
 840                 op.postExecuteCallback(callback);
 841             }
 842         }
 843
 844         public void operationSetValue(final AbstractDomainFieldHandlerImpl fmd, final ValueHandler handler, final Operation op) {
 845             Blob blob = op.getBlobHandle(fmd.storeColumn);
 846             if (handler.isNull(fmd.fieldNumber)) {
 847                 blob.setNull();
 848             } else {
 849                 // set an empty blob first, and later replace it with the real value
 850                 blob.setValue(emptyByteArray);
 851                 Runnable callback = new Runnable() {
 852
 853                     public void run() {
 854                         Blob blob = op.getBlobHandle(fmd.storeColumn);
 855                         byte[] data = handler.getBytes(fmd.fieldNumber);
 856                         int length = data.length;
 857                         if (logger.isDetailEnabled()) {
 858                             logger.detail("Value to operation set blob value for field " + fmd.name + " for column " + fmd.columnName + " wrote length " + length + formatBytes(16, data));
 859                         }
 860                         blob.writeData(data);
 861                     }
 862                 };
 863                 op.postExecuteCallback(callback);
 864             }
 865         }
 866
 867         public String handler() {
 868             return "setBytesLob";
 869         }
 870
 871         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
 872             Blob blob = rs.getBlob(fmd.storeColumn);
 873             int length = blob.getLength().intValue();
 874             byte[] data = new byte[length];
 875             blob.readData(data, length);
 876             if (logger.isDetailEnabled()) {
 877                 logger.detail("ResultSet get blob value for field " + fmd.name + " for column " + fmd.columnName + " returned length " + length + formatBytes(16, data));
 878             }
 879             blob.close();
 880             handler.setBytes(fmd.fieldNumber, data);
 881         }
 882
 883         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
 884             throw new UnsupportedOperationException(local.message("ERR_NotImplemented"));
 885         }
 886
 887         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
 888             throw new UnsupportedOperationException(local.message("ERR_NotImplemented"));
 889         }
 890
 891         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
 892             throw new UnsupportedOperationException(local.message("ERR_NotImplemented"));
 893         }
 894
 895         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
 896             return false;
 897         }
 898
 899         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
 900                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
 901             throw new ClusterJFatalInternalException(
 902                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
 903         }
 904
 905         public Object getValue(QueryExecutionContext context, String index) {
 906             return context.getBoolean(index);
 907         }
 908
 909     };
 910
 911     protected static ObjectOperationHandler objectOperationHandlerStringLob = new ObjectOperationHandler() {
 912
 913         public boolean isPrimitive() {
 914             return false;
 915         }
 916
 917         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
 918         }
 919
 920         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
 921             op.getBlob(fmd.storeColumn);
 922         }
 923
 924         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
 925             if (columnDefaultValue == null) {
 926                 return "";
 927             } else {
 928                 return columnDefaultValue;
 929             }
 930         }
 931
 932         public void operationSetValue(final AbstractDomainFieldHandlerImpl fmd, final Object value, final Operation op) {
 933             Blob blob = op.getBlobHandle(fmd.storeColumn);
 934             if (value == null) {
 935                 blob.setNull();
 936             } else {
 937                 // set an empty blob first, and later replace it with the real value
 938                 blob.setValue(emptyByteArray);
 939                 Runnable callback = new Runnable() {
 940
 941                     public void run() {
 942                         Blob blob = op.getBlobHandle(fmd.storeColumn);
 943                         byte[] data = fmd.storeColumn.encode((String)value);
 944                         int length = data.length;
 945                         if (logger.isDetailEnabled()) {
 946                             logger.detail("Value to operation set text value for field " + fmd.name + " for column " + fmd.columnName + " wrote length " + length + formatBytes(16, data));
 947                         }
 948                         blob.writeData(data);
 949                     }
 950                 };
 951                 op.postExecuteCallback(callback);
 952             }
 953         }
 954
 955         public void operationSetValue(final AbstractDomainFieldHandlerImpl fmd, final ValueHandler handler, final Operation op) {
 956             Blob blob = op.getBlobHandle(fmd.storeColumn);
 957             if (handler.isNull(fmd.fieldNumber)) {
 958                 blob.setNull();
 959             } else {
 960                 // set an empty blob first, and later replace it with the real value
 961                 blob.setValue(emptyByteArray);
 962                 Runnable callback = new Runnable() {
 963
 964                     public void run() {
 965                         Blob blob = op.getBlobHandle(fmd.storeColumn);
 966                         byte[] data = fmd.storeColumn.encode(handler.getString(fmd.fieldNumber));
 967                         int length = data.length;
 968                         if (logger.isDetailEnabled()) {
 969                             logger.detail("Value to operation set text value for field " + fmd.name + " for column " + fmd.columnName + " wrote length " + length + formatBytes(16, data));
 970                         }
 971                         blob.writeData(data);
 972                     }
 973                 };
 974                 op.postExecuteCallback(callback);
 975             }
 976         }
 977
 978         public String handler() {
 979             return "setStringLob";
 980         }
 981
 982         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
 983             Blob blob = rs.getBlob(fmd.storeColumn);
 984             int length = blob.getLength().intValue();
 985             byte[] data = new byte[length];
 986             blob.readData(data, length);
 987             if (logger.isDetailEnabled()) {
 988                 logger.detail("ResultSet get text value for field " + fmd.name + " for column " + fmd.columnName + " returned length " + length + formatBytes(16, data));
 989             }
 990             blob.close();
 991             handler.setString(fmd.fieldNumber, fmd.storeColumn.decode(data));
 992         }
 993
 994         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
 995             throw new UnsupportedOperationException(local.message("ERR_NotImplemented"));
 996         }
 997
 998         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
 999             throw new UnsupportedOperationException(local.message("ERR_NotImplemented"));
1000         }
1001
1002         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1003             throw new UnsupportedOperationException(local.message("ERR_NotImplemented"));
1004         }
1005
1006         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
1007             return false;
1008         }
1009
1010         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1011                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1012             throw new ClusterJFatalInternalException(
1013                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
1014         }
1015
1016         public Object getValue(QueryExecutionContext context, String index) {
1017             return context.getString(index);
1018         }
1019
1020     };
1021
1022     protected static ObjectOperationHandler objectOperationHandlerDecimal = new ObjectOperationHandler() {
1023
1024         public boolean isPrimitive() {
1025             return false;
1026         }
1027
1028         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
1029         }
1030
1031         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
1032             op.getValue(fmd.storeColumn);
1033         }
1034
1035         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
1036             return (BigDecimal) (columnDefaultValue == null ? BigDecimal.ZERO : new BigDecimal(columnDefaultValue));
1037         }
1038
1039         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1040             op.setDecimal(fmd.storeColumn, (BigDecimal) value);
1041         }
1042
1043         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1044             if (handler.isNull(fmd.fieldNumber)) {
1045                 op.setNull(fmd.storeColumn);
1046             } else {
1047                 op.setDecimal(fmd.storeColumn, handler.getBigDecimal(fmd.fieldNumber));
1048             }
1049         }
1050
1051         public String handler() {
1052             return "object BigDecimal";
1053         }
1054
1055         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
1056             handler.setBigDecimal(fmd.fieldNumber, rs.getDecimal(fmd.storeColumn));
1057         }
1058
1059         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
1060             op.setBoundDecimal(fmd.storeColumn, type, (BigDecimal) value);
1061         }
1062
1063         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
1064             filter.cmpDecimal(condition, fmd.storeColumn, (BigDecimal) value);
1065         }
1066
1067         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1068             if (logger.isDetailEnabled()) {
1069                 logger.detail("setDecimal.setEqual " + fmd.columnName + " to value " + value);
1070             }
1071             op.equalDecimal(fmd.storeColumn, (BigDecimal) value);
1072         }
1073
1074         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
1075             return true;
1076         }
1077
1078         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1079                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1080             throw new ClusterJFatalInternalException(
1081                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
1082         }
1083
1084         public Object getValue(QueryExecutionContext context, String index) {
1085             return context.getBigDecimal(index);
1086         }
1087
1088     };
1089
1090     protected static ObjectOperationHandler objectOperationHandlerBigInteger = new ObjectOperationHandler() {
1091
1092         public boolean isPrimitive() {
1093             return false;
1094         }
1095
1096         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
1097         }
1098
1099         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
1100             op.getValue(fmd.storeColumn);
1101         }
1102
1103         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
1104             return (BigInteger)(columnDefaultValue == null ? BigInteger.ZERO : new BigInteger(columnDefaultValue));
1105         }
1106
1107         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1108             op.setBigInteger(fmd.storeColumn, (BigInteger)value);
1109         }
1110
1111         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1112             if (handler.isNull(fmd.fieldNumber)) {
1113                 op.setNull(fmd.storeColumn);
1114             } else {
1115                 op.setBigInteger(fmd.storeColumn, handler.getBigInteger(fmd.fieldNumber));
1116             }
1117         }
1118
1119         public String handler() {
1120             return "object BigInteger";
1121         }
1122
1123         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
1124             handler.setBigInteger(fmd.fieldNumber, rs.getBigInteger(fmd.storeColumn));
1125         }
1126
1127         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
1128             op.setBoundBigInteger(fmd.storeColumn, type, (BigInteger)value);
1129         }
1130
1131         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
1132             filter.cmpBigInteger(condition, fmd.storeColumn, (BigInteger)value);
1133         }
1134
1135         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1136             if (logger.isDetailEnabled()) {
1137                 logger.detail("setDecimal.setEqual " + fmd.columnName + " to value " + value);
1138             }
1139             op.equalBigInteger(fmd.storeColumn, (BigInteger)value);
1140         }
1141
1142         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
1143             return true;
1144         }
1145
1146         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1147                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1148             throw new ClusterJFatalInternalException(
1149                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
1150         }
1151
1152         public Object getValue(QueryExecutionContext context, String index) {
1153             return context.getBigInteger(index);
1154         }
1155
1156     };
1157
1158     protected static ObjectOperationHandler objectOperationHandlerDouble = new ObjectOperationHandler() {
1159
1160         public boolean isPrimitive() {
1161             return true;
1162         }
1163
1164         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
1165             handler.setDouble(fmd.fieldNumber, 0.0D);
1166         }
1167
1168         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
1169             op.getValue(fmd.storeColumn);
1170         }
1171
1172         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
1173             return (Double) (columnDefaultValue == null ? Double.valueOf("0") : Double.valueOf(columnDefaultValue));
1174         }
1175
1176         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1177             op.setDouble(fmd.storeColumn, (Double) value);
1178         }
1179
1180         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1181             op.setDouble(fmd.storeColumn, handler.getDouble(fmd.fieldNumber));
1182         }
1183
1184         public String handler() {
1185             return "primitive double";
1186         }
1187
1188         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
1189             handler.setDouble(fmd.fieldNumber, rs.getDouble(fmd.storeColumn));
1190         }
1191
1192         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
1193             op.setBoundDouble(fmd.storeColumn, type, (Double) value);
1194         }
1195
1196         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
1197             filter.cmpDouble(condition, fmd.storeColumn, ((Double) value).doubleValue());
1198         }
1199
1200         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1201             op.equalDouble(fmd.storeColumn, (Double)value);
1202         }
1203
1204         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
1205             return true;
1206         }
1207
1208         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1209                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1210             throw new ClusterJFatalInternalException(
1211                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
1212         }
1213
1214         public Object getValue(QueryExecutionContext context, String index) {
1215             return context.getDouble(index);
1216         }
1217
1218     };
1219
1220     protected static ObjectOperationHandler objectOperationHandlerFloat = new ObjectOperationHandler() {
1221
1222         public boolean isPrimitive() {
1223             return true;
1224         }
1225
1226         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
1227             handler.setFloat(fmd.fieldNumber, 0.0F);
1228         }
1229
1230         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
1231             op.getValue(fmd.storeColumn);
1232         }
1233
1234         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
1235             return (Float) (columnDefaultValue == null ? Float.valueOf("0") : Float.valueOf(columnDefaultValue));
1236         }
1237
1238         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1239             op.setFloat(fmd.storeColumn, (Float) value);
1240         }
1241
1242         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1243             op.setFloat(fmd.storeColumn, handler.getFloat(fmd.fieldNumber));
1244         }
1245
1246         public String handler() {
1247             return "primitive float";
1248         }
1249
1250         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
1251             handler.setFloat(fmd.fieldNumber, rs.getFloat(fmd.storeColumn));
1252         }
1253
1254         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
1255             op.setBoundFloat(fmd.storeColumn, type, (Float) value);
1256         }
1257
1258         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
1259             filter.cmpFloat(condition, fmd.storeColumn, ((Float) value).floatValue());
1260         }
1261
1262         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1263             op.equalFloat(fmd.storeColumn, (Float)value);
1264         }
1265
1266         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
1267             return true;
1268         }
1269
1270         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1271                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1272             throw new ClusterJFatalInternalException(
1273                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
1274         }
1275
1276         public Object getValue(QueryExecutionContext context, String index) {
1277             return context.getFloat(index);
1278         }
1279
1280     };
1281
1282     protected abstract static class ObjectOperationHandlerInt implements ObjectOperationHandler {
1283
1284         public boolean isPrimitive() {
1285             return true;
1286         }
1287
1288         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
1289             handler.setInt(fmd.fieldNumber, 0);
1290         }
1291
1292         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
1293             op.getValue(fmd.storeColumn);
1294         }
1295
1296         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
1297             return (Integer) (columnDefaultValue == null ? Integer.valueOf(0) : Integer.valueOf(columnDefaultValue));
1298         }
1299
1300         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1301             op.setInt(fmd.storeColumn, (Integer) value);
1302         }
1303
1304         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
1305             int value = rs.getInt(fmd.storeColumn);
1306             if (logger.isDetailEnabled()) {
1307                 logger.detail("Field " + fmd.name + " from column " + fmd.columnName + " set to value " + value);
1308             }
1309             handler.setInt(fmd.fieldNumber, value);
1310         }
1311
1312         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
1313             op.setBoundInt(fmd.storeColumn, type, (Integer) value);
1314         }
1315
1316         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
1317             filter.cmpInt(condition, fmd.storeColumn, ((Integer) value).intValue());
1318         }
1319
1320         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1321             if (logger.isDetailEnabled()) {
1322                 logger.detail("setEqual " + fmd.columnName + " to value " + value);
1323             }
1324             op.equalInt(fmd.storeColumn, ((Integer) value).intValue());
1325         }
1326
1327         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
1328             return true;
1329         }
1330
1331         public Object getValue(QueryExecutionContext context, String index) {
1332             return context.getInt(index);
1333         }
1334
1335     };
1336
1337     protected static ObjectOperationHandler objectOperationHandlerInt = new ObjectOperationHandlerInt() {
1338
1339         public String handler() {
1340             return "primitive int";
1341         }
1342
1343         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1344             if (logger.isDetailEnabled()) {
1345                 logger.detail("Column " + fmd.columnName + " set to value " + handler.getInt(fmd.fieldNumber));
1346             }
1347             op.setInt(fmd.storeColumn, handler.getInt(fmd.fieldNumber));
1348         }
1349
1350         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1351                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1352             throw new ClusterJFatalInternalException(
1353                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
1354         }
1355
1356     };
1357
1358     protected static ObjectOperationHandler objectOperationHandlerKeyInt = new ObjectOperationHandlerInt() {
1359
1360         public String handler() {
1361             return "primitive key int";
1362         }
1363
1364         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1365             if (logger.isDetailEnabled()) {
1366                 logger.detail("Key field " + fmd.name + " set equal to value " + handler.getInt(fmd.getFieldNumber()));
1367             }
1368             op.equalInt(fmd.storeColumn, handler.getInt(fmd.fieldNumber));
1369         }
1370
1371         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1372                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1373             partitionKey.addIntKey(fmd.storeColumn, keyValueHandler.getInt(fmd.fieldNumber));
1374         }
1375
1376     };
1377
1378     protected static ObjectOperationHandler objectOperationHandlerJavaSqlDate = new ObjectOperationHandler() {
1379
1380         public boolean isPrimitive() {
1381             return false;
1382         }
1383
1384         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
1385         }
1386
1387         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
1388             op.getValue(fmd.storeColumn);
1389         }
1390
1391         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
1392             if (columnDefaultValue == null) {
1393                 return new Date(new java.util.Date().getTime());
1394             } else {
1395                 // string is converted using SQL date handler
1396                 return Date.valueOf(columnDefaultValue);
1397             }
1398         }
1399
1400         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1401             op.setLong(fmd.storeColumn, ((Date)value).getTime());
1402         }
1403
1404         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1405             if (handler.isNull(fmd.fieldNumber)) {
1406                 op.setNull(fmd.storeColumn);
1407             } else {
1408                 op.setLong(fmd.storeColumn, (handler.getJavaSqlDate(fmd.fieldNumber)).getTime());
1409             }
1410         }
1411
1412         public String handler() {
1413             return "object java.sql.Date";
1414         }
1415
1416         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
1417             try {
1418                 handler.setJavaSqlDate(fmd.fieldNumber, new Date(rs.getLong(fmd.storeColumn)));
1419             } catch (Exception ex) {
1420                 throw new ClusterJDatastoreException(local.message("ERR_Set_Value", fmd.objectOperationHandlerDelegate.handler()), ex);
1421             }
1422         }
1423
1424         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
1425             op.setBoundLong(fmd.storeColumn, type, ((Date)value).getTime());
1426         }
1427
1428         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
1429             filter.cmpLong(condition, fmd.storeColumn, ((Date)value).getTime());
1430         }
1431
1432         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1433             op.equalLong(fmd.storeColumn, ((Date)value).getTime());
1434         }
1435
1436         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
1437             return true;
1438         }
1439
1440         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1441                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1442             throw new ClusterJFatalInternalException(
1443                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
1444         }
1445
1446         public Object getValue(QueryExecutionContext context, String index) {
1447             return context.getJavaSqlDate(index);
1448         }
1449
1450     };
1451
1452     protected static ObjectOperationHandler objectOperationHandlerJavaSqlTime = new ObjectOperationHandler() {
1453
1454         public boolean isPrimitive() {
1455             return false;
1456         }
1457
1458         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
1459         }
1460
1461         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
1462             op.getValue(fmd.storeColumn);
1463         }
1464
1465         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
1466             if (columnDefaultValue == null) {
1467                 return new Time(new java.util.Date().getTime());
1468             } else {
1469                 // string is converted using SQL time handler
1470                 return Time.valueOf(columnDefaultValue);
1471             }
1472         }
1473
1474         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1475             op.setLong(fmd.storeColumn, ((Time)value).getTime());
1476         }
1477
1478         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1479             if (handler.isNull(fmd.fieldNumber)) {
1480                 op.setNull(fmd.storeColumn);
1481             } else {
1482                 op.setLong(fmd.storeColumn, (handler.getJavaSqlTime(fmd.fieldNumber)).getTime());
1483             }
1484         }
1485
1486         public String handler() {
1487             return "object java.sql.Time";
1488         }
1489
1490         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
1491             handler.setJavaSqlTime(fmd.fieldNumber, new Time(rs.getLong(fmd.storeColumn)));
1492         }
1493
1494         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
1495             op.setBoundLong(fmd.storeColumn, type, ((Time)value).getTime());
1496         }
1497
1498         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
1499             filter.cmpLong(condition, fmd.storeColumn, ((Time)value).getTime());
1500         }
1501
1502         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1503             op.equalLong(fmd.storeColumn, ((Time)value).getTime());
1504         }
1505
1506         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
1507             return true;
1508         }
1509
1510         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1511                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1512             throw new ClusterJFatalInternalException(
1513                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
1514         }
1515
1516         public Object getValue(QueryExecutionContext context, String index) {
1517             return context.getJavaSqlTime(index);
1518         }
1519
1520     };
1521
1522     protected static ObjectOperationHandler objectOperationHandlerJavaSqlTimestamp = new ObjectOperationHandler() {
1523
1524         public boolean isPrimitive() {
1525             return false;
1526         }
1527
1528         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
1529         }
1530
1531         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
1532             op.getValue(fmd.storeColumn);
1533         }
1534
1535         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
1536             if (columnDefaultValue == null) {
1537                 return new Timestamp(new java.util.Date().getTime());
1538             } else {
1539                 // string is converted using SQL timestamp handler
1540                 return Timestamp.valueOf(columnDefaultValue);
1541             }
1542         }
1543
1544         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1545             op.setLong(fmd.storeColumn, ((Timestamp)value).getTime());
1546         }
1547
1548         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1549             if (handler.isNull(fmd.fieldNumber)) {
1550                 op.setNull(fmd.storeColumn);
1551             } else {
1552                 op.setLong(fmd.storeColumn, (handler.getJavaSqlTimestamp(fmd.fieldNumber).getTime()));
1553             }
1554         }
1555
1556         public String handler() {
1557             return "object java.sql.Timestamp";
1558         }
1559
1560         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
1561             handler.setJavaSqlTimestamp(fmd.fieldNumber, new Timestamp(rs.getLong(fmd.storeColumn)));
1562         }
1563
1564         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
1565             op.setBoundLong(fmd.storeColumn, type, ((Timestamp)value).getTime());
1566         }
1567
1568         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
1569             filter.cmpLong(condition, fmd.storeColumn, ((Timestamp)value).getTime());
1570         }
1571
1572         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1573             op.equalLong(fmd.storeColumn, ((Timestamp)value).getTime());
1574         }
1575
1576         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
1577             return true;
1578         }
1579
1580         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1581                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1582             throw new ClusterJFatalInternalException(
1583                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
1584         }
1585
1586         public Object getValue(QueryExecutionContext context, String index) {
1587             return context.getJavaSqlTimestamp(index);
1588         }
1589
1590     };
1591
1592     protected static ObjectOperationHandler objectOperationHandlerJavaUtilDate = new ObjectOperationHandler() {
1593
1594         public boolean isPrimitive() {
1595             return false;
1596         }
1597
1598         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
1599         }
1600
1601         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
1602             op.getValue(fmd.storeColumn);
1603         }
1604
1605         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
1606             if (columnDefaultValue == null) {
1607                 return new java.util.Date();
1608             } else {
1609                 // any other string is converted using SQL timestamp handler
1610                 return parse(columnDefaultValue);
1611             }
1612         }
1613
1614         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1615             op.setLong(fmd.storeColumn, ((java.util.Date)value).getTime());
1616         }
1617
1618         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1619             if (handler.isNull(fmd.fieldNumber)) {
1620                 op.setNull(fmd.storeColumn);
1621             } else {
1622                 op.setLong(fmd.storeColumn, (handler.getJavaUtilDate(fmd.fieldNumber)).getTime());
1623             }
1624         }
1625
1626         public String handler() {
1627             return "object java.util.Date";
1628         }
1629
1630         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
1631             handler.setJavaUtilDate(fmd.fieldNumber, new java.util.Date(rs.getLong(fmd.storeColumn)));
1632         }
1633
1634         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
1635             op.setBoundLong(fmd.storeColumn, type, ((java.util.Date)value).getTime());
1636         }
1637
1638         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
1639             filter.cmpLong(condition, fmd.storeColumn, ((java.util.Date)value).getTime());
1640         }
1641
1642         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1643             op.equalLong(fmd.storeColumn, ((java.util.Date)value).getTime());
1644         }
1645
1646         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
1647             return true;
1648         }
1649
1650         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1651                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1652             throw new ClusterJFatalInternalException(
1653                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
1654         }
1655
1656         public Object getValue(QueryExecutionContext context, String index) {
1657             return context.getJavaUtilDate(index);
1658         }
1659
1660     };
1661
1662     protected static ObjectOperationHandler objectOperationHandlerKeyString = new ObjectOperationHandler() {
1663
1664         public boolean isPrimitive() {
1665             return false;
1666         }
1667
1668         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
1669         }
1670
1671         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
1672             op.getValue(fmd.storeColumn);
1673         }
1674
1675         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
1676             return (String) (columnDefaultValue == null ? "" : columnDefaultValue);
1677         }
1678
1679         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1680             op.setString(fmd.storeColumn, (String) value);
1681         }
1682
1683         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1684             op.equalString(fmd.storeColumn, handler.getString(fmd.fieldNumber));
1685         }
1686
1687         public String handler() {
1688             return "key String";
1689         }
1690
1691         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
1692             handler.setString(fmd.fieldNumber, rs.getString(fmd.storeColumn));
1693         }
1694
1695         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
1696             op.setBoundString(fmd.storeColumn, type, (String) value);
1697         }
1698
1699         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
1700             filter.cmpString(condition, fmd.storeColumn, (String)value);
1701         }
1702
1703         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1704             if (logger.isDetailEnabled()) {
1705                 logger.detail("setString.setEqual " + fmd.columnName + " to value " + value);
1706             }
1707             op.equalString(fmd.storeColumn, (String)value);
1708         }
1709
1710         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
1711             return true;
1712         }
1713
1714         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1715                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1716             partitionKey.addStringKey(fmd.storeColumn, keyValueHandler.getString(fmd.fieldNumber));
1717         }
1718
1719         public Object getValue(QueryExecutionContext context, String index) {
1720             return context.getString(index);
1721         }
1722
1723     };
1724
1725     public abstract static class ObjectOperationHandlerLong implements ObjectOperationHandler {
1726
1727         public boolean isPrimitive() {
1728             return true;
1729         }
1730
1731         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
1732             handler.setLong(fmd.fieldNumber, 0L);
1733         }
1734
1735         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
1736             op.getValue(fmd.storeColumn);
1737         }
1738
1739         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
1740             return (Long) (columnDefaultValue == null ? Long.valueOf(0) : Long.valueOf(columnDefaultValue));
1741         }
1742
1743         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1744             op.setLong(fmd.storeColumn, ((Number) value).longValue());
1745         }
1746
1747         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
1748             handler.setLong(fmd.fieldNumber, rs.getLong(fmd.storeColumn));
1749         }
1750
1751         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
1752             op.setBoundLong(fmd.storeColumn, type, ((Number) value).longValue());
1753         }
1754
1755         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
1756             filter.cmpLong(condition, fmd.storeColumn, ((Number) value).longValue());
1757         }
1758
1759         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1760             if (logger.isDetailEnabled()) {
1761                 logger.detail("setLong.setEqual " + fmd.columnName + " to value " + value);
1762             }
1763             op.equalLong(fmd.storeColumn, ((Number) value).longValue());
1764         }
1765
1766         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
1767             return true;
1768         }
1769
1770         public Object getValue(QueryExecutionContext context, String index) {
1771             return context.getLong(index);
1772         }
1773
1774     }
1775
1776     protected static ObjectOperationHandler objectOperationHandlerLong = new ObjectOperationHandlerLong() {
1777
1778         public String handler() {
1779             return "primitive long";
1780         }
1781
1782         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1783             if (logger.isDetailEnabled()) {
1784                 logger.detail("Column " + fmd.columnName + " set to value " + handler.getLong(fmd.fieldNumber));
1785             }
1786             op.setLong(fmd.storeColumn, handler.getLong(fmd.fieldNumber));
1787         }
1788
1789         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1790                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1791             throw new ClusterJFatalInternalException(
1792                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
1793         }
1794
1795     };
1796
1797     protected static ObjectOperationHandler objectOperationHandlerKeyLong = new ObjectOperationHandlerLong() {
1798
1799         public String handler() {
1800             return "key primitive long";
1801         }
1802
1803         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1804             if (logger.isDetailEnabled()) {
1805                 logger.detail("Column " + fmd.columnName + " set to value " + handler.getLong(fmd.fieldNumber));
1806             }
1807             op.equalLong(fmd.storeColumn, handler.getLong(fmd.fieldNumber));
1808         }
1809
1810         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1811                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1812             partitionKey.addLongKey(fmd.storeColumn, keyValueHandler.getLong(fmd.fieldNumber));
1813         }
1814
1815     };
1816     protected static ObjectOperationHandler objectOperationHandlerObjectByte = new ObjectOperationHandler() {
1817
1818         public boolean isPrimitive() {
1819             return false;
1820         }
1821
1822         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
1823         }
1824
1825         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
1826             op.getValue(fmd.storeColumn);
1827         }
1828
1829         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
1830             return (Byte) (columnDefaultValue == null ? Byte.valueOf((byte)0) : Byte.valueOf(columnDefaultValue));
1831         }
1832
1833         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1834             op.setByte(fmd.storeColumn, (Byte) value);
1835         }
1836
1837         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1838             if (handler.isNull(fmd.fieldNumber)) {
1839                 op.setNull(fmd.storeColumn);
1840             } else {
1841                 op.setByte(fmd.storeColumn, handler.getObjectByte(fmd.fieldNumber).byteValue());
1842             }
1843         }
1844
1845         public String handler() {
1846             return "object Byte";
1847         }
1848
1849         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
1850             handler.setObjectByte(fmd.fieldNumber, rs.getObjectByte(fmd.storeColumn));
1851         }
1852
1853         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
1854             op.setBoundByte(fmd.storeColumn, type, ((Number)value).byteValue());
1855         }
1856
1857         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
1858             filter.cmpByte(condition, fmd.storeColumn, ((Number) value).byteValue());
1859         }
1860
1861         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1862             if (logger.isDetailEnabled()) {
1863                 logger.detail("setObjectByte.setEqual " + fmd.columnName + " to value " + value);
1864             }
1865             op.equalByte(fmd.storeColumn, ((Number) value).byteValue());
1866         }
1867
1868         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
1869             return true;
1870         }
1871
1872         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1873                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1874             throw new ClusterJFatalInternalException(
1875                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
1876         }
1877
1878         public Object getValue(QueryExecutionContext context, String index) {
1879             return context.getByte(index);
1880         }
1881
1882     };
1883
1884     protected static ObjectOperationHandler objectOperationHandlerObjectDouble = new ObjectOperationHandler() {
1885
1886         public boolean isPrimitive() {
1887             return false;
1888         }
1889
1890         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
1891         }
1892
1893         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
1894             op.getValue(fmd.storeColumn);
1895         }
1896
1897         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
1898             return (Double) (columnDefaultValue == null ? Double.valueOf("0") : Double.valueOf(columnDefaultValue));
1899         }
1900
1901         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1902             op.setDouble(fmd.storeColumn, (Double) value);
1903         }
1904
1905         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1906             if (handler.isNull(fmd.fieldNumber)) {
1907                 op.setNull(fmd.storeColumn);
1908             } else {
1909                 op.setDouble(fmd.storeColumn, handler.getObjectDouble(fmd.fieldNumber));
1910             }
1911         }
1912
1913         public String handler() {
1914             return "object Double";
1915         }
1916
1917         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
1918             handler.setObjectDouble(fmd.fieldNumber, rs.getObjectDouble(fmd.storeColumn));
1919         }
1920
1921         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
1922             op.setBoundDouble(fmd.storeColumn, type, (Double) value);
1923         }
1924
1925         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
1926             filter.cmpDouble(condition, fmd.storeColumn, ((Double) value).doubleValue());
1927         }
1928
1929         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1930             op.equalDouble(fmd.storeColumn, (Double)value);
1931         }
1932
1933         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
1934             return true;
1935         }
1936
1937         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
1938                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
1939             throw new ClusterJFatalInternalException(
1940                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
1941         }
1942
1943         public Object getValue(QueryExecutionContext context, String index) {
1944             return context.getDouble(index);
1945         }
1946
1947     };
1948
1949     protected static ObjectOperationHandler objectOperationHandlerObjectFloat = new ObjectOperationHandler() {
1950
1951         public boolean isPrimitive() {
1952             return false;
1953         }
1954
1955         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
1956         }
1957
1958         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
1959             op.getValue(fmd.storeColumn);
1960         }
1961
1962         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
1963             return (Float) (columnDefaultValue == null ? Float.valueOf("0") : Float.valueOf(columnDefaultValue));
1964         }
1965
1966         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1967             op.setFloat(fmd.storeColumn, (Float) value);
1968         }
1969
1970         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
1971             if (handler.isNull(fmd.fieldNumber)) {
1972                 op.setNull(fmd.storeColumn);
1973             } else {
1974                 op.setFloat(fmd.storeColumn, handler.getObjectFloat(fmd.fieldNumber));
1975             }
1976         }
1977
1978         public String handler() {
1979             return "object Float";
1980         }
1981
1982         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
1983             handler.setObjectFloat(fmd.fieldNumber, rs.getObjectFloat(fmd.storeColumn));
1984         }
1985
1986         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
1987             op.setBoundFloat(fmd.storeColumn, type, (Float) value);
1988         }
1989
1990         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
1991             filter.cmpFloat(condition, fmd.storeColumn, ((Float) value).floatValue());
1992         }
1993
1994         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
1995             op.equalFloat(fmd.storeColumn, (Float)value);
1996         }
1997
1998         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
1999             return true;
2000         }
2001
2002         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
2003                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
2004             throw new ClusterJFatalInternalException(
2005                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
2006         }
2007
2008         public Object getValue(QueryExecutionContext context, String index) {
2009             return context.getFloat(index);
2010         }
2011
2012     };
2013
2014     protected abstract static class ObjectOperationHandlerInteger implements ObjectOperationHandler {
2015
2016         public boolean isPrimitive() {
2017             return false;
2018         }
2019
2020         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2021         }
2022
2023         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
2024             op.getValue(fmd.storeColumn);
2025         }
2026
2027         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
2028             return (Integer) (columnDefaultValue == null ? Integer.valueOf(0) : Integer.valueOf(columnDefaultValue));
2029         }
2030
2031         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2032             op.setInt(fmd.storeColumn, (Integer) value);
2033         }
2034
2035         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
2036             handler.setObjectInt(fmd.fieldNumber, rs.getObjectInteger(fmd.storeColumn));
2037         }
2038
2039         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
2040             op.setBoundInt(fmd.storeColumn, type, (Integer) value);
2041         }
2042
2043         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
2044             filter.cmpInt(condition, fmd.storeColumn, ((Integer) value).intValue());
2045         }
2046
2047         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2048             if (logger.isDetailEnabled()) {
2049                 logger.detail("setObjectInteger.setEqual " + fmd.columnName + " to value " + value);
2050             }
2051             op.equalInt(fmd.storeColumn, ((Integer) value).intValue());
2052         }
2053
2054         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
2055             return true;
2056         }
2057
2058         public Object getValue(QueryExecutionContext context, String index) {
2059             return context.getInt(index);
2060         }
2061
2062     }
2063
2064     protected static ObjectOperationHandler objectOperationHandlerObjectInteger = new ObjectOperationHandlerInteger() {
2065
2066         public String handler() {
2067             return "object Integer";
2068         }
2069
2070         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
2071             if (handler.isNull(fmd.fieldNumber)) {
2072                 op.setNull(fmd.storeColumn);
2073             } else {
2074                 op.setInt(fmd.storeColumn, handler.getObjectInt(fmd.fieldNumber));
2075             }
2076         }
2077
2078         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
2079                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
2080             throw new ClusterJFatalInternalException(
2081                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
2082         }
2083
2084     };
2085
2086     protected static ObjectOperationHandler objectOperationHandlerKeyObjectInteger = new ObjectOperationHandlerInteger() {
2087
2088         public String handler() {
2089             return "key object Integer";
2090         }
2091
2092         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
2093             if (handler.isNull(fmd.fieldNumber)) {
2094                 op.setNull(fmd.storeColumn);
2095             } else {
2096                 op.equalInt(fmd.storeColumn, handler.getObjectInt(fmd.fieldNumber));
2097             }
2098         }
2099
2100         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
2101                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
2102             partitionKey.addIntKey(fmd.storeColumn, keyValueHandler.getObjectInt(fmd.fieldNumber));
2103         }
2104
2105     };
2106
2107     public abstract static class ObjectOperationHandlerObjectLong implements ObjectOperationHandler {
2108
2109         public boolean isPrimitive() {
2110             return false;
2111         }
2112
2113         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2114         }
2115
2116         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
2117             op.getValue(fmd.storeColumn);
2118         }
2119
2120         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
2121             return (Long) (columnDefaultValue == null ? Long.valueOf(0) : Long.valueOf(columnDefaultValue));
2122         }
2123
2124         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2125             op.setLong(fmd.storeColumn, ((Number) value).longValue());
2126         }
2127
2128         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
2129             handler.setObjectLong(fmd.fieldNumber, rs.getObjectLong(fmd.storeColumn));
2130         }
2131
2132         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
2133             op.setBoundLong(fmd.storeColumn, type, ((Number) value).longValue());
2134         }
2135
2136         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
2137             filter.cmpLong(condition, fmd.storeColumn, ((Number) value).longValue());
2138         }
2139
2140         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2141             if (logger.isDetailEnabled()) {
2142                 logger.detail("setObjectLong.setEqual " + fmd.columnName + " to value " + value);
2143             }
2144             op.equalLong(fmd.storeColumn, ((Number) value).longValue());
2145         }
2146
2147         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
2148             return true;
2149         }
2150
2151         public Object getValue(QueryExecutionContext context, String index) {
2152             return context.getLong(index);
2153         }
2154
2155     }
2156
2157     protected static ObjectOperationHandler objectOperationHandlerObjectLong = new ObjectOperationHandlerObjectLong() {
2158
2159         public String handler() {
2160             return "object Long";
2161         }
2162
2163         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
2164             if (handler.isNull(fmd.fieldNumber)) {
2165                 op.setNull(fmd.storeColumn);
2166             } else {
2167                 op.setLong(fmd.storeColumn, handler.getObjectLong(fmd.fieldNumber));
2168             }
2169         }
2170
2171         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
2172                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
2173             throw new ClusterJFatalInternalException(
2174                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
2175         }
2176
2177     };
2178
2179     protected static ObjectOperationHandler objectOperationHandlerKeyObjectLong = new ObjectOperationHandlerObjectLong() {
2180
2181         public String handler() {
2182             return "key object Long";
2183         }
2184
2185         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
2186             if (handler.isNull(fmd.fieldNumber)) {
2187                 op.setNull(fmd.storeColumn);
2188             } else {
2189                 op.equalLong(fmd.storeColumn, handler.getObjectLong(fmd.fieldNumber));
2190             }
2191         }
2192
2193         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
2194                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
2195             partitionKey.addLongKey(fmd.storeColumn, keyValueHandler.getObjectLong(fmd.fieldNumber));
2196         }
2197
2198     };
2199
2200     protected static ObjectOperationHandler objectOperationHandlerObjectShort = new ObjectOperationHandler() {
2201
2202         public boolean isPrimitive() {
2203             return false;
2204         }
2205
2206         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2207         }
2208
2209         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
2210             op.getValue(fmd.storeColumn);
2211         }
2212
2213         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
2214             return (Short) (columnDefaultValue == null ? Short.valueOf((short) 0) : Short.valueOf(columnDefaultValue));
2215         }
2216
2217         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2218             op.setShort(fmd.storeColumn, (Short) value);
2219         }
2220
2221         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
2222             if (handler.isNull(fmd.fieldNumber)) {
2223                 op.setNull(fmd.storeColumn);
2224             } else {
2225                 op.setShort(fmd.storeColumn, handler.getObjectShort(fmd.fieldNumber));
2226             }
2227         }
2228
2229         public String handler() {
2230             return "object Short";
2231         }
2232
2233         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
2234             handler.setObjectShort(fmd.fieldNumber, rs.getObjectShort(fmd.storeColumn));
2235         }
2236
2237         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
2238             try {
2239                 op.setBoundShort(fmd.storeColumn, type, ((Number) value).shortValue());
2240             } catch (ClassCastException ex) {
2241                 throw new ClusterJUserException(local.message("ERR_Parameter_Type", "Number", value.getClass().getName()));
2242             }
2243         }
2244
2245         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
2246             try {
2247                 filter.cmpShort(condition, fmd.storeColumn, ((Number) value).shortValue());
2248             } catch (ClassCastException ex) {
2249                 throw new ClusterJUserException(local.message("ERR_Parameter_Type", "Number", value.getClass().getName()));
2250             }
2251         }
2252
2253         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2254             op.equalShort(fmd.storeColumn, ((Number) value).shortValue());
2255         }
2256
2257         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
2258             return true;
2259         }
2260
2261         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
2262                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
2263             throw new ClusterJFatalInternalException(
2264                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
2265         }
2266
2267         public Object getValue(QueryExecutionContext context, String index) {
2268             return context.getShort(index);
2269         }
2270
2271     };
2272
2273     protected static ObjectOperationHandler objectOperationHandlerShort = new ObjectOperationHandler() {
2274
2275         public boolean isPrimitive() {
2276             return true;
2277         }
2278
2279         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2280             handler.setShort(fmd.fieldNumber, (short) 0);
2281         }
2282
2283         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
2284             op.getValue(fmd.storeColumn);
2285         }
2286
2287         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
2288             return (Short) (columnDefaultValue == null ? Short.valueOf((short) 0) : Short.valueOf(columnDefaultValue));
2289         }
2290
2291         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2292             op.setShort(fmd.storeColumn, (Short) value);
2293         }
2294
2295         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
2296             if (logger.isDetailEnabled()) {
2297                 logger.detail("Column " + fmd.columnName + " set to value " + handler.getShort(fmd.fieldNumber));
2298             }
2299             op.setShort(fmd.storeColumn, handler.getShort(fmd.fieldNumber));
2300         }
2301
2302         public String handler() {
2303             return "primitive short";
2304         }
2305
2306         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
2307             handler.setShort(fmd.fieldNumber, rs.getShort(fmd.storeColumn));
2308         }
2309
2310         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
2311             try {
2312                 op.setBoundShort(fmd.storeColumn, type, ((Number) value).shortValue());
2313             } catch (ClassCastException ex) {
2314                 throw new ClusterJUserException(local.message("ERR_Parameter_Type", "Number", value.getClass().getName()));
2315             }
2316         }
2317
2318         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
2319             try {
2320                 filter.cmpShort(condition, fmd.storeColumn, ((Number) value).shortValue());
2321             } catch (ClassCastException ex) {
2322                 throw new ClusterJUserException(local.message("ERR_Parameter_Type", "Number", value.getClass().getName()));
2323             }
2324         }
2325
2326         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2327             op.equalShort(fmd.storeColumn, ((Number) value).shortValue());
2328         }
2329
2330         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
2331             return true;
2332         }
2333
2334         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
2335                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
2336             throw new ClusterJFatalInternalException(
2337                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
2338         }
2339
2340         public Object getValue(QueryExecutionContext context, String index) {
2341             return context.getShort(index);
2342         }
2343
2344     };
2345
2346     protected static ObjectOperationHandler objectOperationHandlerShortYear = new ObjectOperationHandler() {
2347
2348         public boolean isPrimitive() {
2349             return true;
2350         }
2351
2352         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2353             handler.setShort(fmd.fieldNumber, (short) 1900);
2354         }
2355
2356         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
2357             op.getValue(fmd.storeColumn);
2358         }
2359
2360         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
2361             return (Short) (columnDefaultValue == null ? Short.valueOf((short) 1900) : Short.valueOf(columnDefaultValue));
2362         }
2363
2364         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2365             op.setByte(fmd.storeColumn, (byte)((Short)value - 1900));
2366         }
2367
2368         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
2369             op.setByte(fmd.storeColumn, (byte)(handler.getShort(fmd.fieldNumber) - 1900));
2370         }
2371
2372         public String handler() {
2373             return "primitive short year";
2374         }
2375
2376         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
2377             handler.setShort(fmd.fieldNumber, (short)(rs.getByte(fmd.storeColumn) + 1900));
2378         }
2379
2380         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
2381             try {
2382                 op.setBoundByte(fmd.storeColumn, type, (byte)(((Number) value).shortValue() - 1900));
2383             } catch (ClassCastException ex) {
2384                 throw new ClusterJUserException(local.message("ERR_Parameter_Type", "Number", value.getClass().getName()));
2385             }
2386         }
2387
2388         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
2389             try {
2390                 filter.cmpByte(condition, fmd.storeColumn, (byte)(((Number) value).shortValue() - 1900));
2391             } catch (ClassCastException ex) {
2392                 throw new ClusterJUserException(local.message("ERR_Parameter_Type", "Number", value.getClass().getName()));
2393             }
2394         }
2395
2396         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2397             op.equalByte(fmd.storeColumn, (byte)(((Number) value).shortValue() - 1900));
2398         }
2399
2400         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
2401             return true;
2402         }
2403
2404         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
2405                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
2406             throw new ClusterJFatalInternalException(
2407                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
2408         }
2409
2410         public Object getValue(QueryExecutionContext context, String index) {
2411             return context.getShort(index);
2412         }
2413
2414     };
2415
2416     protected static ObjectOperationHandler objectOperationHandlerObjectShortYear = new ObjectOperationHandler() {
2417
2418         public boolean isPrimitive() {
2419             return false;
2420         }
2421
2422         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2423             handler.setShort(fmd.fieldNumber, (short) 1900);
2424         }
2425
2426         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
2427             op.getValue(fmd.storeColumn);
2428         }
2429
2430         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
2431             return (Short) (columnDefaultValue == null ? Short.valueOf((short) 1900) : Short.valueOf(columnDefaultValue));
2432         }
2433
2434         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2435             op.setByte(fmd.storeColumn, (byte)((Short)value - 1900));
2436         }
2437
2438         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
2439             if (handler.isNull(fmd.fieldNumber)) {
2440                 op.setNull(fmd.storeColumn);
2441             } else {
2442                 op.setByte(fmd.storeColumn, (byte)(handler.getShort(fmd.fieldNumber) - 1900));
2443             }
2444         }
2445
2446         public String handler() {
2447             return "object short year";
2448         }
2449
2450         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
2451             handler.setShort(fmd.fieldNumber, (short)(rs.getByte(fmd.storeColumn) + 1900));
2452         }
2453
2454         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
2455             try {
2456                 op.setBoundByte(fmd.storeColumn, type, (byte)(((Number) value).shortValue() - 1900));
2457             } catch (ClassCastException ex) {
2458                 throw new ClusterJUserException(local.message("ERR_Parameter_Type", "Number", value.getClass().getName()));
2459             }
2460         }
2461
2462         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
2463             try {
2464                 filter.cmpByte(condition, fmd.storeColumn, (byte)(((Number) value).shortValue() - 1900));
2465             } catch (ClassCastException ex) {
2466                 throw new ClusterJUserException(local.message("ERR_Parameter_Type", "Number", value.getClass().getName()));
2467             }
2468         }
2469
2470         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2471             op.equalByte(fmd.storeColumn, (byte)(((Number) value).shortValue() - 1900));
2472         }
2473
2474         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
2475             return true;
2476         }
2477
2478         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
2479                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
2480             throw new ClusterJFatalInternalException(
2481                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
2482         }
2483
2484         public Object getValue(QueryExecutionContext context, String index) {
2485             return context.getShort(index);
2486         }
2487
2488     };
2489
2490     protected static ObjectOperationHandler objectOperationHandlerString = new ObjectOperationHandler() {
2491
2492         public boolean isPrimitive() {
2493             return false;
2494         }
2495
2496         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2497         }
2498
2499         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
2500             op.getValue(fmd.storeColumn);
2501         }
2502
2503         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
2504             return (String) (columnDefaultValue == null ? "" : columnDefaultValue);
2505         }
2506
2507         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2508             if (value == null) {
2509                 op.setNull(fmd.storeColumn);
2510             } else {
2511                 op.setString(fmd.storeColumn, (String)value);
2512             }
2513         }
2514
2515         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
2516             if (handler.isNull(fmd.fieldNumber)) {
2517                 op.setNull(fmd.storeColumn);
2518             } else {
2519                 op.setString(fmd.storeColumn, handler.getString(fmd.fieldNumber));
2520             }
2521         }
2522
2523         public String handler() {
2524             return "object String";
2525         }
2526
2527         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
2528             if (logger.isDetailEnabled()) {
2529                 logger.detail("field " + fmd.name + " set to value " + rs.getString(fmd.storeColumn));
2530             }
2531             handler.setString(fmd.fieldNumber, rs.getString(fmd.storeColumn));
2532         }
2533
2534         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
2535             op.setBoundString(fmd.storeColumn, type, (String)value);
2536         }
2537
2538         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
2539             filter.cmpString(condition, fmd.storeColumn, (String)value);
2540         }
2541
2542         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2543             op.equalString(fmd.storeColumn, (String)value);
2544         }
2545
2546         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
2547             return true;
2548         }
2549
2550         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
2551                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
2552             throw new ClusterJFatalInternalException(
2553                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
2554         }
2555
2556         public Object getValue(QueryExecutionContext context, String index) {
2557             return context.getString(index);
2558         }
2559
2560     };
2561
2562     protected static ObjectOperationHandler objectOperationHandlerUnsupportedType = new ObjectOperationHandler() {
2563
2564         public boolean isPrimitive() {
2565             return false;
2566         }
2567
2568         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2569             throw new ClusterJUserException(local.message("ERR_Unsupported_Field_Type", fmd.getTypeName(), fmd.getName()));
2570         }
2571
2572         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
2573             throw new ClusterJUserException(local.message("ERR_Unsupported_Field_Type", fmd.getTypeName(), fmd.getName()));
2574         }
2575
2576         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
2577             return null;
2578         }
2579
2580         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2581             throw new ClusterJUserException(local.message("ERR_Unsupported_Field_Type", fmd.getTypeName(), fmd.getName()));
2582         }
2583
2584         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
2585             throw new ClusterJUserException(local.message("ERR_Unsupported_Field_Type", fmd.getTypeName(), fmd.getName()));
2586         }
2587
2588         public String handler() {
2589             return "unsupported Type";
2590         }
2591
2592         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
2593             throw new ClusterJUserException(local.message("ERR_Unsupported_Field_Type", fmd.getTypeName(), fmd.getName()));
2594         }
2595
2596         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
2597             throw new ClusterJUserException(local.message("ERR_Unsupported_Field_Type", fmd.getTypeName(), fmd.getName()));
2598         }
2599
2600         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
2601             throw new ClusterJUserException(local.message("ERR_Unsupported_Field_Type", fmd.getTypeName(), fmd.getName()));
2602         }
2603
2604         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2605             throw new ClusterJUserException(local.message("ERR_Unsupported_Field_Type", fmd.getTypeName(), fmd.getName()));
2606         }
2607
2608         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
2609             return false;
2610         }
2611
2612         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd, PartitionKey partitionKey, ValueHandler keyValueHandler) {
2613             throw new ClusterJUserException(local.message("ERR_Unsupported_Field_Type", fmd.getTypeName(), fmd.getName()));
2614         }
2615
2616         public Object getValue(QueryExecutionContext context, String index) {
2617             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2618        }
2619
2620     };
2621
2622     /** This operation handler is a no-op for getting and setting values that don't
2623      * have columns in the table that the field is mapped in, i.e. fields
2624      * that are mapped to foreign keys in other tables.
2625      *
2626      */
2627     protected static ObjectOperationHandler objectOperationHandlerVirtualType = new ObjectOperationHandler() {
2628
2629         public boolean isPrimitive() {
2630             return false;
2631         }
2632
2633         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2634             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2635         }
2636
2637         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
2638             return;
2639         }
2640
2641         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
2642             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2643         }
2644
2645         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2646             return;
2647         }
2648
2649         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
2650             return;
2651         }
2652
2653         public String handler() {
2654             return "Virtual Type (field with no columns)";
2655         }
2656
2657         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
2658             return;
2659         }
2660
2661         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
2662             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2663         }
2664
2665         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
2666             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2667         }
2668
2669         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2670             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2671         }
2672
2673         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
2674             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2675         }
2676
2677         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
2678                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
2679             throw new ClusterJFatalInternalException(
2680                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
2681         }
2682
2683         public Object getValue(QueryExecutionContext context, String index) {
2684             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2685        }
2686
2687     };
2688
2689     protected static abstract class ObjectOperationHandlerNotPersistent implements ObjectOperationHandler {
2690
2691         public boolean isPrimitive() {
2692             return true;
2693         }
2694
2695         public void operationGetValue(AbstractDomainFieldHandlerImpl fmd, Operation op) {
2696             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2697         }
2698
2699         public Object getDefaultValueFor(AbstractDomainFieldHandlerImpl fmd, String columnDefaultValue) {
2700             // this value is never used
2701             return null;
2702         }
2703
2704         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2705             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2706         }
2707
2708         public void operationSetValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler, Operation op) {
2709             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2710         }
2711
2712         public void objectSetValue(AbstractDomainFieldHandlerImpl fmd, ResultData rs, ValueHandler handler) {
2713             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2714         }
2715
2716         public void operationSetBounds(AbstractDomainFieldHandlerImpl fmd, Object value, IndexScanOperation.BoundType type, IndexScanOperation op) {
2717             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2718         }
2719
2720         public void filterCompareValue(AbstractDomainFieldHandlerImpl fmd, Object value, ScanFilter.BinaryCondition condition, ScanFilter filter) {
2721             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2722         }
2723
2724         public void operationEqual(AbstractDomainFieldHandlerImpl fmd, Object value, Operation op) {
2725             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2726         }
2727
2728         public boolean isValidIndexType(AbstractDomainFieldHandlerImpl fmd, boolean hashNotOrdered) {
2729             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2730         }
2731
2732         public void partitionKeySetPart(AbstractDomainFieldHandlerImpl fmd,
2733                 PartitionKey partitionKey, ValueHandler keyValueHandler) {
2734             throw new ClusterJFatalInternalException(
2735                     local.message("ERR_Operation_Not_Supported","partitionKeySetPart", "non-key fields"));
2736         }
2737
2738         public Object getValue(QueryExecutionContext context, String index) {
2739             throw new ClusterJFatalInternalException(local.message("ERR_Implementation_Should_Not_Occur"));
2740        }
2741
2742     }
2743
2744     protected static ObjectOperationHandler objectOperationHandlerNotPersistentByte = new ObjectOperationHandlerNotPersistent() {
2745
2746         public String handler() {
2747             return "not persistent primitive byte";
2748         }
2749
2750         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2751             handler.setByte(fmd.fieldNumber, (byte) 0);
2752         }
2753     };
2754     protected static ObjectOperationHandler objectOperationHandlerNotPersistentDouble = new ObjectOperationHandlerNotPersistent() {
2755
2756         public String handler() {
2757             return "not persistent primitive double";
2758         }
2759
2760         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2761             handler.setDouble(fmd.fieldNumber, 0.0D);
2762         }
2763     };
2764     protected static ObjectOperationHandler objectOperationHandlerNotPersistentFloat = new ObjectOperationHandlerNotPersistent() {
2765
2766         public String handler() {
2767             return "not persistent primitive float";
2768         }
2769
2770         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2771             handler.setFloat(fmd.fieldNumber, 0.0F);
2772         }
2773     };
2774     protected static ObjectOperationHandler objectOperationHandlerNotPersistentInt = new ObjectOperationHandlerNotPersistent() {
2775
2776         public String handler() {
2777             return "not persistent primitive int";
2778         }
2779
2780         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2781             handler.setInt(fmd.fieldNumber, 0);
2782         }
2783     };
2784     protected static ObjectOperationHandler objectOperationHandlerNotPersistentLong = new ObjectOperationHandlerNotPersistent() {
2785
2786         public String handler() {
2787             return "not persistent primitive long";
2788         }
2789
2790         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2791             handler.setLong(fmd.fieldNumber, 0L);
2792         }
2793     };
2794     protected static ObjectOperationHandler objectOperationHandlerNotPersistentObject = new ObjectOperationHandlerNotPersistent() {
2795
2796         public String handler() {
2797             return "not persistent Object";
2798         }
2799
2800         @Override
2801         public boolean isPrimitive() {
2802             return false;
2803         }
2804
2805         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2806         }
2807     };
2808     protected static ObjectOperationHandler objectOperationHandlerNotPersistentShort = new ObjectOperationHandlerNotPersistent() {
2809
2810         public String handler() {
2811             return "not persistent primitive short";
2812         }
2813
2814         public void objectInitializeJavaDefaultValue(AbstractDomainFieldHandlerImpl fmd, ValueHandler handler) {
2815             handler.setShort(fmd.fieldNumber, (short) 0);
2816         }
2817     };
2818
2819     /* These methods implement ColumnMetadata
2820      */
2821
2822     protected void initializeColumnMetadata(com.mysql.clusterj.core.store.Column storeColumn) {
2823         this.columnName = storeColumn.getName();;
2824         this.storeColumnType = storeColumn.getType();
2825         this.charsetName = storeColumn.getCharsetName();
2826         this.primaryKey = storeColumn.isPrimaryKey();
2827         this.partitionKey = storeColumn.isPartitionKey();
2828         this.precision = storeColumn.getPrecision();
2829         this.scale = storeColumn.getScale();
2830         this.maximumLength = storeColumn.getLength();
2831         this.nullable = storeColumn.getNullable();
2832     }
2833
2834     public boolean isPartitionKey() {
2835         return partitionKey;
2836     }
2837
2838     public int maximumLength() {
2839         return maximumLength;
2840     }
2841
2842     public String name() {
2843         return name;
2844     }
2845
2846     public int number() {
2847         return fieldNumber;
2848     }
2849
2850     public int precision() {
2851         return precision;
2852     }
2853
2854     public int scale() {
2855         return scale;
2856     }
2857
2858     public ColumnType columnType() {
2859         return this.storeColumnType;
2860     }
2861
2862     public boolean nullable() {
2863         return nullable;
2864     }
2865
2866     public Class<?> javaType() {
2867         return this.type;
2868     }
2869
2870     public String charsetName() {
2871         return this.charsetName;
2872     }
2873
2874 }