Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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 org.apache.pig.impl.util.avro;
 
 
 import java.util.List;
 import java.util.Map;

Object that wraps an Avro object in a tuple.

Parameters:
<T> The type of the Avro object
 
 public final class AvroTupleWrapper <T extends IndexedRecord>
     implements Tuple {

  
The Avro object wrapped in the pig Tuple.
 
   private T avroObject;

  
Creates a new AvroTupleWrapper object.

Parameters:
o The object to wrap
 
   public AvroTupleWrapper(final T o) {
      = o;
   }
 
   @Override
   public void write(final DataOutput othrows IOException {
     throw new IOException(
         this.getClass().toString() + ".write called, but not implemented yet");
   }
 
   @SuppressWarnings("rawtypes")
   @Override
   public int compareTo(final Object o) {
     if (o instanceof AvroTupleWrapper) {
       return GenericData.get().compare(,
           ((AvroTupleWrappero).,
           .getSchema());
     }
     return -1;
   }
 
   @Override
   public void append(final Object o) {
     List<Fieldfields = .getSchema().getFields();
     .put(fields.size(), o);
     Schema fieldSchema = null;
     if (o instanceof String) {
       fieldSchema = Schema.create(.);
     } else if (o instanceof Integer) {
       fieldSchema = Schema.create(.);
     } else if (o instanceof Long) {
       fieldSchema = Schema.create(.);
     } else if (o instanceof Double) {
       fieldSchema = Schema.create(.);
     } else if (o instanceof Float) {
       fieldSchema = Schema.create(.);
     } else if (o == null) {
       fieldSchema = Schema.create(.);
     } else if (o instanceof Boolean) {
       fieldSchema = Schema.create(.);
    } else if (o instanceof Map) {
      fieldSchema = Schema.create(.);
    }
    Field newField = new Field("FIELD_" + fields.size(), fieldSchema""null);
    fields.add(newField);
    .getSchema().setFields(fields);
  }
  @SuppressWarnings("unchecked")
  public Object get(final int posthrows ExecException {
    Schema s = .getSchema().getFields().get(pos).schema();
    Object o = .get(pos);
    switch(s.getType()) {
      case :
        // unwrap avro UTF8 encoding
        return o.toString();
      case :
        return new AvroMapWrapper((Map<CharSequenceObject>) o);
      case :
        return new AvroTupleWrapper<T>((T) o);
      case :
        return o.toString();
      case :
        return new AvroBagWrapper<GenericData.Record>(
            (GenericArray<GenericData.Record>) o);
      case :
        return new DataByteArray(((GenericData.Fixedo).bytes());
      case :
        return new DataByteArray(((ByteBuffero).array());
      case :
        return unionResolver(o);
      default:
        return o;
    }
  }
  public static Object unionResolver(Object o) {
    if (o instanceof org.apache.avro.util.Utf8) {
      return o.toString();
    } else if (o instanceof IndexedRecord) {
      return new AvroTupleWrapper<IndexedRecord>((IndexedRecordo);
    } else if (o instanceof GenericArray) {
      return new AvroBagWrapper<GenericData.Record>(
          (GenericArray<GenericData.Record>) o);
    } else if (o instanceof Map) {
      return new AvroMapWrapper((Map<CharSequenceObject>) o);
    } else if (o instanceof GenericData.Fixed) {
      return new DataByteArray(((GenericData.Fixedo).bytes());
    } else if (o instanceof ByteBuffer) {
      return new DataByteArray(((ByteBuffero).array());
    } else if (o instanceof GenericEnumSymbol) {
      return o.toString();
    } else {
      return o;
    }
  }
  public List<ObjectgetAll() {
    List<Objectall = Lists.newArrayList();
    for (Schema.Field f : .getSchema().getFields()) {
      try {
        all.add(get(f.pos()));
      } catch (ExecException e) {
        LogFactory.getLog(getClass()).error(
            "could not process tuple with contents " + e);
        return null;
      }
    }
    return all;
  }
  public long getMemorySize() {
    return getMemorySize();
  }
  @SuppressWarnings({ "rawtypes""unchecked" })
  private long getMemorySize(final IndexedRecord r) {
    int total = 0;
    final int bitsPerByte = 8;
    for (Field f : r.getSchema().getFields()) {
      switch (f.schema().getType()) {
      case :
      case :
      case :
        total += . << bitsPerByte;
        break;
      case :
        total += . << bitsPerByte;
        break;
      case :
        total += . << bitsPerByte;
        break;
      case :
        break;
      case :
        total += ((Stringr.get(f.pos())).length()
           * (. << bitsPerByte);
        break;
      case :
        total += ((Byte[]) r.get(f.pos())).length;
        break;
      case :
        total += new AvroTupleWrapper(
            (IndexedRecordr.get(f.pos())).getMemorySize();
        break;
      case :
        total += new AvroBagWrapper(
            (GenericArrayr.get(f.pos())).getMemorySize();
        break;
      }
    }
    return total;
  }
  public byte getType(final int arg0throws ExecException {
    Schema s = .getSchema().getFields().get(arg0).schema();
    return AvroStorageSchemaConversionUtilities.getPigType(s);
  }
  public boolean isNull(final int arg0throws ExecException {
    return  == null || .get(arg0) == null;
  }
  @SuppressWarnings("unchecked")
  public void reference(final Tuple arg0) {
     = (T) ((AvroTupleWrapper<T>) arg0).;
  }
  public void set(final int arg0final Object arg1throws ExecException {
    .put(arg0arg1);
  }
  public int size() {
    return .getSchema().getFields().size();
  }
  public String toDelimitedString(final String arg0throws ExecException {
    StringBuffer delimitedString = new StringBuffer();
    boolean notfirst = false;
    for (Field f : .getSchema().getFields()) {
      if (notfirst) {
        delimitedString.append(arg0);
        notfirst = true;
      }
      Object val = .get(f.pos());
      if (val == null) {
          delimitedString.append("");
      } else {
          delimitedString.append(val.toString());
      }
    }
    return delimitedString.toString();
  }
  public void readFields(final DataInput dthrows IOException {
    throw new IOException(
        this.getClass().toString()
        +  ".readFields called but not implemented yet");
  }
  public Iterator<Objectiterator() {
    return Iterators.transform(.getSchema().getFields().iterator(),
        new Function<Schema.FieldObject>() {
            @Override
            public Object apply(final Field f) {
              return .get(f.pos());
            }
          }
        );
  }
New to GrepCode? Check out our FAQ X