src/java/org/apache/cassandra/db/RowIndexEntry.java - cassandra - Git at Google

 /*
  * 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.cassandra.db;

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;

 import com.google.common.primitives.Ints;

 import org.apache.cassandra.config.CFMetaData;
 import org.apache.cassandra.cache.IMeasurableMemory;
 import org.apache.cassandra.io.sstable.IndexHelper;
 import org.apache.cassandra.io.sstable.format.Version;
 import org.apache.cassandra.io.util.DataInputPlus;
 import org.apache.cassandra.io.util.DataOutputPlus;
 import org.apache.cassandra.io.util.FileUtils;
 import org.apache.cassandra.utils.ObjectSizes;

 public class RowIndexEntry<T> implements IMeasurableMemory
 {
     private static final long EMPTY_SIZE = ObjectSizes.measure(new RowIndexEntry(0));

     public final long position;

     public RowIndexEntry(long position)
     {
         this.position = position;
     }

     protected int promotedSize(IndexHelper.IndexInfo.Serializer idxSerializer)
     {
         return 0;
     }

     public static RowIndexEntry<IndexHelper.IndexInfo> create(long position, DeletionTime deletionTime, ColumnIndex index)
     {
         assert index != null;
         assert deletionTime != null;

         // we only consider the columns summary when determining whether to create an IndexedEntry,
         // since if there are insufficient columns to be worth indexing we're going to seek to
         // the beginning of the row anyway, so we might as well read the tombstone there as well.
         if (index.columnsIndex.size() > 1)
             return new IndexedEntry(position, deletionTime, index.partitionHeaderLength, index.columnsIndex);
         else
             return new RowIndexEntry<>(position);
     }

     /**
      * @return true if this index entry contains the row-level tombstone and column summary.  Otherwise,
      * caller should fetch these from the row header.
      */
     public boolean isIndexed()
     {
         return !columnsIndex().isEmpty();
     }

     public DeletionTime deletionTime()
     {
         throw new UnsupportedOperationException();
     }

     /**
      * @return the offset to the start of the header information for this row.
      * For some formats this may not be the start of the row.
      */
     public long headerOffset()
     {
         return 0;
     }

     /**
      * The length of the row header (partition key, partition deletion and static row).
      * This value is only provided for indexed entries and this method will throw
      * {@code UnsupportedOperationException} if {@code !isIndexed()}.
      */
     public long headerLength()
     {
         throw new UnsupportedOperationException();
     }

     public List<T> columnsIndex()
     {
         return Collections.emptyList();
     }

     public long unsharedHeapSize()
     {
         return EMPTY_SIZE;
     }

     public interface IndexSerializer<T>
     {
         void serialize(RowIndexEntry<T> rie, DataOutputPlus out) throws IOException;
         RowIndexEntry<T> deserialize(DataInputPlus in) throws IOException;
         int serializedSize(RowIndexEntry<T> rie);
     }

     public static class Serializer implements IndexSerializer<IndexHelper.IndexInfo>
     {
         private final IndexHelper.IndexInfo.Serializer idxSerializer;
         private final Version version;

         public Serializer(CFMetaData metadata, Version version, SerializationHeader header)
         {
             this.idxSerializer = new IndexHelper.IndexInfo.Serializer(metadata, version, header);
             this.version = version;
         }

         public void serialize(RowIndexEntry<IndexHelper.IndexInfo> rie, DataOutputPlus out) throws IOException
         {
             assert version.storeRows() : "We read old index files but we should never write them";

             out.writeUnsignedVInt(rie.position);
             out.writeUnsignedVInt(rie.promotedSize(idxSerializer));

             if (rie.isIndexed())
             {
                 out.writeUnsignedVInt(rie.headerLength());
                 DeletionTime.serializer.serialize(rie.deletionTime(), out);
                 out.writeUnsignedVInt(rie.columnsIndex().size());

                 // Calculate and write the offsets to the IndexInfo objects.

                 int[] offsets = new int[rie.columnsIndex().size()];

                 if (out.hasPosition())
                 {
                     // Out is usually a SequentialWriter, so using the file-pointer is fine to generate the offsets.
                     // A DataOutputBuffer also works.
                     long start = out.position();
                     int i = 0;
                     for (IndexHelper.IndexInfo info : rie.columnsIndex())
                     {
                         offsets[i] = i == 0 ? 0 : (int)(out.position() - start);
                         i++;
                         idxSerializer.serialize(info, out);
                     }
                 }
                 else
                 {
                     // Not sure this branch will ever be needed, but if it is called, it has to calculate the
                     // serialized sizes instead of simply using the file-pointer.
                     int i = 0;
                     int offset = 0;
                     for (IndexHelper.IndexInfo info : rie.columnsIndex())
                     {
                         offsets[i++] = offset;
                         idxSerializer.serialize(info, out);
                         offset += idxSerializer.serializedSize(info);
                     }
                 }

                 for (int off : offsets)
                     out.writeInt(off);
             }
         }

         public RowIndexEntry<IndexHelper.IndexInfo> deserialize(DataInputPlus in) throws IOException
         {
             if (!version.storeRows())
             {
                 long position = in.readLong();

                 int size = in.readInt();
                 if (size > 0)
                 {
                     DeletionTime deletionTime = DeletionTime.serializer.deserialize(in);

                     int entries = in.readInt();
                     List<IndexHelper.IndexInfo> columnsIndex = new ArrayList<>(entries);

                     long headerLength = 0L;
                     for (int i = 0; i < entries; i++)
                     {
                         IndexHelper.IndexInfo info = idxSerializer.deserialize(in);
                         columnsIndex.add(info);
                         if (i == 0)
                             headerLength = info.offset;
                     }

                     return new IndexedEntry(position, deletionTime, headerLength, columnsIndex);
                 }
                 else
                 {
                     return new RowIndexEntry<>(position);
                 }
             }

             long position = in.readUnsignedVInt();

             int size = (int)in.readUnsignedVInt();
             if (size > 0)
             {
                 long headerLength = in.readUnsignedVInt();
                 DeletionTime deletionTime = DeletionTime.serializer.deserialize(in);
                 int entries = (int)in.readUnsignedVInt();
                 List<IndexHelper.IndexInfo> columnsIndex = new ArrayList<>(entries);
                 for (int i = 0; i < entries; i++)
                     columnsIndex.add(idxSerializer.deserialize(in));

                 in.skipBytesFully(entries * TypeSizes.sizeof(0));

                 return new IndexedEntry(position, deletionTime, headerLength, columnsIndex);
             }
             else
             {
                 return new RowIndexEntry<>(position);
             }
         }

         // Reads only the data 'position' of the index entry and returns it. Note that this left 'in' in the middle
         // of reading an entry, so this is only useful if you know what you are doing and in most case 'deserialize'
         // should be used instead.
         public static long readPosition(DataInputPlus in, Version version) throws IOException
         {
             return version.storeRows() ? in.readUnsignedVInt() : in.readLong();
         }

         public static void skip(DataInputPlus in, Version version) throws IOException
         {
             readPosition(in, version);
             skipPromotedIndex(in, version);
         }

         private static void skipPromotedIndex(DataInputPlus in, Version version) throws IOException
         {
             int size = version.storeRows() ? (int)in.readUnsignedVInt() : in.readInt();
             if (size <= 0)
                 return;

             in.skipBytesFully(size);
         }

         public int serializedSize(RowIndexEntry<IndexHelper.IndexInfo> rie)
         {
             assert version.storeRows() : "We read old index files but we should never write them";

             int indexedSize = 0;
             if (rie.isIndexed())
             {
                 List<IndexHelper.IndexInfo> index = rie.columnsIndex();

                 indexedSize += TypeSizes.sizeofUnsignedVInt(rie.headerLength());
                 indexedSize += DeletionTime.serializer.serializedSize(rie.deletionTime());
                 indexedSize += TypeSizes.sizeofUnsignedVInt(index.size());

                 for (IndexHelper.IndexInfo info : index)
                     indexedSize += idxSerializer.serializedSize(info);

                 indexedSize += index.size() * TypeSizes.sizeof(0);
             }

             return TypeSizes.sizeofUnsignedVInt(rie.position) + TypeSizes.sizeofUnsignedVInt(indexedSize) + indexedSize;
         }
     }

     /**
      * An entry in the row index for a row whose columns are indexed.
      */
     private static class IndexedEntry extends RowIndexEntry<IndexHelper.IndexInfo>
     {
         private final DeletionTime deletionTime;

         // The offset in the file when the index entry end
         private final long headerLength;
         private final List<IndexHelper.IndexInfo> columnsIndex;
         private static final long BASE_SIZE =
                 ObjectSizes.measure(new IndexedEntry(0, DeletionTime.LIVE, 0, Arrays.<IndexHelper.IndexInfo>asList(null, null)))
               + ObjectSizes.measure(new ArrayList<>(1));

         private IndexedEntry(long position, DeletionTime deletionTime, long headerLength, List<IndexHelper.IndexInfo> columnsIndex)
         {
             super(position);
             assert deletionTime != null;
             assert columnsIndex != null && columnsIndex.size() > 1;
             this.deletionTime = deletionTime;
             this.headerLength = headerLength;
             this.columnsIndex = columnsIndex;
         }

         @Override
         public DeletionTime deletionTime()
         {
             return deletionTime;
         }

         @Override
         public long headerLength()
         {
             return headerLength;
         }

         @Override
         public List<IndexHelper.IndexInfo> columnsIndex()
         {
             return columnsIndex;
         }

         @Override
         protected int promotedSize(IndexHelper.IndexInfo.Serializer idxSerializer)
         {
             long size = TypeSizes.sizeofUnsignedVInt(headerLength)
                       + DeletionTime.serializer.serializedSize(deletionTime)
                       + TypeSizes.sizeofUnsignedVInt(columnsIndex.size()); // number of entries
             for (IndexHelper.IndexInfo info : columnsIndex)
                 size += idxSerializer.serializedSize(info);

             size += columnsIndex.size() * TypeSizes.sizeof(0);

             return Ints.checkedCast(size);
         }

         @Override
         public long unsharedHeapSize()
         {
             long entrySize = 0;
             for (IndexHelper.IndexInfo idx : columnsIndex)
                 entrySize += idx.unsharedHeapSize();

             return BASE_SIZE
                    + entrySize
                    + deletionTime.unsharedHeapSize()
                    + ObjectSizes.sizeOfReferenceArray(columnsIndex.size());
         }
     }
 }
	/*
	* 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.cassandra.db;

	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.List;

	import com.google.common.primitives.Ints;

	import org.apache.cassandra.config.CFMetaData;
	import org.apache.cassandra.cache.IMeasurableMemory;
	import org.apache.cassandra.io.sstable.IndexHelper;
	import org.apache.cassandra.io.sstable.format.Version;
	import org.apache.cassandra.io.util.DataInputPlus;
	import org.apache.cassandra.io.util.DataOutputPlus;
	import org.apache.cassandra.io.util.FileUtils;
	import org.apache.cassandra.utils.ObjectSizes;

	public class RowIndexEntry<T> implements IMeasurableMemory
	{
	private static final long EMPTY_SIZE = ObjectSizes.measure(new RowIndexEntry(0));

	public final long position;

	public RowIndexEntry(long position)
	{
	this.position = position;
	}

	protected int promotedSize(IndexHelper.IndexInfo.Serializer idxSerializer)
	{
	return 0;
	}

	public static RowIndexEntry<IndexHelper.IndexInfo> create(long position, DeletionTime deletionTime, ColumnIndex index)
	{
	assert index != null;
	assert deletionTime != null;

	// we only consider the columns summary when determining whether to create an IndexedEntry,
	// since if there are insufficient columns to be worth indexing we're going to seek to
	// the beginning of the row anyway, so we might as well read the tombstone there as well.
	if (index.columnsIndex.size() > 1)
	return new IndexedEntry(position, deletionTime, index.partitionHeaderLength, index.columnsIndex);
	else
	return new RowIndexEntry<>(position);
	}

	/**
	* @return true if this index entry contains the row-level tombstone and column summary. Otherwise,
	* caller should fetch these from the row header.
	*/
	public boolean isIndexed()
	{
	return !columnsIndex().isEmpty();
	}

	public DeletionTime deletionTime()
	{
	throw new UnsupportedOperationException();
	}

	/**
	* @return the offset to the start of the header information for this row.
	* For some formats this may not be the start of the row.
	*/
	public long headerOffset()
	{
	return 0;
	}

	/**
	* The length of the row header (partition key, partition deletion and static row).
	* This value is only provided for indexed entries and this method will throw
	* {@code UnsupportedOperationException} if {@code !isIndexed()}.
	*/
	public long headerLength()
	{
	throw new UnsupportedOperationException();
	}

	public List<T> columnsIndex()
	{
	return Collections.emptyList();
	}

	public long unsharedHeapSize()
	{
	return EMPTY_SIZE;
	}

	public interface IndexSerializer<T>
	{
	void serialize(RowIndexEntry<T> rie, DataOutputPlus out) throws IOException;
	RowIndexEntry<T> deserialize(DataInputPlus in) throws IOException;
	int serializedSize(RowIndexEntry<T> rie);
	}

	public static class Serializer implements IndexSerializer<IndexHelper.IndexInfo>
	{
	private final IndexHelper.IndexInfo.Serializer idxSerializer;
	private final Version version;

	public Serializer(CFMetaData metadata, Version version, SerializationHeader header)
	{
	this.idxSerializer = new IndexHelper.IndexInfo.Serializer(metadata, version, header);
	this.version = version;
	}

	public void serialize(RowIndexEntry<IndexHelper.IndexInfo> rie, DataOutputPlus out) throws IOException
	{
	assert version.storeRows() : "We read old index files but we should never write them";

	out.writeUnsignedVInt(rie.position);
	out.writeUnsignedVInt(rie.promotedSize(idxSerializer));

	if (rie.isIndexed())
	{
	out.writeUnsignedVInt(rie.headerLength());
	DeletionTime.serializer.serialize(rie.deletionTime(), out);
	out.writeUnsignedVInt(rie.columnsIndex().size());

	// Calculate and write the offsets to the IndexInfo objects.

	int[] offsets = new int[rie.columnsIndex().size()];

	if (out.hasPosition())
	{
	// Out is usually a SequentialWriter, so using the file-pointer is fine to generate the offsets.
	// A DataOutputBuffer also works.
	long start = out.position();
	int i = 0;
	for (IndexHelper.IndexInfo info : rie.columnsIndex())
	{
	offsets[i] = i == 0 ? 0 : (int)(out.position() - start);
	i++;
	idxSerializer.serialize(info, out);
	}
	}
	else
	{
	// Not sure this branch will ever be needed, but if it is called, it has to calculate the
	// serialized sizes instead of simply using the file-pointer.
	int i = 0;
	int offset = 0;
	for (IndexHelper.IndexInfo info : rie.columnsIndex())
	{
	offsets[i++] = offset;
	idxSerializer.serialize(info, out);
	offset += idxSerializer.serializedSize(info);
	}
	}

	for (int off : offsets)
	out.writeInt(off);
	}
	}

	public RowIndexEntry<IndexHelper.IndexInfo> deserialize(DataInputPlus in) throws IOException
	{
	if (!version.storeRows())
	{
	long position = in.readLong();

	int size = in.readInt();
	if (size > 0)
	{
	DeletionTime deletionTime = DeletionTime.serializer.deserialize(in);

	int entries = in.readInt();
	List<IndexHelper.IndexInfo> columnsIndex = new ArrayList<>(entries);

	long headerLength = 0L;
	for (int i = 0; i < entries; i++)
	{
	IndexHelper.IndexInfo info = idxSerializer.deserialize(in);
	columnsIndex.add(info);
	if (i == 0)
	headerLength = info.offset;
	}

	return new IndexedEntry(position, deletionTime, headerLength, columnsIndex);
	}
	else
	{
	return new RowIndexEntry<>(position);
	}
	}

	long position = in.readUnsignedVInt();

	int size = (int)in.readUnsignedVInt();
	if (size > 0)
	{
	long headerLength = in.readUnsignedVInt();
	DeletionTime deletionTime = DeletionTime.serializer.deserialize(in);
	int entries = (int)in.readUnsignedVInt();
	List<IndexHelper.IndexInfo> columnsIndex = new ArrayList<>(entries);
	for (int i = 0; i < entries; i++)
	columnsIndex.add(idxSerializer.deserialize(in));

	in.skipBytesFully(entries * TypeSizes.sizeof(0));

	return new IndexedEntry(position, deletionTime, headerLength, columnsIndex);
	}
	else
	{
	return new RowIndexEntry<>(position);
	}
	}

	// Reads only the data 'position' of the index entry and returns it. Note that this left 'in' in the middle
	// of reading an entry, so this is only useful if you know what you are doing and in most case 'deserialize'
	// should be used instead.
	public static long readPosition(DataInputPlus in, Version version) throws IOException
	{
	return version.storeRows() ? in.readUnsignedVInt() : in.readLong();
	}

	public static void skip(DataInputPlus in, Version version) throws IOException
	{
	readPosition(in, version);
	skipPromotedIndex(in, version);
	}

	private static void skipPromotedIndex(DataInputPlus in, Version version) throws IOException
	{
	int size = version.storeRows() ? (int)in.readUnsignedVInt() : in.readInt();
	if (size <= 0)
	return;

	in.skipBytesFully(size);
	}

	public int serializedSize(RowIndexEntry<IndexHelper.IndexInfo> rie)
	{
	assert version.storeRows() : "We read old index files but we should never write them";

	int indexedSize = 0;
	if (rie.isIndexed())
	{
	List<IndexHelper.IndexInfo> index = rie.columnsIndex();

	indexedSize += TypeSizes.sizeofUnsignedVInt(rie.headerLength());
	indexedSize += DeletionTime.serializer.serializedSize(rie.deletionTime());
	indexedSize += TypeSizes.sizeofUnsignedVInt(index.size());

	for (IndexHelper.IndexInfo info : index)
	indexedSize += idxSerializer.serializedSize(info);

	indexedSize += index.size() * TypeSizes.sizeof(0);
	}

	return TypeSizes.sizeofUnsignedVInt(rie.position) + TypeSizes.sizeofUnsignedVInt(indexedSize) + indexedSize;
	}
	}

	/**
	* An entry in the row index for a row whose columns are indexed.
	*/
	private static class IndexedEntry extends RowIndexEntry<IndexHelper.IndexInfo>
	{
	private final DeletionTime deletionTime;

	// The offset in the file when the index entry end
	private final long headerLength;
	private final List<IndexHelper.IndexInfo> columnsIndex;
	private static final long BASE_SIZE =
	ObjectSizes.measure(new IndexedEntry(0, DeletionTime.LIVE, 0, Arrays.<IndexHelper.IndexInfo>asList(null, null)))
	+ ObjectSizes.measure(new ArrayList<>(1));

	private IndexedEntry(long position, DeletionTime deletionTime, long headerLength, List<IndexHelper.IndexInfo> columnsIndex)
	{
	super(position);
	assert deletionTime != null;
	assert columnsIndex != null && columnsIndex.size() > 1;
	this.deletionTime = deletionTime;
	this.headerLength = headerLength;
	this.columnsIndex = columnsIndex;
	}

	@Override
	public DeletionTime deletionTime()
	{
	return deletionTime;
	}

	@Override
	public long headerLength()
	{
	return headerLength;
	}

	@Override
	public List<IndexHelper.IndexInfo> columnsIndex()
	{
	return columnsIndex;
	}

	@Override
	protected int promotedSize(IndexHelper.IndexInfo.Serializer idxSerializer)
	{
	long size = TypeSizes.sizeofUnsignedVInt(headerLength)
	+ DeletionTime.serializer.serializedSize(deletionTime)
	+ TypeSizes.sizeofUnsignedVInt(columnsIndex.size()); // number of entries
	for (IndexHelper.IndexInfo info : columnsIndex)
	size += idxSerializer.serializedSize(info);

	size += columnsIndex.size() * TypeSizes.sizeof(0);

	return Ints.checkedCast(size);
	}

	@Override
	public long unsharedHeapSize()
	{
	long entrySize = 0;
	for (IndexHelper.IndexInfo idx : columnsIndex)
	entrySize += idx.unsharedHeapSize();

	return BASE_SIZE
	+ entrySize
	+ deletionTime.unsharedHeapSize()
	+ ObjectSizes.sizeOfReferenceArray(columnsIndex.size());
	}
	}
	}