cassandra-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbel...@apache.org
Subject [02/14] git commit: Revert "Always record row-level tombstones in index component"
Date Mon, 22 Apr 2013 14:43:03 GMT
Revert "Always record row-level tombstones in index component"

This reverts commit 798470e051af794b605cce28031b33b589cfc6d8.


Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo
Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/17034c08
Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/17034c08
Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/17034c08

Branch: refs/heads/trunk
Commit: 17034c0878659ea99e24b665c71e0b454f21809e
Parents: 798470e
Author: Jonathan Ellis <jbellis@apache.org>
Authored: Fri Apr 19 13:26:27 2013 -0500
Committer: Jonathan Ellis <jbellis@apache.org>
Committed: Fri Apr 19 13:27:45 2013 -0500

----------------------------------------------------------------------
 CHANGES.txt                                        |    1 -
 build.xml                                          |    2 +-
 src/java/org/apache/cassandra/db/ColumnIndex.java  |    5 +-
 .../org/apache/cassandra/db/RowIndexEntry.java     |   85 +++++-----
 .../db/columniterator/IndexedSliceReader.java      |   93 +++++-----
 .../db/columniterator/SSTableNamesIterator.java    |  130 ++++++++++-----
 .../db/columniterator/SimpleSliceReader.java       |   15 +-
 .../apache/cassandra/io/sstable/Descriptor.java    |    7 +-
 .../apache/cassandra/io/sstable/SSTableReader.java |    2 +-
 .../cassandra/utils/AlwaysPresentFilter.java       |    4 -
 .../org/apache/cassandra/utils/FilterFactory.java  |    2 +-
 .../apache/cassandra/db/RangeTombstoneTest.java    |    4 +
 12 files changed, 192 insertions(+), 158 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cassandra/blob/17034c08/CHANGES.txt
----------------------------------------------------------------------
diff --git a/CHANGES.txt b/CHANGES.txt
index 7dbb62a..7fc93f4 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,5 +1,4 @@
 1.2.5
- * Fix promoted row-level tombstone writing (CASSANDRA-5486)
  * Include fatal errors in trace events (CASSANDRA-5447)
  * Ensure that PerRowSecondaryIndex is notified of row-level deletes
    (CASSANDRA-5445)

http://git-wip-us.apache.org/repos/asf/cassandra/blob/17034c08/build.xml
----------------------------------------------------------------------
diff --git a/build.xml b/build.xml
index 2ddd43d..3491431 100644
--- a/build.xml
+++ b/build.xml
@@ -519,7 +519,7 @@
       </artifact:pom>
     </target>
 
-    <target name="maven-ant-tasks-retrieve-build" depends="maven-declare-dependencies"
unless="without.maven">
+    <target name="maven-ant-tasks-retrieve-build" depends="maven-declare-dependencies">
       <artifact:dependencies pomRefId="build-deps-pom"
                              filesetId="build-dependency-jars" 
                              sourcesFilesetId="build-dependency-sources" 

http://git-wip-us.apache.org/repos/asf/cassandra/blob/17034c08/src/java/org/apache/cassandra/db/ColumnIndex.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/cassandra/db/ColumnIndex.java b/src/java/org/apache/cassandra/db/ColumnIndex.java
index e2ac3e4..bcd0eef 100644
--- a/src/java/org/apache/cassandra/db/ColumnIndex.java
+++ b/src/java/org/apache/cassandra/db/ColumnIndex.java
@@ -33,7 +33,7 @@ public class ColumnIndex
     public final List<IndexHelper.IndexInfo> columnsIndex;
     public final IFilter bloomFilter;
 
