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.tie;
  19
  20 import java.math.BigDecimal;
  21 import java.math.BigInteger;
  22 import java.nio.ByteBuffer;
  23 import java.util.Arrays;
  24
  25 import com.mysql.ndbjtie.ndbapi.NdbScanFilter;
  26
  27 import com.mysql.clusterj.ClusterJFatalInternalException;
  28
  29 import com.mysql.clusterj.core.store.Column;
  30 import com.mysql.clusterj.core.store.ScanFilter;
  31 import com.mysql.clusterj.core.util.I18NHelper;
  32 import com.mysql.clusterj.core.util.Logger;
  33 import com.mysql.clusterj.core.util.LoggerFactoryService;
  34
  35 /**
  36  *
  37  */
  38 class ScanFilterImpl implements ScanFilter {
  39
  40     /** My message translator */
  41     static final I18NHelper local = I18NHelper
  42             .getInstance(ScanFilterImpl.class);
  43
  44     /** My logger */
  45     static final Logger logger = LoggerFactoryService.getFactory()
  46             .getInstance(ScanFilterImpl.class);
  47
  48     private NdbScanFilter ndbScanFilter;
  49
  50     public ScanFilterImpl(NdbScanFilter ndbScanFilter) {
  51         this.ndbScanFilter = ndbScanFilter;
  52     }
  53
  54     public void begin() {
  55         int returnCode = ndbScanFilter.begin(NdbScanFilter.Group.AND);
  56         handleError(returnCode, ndbScanFilter);
  57     }
  58
  59     public void begin(Group group) {
  60         int returnCode = ndbScanFilter.begin(convertGroup(group));
  61         handleError(returnCode, ndbScanFilter);
  62     }
  63
  64     public void cmpBigInteger(BinaryCondition condition, Column storeColumn, BigInteger value) {
  65         ByteBuffer buffer = Utility.convertValue(storeColumn, value);
  66         int returnCode = ndbScanFilter.cmp(convertCondition(condition),
  67                 storeColumn.getColumnId(), buffer, buffer.capacity());
  68         handleError(returnCode, ndbScanFilter);
  69     }
  70
  71     public void cmpBoolean(BinaryCondition condition, Column storeColumn, boolean value) {
  72         byte byteValue = (value?(byte)0x01:(byte)0x00);
  73         cmpByte(condition, storeColumn, byteValue);
  74     }
  75
  76     public void cmpByte(BinaryCondition condition, Column storeColumn, byte value) {
  77         ByteBuffer buffer = Utility.convertValue(storeColumn, value);
  78         int returnCode = ndbScanFilter.cmp(convertCondition(condition),
  79                 storeColumn.getColumnId(), buffer, buffer.capacity());
  80         handleError(returnCode, ndbScanFilter);
  81     }
  82
  83     public void cmpBytes(BinaryCondition condition, Column storeColumn, byte[] value) {
  84         ByteBuffer buffer;
  85         if (condition == BinaryCondition.COND_LIKE) {
  86             buffer = Utility.convertValueForLikeFilter(storeColumn, value);
  87         } else {
  88             buffer = Utility.convertValue(storeColumn, value);
  89         }
  90         int returnCode = ndbScanFilter.cmp(convertCondition(condition),
  91                 storeColumn.getColumnId(), buffer, buffer.capacity());
  92         handleError(returnCode, ndbScanFilter);
  93     }
  94
  95     public void cmpDecimal(BinaryCondition condition, Column storeColumn, BigDecimal value) {
  96         ByteBuffer buffer = Utility.convertValue(storeColumn, value);
  97         int returnCode = ndbScanFilter.cmp(convertCondition(condition),
  98                 storeColumn.getColumnId(), buffer, buffer.capacity());
  99         handleError(returnCode, ndbScanFilter);
 100     }
 101
 102     public void cmpDouble(BinaryCondition condition, Column storeColumn, double value) {
 103         ByteBuffer buffer = Utility.convertValue(storeColumn, value);
 104         int returnCode = ndbScanFilter.cmp(convertCondition(condition),
 105                 storeColumn.getColumnId(), buffer, buffer.capacity());
 106         handleError(returnCode, ndbScanFilter);
 107     }
 108
 109     public void cmpFloat(BinaryCondition condition, Column storeColumn, float value) {
 110         ByteBuffer buffer = Utility.convertValue(storeColumn, value);
 111         int returnCode = ndbScanFilter.cmp(convertCondition(condition),
 112                 storeColumn.getColumnId(), buffer, buffer.capacity());
 113         handleError(returnCode, ndbScanFilter);
 114     }
 115
 116     public void cmpShort(BinaryCondition condition, Column storeColumn, short value) {
 117         ByteBuffer buffer = Utility.convertValue(storeColumn, value);
 118         int returnCode = ndbScanFilter.cmp(convertCondition(condition),
 119                 storeColumn.getColumnId(), buffer, buffer.capacity());
 120         handleError(returnCode, ndbScanFilter);
 121     }
 122
 123     public void cmpInt(BinaryCondition condition, Column storeColumn, int value) {
 124         ByteBuffer buffer = Utility.convertValue(storeColumn, value);
 125         int returnCode = ndbScanFilter.cmp(convertCondition(condition),
 126                 storeColumn.getColumnId(), buffer, buffer.capacity());
 127         handleError(returnCode, ndbScanFilter);
 128     }
 129
 130     public void cmpLong(BinaryCondition condition, Column storeColumn, long value) {
 131         ByteBuffer buffer = Utility.convertValue(storeColumn, value);
 132         if (logger.isDetailEnabled()) {
 133             int bufferLength = buffer.limit() - buffer.position();
 134             byte[] array = new byte[bufferLength];
 135             buffer.get(array);
 136             buffer.flip();
 137             logger.detail("column: " + storeColumn.getName() + " condition: " + condition.toString() + " value: " + value + Arrays.toString(array) + "(" + buffer.capacity() + ")");
 138         }
 139         int returnCode = ndbScanFilter.cmp(convertCondition(condition),
 140                 storeColumn.getColumnId(), buffer, buffer.capacity());
 141         handleError(returnCode, ndbScanFilter);
 142     }
 143
 144     public void cmpString(BinaryCondition condition, Column storeColumn, String value) {
 145         if (logger.isDebugEnabled())
 146             logger.debug(storeColumn.getName() + " " + condition + " " + value);
 147         ByteBuffer buffer;
 148         if (condition == BinaryCondition.COND_LIKE) {
 149             buffer = Utility.convertValueForLikeFilter(storeColumn, value);
 150         } else {
 151             buffer = Utility.convertValue(storeColumn, value);
 152         }
 153         int returnCode = ndbScanFilter.cmp(convertCondition(condition),
 154                 storeColumn.getColumnId(), buffer, buffer.limit());
 155         handleError(returnCode, ndbScanFilter);
 156     }
 157
 158     public void isNull(Column storeColumn) {
 159         int returnCode = ndbScanFilter.isnull(storeColumn.getColumnId());
 160         handleError(returnCode, ndbScanFilter);
 161     }
 162
 163     public void end() {
 164         int returnCode = ndbScanFilter.end();
 165         handleError(returnCode, ndbScanFilter);
 166     }
 167
 168     private int convertCondition(BinaryCondition condition) {
 169         switch (condition) {
 170             case COND_EQ:
 171                 return NdbScanFilter.BinaryCondition.COND_EQ;
 172             case COND_LE:
 173                 return NdbScanFilter.BinaryCondition.COND_LE;
 174             case COND_LT:
 175                 return NdbScanFilter.BinaryCondition.COND_LT;
 176             case COND_GE:
 177                 return NdbScanFilter.BinaryCondition.COND_GE;
 178             case COND_GT:
 179                 return NdbScanFilter.BinaryCondition.COND_GT;
 180             case COND_LIKE:
 181                 return NdbScanFilter.BinaryCondition.COND_LIKE;
 182             default:
 183                 throw new ClusterJFatalInternalException(
 184                         local.message("ERR_Implementation_Should_Not_Occur"));
 185         }
 186     }
 187
 188     private int convertGroup(Group group) {
 189         switch(group) {
 190             case GROUP_AND:
 191                 return NdbScanFilter.Group.AND;
 192             case GROUP_NAND:
 193                 return NdbScanFilter.Group.NAND;
 194             case GROUP_OR:
 195                 return NdbScanFilter.Group.OR;
 196             default:
 197                 throw new ClusterJFatalInternalException(
 198                         local.message("ERR_Implementation_Should_Not_Occur"));
 199         }
 200     }
 201
 202     protected static void handleError(int returnCode, NdbScanFilter ndbScanFilter) {
 203         if (returnCode == 0) {
 204             return;
 205         } else {
 206             Utility.throwError(returnCode, ndbScanFilter.getNdbError());
 207         }
 208     }
 209
 210     protected static void handleError(Object object, NdbScanFilter ndbScanFilter) {
 211         if (object != null) {
 212             return;
 213         } else {
 214             Utility.throwError(null, ndbScanFilter.getNdbError());
 215         }
 216     }
 217
 218     public void delete() {
 219         NdbScanFilter.delete(ndbScanFilter);
 220     }
 221
 222 }