private void updateRowBuffer()

in src/main/java/com/amazon/redshift/jdbc/RedshiftResultSet.java [1768:1958]
156 lines of code
43 McCabe index (conditional complexity)

  private void updateRowBuffer() throws SQLException {
    for (Map.Entry<String, Object> entry : updateValues.entrySet()) {
      int columnIndex = findColumn(entry.getKey()) - 1;

      Object valueObject = entry.getValue();
      if (valueObject instanceof RedshiftObject) {
        String value = ((RedshiftObject) valueObject).getValue();
        rowBuffer.set(columnIndex, (value == null) ? null : connection.encodeString(value));
      } else {
        switch (getSQLType(columnIndex + 1)) {

          // boolean needs to be formatted as t or f instead of true or false
          case Types.BIT:
          case Types.BOOLEAN:
            if (isBinary(columnIndex + 1)
            		&& valueObject != null) {
	            byte[] val = new byte[1];
	            ByteConverter.bool(val, 0, ((Boolean) valueObject).booleanValue());
	            rowBuffer.set(columnIndex, val);
            }
            else {
              rowBuffer.set(columnIndex, connection
                  .encodeString(((Boolean) valueObject).booleanValue() ? "t" : "f"));
            }
            break;
            //
            // toString() isn't enough for date and time types; we must format it correctly
            // or we won't be able to re-parse it.
            //
          case Types.DATE:
            if (isBinary(columnIndex + 1)
            		&& valueObject != null) {
	            byte[] val = new byte[4];
	            TimeZone tz = null;
	            connection.getTimestampUtils().toBinDate(tz, val, (Date) valueObject);
	            rowBuffer.set(columnIndex, val);
            }
            else {
	            rowBuffer.set(columnIndex, connection
	                .encodeString(
	                    connection.getTimestampUtils().toString(
	                        getDefaultCalendar(), (Date) valueObject)));
            }
            break;

          case Types.TIME:
            rowBuffer.set(columnIndex, connection
                .encodeString(
                    connection.getTimestampUtils().toString(
                        getDefaultCalendar(), (Time) valueObject)));
            break;

          case Types.TIMESTAMP:
            if (isBinary(columnIndex + 1)
            		&& valueObject != null) {
	            byte[] val = new byte[8];
	            connection.getTimestampUtils().toBinTimestamp(null, val, (Timestamp) valueObject);
	            rowBuffer.set(columnIndex, val);
            }
            else {
	            rowBuffer.set(columnIndex, connection.encodeString(
	                connection.getTimestampUtils().toString(
	                    getDefaultCalendar(), (Timestamp) valueObject)));
            }
            break;

          case Types.NULL:
            // Should never happen?
            break;

          case Types.BINARY:
          case Types.LONGVARBINARY:
          case Types.VARBINARY:
            if (isBinary(columnIndex + 1)) {
              rowBuffer.set(columnIndex, (byte[]) valueObject);
            } else {
              try {
                rowBuffer.set(columnIndex,
                    RedshiftBytea.toRSString((byte[]) valueObject).getBytes("ISO-8859-1"));
              } catch (UnsupportedEncodingException e) {
                throw new RedshiftException(
                    GT.tr("The JVM claims not to support the encoding: {0}", "ISO-8859-1"),
                    RedshiftState.UNEXPECTED_ERROR, e);
              }
            }
            break;
            
          case Types.SMALLINT:
            if (isBinary(columnIndex + 1)
            		&& valueObject != null) {
	            byte[] val = new byte[2];
	            ByteConverter.int2(val, 0, Integer.valueOf(String.valueOf(valueObject)));
	            rowBuffer.set(columnIndex, val);
            }
            else {
            	// Does as default switch case
              rowBuffer.set(columnIndex, connection.encodeString(String.valueOf(valueObject)));
            }
            
          	break;
          	
          case Types.INTEGER:
            if (isBinary(columnIndex + 1)
            		&& valueObject != null) {
	            byte[] val = new byte[4];
	            ByteConverter.int4(val, 0, Integer.valueOf(String.valueOf(valueObject)));
	            rowBuffer.set(columnIndex, val);
            }
            else {
            	// Does as default switch case
              rowBuffer.set(columnIndex, connection.encodeString(String.valueOf(valueObject)));
            }
            
          	break;

          case Types.BIGINT:
            if (isBinary(columnIndex + 1)
            		&& valueObject != null) {
	            byte[] val = new byte[8];
	            ByteConverter.int8(val, 0, Long.valueOf(String.valueOf(valueObject)));
	            rowBuffer.set(columnIndex, val);
            }
            else {
            	// Does as default switch case
              rowBuffer.set(columnIndex, connection.encodeString(String.valueOf(valueObject)));
            }
            
          	break;

          case Types.FLOAT:
            if (isBinary(columnIndex + 1)
            		&& valueObject != null) {
              byte[] val = new byte[4];
              ByteConverter.float4(val, 0, Float.parseFloat(String.valueOf(valueObject)));
	            rowBuffer.set(columnIndex, val);
            }
            else {
            	// Does as default switch case
              rowBuffer.set(columnIndex, connection.encodeString(String.valueOf(valueObject)));
            }

          case Types.DOUBLE:
            if (isBinary(columnIndex + 1)
            		&& valueObject != null) {
              byte[] val = new byte[8];
              ByteConverter.float8(val, 0, Double.parseDouble(String.valueOf(valueObject)));
	            rowBuffer.set(columnIndex, val);
            }
            else {
            	// Does as default switch case
              rowBuffer.set(columnIndex, connection.encodeString(String.valueOf(valueObject)));
            }
            
          	break;

          case Types.DECIMAL:
          case Types.NUMERIC:
            if (isBinary(columnIndex + 1)
            		&& valueObject != null) {
          	  Field field = fields[columnIndex];
          	  int mod = field.getMod();
          	  int serverPrecision;
          	  int serverScale;
          	  
          	  serverPrecision =  (mod == -1) 
          	  										? 0
          	  										: ((mod - 4) & 0xFFFF0000) >> 16;
          	    
          	  serverScale =  (mod == -1) 
          	  									? 0
          	  									: (mod - 4) & 0xFFFF;
            	
              byte[] val = ByteConverter.redshiftNumeric(new BigDecimal(String.valueOf(valueObject)), serverPrecision, serverScale);
	            rowBuffer.set(columnIndex, val);
            }
            else {
            	// Does as default switch case
              rowBuffer.set(columnIndex, connection.encodeString(String.valueOf(valueObject)));
            }
            
          	break;
          	
          	
          default:
            rowBuffer.set(columnIndex, connection.encodeString(String.valueOf(valueObject)));
            break;
        }

      }
    }
  }