Java tutorial
/* Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package edu.mit.ll.graphulo.pig.backend; import java.io.ByteArrayInputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.math.BigDecimal; import java.math.BigInteger; import java.util.Map; import org.apache.accumulo.core.Constants; import org.apache.pig.LoadStoreCaster; import org.apache.pig.ResourceSchema.ResourceFieldSchema; import org.apache.pig.backend.executionengine.ExecException; import org.apache.pig.data.DataBag; import org.apache.pig.data.DataByteArray; import org.apache.pig.data.Tuple; import org.joda.time.DateTime; import com.google.common.base.Preconditions; import static com.google.common.base.Charsets.UTF_8; /** * A LoadStoreCaster implementation which stores most type implementations as * bytes generated from the toString representation with a UTF8 Charset. Pulled * some implementations from the Accumulo Lexicoder implementations in 1.6.0. */ public class AccumuloBinaryConverter implements LoadStoreCaster { private static final int SIZE_OF_INT = Integer.SIZE / Byte.SIZE; private static final int SIZE_OF_LONG = Long.SIZE / Byte.SIZE; public static final java.nio.charset.Charset UTF8 = UTF_8; /** * NOT IMPLEMENTED */ @Override public DataBag bytesToBag(byte[] b, ResourceFieldSchema fieldSchema) throws IOException { throw new ExecException("Can't generate DataBags from byte[]"); } @Override public BigDecimal bytesToBigDecimal(byte[] b) throws IOException { throw new ExecException("Can't generate a BigInteger from byte[]"); } @Override public BigInteger bytesToBigInteger(byte[] b) throws IOException { // Taken from Accumulo's BigIntegerLexicoder in 1.6.0 DataInputStream dis = new DataInputStream(new ByteArrayInputStream(b)); int len = dis.readInt(); len = len ^ 0x80000000; len = Math.abs(len); byte[] bytes = new byte[len]; dis.readFully(bytes); bytes[0] = (byte) (0x80 ^ bytes[0]); return new BigInteger(bytes); } @Override public Boolean bytesToBoolean(byte[] b) throws IOException { Preconditions.checkArgument(1 == b.length); return b[0] == (byte) 1; } @Override public String bytesToCharArray(byte[] b) throws IOException { return new String(b, UTF8); } /** * NOT IMPLEMENTED */ @Override public DateTime bytesToDateTime(byte[] b) throws IOException { String s = new String(b, UTF8); return DateTime.parse(s); } @Override public Double bytesToDouble(byte[] b) throws IOException { return Double.longBitsToDouble(bytesToLong(b)); } @Override public Float bytesToFloat(byte[] b) throws IOException { return Float.intBitsToFloat(bytesToInteger(b)); } @Override public Integer bytesToInteger(byte[] b) throws IOException { Preconditions.checkArgument(b.length == SIZE_OF_INT); int n = 0; for (int i = 0; i < b.length; i++) { n <<= 8; n ^= b[i] & 0xFF; } return n; } @Override public Long bytesToLong(byte[] b) throws IOException { Preconditions.checkArgument(b.length == SIZE_OF_LONG); long l = 0; for (int i = 0; i < b.length; i++) { l <<= 8; l ^= b[i] & 0xFF; } return l; } /** * NOT IMPLEMENTED */ @Override public Map<String, Object> bytesToMap(byte[] b, ResourceFieldSchema fieldSchema) throws IOException { throw new ExecException("Can't generate Map from byte[]"); } /** * NOT IMPLEMENTED */ @Override public Tuple bytesToTuple(byte[] b, ResourceFieldSchema fieldSchema) throws IOException { throw new ExecException("Can't generate a Tuple from byte[]"); } /** * Not implemented! */ @Override public byte[] toBytes(BigDecimal bd) throws IOException { throw new IOException("Can't generate bytes from BigDecimal"); } @Override public byte[] toBytes(BigInteger bi) throws IOException { // Taken from Accumulo's BigIntegerLexicoder in 1.6.0 byte[] bytes = bi.toByteArray(); byte[] ret = new byte[4 + bytes.length]; DataOutputStream dos = new DataOutputStream(new FixedByteArrayOutputStream(ret)); // flip the sign bit bytes[0] = (byte) (0x80 ^ bytes[0]); int len = bytes.length; if (bi.signum() < 0) len = -len; len = len ^ 0x80000000; try { dos.writeInt(len); dos.write(bytes); } finally { dos.close(); } return ret; } @Override public byte[] toBytes(Boolean b) throws IOException { return new byte[] { b ? (byte) 1 : (byte) 0 }; } /** * NOT IMPLEMENTED */ @Override public byte[] toBytes(DataBag bag) throws IOException { throw new ExecException("Cant' generate bytes from DataBag"); } @Override public byte[] toBytes(DataByteArray a) throws IOException { return a.get(); } @Override public byte[] toBytes(DateTime dt) throws IOException { return dt.toString().getBytes(UTF8); } @Override public byte[] toBytes(Double d) throws IOException { return toBytes(Double.doubleToRawLongBits(d)); } @Override public byte[] toBytes(Float f) throws IOException { return toBytes(Float.floatToRawIntBits(f)); } @Override public byte[] toBytes(Integer val) throws IOException { int intVal = val.intValue(); byte[] b = new byte[4]; for (int i = 3; i > 0; i--) { b[i] = (byte) intVal; intVal >>>= 8; } b[0] = (byte) intVal; return b; } @Override public byte[] toBytes(Long val) throws IOException { long longVal = val.longValue(); byte[] b = new byte[8]; for (int i = 7; i > 0; i--) { b[i] = (byte) longVal; longVal >>>= 8; } b[0] = (byte) longVal; return b; } /** * NOT IMPLEMENTED */ @Override public byte[] toBytes(Map<String, Object> m) throws IOException { throw new IOException("Can't generate bytes from Map"); } @Override public byte[] toBytes(String s) throws IOException { return s.getBytes(UTF8); } /** * NOT IMPLEMENTED */ @Override public byte[] toBytes(Tuple t) throws IOException { throw new IOException("Can't generate bytes from Tuple"); } }