AvroConverter.java

/*
 * Copyright 2010 Outerthought bvba
 *
 * Licensed 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.lilyproject.avro;

import java.io.IOException;
import java.lang.reflect.Constructor;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import com.ngdata.lily.security.hbase.client.AuthorizationContext;
import org.apache.avro.AvroRemoteException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.lilyproject.avro.repository.RecordAsBytesConverter;
import org.lilyproject.bytes.impl.DataInputImpl;
import org.lilyproject.repository.api.CompareOp;
import org.lilyproject.repository.api.FieldType;
import org.lilyproject.repository.api.FieldTypeEntry;
import org.lilyproject.repository.api.IdRecord;
import org.lilyproject.repository.api.IdentityRecordStack;
import org.lilyproject.repository.api.LRepository;
import org.lilyproject.repository.api.MutationCondition;
import org.lilyproject.repository.api.QName;
import org.lilyproject.repository.api.Record;
import org.lilyproject.repository.api.RecordId;
import org.lilyproject.repository.api.RecordType;
import org.lilyproject.repository.api.RemoteException;
import org.lilyproject.repository.api.RepositoryException;
import org.lilyproject.repository.api.SchemaId;
import org.lilyproject.repository.api.Scope;
import org.lilyproject.repository.api.TableCreateDescriptor;
import org.lilyproject.repository.api.TypeBucket;
import org.lilyproject.repository.api.TypeManager;
import org.lilyproject.repository.api.ValueType;
import org.lilyproject.repository.impl.id.SchemaIdImpl;
import org.lilyproject.util.Pair;
import org.lilyproject.util.repo.SystemFields;

public class AvroConverter {
    protected Log log = LogFactory.getLog(getClass());

    public AvroConverter() {
    }


    private byte[] asArray(ByteBuffer buffer) {
        byte[] bytes = new byte[buffer.remaining()];
        buffer.get(bytes, 0, bytes.length);
        return bytes;
    }

    public AuthorizationContext convert(AvroAuthzContext authzContext) {
        if (authzContext == null)
            return null;

        Set<String> roles = new HashSet<String>();
        for (String role : authzContext.getRoles()) {
            roles.add(role);
        }

        return new AuthorizationContext(authzContext.getName(), authzContext.getTenant(), roles);
    }

    public AvroAuthzContext convert(AuthorizationContext authzContext) {
        if (authzContext == null)
            return null;

        List<String> roles = new ArrayList<String>(authzContext.getRoles().size());
        for (String role : authzContext.getRoles()) {
            roles.add(role);
        }

        return new AvroAuthzContext(authzContext.getName(), authzContext.getTenant(), roles);
    }

    public ByteBuffer convert(Record record, LRepository repository) throws AvroRepositoryException,
            AvroInterruptedException, RepositoryException, InterruptedException {
        return ByteBuffer.wrap(RecordAsBytesConverter.write(record, repository));
    }

    public ByteBuffer convert(IdRecord idRecord, LRepository repository) throws AvroRepositoryException,
            AvroInterruptedException, RepositoryException, InterruptedException {
        return ByteBuffer.wrap(RecordAsBytesConverter.writeIdRecord(idRecord, repository));
    }

    public Record convertRecord(ByteBuffer recordData, LRepository repository)
            throws RepositoryException, InterruptedException {
        return RecordAsBytesConverter.read(new DataInputImpl(asArray(recordData)), repository);
    }

    public IdRecord convertIdRecord(ByteBuffer avroIdRecord, LRepository repository)
            throws RepositoryException, InterruptedException {
        return RecordAsBytesConverter.readIdRecord(new DataInputImpl(asArray(avroIdRecord)), repository);
    }

    public List<AvroMutationCondition> convert(Record parentRecord, List<MutationCondition> conditions,
            LRepository repository) throws AvroRepositoryException, AvroInterruptedException {

        if (conditions == null) {
            return null;
        }

        List<AvroMutationCondition> avroConditions = new ArrayList<AvroMutationCondition>(conditions.size());

        SystemFields systemFields = SystemFields.getInstance(repository.getTypeManager(), repository.getIdGenerator());

        IdentityRecordStack parentRecords = new IdentityRecordStack(parentRecord);

        for (MutationCondition condition : conditions) {
            FieldType fieldType;
            try {
                if (systemFields.isSystemField(condition.getField())) {
                    fieldType = systemFields.get(condition.getField());
                } else {
                    fieldType = repository.getTypeManager().getFieldTypeByName(condition.getField());
                }

                AvroMutationCondition avroCond = new AvroMutationCondition();

                avroCond.setName(convert(condition.getField()));

                if (condition.getValue() != null) {
                    ValueType valueType = fieldType.getValueType();
                    avroCond.setValueType(valueType.getName());

                    byte[] value = valueType.toBytes(condition.getValue(), parentRecords);
                    avroCond.setValue(ByteBuffer.wrap(value));
                }
                avroCond.setOperator(convert(condition.getOp()));
                avroCond.setAllowMissing(condition.getAllowMissing());

                avroConditions.add(avroCond);
            } catch (RepositoryException e) {
                throw convert(e);
            } catch (InterruptedException e) {
                throw convert(e);
            }

        }

        return avroConditions;
    }

    public List<Record> convertAvroRecords(List<ByteBuffer> avroRecords, LRepository repository)
            throws RepositoryException, InterruptedException {
        List<Record> records = new ArrayList<Record>();
        for (ByteBuffer avroRecord : avroRecords) {
            records.add(convertRecord(avroRecord, repository));
        }
        return records;
    }

    public List<ByteBuffer> convertRecords(Collection<Record> records, LRepository repository)
            throws AvroRepositoryException, AvroInterruptedException, RepositoryException, InterruptedException {
        List<ByteBuffer> avroRecords = new ArrayList<ByteBuffer>(records.size());
        for (Record record : records) {
            avroRecords.add(convert(record, repository));
        }
        return avroRecords;
    }


    public FieldType convert(AvroFieldType avroFieldType, TypeManager typeManager)
            throws RepositoryException, InterruptedException {
        ValueType valueType = convert(avroFieldType.getValueType(), typeManager);
        QName name = convert(avroFieldType.getName());
        SchemaId id = convert(avroFieldType.getId());
        if (id != null) {
            return typeManager.newFieldType(id, valueType, name, convert(avroFieldType.getScope()));
        }
        return typeManager.newFieldType(valueType, name, convert(avroFieldType.getScope()));
    }

    public Scope convert(AvroScope scope) {
        return scope == null ? null : Scope.values()[scope.ordinal()];
    }

    public AvroFieldType convert(FieldType fieldType) {
        AvroFieldType avroFieldType = new AvroFieldType();

        avroFieldType.setId(convert(fieldType.getId()));
        avroFieldType.setName(convert(fieldType.getName()));
        avroFieldType.setValueType(convert(fieldType.getValueType()));
        avroFieldType.setScope(convert(fieldType.getScope()));
        return avroFieldType;
    }

    public AvroScope convert(Scope scope) {
        return scope == null ? null : AvroScope.values()[scope.ordinal()];
    }

    public RecordType convert(AvroRecordType avroRecordType, TypeManager typeManager) throws RepositoryException {
        SchemaId recordTypeId = convert(avroRecordType.getId());
        QName recordTypeName = convert(avroRecordType.getName());
        RecordType recordType = typeManager.newRecordType(recordTypeId, recordTypeName);
        recordType.setVersion(avroRecordType.getVersion());
        List<AvroFieldTypeEntry> fieldTypeEntries = avroRecordType.getFieldTypeEntries();
        if (fieldTypeEntries != null) {
            for (AvroFieldTypeEntry avroFieldTypeEntry : fieldTypeEntries) {
                recordType.addFieldTypeEntry(convert(avroFieldTypeEntry, typeManager));
            }
        }
        List<AvroSupertype> supertypes = avroRecordType.getSupertypes();
        if (supertypes != null) {
            for (AvroSupertype avroSupertype : supertypes) {
                recordType.addSupertype(convert(avroSupertype.getRecordTypeId()), avroSupertype.getRecordTypeVersion());
            }
        }
        return recordType;
    }

    public AvroRecordType convert(RecordType recordType) {
        AvroRecordType avroRecordType = new AvroRecordType();
        avroRecordType.setId(convert(recordType.getId()));
        avroRecordType.setName(convert(recordType.getName()));
        Long version = recordType.getVersion();
        if (version != null) {
            avroRecordType.setVersion(version);
        }
        Collection<FieldTypeEntry> fieldTypeEntries = recordType.getFieldTypeEntries();
        avroRecordType.setFieldTypeEntries(new ArrayList<AvroFieldTypeEntry>(fieldTypeEntries.size()));
        for (FieldTypeEntry fieldTypeEntry : fieldTypeEntries) {
            avroRecordType.getFieldTypeEntries().add(convert(fieldTypeEntry));
        }
        Set<Entry<SchemaId, Long>> supertypeEntries = recordType.getSupertypes().entrySet();
        avroRecordType.setSupertypes(new ArrayList<AvroSupertype>(supertypeEntries.size()));
        for (Entry<SchemaId, Long> supertypeEntry : supertypeEntries) {
            avroRecordType.getSupertypes().add(convert(supertypeEntry));
        }
        return avroRecordType;
    }

    public AvroFieldAndRecordTypes convertFieldAndRecordTypes(Pair<List<FieldType>, List<RecordType>> types) {
        AvroFieldAndRecordTypes avroTypes = new AvroFieldAndRecordTypes();
        List<FieldType> fieldTypes = types.getV1();
        avroTypes.setFieldTypes(new ArrayList<AvroFieldType>(fieldTypes.size()));
        for (FieldType fieldType : fieldTypes) {
            avroTypes.getFieldTypes().add(convert(fieldType));
        }
        List<RecordType> recordTypes = types.getV2();
        avroTypes.setRecordTypes(new ArrayList<AvroRecordType>(recordTypes.size()));
        for (RecordType recordType : recordTypes) {
            avroTypes.getRecordTypes().add(convert(recordType));
        }
        return avroTypes;
    }

    public Pair<List<FieldType>, List<RecordType>> convertAvroFieldAndRecordTypes(AvroFieldAndRecordTypes types,
            TypeManager typeManager) throws RepositoryException, InterruptedException {
        List<FieldType> fieldTypes = new ArrayList<FieldType>(types.getFieldTypes().size());
        for (AvroFieldType avroFieldType : types.getFieldTypes()) {
            fieldTypes.add(convert(avroFieldType, typeManager));
        }
        List<RecordType> recordTypes = new ArrayList<RecordType>(types.getRecordTypes().size());
        for (AvroRecordType avroRecordType : types.getRecordTypes()) {
            recordTypes.add(convert(avroRecordType, typeManager));
        }
        return new Pair<List<FieldType>, List<RecordType>>(fieldTypes, recordTypes);
    }

    public AvroTypeBucket convertTypeBucket(TypeBucket typeBucket) {
        AvroTypeBucket avroTypeBucket = new AvroTypeBucket();
        avroTypeBucket.setBucketId(typeBucket.getBucketId());
        List<FieldType> fieldTypes = typeBucket.getFieldTypes();
        avroTypeBucket.setFieldTypes(new ArrayList<AvroFieldType>(fieldTypes.size()));
        for (FieldType fieldType : fieldTypes) {
            avroTypeBucket.getFieldTypes().add(convert(fieldType));
        }
        List<RecordType> recordTypes = typeBucket.getRecordTypes();
        avroTypeBucket.setRecordTypes(new ArrayList<AvroRecordType>(recordTypes.size()));
        for (RecordType recordType : recordTypes) {
            avroTypeBucket.getRecordTypes().add(convert(recordType));
        }
        return avroTypeBucket;
    }

    public TypeBucket convertAvroTypeBucket(AvroTypeBucket avroTypeBucket, TypeManager  typeManager)
            throws RepositoryException, InterruptedException {
        TypeBucket typeBucket = new TypeBucket(avroTypeBucket.getBucketId());
        for (AvroFieldType avroFieldType : avroTypeBucket.getFieldTypes()) {
            typeBucket.add(convert(avroFieldType, typeManager));
        }
        for (AvroRecordType avroRecordType : avroTypeBucket.getRecordTypes()) {
            typeBucket.add(convert(avroRecordType, typeManager));
        }
        return typeBucket;
    }

    public ValueType convert(AvroValueType valueType, TypeManager typeManager)
            throws RepositoryException, InterruptedException {
        return valueType == null ? null : typeManager.getValueType(valueType.getValueType());
    }

    public AvroValueType convert(ValueType valueType) {
        if (valueType == null) {
            return null;
        }

        AvroValueType avroValueType = new AvroValueType();
        avroValueType.setValueType(valueType.getName());
        return avroValueType;
    }

    public QName convert(AvroQName name) {
        if (name == null) {
            return null;
        }
        return new QName(name.getNamespace(), name.getName());
    }

    public AvroQName convert(QName name) {
        if (name == null) {
            return null;
        }

        AvroQName avroQName = new AvroQName();
        avroQName.setNamespace(name.getNamespace());
        avroQName.setName(name.getName());
        return avroQName;
    }

    public AvroSupertype convert(Entry<SchemaId, Long> supertypeEntry) {
        AvroSupertype avroSupertype = new AvroSupertype();
        avroSupertype.setRecordTypeId(convert(supertypeEntry.getKey()));
        Long version = supertypeEntry.getValue();
        if (version != null) {
            avroSupertype.setRecordTypeVersion(version);
        }
        return avroSupertype;
    }

    public FieldTypeEntry convert(AvroFieldTypeEntry avroFieldTypeEntry, TypeManager typeManager) {
        return typeManager.newFieldTypeEntry(convert(avroFieldTypeEntry.getId()),
                avroFieldTypeEntry.getMandatory());
    }

    public AvroFieldTypeEntry convert(FieldTypeEntry fieldTypeEntry) {
        AvroFieldTypeEntry avroFieldTypeEntry = new AvroFieldTypeEntry();
        avroFieldTypeEntry.setId(convert(fieldTypeEntry.getFieldTypeId()));
        avroFieldTypeEntry.setMandatory(fieldTypeEntry.isMandatory());
        return avroFieldTypeEntry;
    }

    public static AvroGenericException convertOtherException(Throwable throwable) {
        AvroGenericException avroException = new AvroGenericException();
        avroException.setMessage$(throwable.getMessage());
        avroException.setExceptionClass(throwable.getClass().getName());
        avroException.setRemoteCauses(buildCauses(throwable));
        return avroException;
    }

    public RuntimeException convert(AvroGenericException avroException) {
        try {
            // Attempt to restore the original exception: only for RuntimeExceptions which
            // have a constructor that takes a string argument.
            Class exceptionClass = Class.forName(avroException.getExceptionClass());
            if (RuntimeException.class.isAssignableFrom(exceptionClass)) {
                Constructor constructor = exceptionClass.getConstructor(String.class);
                constructor.setAccessible(true);
                RuntimeException runtimeException = (RuntimeException) constructor.newInstance(
                        avroException.getMessage$());
                restoreCauses(avroException.getRemoteCauses(), runtimeException);
                return runtimeException;
            }
        } catch (Exception e) {
            // cannot restore the original exception, will create a generic exception
        }

        RuntimeException exception = new RuntimeException(avroException.getExceptionClass() + ": "
                + avroException.getMessage());
        restoreCauses(avroException.getRemoteCauses(), exception);
        return exception;
    }

    public RemoteException convert(AvroRemoteException exception) {
        return new RemoteException(exception.getMessage(), exception);
    }

    public AvroRepositoryException convert(RepositoryException exception) {
        AvroRepositoryException avroRepositoryException = new AvroRepositoryException();
        avroRepositoryException.setMessage$(exception.getMessage());
        avroRepositoryException.setRemoteCauses(buildCauses(exception));
        avroRepositoryException.setExceptionClass(exception.getClass().getName());
        avroRepositoryException.setParams(exception.getState());
        return avroRepositoryException;
    }

    public RepositoryException convert(AvroRepositoryException avroException) {
        try {
            Class exceptionClass = Class.forName(avroException.getExceptionClass());
            Constructor constructor = exceptionClass.getConstructor(String.class, Map.class);
            RepositoryException repositoryException = (RepositoryException) constructor.newInstance(
                    avroException.getMessage$(), avroException.getParams());
            restoreCauses(avroException.getRemoteCauses(), repositoryException);
            return repositoryException;
        } catch (Exception e) {
            log.error("Failure while converting remote exception", e);

            RepositoryException repositoryException = new RepositoryException(avroException.getMessage$());
            restoreCauses(avroException.getRemoteCauses(), repositoryException);
            return repositoryException;
        }
    }

    public AvroInterruptedException convert(InterruptedException exception) {
        AvroInterruptedException avroException = new AvroInterruptedException();
        avroException.setMessage$(exception.getMessage());
        return avroException;
    }

    public AvroIOException convert(IOException exception) {
        AvroIOException avroIOException = new AvroIOException();
        avroIOException.setMessage$(exception.getMessage());
        avroIOException.setRemoteCauses(buildCauses(exception));
        avroIOException.setExceptionClass(exception.getClass().getName());
        return avroIOException;
    }

    public IOException convert(AvroIOException avroException) {
        try {
            Class exceptionClass = Class.forName(avroException.getExceptionClass());
            Constructor constructor = exceptionClass.getConstructor(String.class);
            IOException ioException = (IOException) constructor.newInstance(avroException.getMessage$());
            restoreCauses(avroException.getRemoteCauses(), ioException);
            return ioException;
        } catch (Exception e) {
            log.error("Failure while converting remote exception", e);

            IOException ioException = new IOException(avroException.getMessage$());
            restoreCauses(avroException.getRemoteCauses(), ioException);
            return ioException;
        }
    }

    public ByteBuffer convert(RecordId recordId) {
        if (recordId == null) {
            return null;
        }
        return ByteBuffer.wrap(recordId.toBytes());
    }

    public Long convertAvroVersion(long avroVersion) {
        if (avroVersion == -1) {
            return null;
        }
        return avroVersion;
    }

    public long convertVersion(Long version) {
        if (version == null) {
            return -1;
        }
        return version;
    }

    private static List<AvroExceptionCause> buildCauses(Throwable throwable) {
        List<AvroExceptionCause> causes = new ArrayList<AvroExceptionCause>();

        Throwable cause = throwable;

        while (cause != null) {
            causes.add(convertCause(cause));
            cause = cause.getCause();
        }

        return causes;
    }

    private static AvroExceptionCause convertCause(Throwable throwable) {
        AvroExceptionCause cause = new AvroExceptionCause();
        cause.setClassName(throwable.getClass().getName());
        cause.setMessage(throwable.getMessage());

        StackTraceElement[] stackTrace = throwable.getStackTrace();

        cause.setStackTrace(new ArrayList<AvroStackTraceElement>(stackTrace.length));

        for (StackTraceElement el : stackTrace) {
            cause.getStackTrace().add(convert(el));
        }

        return cause;
    }

    private static AvroStackTraceElement convert(StackTraceElement el) {
        AvroStackTraceElement result = new AvroStackTraceElement();
        result.setClassName(el.getClassName());
        result.setMethodName(el.getMethodName());
        result.setFileName(el.getFileName());
        result.setLineNumber(el.getLineNumber());
        return result;
    }

    private void restoreCauses(List<AvroExceptionCause> remoteCauses, Throwable throwable) {
        Throwable causes = restoreCauses(remoteCauses);
        if (causes != null) {
            throwable.initCause(causes);
        }
    }

    private Throwable restoreCauses(List<AvroExceptionCause> remoteCauses) {
        Throwable result = null;

        for (AvroExceptionCause remoteCause : remoteCauses) {
            List<StackTraceElement> stackTrace = new ArrayList<StackTraceElement>(remoteCause.getStackTrace().size());

            for (AvroStackTraceElement el : remoteCause.getStackTrace()) {
                stackTrace.add(new StackTraceElement(el.getClassName(), el.getMethodName(),
                        el.getFileName(), el.getLineNumber()));
            }

            RestoredException cause = new RestoredException(remoteCause.getMessage(),
                    remoteCause.getClassName(), stackTrace);

            if (result == null) {
                result = cause;
            } else {
                result.initCause(cause);
                result = cause;
            }
        }

        return result;
    }

    public List<FieldType> convertAvroFieldTypes(List<AvroFieldType> avroFieldTypes, TypeManager typeManager)
            throws RepositoryException, InterruptedException {
        List<FieldType> fieldTypes = new ArrayList<FieldType>();
        for (AvroFieldType avroFieldType : avroFieldTypes) {
            fieldTypes.add(convert(avroFieldType, typeManager));
        }
        return fieldTypes;
    }

    public List<RecordType> convertAvroRecordTypes(List<AvroRecordType> avroRecordTypes, TypeManager typeManager)
            throws RepositoryException, InterruptedException {
        List<RecordType> recordTypes = new ArrayList<RecordType>();
        for (AvroRecordType avroRecordType : avroRecordTypes) {
            recordTypes.add(convert(avroRecordType, typeManager));
        }
        return recordTypes;
    }

    public List<AvroFieldType> convertFieldTypes(Collection<FieldType> fieldTypes) {
        List<AvroFieldType> avroFieldTypes = new ArrayList<AvroFieldType>(fieldTypes.size());
        for (FieldType fieldType : fieldTypes) {
            avroFieldTypes.add(convert(fieldType));
        }
        return avroFieldTypes;
    }

    public List<AvroRecordType> convertRecordTypes(Collection<RecordType> recordTypes) {
        List<AvroRecordType> avroRecordTypes = new ArrayList<AvroRecordType>(recordTypes.size());
        for (RecordType recordType : recordTypes) {
            avroRecordTypes.add(convert(recordType));
        }
        return avroRecordTypes;
    }





    public SchemaId convert(AvroSchemaId avroSchemaId) {
        if (avroSchemaId == null) {
            return null;
        }
        byte[] idBytes = null;
        if (avroSchemaId.getIdBytes() != null) {
            idBytes = avroSchemaId.getIdBytes().array();
        }
        return new SchemaIdImpl(idBytes);
    }

    public AvroSchemaId convert(SchemaId schemaId) {
        if (schemaId == null) {
            return null;
        }
        AvroSchemaId avroSchemaId = new AvroSchemaId();
        if (schemaId.getBytes() != null) {
            avroSchemaId.setIdBytes(ByteBuffer.wrap(schemaId.getBytes()));
        }
        return avroSchemaId;
    }

    public QName[] convert(List<AvroQName> avroNames) {
        QName[] names = null;
        if (avroNames != null) {
            names = new QName[avroNames.size()];
            int i = 0;
            for (AvroQName avroQName : avroNames) {
                names[i++] = convert(avroQName);
            }
        }
        return names;
    }





    public List<String> convert(Set<RecordId> recordIds) {
        List<String> avroRecordIds = new ArrayList<String>(recordIds.size());
        for (RecordId recordId : recordIds) {
            avroRecordIds.add(recordId.toString());
        }
        return avroRecordIds;
    }

    public CompareOp convert(AvroCompareOp op) {
        return op == null ? null : CompareOp.values()[op.ordinal()];
    }



    public List<MutationCondition> convertFromAvro(List<AvroMutationCondition> avroConditions, LRepository repository)
            throws RepositoryException, InterruptedException {

        if (avroConditions == null) {
            return null;
        }

        List<MutationCondition> conditions = new ArrayList<MutationCondition>(avroConditions.size());

        for (AvroMutationCondition avroCond : avroConditions) {
            QName name = convert(avroCond.getName());

            // value is optional
            Object value = null;
            if (avroCond.getValue() != null) {
                ValueType valueType = repository.getTypeManager().getValueType(avroCond.getValueType());
                value = valueType.read(avroCond.getValue().array());
            }

            CompareOp op = convert(avroCond.getOperator());
            boolean allowMissing = avroCond.getAllowMissing();

            conditions.add(new MutationCondition(name, op, value, allowMissing));
        }

        return conditions;
    }



    public AvroTableCreateDescriptor convert(TableCreateDescriptor descriptor) {
        AvroTableCreateDescriptor avroDescriptor = new AvroTableCreateDescriptor();
        avroDescriptor.setName(descriptor.getName());
        byte[][] splitKeys = descriptor.getSplitKeys();
        if (splitKeys != null) {
            List<ByteBuffer> avroSplitKeys = new ArrayList<ByteBuffer>(splitKeys.length);
            for (byte[] splitKey : splitKeys) {
                avroSplitKeys.add(ByteBuffer.wrap(splitKey));
            }
            avroDescriptor.setSplitKeys(avroSplitKeys);
        }
        return avroDescriptor;
    }

    public TableCreateDescriptor convert(AvroTableCreateDescriptor avroDescriptor) {
        String name = avroDescriptor.getName();

        List<ByteBuffer> avroSplitKeys = avroDescriptor.getSplitKeys();
        byte[][] splitKeys = null;
        if (avroSplitKeys != null) {
            splitKeys = new byte[avroSplitKeys.size()][];
            for (int i = 0; i < avroSplitKeys.size(); i++) {
                splitKeys[i] = asArray(avroSplitKeys.get(i));
            }
        }

        return new TableCreateDescriptor(name, splitKeys);
    }



    public AvroCompareOp convert(CompareOp op) {
        return op == null ? null : AvroCompareOp.values()[op.ordinal()];
    }

    public RecordId convertAvroRecordId(ByteBuffer recordId, LRepository repository) {
        byte[] bytes = new byte[recordId.remaining()];
        recordId.get(bytes);
        return repository.getIdGenerator().fromBytes(bytes);
    }

    public Set<RecordId> convertAvroRecordIds(List<String> avroRecordIds, LRepository repository) {
        Set<RecordId> recordIds = new HashSet<RecordId>();
        for (String avroRecordId : avroRecordIds) {
            recordIds.add(repository.getIdGenerator().fromString(avroRecordId));
        }
        return recordIds;
    }
}