/*
* 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());
}
}
}