-    private static final ColumnIndex EMPTY = new ColumnIndex(Collections.<IndexHelper.IndexInfo>emptyList(),
AlwaysPresentFilter.instance);
+    private static final ColumnIndex EMPTY = new ColumnIndex(Collections.<IndexHelper.IndexInfo>emptyList(),
new AlwaysPresentFilter());
 
     private ColumnIndex(int estimatedColumnCount)
     {
@@ -42,9 +42,6 @@ public class ColumnIndex
 
     private ColumnIndex(List<IndexHelper.IndexInfo> columnsIndex, IFilter bloomFilter)
     {
-        assert columnsIndex != null;
-        assert bloomFilter != null;
-
         this.columnsIndex = columnsIndex;
         this.bloomFilter = bloomFilter;
     }

http://git-wip-us.apache.org/repos/asf/cassandra/blob/17034c08/src/java/org/apache/cassandra/db/RowIndexEntry.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/cassandra/db/RowIndexEntry.java b/src/java/org/apache/cassandra/db/RowIndexEntry.java
index a60bf6d..a831498 100644
--- a/src/java/org/apache/cassandra/db/RowIndexEntry.java
+++ b/src/java/org/apache/cassandra/db/RowIndexEntry.java
@@ -28,7 +28,6 @@ import org.apache.cassandra.cache.IMeasurableMemory;
 import org.apache.cassandra.io.sstable.Descriptor;
 import org.apache.cassandra.io.sstable.IndexHelper;
 import org.apache.cassandra.io.util.FileUtils;
-import org.apache.cassandra.utils.AlwaysPresentFilter;
 import org.apache.cassandra.utils.IFilter;
 import org.apache.cassandra.utils.FilterFactory;
 import org.apache.cassandra.utils.ObjectSizes;
@@ -46,42 +45,35 @@ public class RowIndexEntry implements IMeasurableMemory
 
     public int serializedSize()
     {
-        return TypeSizes.NATIVE.sizeof(position) + promotedSize();
+        return TypeSizes.NATIVE.sizeof(position);
     }
 
-    public int promotedSize()
-    {
-        return 0;
-    }
-
-    // TODO only store DeletionTime
     public static RowIndexEntry create(long position, DeletionInfo deletionInfo, ColumnIndex
index)
     {
-        assert deletionInfo != null;
-        assert index != null;
-
-        if (index.columnsIndex.size() > 1 || deletionInfo.getTopLevelDeletion() != DeletionTime.LIVE)
-            return new IndexedEntry(position,
-                                    deletionInfo,
-                                    index.columnsIndex.isEmpty() ? Collections.<IndexHelper.IndexInfo>emptyList()
: index.columnsIndex,
-                                    index.columnsIndex.isEmpty() ? AlwaysPresentFilter.instance
: index.bloomFilter);
+        if (index != null && index.columnsIndex != null && index.columnsIndex.size()
> 1)
+            return new IndexedEntry(position, deletionInfo, index.columnsIndex, index.bloomFilter);
         else
             return new RowIndexEntry(position);
     }
 
+    public boolean isIndexed()
+    {
+        return !columnsIndex().isEmpty();
+    }
+
     public DeletionInfo deletionInfo()
     {
-        return DeletionInfo.LIVE;
+        throw new UnsupportedOperationException();
     }
 
     public List<IndexHelper.IndexInfo> columnsIndex()
     {
-        return Collections.emptyList();
+        return Collections.<IndexHelper.IndexInfo>emptyList();
     }
 
     public IFilter bloomFilter()
     {
-        return AlwaysPresentFilter.instance;
+        throw new UnsupportedOperationException();
     }
 
     public long memorySize()
@@ -95,15 +87,14 @@ public class RowIndexEntry implements IMeasurableMemory
         public void serialize(RowIndexEntry rie, DataOutput dos) throws IOException
         {
             dos.writeLong(rie.position);
-            if (!rie.columnsIndex().isEmpty() || rie.deletionInfo().getTopLevelDeletion()
!= DeletionTime.LIVE)
+            if (rie.isIndexed())
             {
-                dos.writeInt(rie.promotedSize());
+                dos.writeInt(((IndexedEntry)rie).serializedSize());
                 DeletionInfo.serializer().serializeForSSTable(rie.deletionInfo(), dos);
                 dos.writeInt(rie.columnsIndex().size());
                 for (IndexHelper.IndexInfo info : rie.columnsIndex())
                     info.serialize(dos);
-                if (!rie.columnsIndex().isEmpty())
-                    FilterFactory.serialize(rie.bloomFilter(), dos);
+                FilterFactory.serialize(rie.bloomFilter(), dos);
             }
             else
             {
@@ -111,24 +102,38 @@ public class RowIndexEntry implements IMeasurableMemory
             }
         }
 
-        public RowIndexEntry deserialize(DataInput dis, Descriptor.Version version) throws
IOException
+        public RowIndexEntry deserializePositionOnly(DataInput dis, Descriptor.Version version)
throws IOException
         {
             long position = dis.readLong();
-            if (!version.hasPromotedIndexes)
-                return new RowIndexEntry(position);
+            if (version.hasPromotedIndexes)
+            {
+                int size = dis.readInt();
+                if (size > 0)
+                    FileUtils.skipBytesFully(dis, size);
+            }
+            return new RowIndexEntry(position);
+        }
 
-            int size = dis.readInt();
-            if (size > 0)
+        public RowIndexEntry deserialize(DataInput dis, Descriptor.Version version) throws
IOException
+        {
+            long position = dis.readLong();
+            if (version.hasPromotedIndexes)
             {
-                DeletionInfo delInfo = DeletionInfo.serializer().deserializeFromSSTable(dis,
version);
-                int entries = dis.readInt();
-                List<IndexHelper.IndexInfo> columnsIndex = new ArrayList<IndexHelper.IndexInfo>(entries);
-                for (int i = 0; i < entries; i++)
-                    columnsIndex.add(IndexHelper.IndexInfo.deserialize(dis));
-                IFilter bf = entries == 0
-                             ? AlwaysPresentFilter.instance
-                             : FilterFactory.deserialize(dis, version.filterType, false);
-                return new IndexedEntry(position, delInfo, columnsIndex, bf);
+                int size = dis.readInt();
+                if (size > 0)
+                {
+                    DeletionInfo delInfo = DeletionInfo.serializer().deserializeFromSSTable(dis,
version);
+                    int entries = dis.readInt();
+                    List<IndexHelper.IndexInfo> columnsIndex = new ArrayList<IndexHelper.IndexInfo>(entries);
+                    for (int i = 0; i < entries; i++)
+                        columnsIndex.add(IndexHelper.IndexInfo.deserialize(dis));
+                    IFilter bf = FilterFactory.deserialize(dis, version.filterType, false);
+                    return new IndexedEntry(position, delInfo, columnsIndex, bf);
+                }
+                else
+                {
+                    return new RowIndexEntry(position);
+                }
             }
             else
             {
@@ -166,7 +171,7 @@ public class RowIndexEntry implements IMeasurableMemory
         {
             super(position);
             assert deletionInfo != null;
-            assert columnsIndex != null;
+            assert columnsIndex != null && columnsIndex.size() > 1;
             this.deletionInfo = deletionInfo;
             this.columnsIndex = columnsIndex;
             this.bloomFilter = bloomFilter;
@@ -191,7 +196,7 @@ public class RowIndexEntry implements IMeasurableMemory
         }
 
         @Override
-        public int promotedSize()
+        public int serializedSize()
         {
             TypeSizes typeSizes = TypeSizes.NATIVE;
             long size = DeletionTime.serializer.serializedSize(deletionInfo.getTopLevelDeletion(),
typeSizes);
@@ -199,7 +204,7 @@ public class RowIndexEntry implements IMeasurableMemory
             for (IndexHelper.IndexInfo info : columnsIndex)
                 size += info.serializedSize(typeSizes);
 
-            size += bloomFilter instanceof AlwaysPresentFilter ? 0 : FilterFactory.serializedSize(bloomFilter);
+            size += FilterFactory.serializedSize(bloomFilter);
             assert size <= Integer.MAX_VALUE;
             return (int)size;
         }

http://git-wip-us.apache.org/repos/asf/cassandra/blob/17034c08/src/java/org/apache/cassandra/db/columniterator/IndexedSliceReader.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/cassandra/db/columniterator/IndexedSliceReader.java b/src/java/org/apache/cassandra/db/columniterator/IndexedSliceReader.java
index 61ae00e..7289ab0 100644
--- a/src/java/org/apache/cassandra/db/columniterator/IndexedSliceReader.java
+++ b/src/java/org/apache/cassandra/db/columniterator/IndexedSliceReader.java
@@ -65,7 +65,7 @@ class IndexedSliceReader extends AbstractIterator<OnDiskAtom> implements
OnDiskA
      * finish (reverse start) elements. i.e. forward: [a,b],[d,e],[g,h] reverse: [h,g],[e,d],[b,a].
This reader also
      * assumes that validation has been performed in terms of intervals (no overlapping intervals).
      */
-    public IndexedSliceReader(SSTableReader sstable, RowIndexEntry rowEntry, FileDataInput
input, ColumnSlice[] slices, boolean reversed)
+    public IndexedSliceReader(SSTableReader sstable, RowIndexEntry indexEntry, FileDataInput
input, ColumnSlice[] slices, boolean reversed)
     {
         this.sstable = sstable;
         this.originalInput = input;
@@ -76,53 +76,34 @@ class IndexedSliceReader extends AbstractIterator<OnDiskAtom> implements
OnDiskA
         try
         {
             Descriptor.Version version = sstable.descriptor.version;
-            emptyColumnFamily = ColumnFamily.create(sstable.metadata);
-
-            if (version.hasPromotedRowTombstones && !rowEntry.columnsIndex().isEmpty())
-            {
-                // skip the row header entirely
-                indexes = rowEntry.columnsIndex();
-                emptyColumnFamily.delete(rowEntry.deletionInfo());
-                fetcher = new IndexedBlockFetcher(rowEntry.position);
-                return;
-            }
-
-            // skip up to bloom filter where things get a bit more interesting
-            if (input == null)
-            {
-                file = sstable.getFileDataInput(rowEntry.position);
-            }
-            else
-            {
-                file = input;
-                file.seek(rowEntry.position);
-            }
-            this.sstable.decodeKey(ByteBufferUtil.readWithShortLength(file));
-            SSTableReader.readRowSize(file, this.sstable.descriptor);
-
-            // read the row header up to and including the row-level tombstones
             if (version.hasPromotedIndexes)
             {
-                indexes = rowEntry.columnsIndex();
-                emptyColumnFamily.delete(rowEntry.deletionInfo());
-            }
-            else
-            {
-                IndexHelper.skipSSTableBloomFilter(input, version);
-                indexes = IndexHelper.deserializeIndex(file);
-            }
-            emptyColumnFamily.delete(DeletionInfo.serializer().deserializeFromSSTable(file,
version));
-
-            if (indexes.isEmpty())
-            {
-                fetcher = new SimpleBlockFetcher();
+                this.indexes = indexEntry.columnsIndex();
+                if (indexes.isEmpty())
+                {
+                    setToRowStart(sstable, indexEntry, input);
+                    this.emptyColumnFamily = ColumnFamily.create(sstable.metadata);
+                    emptyColumnFamily.delete(DeletionInfo.serializer().deserializeFromSSTable(file,
version));
+                    fetcher = new SimpleBlockFetcher();
+                }
+                else
+                {
+                    this.emptyColumnFamily = ColumnFamily.create(sstable.metadata);
+                    emptyColumnFamily.delete(indexEntry.deletionInfo());
+                    fetcher = new IndexedBlockFetcher(indexEntry.position);
+                }
             }
             else
             {
-                // index offsets changed to be based against the row key start in 1.2
-                fetcher = version.hasPromotedIndexes
-                        ? new IndexedBlockFetcher(rowEntry.position)
-                        : new IndexedBlockFetcher(file.getFilePointer() + 4); // +4 to skip
the int column count
+                setToRowStart(sstable, indexEntry, input);
+                IndexHelper.skipSSTableBloomFilter(file, version);
+                this.indexes = IndexHelper.deserializeIndex(file);
+                this.emptyColumnFamily = ColumnFamily.create(sstable.metadata);
+                emptyColumnFamily.delete(DeletionInfo.serializer().deserializeFromSSTable(file,
version));
+                fetcher = indexes.isEmpty()
+                        ? new SimpleBlockFetcher()
+                        : new IndexedBlockFetcher(file.getFilePointer() + 4); // We still
have the column count to
+                                                                              // skip to
get the basePosition
             }
         }
         catch (IOException e)
@@ -132,6 +113,24 @@ class IndexedSliceReader extends AbstractIterator<OnDiskAtom> implements
OnDiskA
         }
     }
 
+    /**
+     * Sets the seek position to the start of the row for column scanning.
+     */
+    private void setToRowStart(SSTableReader reader, RowIndexEntry indexEntry, FileDataInput
input) throws IOException
+    {
+        if (input == null)
+        {
+            this.file = sstable.getFileDataInput(indexEntry.position);
+        }
+        else
+        {
+            this.file = input;
+            input.seek(indexEntry.position);
+        }
+        sstable.decodeKey(ByteBufferUtil.readWithShortLength(file));
+        SSTableReader.readRowSize(file, sstable.descriptor);
+    }
+
     public ColumnFamily getColumnFamily()
     {
         return emptyColumnFamily;
@@ -198,6 +197,8 @@ class IndexedSliceReader extends AbstractIterator<OnDiskAtom> implements
OnDiskA
             return reversed ? slices[currentSliceIdx].start : slices[currentSliceIdx].finish;
         }
 
+        protected abstract boolean setNextSlice();
+
         protected abstract boolean fetchMoreData();
 
         protected boolean isColumnBeforeSliceStart(OnDiskAtom column)
@@ -247,7 +248,7 @@ class IndexedSliceReader extends AbstractIterator<OnDiskAtom> implements
OnDiskA
             setNextSlice();
         }
 
-        private boolean setNextSlice()
+        protected boolean setNextSlice()
         {
             while (++currentSliceIdx < slices.length)
             {
@@ -349,7 +350,7 @@ class IndexedSliceReader extends AbstractIterator<OnDiskAtom> implements
OnDiskA
             /* seek to the correct offset to the data, and calculate the data size */
             long positionToSeek = basePosition + currentIndex.offset;
 
-            // With 1.2 promoted indexes, our first seek in the data file will happen at
this point
+            // With new promoted indexes, our first seek in the data file will happen at
that point.
             if (file == null)
                 file = originalInput == null ? sstable.getFileDataInput(positionToSeek) :
originalInput;
 
@@ -463,7 +464,7 @@ class IndexedSliceReader extends AbstractIterator<OnDiskAtom> implements
OnDiskA
             }
         }
 
-        private boolean setNextSlice()
+        protected boolean setNextSlice()
         {
             if (reversed)
             {

http://git-wip-us.apache.org/repos/asf/cassandra/blob/17034c08/src/java/org/apache/cassandra/db/columniterator/SSTableNamesIterator.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/cassandra/db/columniterator/SSTableNamesIterator.java b/src/java/org/apache/cassandra/db/columniterator/SSTableNamesIterator.java
index 326447f..da4631d 100644
--- a/src/java/org/apache/cassandra/db/columniterator/SSTableNamesIterator.java
+++ b/src/java/org/apache/cassandra/db/columniterator/SSTableNamesIterator.java
@@ -19,22 +19,25 @@ package org.apache.cassandra.db.columniterator;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import java.util.SortedSet;
+import java.util.*;
 
 import org.apache.cassandra.config.CFMetaData;
-import org.apache.cassandra.db.*;
+import org.apache.cassandra.db.ColumnFamily;
+import org.apache.cassandra.db.ColumnFamilySerializer;
+import org.apache.cassandra.db.DecoratedKey;
+import org.apache.cassandra.db.DeletionInfo;
+import org.apache.cassandra.db.IColumn;
+import org.apache.cassandra.db.RowIndexEntry;
+import org.apache.cassandra.db.OnDiskAtom;
 import org.apache.cassandra.db.marshal.AbstractType;
 import org.apache.cassandra.io.sstable.CorruptSSTableException;
-import org.apache.cassandra.io.sstable.Descriptor;
 import org.apache.cassandra.io.sstable.IndexHelper;
 import org.apache.cassandra.io.sstable.SSTableReader;
 import org.apache.cassandra.io.util.FileDataInput;
 import org.apache.cassandra.io.util.FileMark;
 import org.apache.cassandra.io.util.FileUtils;
 import org.apache.cassandra.utils.ByteBufferUtil;
+import org.apache.cassandra.utils.IFilter;
 
 public class SSTableNamesIterator extends SimpleAbstractColumnIterator implements ISSTableColumnIterator
 {
@@ -52,13 +55,13 @@ public class SSTableNamesIterator extends SimpleAbstractColumnIterator
implement
         this.columns = columns;
         this.key = key;
 
-        RowIndexEntry rowEntry = sstable.getPosition(key, SSTableReader.Operator.EQ);
-        if (rowEntry == null)
+        RowIndexEntry indexEntry = sstable.getPosition(key, SSTableReader.Operator.EQ);
+        if (indexEntry == null)
             return;
 
         try
         {
-            read(sstable, null, rowEntry);
+            read(sstable, null, indexEntry);
         }
         catch (IOException e)
         {
@@ -72,7 +75,7 @@ public class SSTableNamesIterator extends SimpleAbstractColumnIterator implement
         }
     }
 
-    public SSTableNamesIterator(SSTableReader sstable, FileDataInput file, DecoratedKey key,
SortedSet<ByteBuffer> columns, RowIndexEntry rowEntry)
+    public SSTableNamesIterator(SSTableReader sstable, FileDataInput file, DecoratedKey key,
SortedSet<ByteBuffer> columns, RowIndexEntry indexEntry)
     {
         assert columns != null;
         this.sstable = sstable;
@@ -81,7 +84,7 @@ public class SSTableNamesIterator extends SimpleAbstractColumnIterator implement
 
         try
         {
-            read(sstable, file, rowEntry);
+            read(sstable, file, indexEntry);
         }
         catch (IOException e)
         {
@@ -101,66 +104,101 @@ public class SSTableNamesIterator extends SimpleAbstractColumnIterator
implement
         return sstable;
     }
 
-    private void read(SSTableReader sstable, FileDataInput file, RowIndexEntry rowEntry)
-            throws IOException
+    private void read(SSTableReader sstable, FileDataInput file, RowIndexEntry indexEntry)
+    throws IOException
     {
+        IFilter bf;
         List<IndexHelper.IndexInfo> indexList;
 
-        Descriptor.Version version = sstable.descriptor.version;
-        cf = ColumnFamily.create(sstable.metadata);
-        List<OnDiskAtom> result = new ArrayList<OnDiskAtom>(columns.size());
-
-        if (version.hasPromotedRowTombstones && !rowEntry.columnsIndex().isEmpty())
+        // If the entry is not indexed or the index is not promoted, read from the row start
+        if (!indexEntry.isIndexed())
         {
-            // skip the row header entirely
-            cf.delete(rowEntry.deletionInfo());
+            if (file == null)
+                file = createFileDataInput(indexEntry.position);
+            else
+                file.seek(indexEntry.position);
 
-            readIndexedColumns(sstable.metadata, file, columns, rowEntry.columnsIndex(),
rowEntry.position, result);
-            iter = result.iterator();
-            return;
+            DecoratedKey keyInDisk = SSTableReader.decodeKey(sstable.partitioner,
+                                                             sstable.descriptor,
+                                                             ByteBufferUtil.readWithShortLength(file));
+            assert keyInDisk.equals(key) : String.format("%s != %s in %s", keyInDisk, key,
file.getPath());
+            SSTableReader.readRowSize(file, sstable.descriptor);
         }
 
-        if (file == null)
-            file = createFileDataInput(rowEntry.position);
-        else
-            file.seek(rowEntry.position);
-
-        DecoratedKey keyInDisk = SSTableReader.decodeKey(sstable.partitioner,
-                                                         sstable.descriptor,
-                                                         ByteBufferUtil.readWithShortLength(file));
-        assert keyInDisk.equals(key) : String.format("%s != %s in %s", keyInDisk, key, file.getPath());
-        SSTableReader.readRowSize(file, sstable.descriptor);
-
         if (sstable.descriptor.version.hasPromotedIndexes)
         {
-            indexList = rowEntry.columnsIndex();
-            cf.delete(rowEntry.deletionInfo());
+            bf = indexEntry.isIndexed() ? indexEntry.bloomFilter() : null;
+            indexList = indexEntry.columnsIndex();
         }
         else
         {
+            assert file != null;
+            bf = IndexHelper.defreezeBloomFilter(file, sstable.descriptor.version.filterType);
             indexList = IndexHelper.deserializeIndex(file);
         }
 
-        cf.delete(DeletionInfo.serializer().deserializeFromSSTable(file, sstable.descriptor.version));
+        if (!indexEntry.isIndexed())
+        {
+            // we can stop early if bloom filter says none of the columns actually exist
-- but,
+            // we can't stop before initializing the cf above, in case there's a relevant
tombstone
+            ColumnFamilySerializer serializer = ColumnFamily.serializer;
+            try
+            {
+                cf = ColumnFamily.create(sstable.metadata);
+                cf.delete(DeletionInfo.serializer().deserializeFromSSTable(file, sstable.descriptor.version));
+            }
+            catch (Exception e)
+            {
+                throw new IOException(serializer + " failed to deserialize " + sstable.getColumnFamilyName()
+ " with " + sstable.metadata + " from " + file, e);
+            }
+        }
+        else
+        {
+            cf = ColumnFamily.create(sstable.metadata);
+            cf.delete(indexEntry.deletionInfo());
+        }
+
+        List<OnDiskAtom> result = new ArrayList<OnDiskAtom>();
+        List<ByteBuffer> filteredColumnNames = new ArrayList<ByteBuffer>(columns.size());
+        for (ByteBuffer name : columns)
+        {
+            if (bf == null || bf.isPresent(name))
+            {
+                filteredColumnNames.add(name);
+            }
+        }
+        if (filteredColumnNames.isEmpty())
+            return;
 
         if (indexList.isEmpty())
         {
-            readSimpleColumns(file, columns, result);
+            readSimpleColumns(file, columns, filteredColumnNames, result);
         }
         else
         {
-            long basePosition = version.hasPromotedIndexes ? rowEntry.position : file.getFilePointer()
+ 4;
-            readIndexedColumns(sstable.metadata, file, columns, indexList, basePosition,
result);
+            long basePosition;
+            if (sstable.descriptor.version.hasPromotedIndexes)
+            {
+                basePosition = indexEntry.position;
+            }
+            else
+            {
+                assert file != null;
+                file.readInt(); // column count
+                basePosition = file.getFilePointer();
+            }
+            readIndexedColumns(sstable.metadata, file, columns, filteredColumnNames, indexList,
basePosition, result);
         }
 
         // create an iterator view of the columns we read
         iter = result.iterator();
     }
 
-    private void readSimpleColumns(FileDataInput file, SortedSet<ByteBuffer> columnNames,
List<OnDiskAtom> result) throws IOException
+    private void readSimpleColumns(FileDataInput file, SortedSet<ByteBuffer> columnNames,
List<ByteBuffer> filteredColumnNames, List<OnDiskAtom> result) throws IOException
     {
         OnDiskAtom.Serializer atomSerializer = cf.getOnDiskSerializer();
         int columns = file.readInt();
+        int n = 0;
         for (int i = 0; i < columns; i++)
         {
             OnDiskAtom column = atomSerializer.deserializeFromSSTable(file, sstable.descriptor.version);
@@ -169,7 +207,7 @@ public class SSTableNamesIterator extends SimpleAbstractColumnIterator
implement
                 if (columnNames.contains(column.name()))
                 {
                     result.add(column);
-                    if (result.size() >= columnNames.size())
+                    if (n++ > filteredColumnNames.size())
                         break;
                 }
             }
@@ -183,16 +221,17 @@ public class SSTableNamesIterator extends SimpleAbstractColumnIterator
implement
     private void readIndexedColumns(CFMetaData metadata,
                                     FileDataInput file,
                                     SortedSet<ByteBuffer> columnNames,
+                                    List<ByteBuffer> filteredColumnNames,
                                     List<IndexHelper.IndexInfo> indexList,
                                     long basePosition,
                                     List<OnDiskAtom> result)
-            throws IOException
+    throws IOException
     {
         /* get the various column ranges we have to read */
         AbstractType<?> comparator = metadata.comparator;
         List<IndexHelper.IndexInfo> ranges = new ArrayList<IndexHelper.IndexInfo>();
         int lastIndexIdx = -1;
-        for (ByteBuffer name : columnNames)
+        for (ByteBuffer name : filteredColumnNames)
         {
             int index = IndexHelper.indexFor(name, indexList, comparator, false, lastIndexIdx);
             if (index < 0 || index == indexList.size())
@@ -212,7 +251,7 @@ public class SSTableNamesIterator extends SimpleAbstractColumnIterator
implement
         {
             long positionToSeek = basePosition + indexInfo.offset;
 
-            // With 1.2 promoted indexes, our first seek in the data file will happen at
this point
+            // With new promoted indexes, our first seek in the data file will happen at
that point.
             if (file == null)
                 file = createFileDataInput(positionToSeek);
 
@@ -223,6 +262,7 @@ public class SSTableNamesIterator extends SimpleAbstractColumnIterator
implement
             while (file.bytesPastMark(mark) < indexInfo.width)
             {
                 OnDiskAtom column = atomSerializer.deserializeFromSSTable(file, sstable.descriptor.version);
+                // we check vs the original Set, not the filtered List, for efficiency
                 if (!(column instanceof IColumn) || columnNames.contains(column.name()))
                     result.add(column);
             }

http://git-wip-us.apache.org/repos/asf/cassandra/blob/17034c08/src/java/org/apache/cassandra/db/columniterator/SimpleSliceReader.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/cassandra/db/columniterator/SimpleSliceReader.java b/src/java/org/apache/cassandra/db/columniterator/SimpleSliceReader.java
index 0cf9af6..b30d360 100644
--- a/src/java/org/apache/cassandra/db/columniterator/SimpleSliceReader.java
+++ b/src/java/org/apache/cassandra/db/columniterator/SimpleSliceReader.java
@@ -49,7 +49,7 @@ class SimpleSliceReader extends AbstractIterator<OnDiskAtom> implements
OnDiskAt
     private FileMark mark;
     private final OnDiskAtom.Serializer atomSerializer;
 
-    public SimpleSliceReader(SSTableReader sstable, RowIndexEntry rowEntry, FileDataInput
input, ByteBuffer finishColumn)
+    public SimpleSliceReader(SSTableReader sstable, RowIndexEntry indexEntry, FileDataInput
input, ByteBuffer finishColumn)
     {
         this.sstable = sstable;
         this.finishColumn = finishColumn;
@@ -58,13 +58,13 @@ class SimpleSliceReader extends AbstractIterator<OnDiskAtom> implements
OnDiskAt
         {
             if (input == null)
             {
-                this.file = sstable.getFileDataInput(rowEntry.position);
+                this.file = sstable.getFileDataInput(indexEntry.position);
                 this.needsClosing = true;
             }
             else
             {
                 this.file = input;
-                input.seek(rowEntry.position);
+                input.seek(indexEntry.position);
                 this.needsClosing = false;
             }
 
@@ -72,19 +72,14 @@ class SimpleSliceReader extends AbstractIterator<OnDiskAtom> implements
OnDiskAt
             ByteBufferUtil.skipShortLength(file);
             SSTableReader.readRowSize(file, sstable.descriptor);
 
-            emptyColumnFamily = ColumnFamily.create(sstable.metadata);
-
             Descriptor.Version version = sstable.descriptor.version;
-            if (version.hasPromotedIndexes)
-            {
-                emptyColumnFamily.delete(rowEntry.deletionInfo());
-            }
-            else
+            if (!version.hasPromotedIndexes)
             {
                 IndexHelper.skipSSTableBloomFilter(file, version);
                 IndexHelper.skipIndex(file);
             }
 
+            emptyColumnFamily = ColumnFamily.create(sstable.metadata);
             emptyColumnFamily.delete(DeletionInfo.serializer().deserializeFromSSTable(file,
version));
             atomSerializer = emptyColumnFamily.getOnDiskSerializer();
             columns = file.readInt();

http://git-wip-us.apache.org/repos/asf/cassandra/blob/17034c08/src/java/org/apache/cassandra/io/sstable/Descriptor.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/cassandra/io/sstable/Descriptor.java b/src/java/org/apache/cassandra/io/sstable/Descriptor.java
index 7b916cb..f21a0d5 100644
--- a/src/java/org/apache/cassandra/io/sstable/Descriptor.java
+++ b/src/java/org/apache/cassandra/io/sstable/Descriptor.java
@@ -47,7 +47,7 @@ public class Descriptor
     public static class Version
     {
         // This needs to be at the begining for initialization sake
-        public static final String current_version = "ic";
+        public static final String current_version = "ib";
 
         public static final Version LEGACY = new Version("a"); // "pre-history"
         // b (0.7.0): added version to sstable filenames
@@ -62,11 +62,10 @@ public class Descriptor
         // hd (1.0.10): includes row tombstones in maxtimestamp
         // he (1.1.3): includes ancestors generation in metadata component
         // hf (1.1.6): marker that replay position corresponds to 1.1.5+ millis-based id
(see CASSANDRA-4782)
-        // ia (1.2.0): column indexes are promoted to the index file.  (this means index
offsets are now against the start of the row key, rather than the start of columns data, since
the former allows us to skip the row header)
+        // ia (1.2.0): column indexes are promoted to the index file
         //             records estimated histogram of deletion times in tombstones
         //             bloom filter (keys and columns) upgraded to Murmur3
         // ib (1.2.1): tracks min client timestamp in metadata component
-        // ic (1.2.6): always promotes row-level tombstones into index file; previously this
was unreliable
 
         public static final Version CURRENT = new Version(current_version);
 
@@ -84,7 +83,6 @@ public class Descriptor
         public final boolean hasPartitioner;
         public final boolean tracksTombstones;
         public final boolean hasPromotedIndexes;
-        public final boolean hasPromotedRowTombstones;
         public final FilterFactory.Type filterType;
         public final boolean hasAncestors;
         public final boolean hasBloomFilterSizeInHeader;
@@ -104,7 +102,6 @@ public class Descriptor
             metadataIncludesModernReplayPosition = version.compareTo("hf") >= 0;
             tracksTombstones = version.compareTo("ia") >= 0;
             hasPromotedIndexes = version.compareTo("ia") >= 0;
-            hasPromotedRowTombstones = version.compareTo("ic") >= 0;
             isLatestVersion = version.compareTo(current_version) == 0;
             if (version.compareTo("f") < 0)
                 filterType = FilterFactory.Type.SHA;

http://git-wip-us.apache.org/repos/asf/cassandra/blob/17034c08/src/java/org/apache/cassandra/io/sstable/SSTableReader.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/cassandra/io/sstable/SSTableReader.java b/src/java/org/apache/cassandra/io/sstable/SSTableReader.java
index 61f505d..21a8673 100644
--- a/src/java/org/apache/cassandra/io/sstable/SSTableReader.java
+++ b/src/java/org/apache/cassandra/io/sstable/SSTableReader.java
@@ -323,7 +323,7 @@ public class SSTableReader extends SSTable
     {
         if (!components.contains(Component.FILTER))
         {
-            bf = AlwaysPresentFilter.instance;
+            bf = new AlwaysPresentFilter();
             return;
         }
 

http://git-wip-us.apache.org/repos/asf/cassandra/blob/17034c08/src/java/org/apache/cassandra/utils/AlwaysPresentFilter.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/cassandra/utils/AlwaysPresentFilter.java b/src/java/org/apache/cassandra/utils/AlwaysPresentFilter.java
index 39b3d5d..67ac111 100644
--- a/src/java/org/apache/cassandra/utils/AlwaysPresentFilter.java
+++ b/src/java/org/apache/cassandra/utils/AlwaysPresentFilter.java
@@ -26,10 +26,6 @@ import java.nio.ByteBuffer;
 
 public class AlwaysPresentFilter implements IFilter
 {
-    public static final AlwaysPresentFilter instance = new AlwaysPresentFilter();
-
-    private AlwaysPresentFilter() { }
-
     public boolean isPresent(ByteBuffer key)
     {
         return true;

http://git-wip-us.apache.org/repos/asf/cassandra/blob/17034c08/src/java/org/apache/cassandra/utils/FilterFactory.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/cassandra/utils/FilterFactory.java b/src/java/org/apache/cassandra/utils/FilterFactory.java
index 1b9027d..88c8973 100644
--- a/src/java/org/apache/cassandra/utils/FilterFactory.java
+++ b/src/java/org/apache/cassandra/utils/FilterFactory.java
@@ -131,7 +131,7 @@ public class FilterFactory
     {
         assert maxFalsePosProbability <= 1.0 : "Invalid probability";
         if (maxFalsePosProbability == 1.0)
-            return AlwaysPresentFilter.instance;
+            return new AlwaysPresentFilter();
         int bucketsPerElement = BloomCalculations.maxBucketsPerElement(numElements);
         BloomCalculations.BloomSpecification spec = BloomCalculations.computeBloomSpec(bucketsPerElement,
maxFalsePosProbability);
         return createFilter(spec.K, numElements, spec.bucketsPerElement, type, offheap);

http://git-wip-us.apache.org/repos/asf/cassandra/blob/17034c08/test/unit/org/apache/cassandra/db/RangeTombstoneTest.java
----------------------------------------------------------------------
diff --git a/test/unit/org/apache/cassandra/db/RangeTombstoneTest.java b/test/unit/org/apache/cassandra/db/RangeTombstoneTest.java
index c531461..1bc846b 100644
--- a/test/unit/org/apache/cassandra/db/RangeTombstoneTest.java
+++ b/test/unit/org/apache/cassandra/db/RangeTombstoneTest.java
@@ -164,6 +164,10 @@ public class RangeTombstoneTest extends SchemaLoader
         return ByteBufferUtil.bytes(i);
     }
 
+    private static void insertData(ColumnFamilyStore cfs, String key) throws Exception
+    {
+    }
+
     private static void add(RowMutation rm, int value, long timestamp)
     {
         rm.add(new QueryPath(CFNAME, null, b(value)), b(value), timestamp);


Mime
View raw message