options, AbstractType validator)
+ {
+ init(StandardTokenizerOptions.buildFromMap(options), validator);
+ }
+
+ @VisibleForTesting
+ protected void init(StandardTokenizerOptions options)
+ {
+ init(options, UTF8Type.instance);
+ }
+
+ public void init(StandardTokenizerOptions tokenizerOptions, AbstractType validator)
+ {
+ this.validator = validator;
+ this.options = tokenizerOptions;
+ this.filterPipeline = getFilterPipeline();
+
+ Reader reader = new InputStreamReader(new DataInputBuffer(ByteBufferUtil.EMPTY_BYTE_BUFFER, false));
+ this.scanner = new StandardTokenizerImpl(reader);
+ this.inputReader = reader;
+ }
+
+ public boolean hasNext()
+ {
+ try
+ {
+ if (incrementToken())
+ {
+ if (getFilteredCurrentToken() != null)
+ {
+ this.next = validator.fromString(normalize(getFilteredCurrentToken()));
+ return true;
+ }
+ }
+ }
+ catch (IOException e)
+ {}
+
+ return false;
+ }
+
+ public void reset(ByteBuffer input)
+ {
+ this.next = null;
+ Reader reader = new InputStreamReader(new DataInputBuffer(input, false));
+ scanner.yyreset(reader);
+ this.inputReader = reader;
+ }
+
+ public void reset(InputStream input)
+ {
+ this.next = null;
+ Reader reader = new InputStreamReader(input);
+ scanner.yyreset(reader);
+ this.inputReader = reader;
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/analyzer/StandardTokenizerImpl.jflex b/src/java/org/apache/cassandra/index/sasi/analyzer/StandardTokenizerImpl.jflex
new file mode 100644
index 0000000000..d0270ff01c
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/analyzer/StandardTokenizerImpl.jflex
@@ -0,0 +1,220 @@
+package org.apache.cassandra.index.sasi.analyzer;
+
+/*
+ * 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.
+ */
+
+import java.util.Arrays;
+
+/**
+ * This class implements Word Break rules from the Unicode Text Segmentation
+ * algorithm, as specified in
+ * Unicode Standard Annex #29. ∂
+ *
+ * Tokens produced are of the following types:
+ *
+ * - <ALPHANUM>: A sequence of alphabetic and numeric characters
+ * - <NUM>: A number
+ * - <SOUTHEAST_ASIAN>: A sequence of characters from South and Southeast
+ * Asian languages, including Thai, Lao, Myanmar, and Khmer
+ * - <IDEOGRAPHIC>: A single CJKV ideographic character
+ * - <HIRAGANA>: A single hiragana character
+ * - <KATAKANA>: A sequence of katakana characters
+ * - <HANGUL>: A sequence of Hangul characters
+ *
+ */
+%%
+
+%unicode 6.3
+%integer
+%final
+%public
+%class StandardTokenizerImpl
+%implements StandardTokenizerInterface
+%function getNextToken
+%char
+%buffer 4096
+
+%include SUPPLEMENTARY.jflex-macro
+ALetter = (\p{WB:ALetter} | {ALetterSupp})
+Format = (\p{WB:Format} | {FormatSupp})
+Numeric = ([\p{WB:Numeric}[\p{Blk:HalfAndFullForms}&&\p{Nd}]] | {NumericSupp})
+Extend = (\p{WB:Extend} | {ExtendSupp})
+Katakana = (\p{WB:Katakana} | {KatakanaSupp})
+MidLetter = (\p{WB:MidLetter} | {MidLetterSupp})
+MidNum = (\p{WB:MidNum} | {MidNumSupp})
+MidNumLet = (\p{WB:MidNumLet} | {MidNumLetSupp})
+ExtendNumLet = (\p{WB:ExtendNumLet} | {ExtendNumLetSupp})
+ComplexContext = (\p{LB:Complex_Context} | {ComplexContextSupp})
+Han = (\p{Script:Han} | {HanSupp})
+Hiragana = (\p{Script:Hiragana} | {HiraganaSupp})
+SingleQuote = (\p{WB:Single_Quote} | {SingleQuoteSupp})
+DoubleQuote = (\p{WB:Double_Quote} | {DoubleQuoteSupp})
+HebrewLetter = (\p{WB:Hebrew_Letter} | {HebrewLetterSupp})
+RegionalIndicator = (\p{WB:Regional_Indicator} | {RegionalIndicatorSupp})
+HebrewOrALetter = ({HebrewLetter} | {ALetter})
+
+// UAX#29 WB4. X (Extend | Format)* --> X
+//
+HangulEx = [\p{Script:Hangul}&&[\p{WB:ALetter}\p{WB:Hebrew_Letter}]] ({Format} | {Extend})*
+HebrewOrALetterEx = {HebrewOrALetter} ({Format} | {Extend})*
+NumericEx = {Numeric} ({Format} | {Extend})*
+KatakanaEx = {Katakana} ({Format} | {Extend})*
+MidLetterEx = ({MidLetter} | {MidNumLet} | {SingleQuote}) ({Format} | {Extend})*
+MidNumericEx = ({MidNum} | {MidNumLet} | {SingleQuote}) ({Format} | {Extend})*
+ExtendNumLetEx = {ExtendNumLet} ({Format} | {Extend})*
+HanEx = {Han} ({Format} | {Extend})*
+HiraganaEx = {Hiragana} ({Format} | {Extend})*
+SingleQuoteEx = {SingleQuote} ({Format} | {Extend})*
+DoubleQuoteEx = {DoubleQuote} ({Format} | {Extend})*
+HebrewLetterEx = {HebrewLetter} ({Format} | {Extend})*
+RegionalIndicatorEx = {RegionalIndicator} ({Format} | {Extend})*
+
+
+%{
+ /** Alphanumeric sequences */
+ public static final int WORD_TYPE = StandardAnalyzer.TokenType.ALPHANUM.value;
+
+ /** Numbers */
+ public static final int NUMERIC_TYPE = StandardAnalyzer.TokenType.NUM.value;
+
+ /**
+ * Chars in class \p{Line_Break = Complex_Context} are from South East Asian
+ * scripts (Thai, Lao, Myanmar, Khmer, etc.). Sequences of these are kept
+ * together as as a single token rather than broken up, because the logic
+ * required to break them at word boundaries is too complex for UAX#29.
+ *
+ * See Unicode Line Breaking Algorithm: http://www.unicode.org/reports/tr14/#SA
+ */
+ public static final int SOUTH_EAST_ASIAN_TYPE = StandardAnalyzer.TokenType.SOUTHEAST_ASIAN.value;
+
+ public static final int IDEOGRAPHIC_TYPE = StandardAnalyzer.TokenType.IDEOGRAPHIC.value;
+
+ public static final int HIRAGANA_TYPE = StandardAnalyzer.TokenType.HIRAGANA.value;
+
+ public static final int KATAKANA_TYPE = StandardAnalyzer.TokenType.KATAKANA.value;
+
+ public static final int HANGUL_TYPE = StandardAnalyzer.TokenType.HANGUL.value;
+
+ public final int yychar()
+ {
+ return yychar;
+ }
+
+ public String getText()
+ {
+ return String.valueOf(zzBuffer, zzStartRead, zzMarkedPos-zzStartRead);
+ }
+
+ public char[] getArray()
+ {
+ return Arrays.copyOfRange(zzBuffer, zzStartRead, zzMarkedPos);
+ }
+
+ public byte[] getBytes()
+ {
+ return getText().getBytes();
+ }
+
+%}
+
+%%
+
+// UAX#29 WB1. sot ÷
+// WB2. ÷ eot
+//
+<> { return StandardAnalyzer.TokenType.EOF.value; }
+
+// UAX#29 WB8. Numeric × Numeric
+// WB11. Numeric (MidNum | MidNumLet | Single_Quote) × Numeric
+// WB12. Numeric × (MidNum | MidNumLet | Single_Quote) Numeric
+// WB13a. (ALetter | Hebrew_Letter | Numeric | Katakana | ExtendNumLet) × ExtendNumLet
+// WB13b. ExtendNumLet × (ALetter | Hebrew_Letter | Numeric | Katakana)
+//
+{ExtendNumLetEx}* {NumericEx} ( ( {ExtendNumLetEx}* | {MidNumericEx} ) {NumericEx} )* {ExtendNumLetEx}*
+ { return NUMERIC_TYPE; }
+
+// subset of the below for typing purposes only!
+{HangulEx}+
+ { return HANGUL_TYPE; }
+
+{KatakanaEx}+
+ { return KATAKANA_TYPE; }
+
+// UAX#29 WB5. (ALetter | Hebrew_Letter) × (ALetter | Hebrew_Letter)
+// WB6. (ALetter | Hebrew_Letter) × (MidLetter | MidNumLet | Single_Quote) (ALetter | Hebrew_Letter)
+// WB7. (ALetter | Hebrew_Letter) (MidLetter | MidNumLet | Single_Quote) × (ALetter | Hebrew_Letter)
+// WB7a. Hebrew_Letter × Single_Quote
+// WB7b. Hebrew_Letter × Double_Quote Hebrew_Letter
+// WB7c. Hebrew_Letter Double_Quote × Hebrew_Letter
+// WB9. (ALetter | Hebrew_Letter) × Numeric
+// WB10. Numeric × (ALetter | Hebrew_Letter)
+// WB13. Katakana × Katakana
+// WB13a. (ALetter | Hebrew_Letter | Numeric | Katakana | ExtendNumLet) × ExtendNumLet
+// WB13b. ExtendNumLet × (ALetter | Hebrew_Letter | Numeric | Katakana)
+//
+{ExtendNumLetEx}* ( {KatakanaEx} ( {ExtendNumLetEx}* {KatakanaEx} )*
+ | ( {HebrewLetterEx} ( {SingleQuoteEx} | {DoubleQuoteEx} {HebrewLetterEx} )
+ | {NumericEx} ( ( {ExtendNumLetEx}* | {MidNumericEx} ) {NumericEx} )*
+ | {HebrewOrALetterEx} ( ( {ExtendNumLetEx}* | {MidLetterEx} ) {HebrewOrALetterEx} )*
+ )+
+ )
+({ExtendNumLetEx}+ ( {KatakanaEx} ( {ExtendNumLetEx}* {KatakanaEx} )*
+ | ( {HebrewLetterEx} ( {SingleQuoteEx} | {DoubleQuoteEx} {HebrewLetterEx} )
+ | {NumericEx} ( ( {ExtendNumLetEx}* | {MidNumericEx} ) {NumericEx} )*
+ | {HebrewOrALetterEx} ( ( {ExtendNumLetEx}* | {MidLetterEx} ) {HebrewOrALetterEx} )*
+ )+
+ )
+)*
+{ExtendNumLetEx}*
+ { return WORD_TYPE; }
+
+
+// From UAX #29:
+//
+// [C]haracters with the Line_Break property values of Contingent_Break (CB),
+// Complex_Context (SA/South East Asian), and XX (Unknown) are assigned word
+// boundary property values based on criteria outside of the scope of this
+// annex. That means that satisfactory treatment of languages like Chinese
+// or Thai requires special handling.
+//
+// In Unicode 6.3, only one character has the \p{Line_Break = Contingent_Break}
+// property: U+FFFC (  ) OBJECT REPLACEMENT CHARACTER.
+//
+// In the ICU implementation of UAX#29, \p{Line_Break = Complex_Context}
+// character sequences (from South East Asian scripts like Thai, Myanmar, Khmer,
+// Lao, etc.) are kept together. This grammar does the same below.
+//
+// See also the Unicode Line Breaking Algorithm:
+//
+// http://www.unicode.org/reports/tr14/#SA
+//
+{ComplexContext}+ { return SOUTH_EAST_ASIAN_TYPE; }
+
+// UAX#29 WB14. Any ÷ Any
+//
+{HanEx} { return IDEOGRAPHIC_TYPE; }
+{HiraganaEx} { return HIRAGANA_TYPE; }
+
+
+// UAX#29 WB3. CR × LF
+// WB3a. (Newline | CR | LF) ÷
+// WB3b. ÷ (Newline | CR | LF)
+// WB13c. Regional_Indicator × Regional_Indicator
+// WB14. Any ÷ Any
+//
+{RegionalIndicatorEx} {RegionalIndicatorEx}+ | [^]
+ { /* Break so we don't hit fall-through warning: */ break; /* Not numeric, word, ideographic, hiragana, or SE Asian -- ignore it. */ }
diff --git a/src/java/org/apache/cassandra/index/sasi/analyzer/StandardTokenizerInterface.java b/src/java/org/apache/cassandra/index/sasi/analyzer/StandardTokenizerInterface.java
new file mode 100644
index 0000000000..57e35d7e29
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/analyzer/StandardTokenizerInterface.java
@@ -0,0 +1,65 @@
+/*
+ * 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.index.sasi.analyzer;
+
+import java.io.IOException;
+import java.io.Reader;
+
+/**
+ * Internal interface for supporting versioned grammars.
+ */
+public interface StandardTokenizerInterface
+{
+
+ String getText();
+
+ char[] getArray();
+
+ byte[] getBytes();
+
+ /**
+ * Returns the current position.
+ */
+ int yychar();
+
+ /**
+ * Returns the length of the matched text region.
+ */
+ int yylength();
+
+ /**
+ * Resumes scanning until the next regular expression is matched,
+ * the end of input is encountered or an I/O-Error occurs.
+ *
+ * @return the next token, {@link #YYEOF} on end of stream
+ * @exception java.io.IOException if any I/O-Error occurs
+ */
+ int getNextToken() throws IOException;
+
+ /**
+ * Resets the scanner to read from a new input stream.
+ * Does not close the old reader.
+ *
+ * All internal variables are reset, the old input stream
+ * cannot be reused (internal buffer is discarded and lost).
+ * Lexical state is set to ZZ_INITIAL.
+ *
+ * @param reader the new input stream
+ */
+ void yyreset(Reader reader);
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/analyzer/StandardTokenizerOptions.java b/src/java/org/apache/cassandra/index/sasi/analyzer/StandardTokenizerOptions.java
new file mode 100644
index 0000000000..2a5e4ef9f9
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/analyzer/StandardTokenizerOptions.java
@@ -0,0 +1,272 @@
+/*
+ * 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.index.sasi.analyzer;
+
+import java.util.Locale;
+import java.util.Map;
+
+/**
+ * Various options for controlling tokenization and enabling
+ * or disabling features
+ */
+public class StandardTokenizerOptions
+{
+ public static final String TOKENIZATION_ENABLE_STEMMING = "tokenization_enable_stemming";
+ public static final String TOKENIZATION_SKIP_STOP_WORDS = "tokenization_skip_stop_words";
+ public static final String TOKENIZATION_LOCALE = "tokenization_locale";
+ public static final String TOKENIZATION_NORMALIZE_LOWERCASE = "tokenization_normalize_lowercase";
+ public static final String TOKENIZATION_NORMALIZE_UPPERCASE = "tokenization_normalize_uppercase";
+
+ public static final int DEFAULT_MAX_TOKEN_LENGTH = 255;
+ public static final int DEFAULT_MIN_TOKEN_LENGTH = 0;
+
+ private boolean stemTerms;
+ private boolean ignoreStopTerms;
+ private Locale locale;
+ private boolean caseSensitive;
+ private boolean allTermsToUpperCase;
+ private boolean allTermsToLowerCase;
+ private int minTokenLength;
+ private int maxTokenLength;
+
+ public boolean shouldStemTerms()
+ {
+ return stemTerms;
+ }
+
+ public void setStemTerms(boolean stemTerms)
+ {
+ this.stemTerms = stemTerms;
+ }
+
+ public boolean shouldIgnoreStopTerms()
+ {
+ return ignoreStopTerms;
+ }
+
+ public void setIgnoreStopTerms(boolean ignoreStopTerms)
+ {
+ this.ignoreStopTerms = ignoreStopTerms;
+ }
+
+ public Locale getLocale()
+ {
+ return locale;
+ }
+
+ public void setLocale(Locale locale)
+ {
+ this.locale = locale;
+ }
+
+ public boolean isCaseSensitive()
+ {
+ return caseSensitive;
+ }
+
+ public void setCaseSensitive(boolean caseSensitive)
+ {
+ this.caseSensitive = caseSensitive;
+ }
+
+ public boolean shouldUpperCaseTerms()
+ {
+ return allTermsToUpperCase;
+ }
+
+ public void setAllTermsToUpperCase(boolean allTermsToUpperCase)
+ {
+ this.allTermsToUpperCase = allTermsToUpperCase;
+ }
+
+ public boolean shouldLowerCaseTerms()
+ {
+ return allTermsToLowerCase;
+ }
+
+ public void setAllTermsToLowerCase(boolean allTermsToLowerCase)
+ {
+ this.allTermsToLowerCase = allTermsToLowerCase;
+ }
+
+ public int getMinTokenLength()
+ {
+ return minTokenLength;
+ }
+
+ public void setMinTokenLength(int minTokenLength)
+ {
+ this.minTokenLength = minTokenLength;
+ }
+
+ public int getMaxTokenLength()
+ {
+ return maxTokenLength;
+ }
+
+ public void setMaxTokenLength(int maxTokenLength)
+ {
+ this.maxTokenLength = maxTokenLength;
+ }
+
+ public static class OptionsBuilder {
+ private boolean stemTerms;
+ private boolean ignoreStopTerms;
+ private Locale locale;
+ private boolean caseSensitive;
+ private boolean allTermsToUpperCase;
+ private boolean allTermsToLowerCase;
+ private int minTokenLength = DEFAULT_MIN_TOKEN_LENGTH;
+ private int maxTokenLength = DEFAULT_MAX_TOKEN_LENGTH;
+
+ public OptionsBuilder()
+ {
+ }
+
+ public OptionsBuilder stemTerms(boolean stemTerms)
+ {
+ this.stemTerms = stemTerms;
+ return this;
+ }
+
+ public OptionsBuilder ignoreStopTerms(boolean ignoreStopTerms)
+ {
+ this.ignoreStopTerms = ignoreStopTerms;
+ return this;
+ }
+
+ public OptionsBuilder useLocale(Locale locale)
+ {
+ this.locale = locale;
+ return this;
+ }
+
+ public OptionsBuilder caseSensitive(boolean caseSensitive)
+ {
+ this.caseSensitive = caseSensitive;
+ return this;
+ }
+
+ public OptionsBuilder alwaysUpperCaseTerms(boolean allTermsToUpperCase)
+ {
+ this.allTermsToUpperCase = allTermsToUpperCase;
+ return this;
+ }
+
+ public OptionsBuilder alwaysLowerCaseTerms(boolean allTermsToLowerCase)
+ {
+ this.allTermsToLowerCase = allTermsToLowerCase;
+ return this;
+ }
+
+ /**
+ * Set the min allowed token length. Any token shorter
+ * than this is skipped.
+ */
+ public OptionsBuilder minTokenLength(int minTokenLength)
+ {
+ if (minTokenLength < 1)
+ throw new IllegalArgumentException("minTokenLength must be greater than zero");
+ this.minTokenLength = minTokenLength;
+ return this;
+ }
+
+ /**
+ * Set the max allowed token length. Any token longer
+ * than this is skipped.
+ */
+ public OptionsBuilder maxTokenLength(int maxTokenLength)
+ {
+ if (maxTokenLength < 1)
+ throw new IllegalArgumentException("maxTokenLength must be greater than zero");
+ this.maxTokenLength = maxTokenLength;
+ return this;
+ }
+
+ public StandardTokenizerOptions build()
+ {
+ if(allTermsToLowerCase && allTermsToUpperCase)
+ throw new IllegalArgumentException("Options to normalize terms cannot be " +
+ "both uppercase and lowercase at the same time");
+
+ StandardTokenizerOptions options = new StandardTokenizerOptions();
+ options.setIgnoreStopTerms(ignoreStopTerms);
+ options.setStemTerms(stemTerms);
+ options.setLocale(locale);
+ options.setCaseSensitive(caseSensitive);
+ options.setAllTermsToLowerCase(allTermsToLowerCase);
+ options.setAllTermsToUpperCase(allTermsToUpperCase);
+ options.setMinTokenLength(minTokenLength);
+ options.setMaxTokenLength(maxTokenLength);
+ return options;
+ }
+ }
+
+ public static StandardTokenizerOptions buildFromMap(Map optionsMap)
+ {
+ OptionsBuilder optionsBuilder = new OptionsBuilder();
+
+ for (Map.Entry entry : optionsMap.entrySet())
+ {
+ switch(entry.getKey())
+ {
+ case TOKENIZATION_ENABLE_STEMMING:
+ {
+ boolean bool = Boolean.parseBoolean(entry.getValue());
+ optionsBuilder = optionsBuilder.stemTerms(bool);
+ break;
+ }
+ case TOKENIZATION_SKIP_STOP_WORDS:
+ {
+ boolean bool = Boolean.parseBoolean(entry.getValue());
+ optionsBuilder = optionsBuilder.ignoreStopTerms(bool);
+ break;
+ }
+ case TOKENIZATION_LOCALE:
+ {
+ Locale locale = new Locale(entry.getValue());
+ optionsBuilder = optionsBuilder.useLocale(locale);
+ break;
+ }
+ case TOKENIZATION_NORMALIZE_UPPERCASE:
+ {
+ boolean bool = Boolean.parseBoolean(entry.getValue());
+ optionsBuilder = optionsBuilder.alwaysUpperCaseTerms(bool);
+ break;
+ }
+ case TOKENIZATION_NORMALIZE_LOWERCASE:
+ {
+ boolean bool = Boolean.parseBoolean(entry.getValue());
+ optionsBuilder = optionsBuilder.alwaysLowerCaseTerms(bool);
+ break;
+ }
+ default:
+ {
+ }
+ }
+ }
+ return optionsBuilder.build();
+ }
+
+ public static StandardTokenizerOptions getDefaultOptions()
+ {
+ return new OptionsBuilder()
+ .ignoreStopTerms(true).alwaysLowerCaseTerms(true)
+ .stemTerms(false).useLocale(Locale.ENGLISH).build();
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/analyzer/filter/BasicResultFilters.java b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/BasicResultFilters.java
new file mode 100644
index 0000000000..2b949b898b
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/BasicResultFilters.java
@@ -0,0 +1,76 @@
+/*
+ * 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.index.sasi.analyzer.filter;
+
+import java.util.Locale;
+
+/**
+ * Basic/General Token Filters
+ */
+public class BasicResultFilters
+{
+ private static final Locale DEFAULT_LOCALE = Locale.getDefault();
+
+ public static class LowerCase extends FilterPipelineTask
+ {
+ private Locale locale;
+
+ public LowerCase(Locale locale)
+ {
+ this.locale = locale;
+ }
+
+ public LowerCase()
+ {
+ this.locale = DEFAULT_LOCALE;
+ }
+
+ public String process(String input) throws Exception
+ {
+ return input.toLowerCase(locale);
+ }
+ }
+
+ public static class UpperCase extends FilterPipelineTask
+ {
+ private Locale locale;
+
+ public UpperCase(Locale locale)
+ {
+ this.locale = locale;
+ }
+
+ public UpperCase()
+ {
+ this.locale = DEFAULT_LOCALE;
+ }
+
+ public String process(String input) throws Exception
+ {
+ return input.toUpperCase(locale);
+ }
+ }
+
+ public static class NoOperation extends FilterPipelineTask
+ {
+ public Object process(Object input) throws Exception
+ {
+ return input;
+ }
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/analyzer/filter/FilterPipelineBuilder.java b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/FilterPipelineBuilder.java
new file mode 100644
index 0000000000..e9d262d96d
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/FilterPipelineBuilder.java
@@ -0,0 +1,51 @@
+/*
+ * 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.index.sasi.analyzer.filter;
+
+/**
+ * Creates a Pipeline object for applying n pieces of logic
+ * from the provided methods to the builder in a guaranteed order
+ */
+public class FilterPipelineBuilder
+{
+ private final FilterPipelineTask parent;
+ private FilterPipelineTask current;
+
+ public FilterPipelineBuilder(FilterPipelineTask first)
+ {
+ this(first, first);
+ }
+
+ private FilterPipelineBuilder(FilterPipelineTask first, FilterPipelineTask current)
+ {
+ this.parent = first;
+ this.current = current;
+ }
+
+ public FilterPipelineBuilder add(String name, FilterPipelineTask nextTask)
+ {
+ this.current.setLast(name, nextTask);
+ this.current = nextTask;
+ return this;
+ }
+
+ public FilterPipelineTask build()
+ {
+ return this.parent;
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/analyzer/filter/FilterPipelineExecutor.java b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/FilterPipelineExecutor.java
new file mode 100644
index 0000000000..68c055e6c0
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/FilterPipelineExecutor.java
@@ -0,0 +1,53 @@
+/*
+ * 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.index.sasi.analyzer.filter;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Executes all linked Pipeline Tasks serially and returns
+ * output (if exists) from the executed logic
+ */
+public class FilterPipelineExecutor
+{
+ private static final Logger logger = LoggerFactory.getLogger(FilterPipelineExecutor.class);
+
+ public static T execute(FilterPipelineTask task, T initialInput)
+ {
+ FilterPipelineTask taskPtr = task;
+ T result = initialInput;
+ try
+ {
+ while (true)
+ {
+ FilterPipelineTask taskGeneric = (FilterPipelineTask) taskPtr;
+ result = taskGeneric.process((F) result);
+ taskPtr = taskPtr.next;
+ if(taskPtr == null)
+ return result;
+ }
+ }
+ catch (Exception e)
+ {
+ logger.info("An unhandled exception to occurred while processing " +
+ "pipeline [{}]", task.getName(), e);
+ }
+ return null;
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/analyzer/filter/FilterPipelineTask.java b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/FilterPipelineTask.java
new file mode 100644
index 0000000000..13e2a174a4
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/FilterPipelineTask.java
@@ -0,0 +1,52 @@
+/*
+ * 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.index.sasi.analyzer.filter;
+
+/**
+ * A single task or set of work to process an input
+ * and return a single output. Maintains a link to the
+ * next task to be executed after itself
+ */
+public abstract class FilterPipelineTask
+{
+ private String name;
+ public FilterPipelineTask next;
+
+ protected void setLast(String name, FilterPipelineTask last)
+ {
+ if (last == this)
+ throw new IllegalArgumentException("provided last task [" + last.name + "] cannot be set to itself");
+
+ if (this.next == null)
+ {
+ this.next = last;
+ this.name = name;
+ }
+ else
+ {
+ this.next.setLast(name, last);
+ }
+ }
+
+ public abstract T process(F input) throws Exception;
+
+ public String getName()
+ {
+ return name;
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/analyzer/filter/StemmerFactory.java b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/StemmerFactory.java
new file mode 100644
index 0000000000..04da55c368
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/StemmerFactory.java
@@ -0,0 +1,101 @@
+/*
+ * 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.index.sasi.analyzer.filter;
+
+import java.lang.reflect.Constructor;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+
+import org.tartarus.snowball.SnowballStemmer;
+import org.tartarus.snowball.ext.*;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Returns a SnowballStemmer instance appropriate for
+ * a given language
+ */
+public class StemmerFactory
+{
+ private static final Logger logger = LoggerFactory.getLogger(StemmerFactory.class);
+ private static final LoadingCache> STEMMER_CONSTRUCTOR_CACHE = CacheBuilder.newBuilder()
+ .build(new CacheLoader>()
+ {
+ public Constructor load(Class aClass) throws Exception
+ {
+ try
+ {
+ return aClass.getConstructor();
+ }
+ catch (Exception e) {
+ logger.error("Failed to get stemmer constructor", e);
+ }
+ return null;
+ }
+ });
+
+ private static final Map SUPPORTED_LANGUAGES;
+
+ static
+ {
+ SUPPORTED_LANGUAGES = new HashMap<>();
+ SUPPORTED_LANGUAGES.put("de", germanStemmer.class);
+ SUPPORTED_LANGUAGES.put("da", danishStemmer.class);
+ SUPPORTED_LANGUAGES.put("es", spanishStemmer.class);
+ SUPPORTED_LANGUAGES.put("en", englishStemmer.class);
+ SUPPORTED_LANGUAGES.put("fl", finnishStemmer.class);
+ SUPPORTED_LANGUAGES.put("fr", frenchStemmer.class);
+ SUPPORTED_LANGUAGES.put("hu", hungarianStemmer.class);
+ SUPPORTED_LANGUAGES.put("it", italianStemmer.class);
+ SUPPORTED_LANGUAGES.put("nl", dutchStemmer.class);
+ SUPPORTED_LANGUAGES.put("no", norwegianStemmer.class);
+ SUPPORTED_LANGUAGES.put("pt", portugueseStemmer.class);
+ SUPPORTED_LANGUAGES.put("ro", romanianStemmer.class);
+ SUPPORTED_LANGUAGES.put("ru", russianStemmer.class);
+ SUPPORTED_LANGUAGES.put("sv", swedishStemmer.class);
+ SUPPORTED_LANGUAGES.put("tr", turkishStemmer.class);
+ }
+
+ public static SnowballStemmer getStemmer(Locale locale)
+ {
+ if (locale == null)
+ return null;
+
+ String rootLang = locale.getLanguage().substring(0, 2);
+ try
+ {
+ Class clazz = SUPPORTED_LANGUAGES.get(rootLang);
+ if(clazz == null)
+ return null;
+ Constructor ctor = STEMMER_CONSTRUCTOR_CACHE.get(clazz);
+ return (SnowballStemmer) ctor.newInstance();
+ }
+ catch (Exception e)
+ {
+ logger.debug("Failed to create new SnowballStemmer instance " +
+ "for language [{}]", locale.getLanguage(), e);
+ }
+ return null;
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/analyzer/filter/StemmingFilters.java b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/StemmingFilters.java
new file mode 100644
index 0000000000..9e098d1464
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/StemmingFilters.java
@@ -0,0 +1,46 @@
+/*
+ * 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.index.sasi.analyzer.filter;
+
+import java.util.Locale;
+
+import org.tartarus.snowball.SnowballStemmer;
+
+/**
+ * Filters for performing Stemming on tokens
+ */
+public class StemmingFilters
+{
+ public static class DefaultStemmingFilter extends FilterPipelineTask
+ {
+ private SnowballStemmer stemmer;
+
+ public DefaultStemmingFilter(Locale locale)
+ {
+ stemmer = StemmerFactory.getStemmer(locale);
+ }
+
+ public String process(String input) throws Exception
+ {
+ if (stemmer == null)
+ return input;
+ stemmer.setCurrent(input);
+ return (stemmer.stem()) ? stemmer.getCurrent() : input;
+ }
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/analyzer/filter/StopWordFactory.java b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/StopWordFactory.java
new file mode 100644
index 0000000000..0492822824
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/StopWordFactory.java
@@ -0,0 +1,100 @@
+/*
+ * 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.index.sasi.analyzer.filter;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Provides a list of Stop Words for a given language
+ */
+public class StopWordFactory
+{
+ private static final Logger logger = LoggerFactory.getLogger(StopWordFactory.class);
+
+ private static final String DEFAULT_RESOURCE_EXT = "_ST.txt";
+ private static final String DEFAULT_RESOURCE_PREFIX = StopWordFactory.class.getPackage()
+ .getName().replace(".", File.separator);
+ private static final Set SUPPORTED_LANGUAGES = new HashSet<>(
+ Arrays.asList("ar","bg","cs","de","en","es","fi","fr","hi","hu","it",
+ "pl","pt","ro","ru","sv"));
+
+ private static final LoadingCache> STOP_WORDS_CACHE = CacheBuilder.newBuilder()
+ .build(new CacheLoader>()
+ {
+ public Set load(String s) throws Exception
+ {
+ return getStopWordsFromResource(s);
+ }
+ });
+
+ public static Set getStopWordsForLanguage(Locale locale)
+ {
+ if (locale == null)
+ return null;
+
+ String rootLang = locale.getLanguage().substring(0, 2);
+ try
+ {
+ return (!SUPPORTED_LANGUAGES.contains(rootLang)) ? null : STOP_WORDS_CACHE.get(rootLang);
+ }
+ catch (ExecutionException e)
+ {
+ logger.error("Failed to populate Stop Words Cache for language [{}]", locale.getLanguage(), e);
+ return null;
+ }
+ }
+
+ private static Set getStopWordsFromResource(String language)
+ {
+ Set stopWords = new HashSet<>();
+ String resourceName = DEFAULT_RESOURCE_PREFIX + File.separator + language + DEFAULT_RESOURCE_EXT;
+ try (InputStream is = StopWordFactory.class.getClassLoader().getResourceAsStream(resourceName);
+ BufferedReader r = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8)))
+ {
+ String line;
+ while ((line = r.readLine()) != null)
+ {
+ //skip comments (lines starting with # char)
+ if(line.charAt(0) == '#')
+ continue;
+ stopWords.add(line.trim());
+ }
+ }
+ catch (Exception e)
+ {
+ logger.error("Failed to retrieve Stop Terms resource for language [{}]", language, e);
+ }
+ return stopWords;
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/analyzer/filter/StopWordFilters.java b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/StopWordFilters.java
new file mode 100644
index 0000000000..4ae849c1f4
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/analyzer/filter/StopWordFilters.java
@@ -0,0 +1,42 @@
+/*
+ * 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.index.sasi.analyzer.filter;
+
+import java.util.Locale;
+import java.util.Set;
+
+/**
+ * Filter implementations for input matching Stop Words
+ */
+public class StopWordFilters
+{
+ public static class DefaultStopWordFilter extends FilterPipelineTask
+ {
+ private Set stopWords = null;
+
+ public DefaultStopWordFilter(Locale locale)
+ {
+ this.stopWords = StopWordFactory.getStopWordsForLanguage(locale);
+ }
+
+ public String process(String input) throws Exception
+ {
+ return (stopWords != null && stopWords.contains(input)) ? null : input;
+ }
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/conf/ColumnIndex.java b/src/java/org/apache/cassandra/index/sasi/conf/ColumnIndex.java
new file mode 100644
index 0000000000..0bc9a96bbb
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/conf/ColumnIndex.java
@@ -0,0 +1,193 @@
+/*
+ * 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.index.sasi.conf;
+
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.apache.cassandra.config.ColumnDefinition;
+import org.apache.cassandra.db.DecoratedKey;
+import org.apache.cassandra.db.marshal.AbstractType;
+import org.apache.cassandra.db.marshal.AsciiType;
+import org.apache.cassandra.db.marshal.UTF8Type;
+import org.apache.cassandra.db.rows.Cell;
+import org.apache.cassandra.db.rows.Row;
+import org.apache.cassandra.exceptions.ConfigurationException;
+import org.apache.cassandra.index.sasi.analyzer.AbstractAnalyzer;
+import org.apache.cassandra.index.sasi.conf.view.View;
+import org.apache.cassandra.index.sasi.disk.Token;
+import org.apache.cassandra.index.sasi.memory.IndexMemtable;
+import org.apache.cassandra.index.sasi.plan.Expression;
+import org.apache.cassandra.index.sasi.utils.RangeIterator;
+import org.apache.cassandra.io.sstable.Component;
+import org.apache.cassandra.io.sstable.format.SSTableReader;
+import org.apache.cassandra.schema.IndexMetadata;
+import org.apache.cassandra.utils.FBUtilities;
+
+public class ColumnIndex
+{
+ private static final String FILE_NAME_FORMAT = "SI_%s.db";
+
+ private final AbstractType keyValidator;
+
+ private final ColumnDefinition column;
+ private final Optional config;
+
+ private final AtomicReference memtable;
+ private final IndexMode mode;
+
+ private final Component component;
+ private final DataTracker tracker;
+
+ public ColumnIndex(AbstractType keyValidator, ColumnDefinition column, IndexMetadata metadata)
+ {
+ this.keyValidator = keyValidator;
+ this.column = column;
+ this.config = metadata == null ? Optional.empty() : Optional.of(metadata);
+ this.mode = IndexMode.getMode(column, config);
+ this.memtable = new AtomicReference<>(new IndexMemtable(this));
+ this.tracker = new DataTracker(keyValidator, this);
+ this.component = new Component(Component.Type.SECONDARY_INDEX, String.format(FILE_NAME_FORMAT, getIndexName()));
+ }
+
+ public void validate() throws ConfigurationException
+ {
+ mode.validate(config);
+ }
+
+ /**
+ * Initialize this column index with specific set of SSTables.
+ *
+ * @param sstables The sstables to be used by index initially.
+ *
+ * @return A collection of sstables which don't have this specific index attached to them.
+ */
+ public Iterable init(Set sstables)
+ {
+ return tracker.update(Collections.emptySet(), sstables);
+ }
+
+ public AbstractType keyValidator()
+ {
+ return keyValidator;
+ }
+
+ public long index(DecoratedKey key, Row row)
+ {
+ return memtable.get().index(key, getValueOf(column, row, FBUtilities.nowInSeconds()));
+ }
+
+ public void switchMemtable()
+ {
+ memtable.set(new IndexMemtable(this));
+ }
+
+ public RangeIterator searchMemtable(Expression e)
+ {
+ return memtable.get().search(e);
+ }
+
+ public void update(Collection oldSSTables, Collection newSSTables)
+ {
+ tracker.update(oldSSTables, newSSTables);
+ }
+
+ public ColumnDefinition getDefinition()
+ {
+ return column;
+ }
+
+ public AbstractType getValidator()
+ {
+ return column.cellValueType();
+ }
+
+ public Component getComponent()
+ {
+ return component;
+ }
+
+ public IndexMode getMode()
+ {
+ return mode;
+ }
+
+ public String getColumnName()
+ {
+ return column.name.toString();
+ }
+
+ public String getIndexName()
+ {
+ return config.isPresent() ? config.get().name : "undefined";
+ }
+
+ public AbstractAnalyzer getAnalyzer()
+ {
+ AbstractAnalyzer analyzer = mode.getAnalyzer(getValidator());
+ analyzer.init(config.isPresent() ? config.get().options : Collections.emptyMap(), column.cellValueType());
+ return analyzer;
+ }
+
+ public View getView()
+ {
+ return tracker.getView();
+ }
+
+ public boolean hasSSTable(SSTableReader sstable)
+ {
+ return tracker.hasSSTable(sstable);
+ }
+
+ public void dropData(long truncateUntil)
+ {
+ switchMemtable();
+ tracker.dropData(truncateUntil);
+ }
+
+ public boolean isIndexed()
+ {
+ return mode != IndexMode.NOT_INDEXED;
+ }
+
+ public boolean isLiteral()
+ {
+ AbstractType validator = getValidator();
+ return isIndexed() ? mode.isLiteral : (validator instanceof UTF8Type || validator instanceof AsciiType);
+ }
+
+ public static ByteBuffer getValueOf(ColumnDefinition column, Row row, int nowInSecs)
+ {
+ switch (column.kind)
+ {
+ case CLUSTERING:
+ return row.clustering().get(column.position());
+
+ case REGULAR:
+ Cell cell = row.getCell(column);
+ return cell == null || !cell.isLive(nowInSecs) ? null : cell.value();
+
+ default:
+ return null;
+ }
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/conf/DataTracker.java b/src/java/org/apache/cassandra/index/sasi/conf/DataTracker.java
new file mode 100644
index 0000000000..9475d12f86
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/conf/DataTracker.java
@@ -0,0 +1,162 @@
+/*
+ * 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.index.sasi.conf;
+
+import java.io.File;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+
+import org.apache.cassandra.db.marshal.AbstractType;
+import org.apache.cassandra.index.sasi.SSTableIndex;
+import org.apache.cassandra.index.sasi.conf.view.View;
+import org.apache.cassandra.io.sstable.format.SSTableReader;
+
+import com.google.common.collect.Sets;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/** a pared-down version of DataTracker and DT.View. need one for each index of each column family */
+public class DataTracker
+{
+ private static final Logger logger = LoggerFactory.getLogger(DataTracker.class);
+
+ private final AbstractType keyValidator;
+ private final ColumnIndex columnIndex;
+ private final AtomicReference view = new AtomicReference<>();
+
+ public DataTracker(AbstractType keyValidator, ColumnIndex index)
+ {
+ this.keyValidator = keyValidator;
+ this.columnIndex = index;
+ this.view.set(new View(index, Collections.emptySet()));
+ }
+
+ public View getView()
+ {
+ return view.get();
+ }
+
+ /**
+ * Replaces old SSTables with new by creating new immutable tracker.
+ *
+ * @param oldSSTables A set of SSTables to remove.
+ * @param newSSTables A set of SSTables to add to tracker.
+ *
+ * @return A collection of SSTables which don't have component attached for current index.
+ */
+ public Iterable update(Collection oldSSTables, Collection newSSTables)
+ {
+ final Set newIndexes = getIndexes(newSSTables);
+ final Set indexedSSTables = getSSTables(newIndexes);
+
+ View currentView, newView;
+ do
+ {
+ currentView = view.get();
+ newView = new View(columnIndex, currentView.getIndexes(), oldSSTables, newIndexes);
+ }
+ while (!view.compareAndSet(currentView, newView));
+
+ return newSSTables.stream().filter(sstable -> !indexedSSTables.contains(sstable)).collect(Collectors.toList());
+ }
+
+ public boolean hasSSTable(SSTableReader sstable)
+ {
+ View currentView = view.get();
+ for (SSTableIndex index : currentView)
+ {
+ if (index.getSSTable().equals(sstable))
+ return true;
+ }
+
+ return false;
+ }
+
+ public void dropData(long truncateUntil)
+ {
+ View currentView = view.get();
+ if (currentView == null)
+ return;
+
+ Set toRemove = new HashSet<>();
+ for (SSTableIndex index : currentView)
+ {
+ SSTableReader sstable = index.getSSTable();
+ if (sstable.getMaxTimestamp() > truncateUntil)
+ continue;
+
+ index.markObsolete();
+ toRemove.add(sstable);
+ }
+
+ update(toRemove, Collections.emptyList());
+ }
+
+ private Set getIndexes(Collection sstables)
+ {
+ Set indexes = new HashSet<>(sstables.size());
+ for (SSTableReader sstable : sstables)
+ {
+ if (sstable.isMarkedCompacted())
+ continue;
+
+ File indexFile = new File(sstable.descriptor.filenameFor(columnIndex.getComponent()));
+ if (!indexFile.exists())
+ continue;
+
+ SSTableIndex index = null;
+
+ try
+ {
+ index = new SSTableIndex(columnIndex, indexFile, sstable);
+
+ logger.info("SSTableIndex.open(column: {}, minTerm: {}, maxTerm: {}, minKey: {}, maxKey: {}, sstable: {})",
+ columnIndex.getColumnName(),
+ columnIndex.getValidator().getString(index.minTerm()),
+ columnIndex.getValidator().getString(index.maxTerm()),
+ keyValidator.getString(index.minKey()),
+ keyValidator.getString(index.maxKey()),
+ index.getSSTable());
+
+ // Try to add new index to the set, if set already has such index, we'll simply release and move on.
+ // This covers situation when sstable collection has the same sstable multiple
+ // times because we don't know what kind of collection it actually is.
+ if (!indexes.add(index))
+ index.release();
+ }
+ catch (Throwable t)
+ {
+ logger.error("Can't open index file at " + indexFile.getAbsolutePath() + ", skipping.", t);
+ if (index != null)
+ index.release();
+ }
+ }
+
+ return indexes;
+ }
+
+ private Set getSSTables(Set indexes)
+ {
+ return Sets.newHashSet(indexes.stream().map(SSTableIndex::getSSTable).collect(Collectors.toList()));
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/conf/IndexMode.java b/src/java/org/apache/cassandra/index/sasi/conf/IndexMode.java
new file mode 100644
index 0000000000..628a6ce891
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/conf/IndexMode.java
@@ -0,0 +1,169 @@
+/*
+ * 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.index.sasi.conf;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+import org.apache.cassandra.config.ColumnDefinition;
+import org.apache.cassandra.index.sasi.analyzer.AbstractAnalyzer;
+import org.apache.cassandra.index.sasi.analyzer.NoOpAnalyzer;
+import org.apache.cassandra.index.sasi.analyzer.NonTokenizingAnalyzer;
+import org.apache.cassandra.index.sasi.analyzer.StandardAnalyzer;
+import org.apache.cassandra.index.sasi.disk.OnDiskIndexBuilder.Mode;
+import org.apache.cassandra.db.marshal.AbstractType;
+import org.apache.cassandra.db.marshal.AsciiType;
+import org.apache.cassandra.db.marshal.UTF8Type;
+import org.apache.cassandra.exceptions.ConfigurationException;
+import org.apache.cassandra.schema.IndexMetadata;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class IndexMode
+{
+ private static final Logger logger = LoggerFactory.getLogger(IndexMode.class);
+
+ public static final IndexMode NOT_INDEXED = new IndexMode(Mode.PREFIX, true, false, NonTokenizingAnalyzer.class, 0);
+
+ private static final Set> TOKENIZABLE_TYPES = new HashSet>()
+ {{
+ add(UTF8Type.instance);
+ add(AsciiType.instance);
+ }};
+
+ private static final String INDEX_MODE_OPTION = "mode";
+ private static final String INDEX_ANALYZED_OPTION = "analyzed";
+ private static final String INDEX_ANALYZER_CLASS_OPTION = "analyzer_class";
+ private static final String INDEX_IS_LITERAL_OPTION = "is_literal";
+ private static final String INDEX_MAX_FLUSH_MEMORY_OPTION = "max_compaction_flush_memory_in_mb";
+ private static final double INDEX_MAX_FLUSH_DEFAULT_MULTIPLIER = 0.15;
+
+ public final Mode mode;
+ public final boolean isAnalyzed, isLiteral;
+ public final Class analyzerClass;
+ public final long maxCompactionFlushMemoryInMb;
+
+ private IndexMode(Mode mode, boolean isLiteral, boolean isAnalyzed, Class analyzerClass, long maxFlushMemMb)
+ {
+ this.mode = mode;
+ this.isLiteral = isLiteral;
+ this.isAnalyzed = isAnalyzed;
+ this.analyzerClass = analyzerClass;
+ this.maxCompactionFlushMemoryInMb = maxFlushMemMb;
+ }
+
+ public void validate(Optional config) throws ConfigurationException
+ {
+ if (!config.isPresent())
+ return;
+
+ Map indexOptions = config.get().options;
+ // validate that a valid analyzer class was provided if specified
+ if (indexOptions.containsKey(INDEX_ANALYZER_CLASS_OPTION))
+ {
+ try
+ {
+ Class.forName(indexOptions.get(INDEX_ANALYZER_CLASS_OPTION));
+ }
+ catch (ClassNotFoundException e)
+ {
+ throw new ConfigurationException(String.format("Invalid analyzer class option specified [%s]",
+ indexOptions.get(INDEX_ANALYZER_CLASS_OPTION)));
+ }
+ }
+ }
+
+ public AbstractAnalyzer getAnalyzer(AbstractType validator)
+ {
+ AbstractAnalyzer analyzer = new NoOpAnalyzer();
+
+ try
+ {
+ if (isAnalyzed)
+ {
+ if (analyzerClass != null)
+ analyzer = (AbstractAnalyzer) analyzerClass.newInstance();
+ else if (TOKENIZABLE_TYPES.contains(validator))
+ analyzer = new StandardAnalyzer();
+ }
+ }
+ catch (InstantiationException | IllegalAccessException e)
+ {
+ logger.error("Failed to create new instance of analyzer with class [{}]", analyzerClass.getName(), e);
+ }
+
+ return analyzer;
+ }
+
+ public static IndexMode getMode(ColumnDefinition column, Optional config)
+ {
+ Map indexOptions = config.isPresent() ? config.get().options : null;
+ if (indexOptions == null || indexOptions.isEmpty())
+ return IndexMode.NOT_INDEXED;
+
+ Mode mode = indexOptions.get(INDEX_MODE_OPTION) == null
+ ? Mode.PREFIX
+ : Mode.mode(indexOptions.get(INDEX_MODE_OPTION));
+
+ boolean isAnalyzed = false;
+ Class analyzerClass = null;
+ try
+ {
+ if (indexOptions.get(INDEX_ANALYZER_CLASS_OPTION) != null)
+ {
+ analyzerClass = Class.forName(indexOptions.get(INDEX_ANALYZER_CLASS_OPTION));
+ isAnalyzed = indexOptions.get(INDEX_ANALYZED_OPTION) == null
+ ? true : Boolean.valueOf(indexOptions.get(INDEX_ANALYZED_OPTION));
+ }
+ else if (indexOptions.get(INDEX_ANALYZED_OPTION) != null)
+ {
+ isAnalyzed = Boolean.valueOf(indexOptions.get(INDEX_ANALYZED_OPTION));
+ }
+ }
+ catch (ClassNotFoundException e)
+ {
+ // should not happen as we already validated we could instantiate an instance in validateOptions()
+ logger.error("Failed to find specified analyzer class [{}]. Falling back to default analyzer",
+ indexOptions.get(INDEX_ANALYZER_CLASS_OPTION));
+ }
+
+ boolean isLiteral = false;
+ try
+ {
+ String literalOption = indexOptions.get(INDEX_IS_LITERAL_OPTION);
+ AbstractType validator = column.cellValueType();
+
+ isLiteral = literalOption == null
+ ? (validator instanceof UTF8Type || validator instanceof AsciiType)
+ : Boolean.valueOf(literalOption);
+ }
+ catch (Exception e)
+ {
+ logger.error("failed to parse {} option, defaulting to 'false' for {} index.", INDEX_IS_LITERAL_OPTION, config.get().name);
+ }
+
+ Long maxMemMb = indexOptions.get(INDEX_MAX_FLUSH_MEMORY_OPTION) == null
+ ? (long) (1073741824 * INDEX_MAX_FLUSH_DEFAULT_MULTIPLIER) // 1G default for memtable
+ : Long.parseLong(indexOptions.get(INDEX_MAX_FLUSH_MEMORY_OPTION));
+
+ return new IndexMode(mode, isLiteral, isAnalyzed, analyzerClass, maxMemMb);
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/conf/view/PrefixTermTree.java b/src/java/org/apache/cassandra/index/sasi/conf/view/PrefixTermTree.java
new file mode 100644
index 0000000000..72b6daf943
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/conf/view/PrefixTermTree.java
@@ -0,0 +1,194 @@
+/*
+ * 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.index.sasi.conf.view;
+
+import java.nio.ByteBuffer;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.cassandra.index.sasi.SSTableIndex;
+import org.apache.cassandra.index.sasi.disk.OnDiskIndexBuilder;
+import org.apache.cassandra.index.sasi.plan.Expression;
+import org.apache.cassandra.index.sasi.utils.trie.KeyAnalyzer;
+import org.apache.cassandra.index.sasi.utils.trie.PatriciaTrie;
+import org.apache.cassandra.index.sasi.utils.trie.Trie;
+import org.apache.cassandra.db.marshal.AbstractType;
+import org.apache.cassandra.utils.Interval;
+import org.apache.cassandra.utils.IntervalTree;
+
+import com.google.common.collect.Sets;
+
+/**
+ * This class is an extension over RangeTermTree for string terms,
+ * it is required because interval tree can't handle matching if search is on the
+ * prefix of min/max of the range, so for ascii/utf8 fields we build an additional
+ * prefix trie (including both min/max terms of the index) and do union of the results
+ * of the prefix tree search and results from the interval tree lookup.
+ */
+public class PrefixTermTree extends RangeTermTree
+{
+ private final OnDiskIndexBuilder.Mode mode;
+ private final Trie> trie;
+
+ public PrefixTermTree(ByteBuffer min, ByteBuffer max,
+ Trie> trie,
+ IntervalTree> ranges,
+ OnDiskIndexBuilder.Mode mode)
+ {
+ super(min, max, ranges);
+
+ this.mode = mode;
+ this.trie = trie;
+ }
+
+ public Set search(Expression e)
+ {
+ Map> indexes = (e == null || e.lower == null || mode == OnDiskIndexBuilder.Mode.CONTAINS)
+ ? trie : trie.prefixMap(e.lower.value);
+
+ Set view = new HashSet<>(indexes.size());
+ indexes.values().forEach(view::addAll);
+
+ return Sets.union(view, super.search(e));
+ }
+
+ public static class Builder extends RangeTermTree.Builder
+ {
+ private final PatriciaTrie> trie;
+
+ protected Builder(OnDiskIndexBuilder.Mode mode, final AbstractType comparator)
+ {
+ super(mode, comparator);
+ trie = new PatriciaTrie<>(new ByteBufferKeyAnalyzer(comparator));
+ }
+
+ public void addIndex(SSTableIndex index)
+ {
+ super.addIndex(index);
+ addTerm(index.minTerm(), index);
+ addTerm(index.maxTerm(), index);
+ }
+
+ public TermTree build()
+ {
+ return new PrefixTermTree(min, max, trie, IntervalTree.build(intervals), mode);
+ }
+
+ private void addTerm(ByteBuffer term, SSTableIndex index)
+ {
+ Set indexes = trie.get(term);
+ if (indexes == null)
+ trie.put(term, (indexes = new HashSet<>()));
+
+ indexes.add(index);
+ }
+ }
+
+ private static class ByteBufferKeyAnalyzer implements KeyAnalyzer
+ {
+ private final AbstractType comparator;
+
+ public ByteBufferKeyAnalyzer(AbstractType comparator)
+ {
+ this.comparator = comparator;
+ }
+
+ /**
+ * A bit mask where the first bit is 1 and the others are zero
+ */
+ private static final int MSB = 1 << Byte.SIZE-1;
+
+ public int compare(ByteBuffer a, ByteBuffer b)
+ {
+ return comparator.compare(a, b);
+ }
+
+ public int lengthInBits(ByteBuffer o)
+ {
+ return o.remaining() * Byte.SIZE;
+ }
+
+ public boolean isBitSet(ByteBuffer key, int bitIndex)
+ {
+ if (bitIndex >= lengthInBits(key))
+ return false;
+
+ int index = bitIndex / Byte.SIZE;
+ int bit = bitIndex % Byte.SIZE;
+ return (key.get(index) & mask(bit)) != 0;
+ }
+
+ public int bitIndex(ByteBuffer key, ByteBuffer otherKey)
+ {
+ int length = Math.max(key.remaining(), otherKey.remaining());
+
+ boolean allNull = true;
+ for (int i = 0; i < length; i++)
+ {
+ byte b1 = valueAt(key, i);
+ byte b2 = valueAt(otherKey, i);
+
+ if (b1 != b2)
+ {
+ int xor = b1 ^ b2;
+ for (int j = 0; j < Byte.SIZE; j++)
+ {
+ if ((xor & mask(j)) != 0)
+ return (i * Byte.SIZE) + j;
+ }
+ }
+
+ if (b1 != 0)
+ allNull = false;
+ }
+
+ return allNull ? KeyAnalyzer.NULL_BIT_KEY : KeyAnalyzer.EQUAL_BIT_KEY;
+ }
+
+ public boolean isPrefix(ByteBuffer key, ByteBuffer prefix)
+ {
+ if (key.remaining() < prefix.remaining())
+ return false;
+
+ for (int i = 0; i < prefix.remaining(); i++)
+ {
+ if (key.get(i) != prefix.get(i))
+ return false;
+ }
+
+ return true;
+ }
+
+ /**
+ * Returns the {@code byte} value at the given index.
+ */
+ private byte valueAt(ByteBuffer value, int index)
+ {
+ return index >= 0 && index < value.remaining() ? value.get(index) : 0;
+ }
+
+ /**
+ * Returns a bit mask where the given bit is set
+ */
+ private int mask(int bit)
+ {
+ return MSB >>> bit;
+ }
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/conf/view/RangeTermTree.java b/src/java/org/apache/cassandra/index/sasi/conf/view/RangeTermTree.java
new file mode 100644
index 0000000000..62e5636439
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/conf/view/RangeTermTree.java
@@ -0,0 +1,77 @@
+/*
+ * 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.index.sasi.conf.view;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.cassandra.index.sasi.SSTableIndex;
+import org.apache.cassandra.index.sasi.disk.OnDiskIndexBuilder;
+import org.apache.cassandra.index.sasi.plan.Expression;
+import org.apache.cassandra.db.marshal.AbstractType;
+import org.apache.cassandra.utils.Interval;
+import org.apache.cassandra.utils.IntervalTree;
+
+public class RangeTermTree implements TermTree
+{
+ protected final ByteBuffer min, max;
+ protected final IntervalTree> rangeTree;
+
+ public RangeTermTree(ByteBuffer min, ByteBuffer max, IntervalTree> rangeTree)
+ {
+ this.min = min;
+ this.max = max;
+ this.rangeTree = rangeTree;
+ }
+
+ public Set search(Expression e)
+ {
+ ByteBuffer minTerm = e.lower == null ? min : e.lower.value;
+ ByteBuffer maxTerm = e.upper == null ? max : e.upper.value;
+
+ return new HashSet<>(rangeTree.search(Interval.create(minTerm, maxTerm, (SSTableIndex) null)));
+ }
+
+ public int intervalCount()
+ {
+ return rangeTree.intervalCount();
+ }
+
+ static class Builder extends TermTree.Builder
+ {
+ protected final List> intervals = new ArrayList<>();
+
+ protected Builder(OnDiskIndexBuilder.Mode mode, AbstractType comparator)
+ {
+ super(mode, comparator);
+ }
+
+ public void addIndex(SSTableIndex index)
+ {
+ intervals.add(Interval.create(index.minTerm(), index.maxTerm(), index));
+ }
+
+ public TermTree build()
+ {
+ return new RangeTermTree(min, max, IntervalTree.build(intervals));
+ }
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/conf/view/TermTree.java b/src/java/org/apache/cassandra/index/sasi/conf/view/TermTree.java
new file mode 100644
index 0000000000..a175e22568
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/conf/view/TermTree.java
@@ -0,0 +1,58 @@
+/*
+ * 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.index.sasi.conf.view;
+
+import java.nio.ByteBuffer;
+import java.util.Set;
+
+import org.apache.cassandra.index.sasi.SSTableIndex;
+import org.apache.cassandra.index.sasi.disk.OnDiskIndexBuilder;
+import org.apache.cassandra.index.sasi.plan.Expression;
+import org.apache.cassandra.db.marshal.AbstractType;
+
+public interface TermTree
+{
+ Set search(Expression e);
+
+ int intervalCount();
+
+ abstract class Builder
+ {
+ protected final OnDiskIndexBuilder.Mode mode;
+ protected final AbstractType comparator;
+ protected ByteBuffer min, max;
+
+ protected Builder(OnDiskIndexBuilder.Mode mode, AbstractType comparator)
+ {
+ this.mode = mode;
+ this.comparator = comparator;
+ }
+
+ public final void add(SSTableIndex index)
+ {
+ addIndex(index);
+
+ min = min == null || comparator.compare(min, index.minTerm()) > 0 ? index.minTerm() : min;
+ max = max == null || comparator.compare(max, index.maxTerm()) < 0 ? index.maxTerm() : max;
+ }
+
+ protected abstract void addIndex(SSTableIndex index);
+
+ public abstract TermTree build();
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/conf/view/View.java b/src/java/org/apache/cassandra/index/sasi/conf/view/View.java
new file mode 100644
index 0000000000..378c3c6cd7
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/conf/view/View.java
@@ -0,0 +1,104 @@
+/*
+ * 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.index.sasi.conf.view;
+
+import java.nio.ByteBuffer;
+import java.util.*;
+
+import org.apache.cassandra.index.sasi.SSTableIndex;
+import org.apache.cassandra.index.sasi.conf.ColumnIndex;
+import org.apache.cassandra.index.sasi.plan.Expression;
+import org.apache.cassandra.db.marshal.AbstractType;
+import org.apache.cassandra.db.marshal.AsciiType;
+import org.apache.cassandra.db.marshal.UTF8Type;
+import org.apache.cassandra.io.sstable.Descriptor;
+import org.apache.cassandra.io.sstable.format.SSTableReader;
+import org.apache.cassandra.utils.Interval;
+import org.apache.cassandra.utils.IntervalTree;
+
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Sets;
+
+public class View implements Iterable
+{
+ private final Map view;
+
+ private final TermTree termTree;
+ private final IntervalTree> keyIntervalTree;
+
+ public View(ColumnIndex index, Set indexes)
+ {
+ this(index, Collections.emptyList(), Collections.emptyList(), indexes);
+ }
+
+ public View(ColumnIndex index,
+ Collection currentView,
+ Collection oldSSTables,
+ Set newIndexes)
+ {
+ Map newView = new HashMap<>();
+
+ AbstractType validator = index.getValidator();
+ TermTree.Builder termTreeBuilder = (validator instanceof AsciiType || validator instanceof UTF8Type)
+ ? new PrefixTermTree.Builder(index.getMode().mode, validator)
+ : new RangeTermTree.Builder(index.getMode().mode, validator);
+
+ List> keyIntervals = new ArrayList<>();
+ for (SSTableIndex sstableIndex : Iterables.concat(currentView, newIndexes))
+ {
+ SSTableReader sstable = sstableIndex.getSSTable();
+ if (oldSSTables.contains(sstable) || sstable.isMarkedCompacted() || newView.containsKey(sstable.descriptor))
+ {
+ sstableIndex.release();
+ continue;
+ }
+
+ newView.put(sstable.descriptor, sstableIndex);
+
+ termTreeBuilder.add(sstableIndex);
+ keyIntervals.add(Interval.create(sstableIndex.minKey(), sstableIndex.maxKey(), sstableIndex));
+ }
+
+ this.view = newView;
+ this.termTree = termTreeBuilder.build();
+ this.keyIntervalTree = IntervalTree.build(keyIntervals);
+
+ if (keyIntervalTree.intervalCount() != termTree.intervalCount())
+ throw new IllegalStateException(String.format("mismatched sizes for intervals tree for keys vs terms: %d != %d", keyIntervalTree.intervalCount(), termTree.intervalCount()));
+ }
+
+ public Set match(final Set scope, Expression expression)
+ {
+ return Sets.filter(termTree.search(expression), index -> scope.contains(index.getSSTable()));
+ }
+
+ public List match(ByteBuffer minKey, ByteBuffer maxKey)
+ {
+ return keyIntervalTree.search(Interval.create(minKey, maxKey, (SSTableIndex) null));
+ }
+
+ public Iterator iterator()
+ {
+ return view.values().iterator();
+ }
+
+ public Collection getIndexes()
+ {
+ return view.values();
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/disk/Descriptor.java b/src/java/org/apache/cassandra/index/sasi/disk/Descriptor.java
new file mode 100644
index 0000000000..a719f50ca1
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/disk/Descriptor.java
@@ -0,0 +1,51 @@
+/*
+ * 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.index.sasi.disk;
+
+/**
+ * Object descriptor for SSTableAttachedSecondaryIndex files. Similar to, and based upon, the sstable descriptor.
+ */
+public class Descriptor
+{
+ public static final String VERSION_AA = "aa";
+ public static final String VERSION_AB = "ab";
+ public static final String CURRENT_VERSION = VERSION_AB;
+ public static final Descriptor CURRENT = new Descriptor(CURRENT_VERSION);
+
+ public static class Version
+ {
+ public final String version;
+
+ public Version(String version)
+ {
+ this.version = version;
+ }
+
+ public String toString()
+ {
+ return version;
+ }
+ }
+
+ public final Version version;
+
+ public Descriptor(String v)
+ {
+ this.version = new Version(v);
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/disk/OnDiskBlock.java b/src/java/org/apache/cassandra/index/sasi/disk/OnDiskBlock.java
new file mode 100644
index 0000000000..32cda53d7e
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/disk/OnDiskBlock.java
@@ -0,0 +1,142 @@
+/*
+ * 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.index.sasi.disk;
+
+import java.nio.ByteBuffer;
+
+import org.apache.cassandra.index.sasi.Term;
+import org.apache.cassandra.index.sasi.utils.MappedBuffer;
+import org.apache.cassandra.db.marshal.AbstractType;
+
+public abstract class OnDiskBlock
+{
+ public enum BlockType
+ {
+ POINTER, DATA
+ }
+
+ // this contains offsets of the terms and term data
+ protected final MappedBuffer blockIndex;
+ protected final int blockIndexSize;
+
+ protected final boolean hasCombinedIndex;
+ protected final TokenTree combinedIndex;
+
+ public OnDiskBlock(Descriptor descriptor, MappedBuffer block, BlockType blockType)
+ {
+ blockIndex = block;
+
+ if (blockType == BlockType.POINTER)
+ {
+ hasCombinedIndex = false;
+ combinedIndex = null;
+ blockIndexSize = block.getInt() << 1; // num terms * sizeof(short)
+ return;
+ }
+
+ long blockOffset = block.position();
+ int combinedIndexOffset = block.getInt(blockOffset + OnDiskIndexBuilder.BLOCK_SIZE);
+
+ hasCombinedIndex = (combinedIndexOffset >= 0);
+ long blockIndexOffset = blockOffset + OnDiskIndexBuilder.BLOCK_SIZE + 4 + combinedIndexOffset;
+
+ combinedIndex = hasCombinedIndex ? new TokenTree(descriptor, blockIndex.duplicate().position(blockIndexOffset)) : null;
+ blockIndexSize = block.getInt() * 2;
+ }
+
+ public SearchResult search(AbstractType comparator, ByteBuffer query)
+ {
+ int cmp = -1, start = 0, end = termCount() - 1, middle = 0;
+
+ T element = null;
+ while (start <= end)
+ {
+ middle = start + ((end - start) >> 1);
+ element = getTerm(middle);
+
+ cmp = element.compareTo(comparator, query);
+ if (cmp == 0)
+ return new SearchResult<>(element, cmp, middle);
+ else if (cmp < 0)
+ start = middle + 1;
+ else
+ end = middle - 1;
+ }
+
+ return new SearchResult<>(element, cmp, middle);
+ }
+
+ protected T getTerm(int index)
+ {
+ MappedBuffer dup = blockIndex.duplicate();
+ long startsAt = getTermPosition(index);
+ if (termCount() - 1 == index) // last element
+ dup.position(startsAt);
+ else
+ dup.position(startsAt).limit(getTermPosition(index + 1));
+
+ return cast(dup);
+ }
+
+ protected long getTermPosition(int idx)
+ {
+ return getTermPosition(blockIndex, idx, blockIndexSize);
+ }
+
+ protected int termCount()
+ {
+ return blockIndexSize >> 1;
+ }
+
+ protected abstract T cast(MappedBuffer data);
+
+ static long getTermPosition(MappedBuffer data, int idx, int indexSize)
+ {
+ idx <<= 1;
+ assert idx < indexSize;
+ return data.position() + indexSize + data.getShort(data.position() + idx);
+ }
+
+ public TokenTree getBlockIndex()
+ {
+ return combinedIndex;
+ }
+
+ public int minOffset(OnDiskIndex.IteratorOrder order)
+ {
+ return order == OnDiskIndex.IteratorOrder.DESC ? 0 : termCount() - 1;
+ }
+
+ public int maxOffset(OnDiskIndex.IteratorOrder order)
+ {
+ return minOffset(order) == 0 ? termCount() - 1 : 0;
+ }
+
+ public static class SearchResult
+ {
+ public final T result;
+ public final int index, cmp;
+
+ public SearchResult(T result, int cmp, int index)
+ {
+ this.result = result;
+ this.index = index;
+ this.cmp = cmp;
+ }
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/disk/OnDiskIndex.java b/src/java/org/apache/cassandra/index/sasi/disk/OnDiskIndex.java
new file mode 100644
index 0000000000..0f9e389001
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/disk/OnDiskIndex.java
@@ -0,0 +1,773 @@
+/*
+ * 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.index.sasi.disk;
+
+import java.io.*;
+import java.nio.ByteBuffer;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import org.apache.cassandra.db.DecoratedKey;
+import org.apache.cassandra.index.sasi.Term;
+import org.apache.cassandra.index.sasi.plan.Expression;
+import org.apache.cassandra.index.sasi.plan.Expression.Op;
+import org.apache.cassandra.index.sasi.utils.MappedBuffer;
+import org.apache.cassandra.index.sasi.utils.RangeUnionIterator;
+import org.apache.cassandra.index.sasi.utils.AbstractIterator;
+import org.apache.cassandra.index.sasi.utils.RangeIterator;
+import org.apache.cassandra.db.marshal.AbstractType;
+import org.apache.cassandra.io.FSReadError;
+import org.apache.cassandra.io.util.ChannelProxy;
+import org.apache.cassandra.io.util.FileUtils;
+import org.apache.cassandra.utils.ByteBufferUtil;
+import org.apache.cassandra.utils.FBUtilities;
+
+import com.google.common.base.Function;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Iterators;
+import com.google.common.collect.PeekingIterator;
+
+import static org.apache.cassandra.index.sasi.disk.OnDiskBlock.SearchResult;
+
+public class OnDiskIndex implements Iterable, Closeable
+{
+ public enum IteratorOrder
+ {
+ DESC(1), ASC(-1);
+
+ public final int step;
+
+ IteratorOrder(int step)
+ {
+ this.step = step;
+ }
+
+ public int startAt(OnDiskBlock block, Expression e)
+ {
+ switch (this)
+ {
+ case DESC:
+ return e.lower == null
+ ? 0
+ : startAt(block.search(e.validator, e.lower.value), e.lower.inclusive);
+
+ case ASC:
+ return e.upper == null
+ ? block.termCount() - 1
+ : startAt(block.search(e.validator, e.upper.value), e.upper.inclusive);
+
+ default:
+ throw new IllegalArgumentException("Unknown order: " + this);
+ }
+ }
+
+ public int startAt(SearchResult found, boolean inclusive)
+ {
+ switch (this)
+ {
+ case DESC:
+ if (found.cmp < 0)
+ return found.index + 1;
+
+ return inclusive || found.cmp != 0 ? found.index : found.index + 1;
+
+ case ASC:
+ if (found.cmp < 0) // search term was bigger then whole data set
+ return found.index;
+ return inclusive && (found.cmp == 0 || found.cmp < 0) ? found.index : found.index - 1;
+
+ default:
+ throw new IllegalArgumentException("Unknown order: " + this);
+ }
+ }
+ }
+
+ public final Descriptor descriptor;
+ protected final OnDiskIndexBuilder.Mode mode;
+ protected final OnDiskIndexBuilder.TermSize termSize;
+
+ protected final AbstractType comparator;
+ protected final MappedBuffer indexFile;
+ protected final long indexSize;
+
+ protected final Function keyFetcher;
+
+ protected final String indexPath;
+
+ protected final PointerLevel[] levels;
+ protected final DataLevel dataLevel;
+
+ protected final ByteBuffer minTerm, maxTerm, minKey, maxKey;
+
+ public OnDiskIndex(File index, AbstractType cmp, Function keyReader)
+ {
+ keyFetcher = keyReader;
+
+ comparator = cmp;
+ indexPath = index.getAbsolutePath();
+
+ RandomAccessFile backingFile = null;
+ try
+ {
+ backingFile = new RandomAccessFile(index, "r");
+
+ descriptor = new Descriptor(backingFile.readUTF());
+
+ termSize = OnDiskIndexBuilder.TermSize.of(backingFile.readShort());
+
+ minTerm = ByteBufferUtil.readWithShortLength(backingFile);
+ maxTerm = ByteBufferUtil.readWithShortLength(backingFile);
+
+ minKey = ByteBufferUtil.readWithShortLength(backingFile);
+ maxKey = ByteBufferUtil.readWithShortLength(backingFile);
+
+ mode = OnDiskIndexBuilder.Mode.mode(backingFile.readUTF());
+
+ indexSize = backingFile.length();
+ indexFile = new MappedBuffer(new ChannelProxy(indexPath, backingFile.getChannel()));
+
+ // start of the levels
+ indexFile.position(indexFile.getLong(indexSize - 8));
+
+ int numLevels = indexFile.getInt();
+ levels = new PointerLevel[numLevels];
+ for (int i = 0; i < levels.length; i++)
+ {
+ int blockCount = indexFile.getInt();
+ levels[i] = new PointerLevel(indexFile.position(), blockCount);
+ indexFile.position(indexFile.position() + blockCount * 8);
+ }
+
+ int blockCount = indexFile.getInt();
+ dataLevel = new DataLevel(indexFile.position(), blockCount);
+ }
+ catch (IOException e)
+ {
+ throw new FSReadError(e, index);
+ }
+ finally
+ {
+ FileUtils.closeQuietly(backingFile);
+ }
+ }
+
+ public ByteBuffer minTerm()
+ {
+ return minTerm;
+ }
+
+ public ByteBuffer maxTerm()
+ {
+ return maxTerm;
+ }
+
+ public ByteBuffer minKey()
+ {
+ return minKey;
+ }
+
+ public ByteBuffer maxKey()
+ {
+ return maxKey;
+ }
+
+ public DataTerm min()
+ {
+ return dataLevel.getBlock(0).getTerm(0);
+ }
+
+ public DataTerm max()
+ {
+ DataBlock block = dataLevel.getBlock(dataLevel.blockCount - 1);
+ return block.getTerm(block.termCount() - 1);
+ }
+
+ /**
+ * Search for rows which match all of the terms inside the given expression in the index file.
+ *
+ * @param exp The expression to use for the query.
+ *
+ * @return Iterator which contains rows for all of the terms from the given range.
+ */
+ public RangeIterator search(Expression exp)
+ {
+ // convert single NOT_EQ to range with exclusion
+ final Expression expression = (exp.getOp() != Op.NOT_EQ)
+ ? exp
+ : new Expression(exp).setOp(Op.RANGE)
+ .setLower(new Expression.Bound(minTerm, true))
+ .setUpper(new Expression.Bound(maxTerm, true))
+ .addExclusion(exp.lower.value);
+
+ List exclusions = new ArrayList<>(expression.exclusions.size());
+
+ Iterables.addAll(exclusions, expression.exclusions.stream().filter(exclusion -> {
+ // accept only exclusions which are in the bounds of lower/upper
+ return !(expression.lower != null && comparator.compare(exclusion, expression.lower.value) < 0)
+ && !(expression.upper != null && comparator.compare(exclusion, expression.upper.value) > 0);
+ }).collect(Collectors.toList()));
+
+ Collections.sort(exclusions, comparator);
+
+ if (exclusions.size() == 0)
+ return searchRange(expression);
+
+ List ranges = new ArrayList<>(exclusions.size());
+
+ // calculate range splits based on the sorted exclusions
+ Iterator exclusionsIterator = exclusions.iterator();
+
+ Expression.Bound min = expression.lower, max = null;
+ while (exclusionsIterator.hasNext())
+ {
+ max = new Expression.Bound(exclusionsIterator.next(), false);
+ ranges.add(new Expression(expression).setOp(Op.RANGE).setLower(min).setUpper(max));
+ min = max;
+ }
+
+ assert max != null;
+ ranges.add(new Expression(expression).setOp(Op.RANGE).setLower(max).setUpper(expression.upper));
+
+ RangeUnionIterator.Builder builder = RangeUnionIterator.builder();
+ for (Expression e : ranges)
+ {
+ RangeIterator range = searchRange(e);
+ if (range != null)
+ builder.add(range);
+ }
+
+ return builder.build();
+ }
+
+ private RangeIterator searchRange(Expression range)
+ {
+ Expression.Bound lower = range.lower;
+ Expression.Bound upper = range.upper;
+
+ int lowerBlock = lower == null ? 0 : getDataBlock(lower.value);
+ int upperBlock = upper == null
+ ? dataLevel.blockCount - 1
+ // optimization so we don't have to fetch upperBlock when query has lower == upper
+ : (lower != null && comparator.compare(lower.value, upper.value) == 0) ? lowerBlock : getDataBlock(upper.value);
+
+ return (mode != OnDiskIndexBuilder.Mode.SPARSE || lowerBlock == upperBlock || upperBlock - lowerBlock <= 1)
+ ? searchPoint(lowerBlock, range)
+ : searchRange(lowerBlock, lower, upperBlock, upper);
+ }
+
+ private RangeIterator searchRange(int lowerBlock, Expression.Bound lower, int upperBlock, Expression.Bound upper)
+ {
+ // if lower is at the beginning of the block that means we can just do a single iterator per block
+ SearchResult lowerPosition = (lower == null) ? null : searchIndex(lower.value, lowerBlock);
+ SearchResult upperPosition = (upper == null) ? null : searchIndex(upper.value, upperBlock);
+
+ RangeUnionIterator.Builder builder = RangeUnionIterator.builder();
+
+ // optimistically assume that first and last blocks are full block reads, saves at least 3 'else' conditions
+ int firstFullBlockIdx = lowerBlock, lastFullBlockIdx = upperBlock;
+
+ // 'lower' doesn't cover the whole block so we need to do a partial iteration
+ // Two reasons why that can happen:
+ // - 'lower' is not the first element of the block
+ // - 'lower' is first element but it's not inclusive in the query
+ if (lowerPosition != null && (lowerPosition.index > 0 || !lower.inclusive))
+ {
+ DataBlock block = dataLevel.getBlock(lowerBlock);
+ int start = (lower.inclusive || lowerPosition.cmp != 0) ? lowerPosition.index : lowerPosition.index + 1;
+
+ builder.add(block.getRange(start, block.termCount()));
+ firstFullBlockIdx = lowerBlock + 1;
+ }
+
+ if (upperPosition != null)
+ {
+ DataBlock block = dataLevel.getBlock(upperBlock);
+ int lastIndex = block.termCount() - 1;
+
+ // The save as with 'lower' but here we need to check if the upper is the last element of the block,
+ // which means that we only have to get individual results if:
+ // - if it *is not* the last element, or
+ // - it *is* but shouldn't be included (dictated by upperInclusive)
+ if (upperPosition.index != lastIndex || !upper.inclusive)
+ {
+ int end = (upperPosition.cmp < 0 || (upperPosition.cmp == 0 && upper.inclusive))
+ ? upperPosition.index + 1 : upperPosition.index;
+
+ builder.add(block.getRange(0, end));
+ lastFullBlockIdx = upperBlock - 1;
+ }
+ }
+
+ int totalSuperBlocks = (lastFullBlockIdx - firstFullBlockIdx) / OnDiskIndexBuilder.SUPER_BLOCK_SIZE;
+
+ // if there are no super-blocks, we can simply read all of the block iterators in sequence
+ if (totalSuperBlocks == 0)
+ {
+ for (int i = firstFullBlockIdx; i <= lastFullBlockIdx; i++)
+ builder.add(dataLevel.getBlock(i).getBlockIndex().iterator(keyFetcher));
+
+ return builder.build();
+ }
+
+ // first get all of the blocks which are aligned before the first super-block in the sequence,
+ // e.g. if the block range was (1, 9) and super-block-size = 4, we need to read 1, 2, 3, 4 - 7 is covered by
+ // super-block, 8, 9 is a remainder.
+
+ int superBlockAlignedStart = firstFullBlockIdx == 0 ? 0 : (int) FBUtilities.align(firstFullBlockIdx, OnDiskIndexBuilder.SUPER_BLOCK_SIZE);
+ for (int blockIdx = firstFullBlockIdx; blockIdx < Math.min(superBlockAlignedStart, lastFullBlockIdx); blockIdx++)
+ builder.add(getBlockIterator(blockIdx));
+
+ // now read all of the super-blocks matched by the request, from the previous comment
+ // it's a block with index 1 (which covers everything from 4 to 7)
+
+ int superBlockIdx = superBlockAlignedStart / OnDiskIndexBuilder.SUPER_BLOCK_SIZE;
+ for (int offset = 0; offset < totalSuperBlocks - 1; offset++)
+ builder.add(dataLevel.getSuperBlock(superBlockIdx++).iterator());
+
+ // now it's time for a remainder read, again from the previous example it's 8, 9 because
+ // we have over-shot previous block but didn't request enough to cover next super-block.
+
+ int lastCoveredBlock = superBlockIdx * OnDiskIndexBuilder.SUPER_BLOCK_SIZE;
+ for (int offset = 0; offset <= (lastFullBlockIdx - lastCoveredBlock); offset++)
+ builder.add(getBlockIterator(lastCoveredBlock + offset));
+
+ return builder.build();
+ }
+
+ private RangeIterator searchPoint(int lowerBlock, Expression expression)
+ {
+ Iterator terms = new TermIterator(lowerBlock, expression, IteratorOrder.DESC);
+ RangeUnionIterator.Builder builder = RangeUnionIterator.builder();
+
+ while (terms.hasNext())
+ {
+ try
+ {
+ builder.add(terms.next().getTokens());
+ }
+ finally
+ {
+ expression.checkpoint();
+ }
+ }
+
+ return builder.build();
+ }
+
+ private RangeIterator getBlockIterator(int blockIdx)
+ {
+ DataBlock block = dataLevel.getBlock(blockIdx);
+ return (block.hasCombinedIndex)
+ ? block.getBlockIndex().iterator(keyFetcher)
+ : block.getRange(0, block.termCount());
+ }
+
+ public Iterator iteratorAt(ByteBuffer query, IteratorOrder order, boolean inclusive)
+ {
+ Expression e = new Expression("", comparator);
+ Expression.Bound bound = new Expression.Bound(query, inclusive);
+
+ switch (order)
+ {
+ case DESC:
+ e.setLower(bound);
+ break;
+
+ case ASC:
+ e.setUpper(bound);
+ break;
+
+ default:
+ throw new IllegalArgumentException("Unknown order: " + order);
+ }
+
+ return new TermIterator(levels.length == 0 ? 0 : getBlockIdx(findPointer(query), query), e, order);
+ }
+
+ private int getDataBlock(ByteBuffer query)
+ {
+ return levels.length == 0 ? 0 : getBlockIdx(findPointer(query), query);
+ }
+
+ public Iterator iterator()
+ {
+ return new TermIterator(0, new Expression("", comparator), IteratorOrder.DESC);
+ }
+
+ public void close() throws IOException
+ {
+ FileUtils.closeQuietly(indexFile);
+ }
+
+ private PointerTerm findPointer(ByteBuffer query)
+ {
+ PointerTerm ptr = null;
+ for (PointerLevel level : levels)
+ {
+ if ((ptr = level.getPointer(ptr, query)) == null)
+ return null;
+ }
+
+ return ptr;
+ }
+
+ private SearchResult searchIndex(ByteBuffer query, int blockIdx)
+ {
+ return dataLevel.getBlock(blockIdx).search(comparator, query);
+ }
+
+ private int getBlockIdx(PointerTerm ptr, ByteBuffer query)
+ {
+ int blockIdx = 0;
+ if (ptr != null)
+ {
+ int cmp = ptr.compareTo(comparator, query);
+ blockIdx = (cmp == 0 || cmp > 0) ? ptr.getBlock() : ptr.getBlock() + 1;
+ }
+
+ return blockIdx;
+ }
+
+ protected class PointerLevel extends Level
+ {
+ public PointerLevel(long offset, int count)
+ {
+ super(offset, count);
+ }
+
+ public PointerTerm getPointer(PointerTerm parent, ByteBuffer query)
+ {
+ return getBlock(getBlockIdx(parent, query)).search(comparator, query).result;
+ }
+
+ protected PointerBlock cast(MappedBuffer block)
+ {
+ return new PointerBlock(block);
+ }
+ }
+
+ protected class DataLevel extends Level
+ {
+ protected final int superBlockCnt;
+ protected final long superBlocksOffset;
+
+ public DataLevel(long offset, int count)
+ {
+ super(offset, count);
+ long baseOffset = blockOffsets + blockCount * 8;
+ superBlockCnt = indexFile.getInt(baseOffset);
+ superBlocksOffset = baseOffset + 4;
+ }
+
+ protected DataBlock cast(MappedBuffer block)
+ {
+ return new DataBlock(block);
+ }
+
+ public OnDiskSuperBlock getSuperBlock(int idx)
+ {
+ assert idx < superBlockCnt : String.format("requested index %d is greater than super block count %d", idx, superBlockCnt);
+ long blockOffset = indexFile.getLong(superBlocksOffset + idx * 8);
+ return new OnDiskSuperBlock(indexFile.duplicate().position(blockOffset));
+ }
+ }
+
+ protected class OnDiskSuperBlock
+ {
+ private final TokenTree tokenTree;
+
+ public OnDiskSuperBlock(MappedBuffer buffer)
+ {
+ tokenTree = new TokenTree(descriptor, buffer);
+ }
+
+ public RangeIterator iterator()
+ {
+ return tokenTree.iterator(keyFetcher);
+ }
+ }
+
+ protected abstract class Level
+ {
+ protected final long blockOffsets;
+ protected final int blockCount;
+
+ public Level(long offsets, int count)
+ {
+ this.blockOffsets = offsets;
+ this.blockCount = count;
+ }
+
+ public T getBlock(int idx) throws FSReadError
+ {
+ assert idx >= 0 && idx < blockCount;
+
+ // calculate block offset and move there
+ // (long is intentional, we'll just need mmap implementation which supports long positions)
+ long blockOffset = indexFile.getLong(blockOffsets + idx * 8);
+ return cast(indexFile.duplicate().position(blockOffset));
+ }
+
+ protected abstract T cast(MappedBuffer block);
+ }
+
+ protected class DataBlock extends OnDiskBlock
+ {
+ public DataBlock(MappedBuffer data)
+ {
+ super(descriptor, data, BlockType.DATA);
+ }
+
+ protected DataTerm cast(MappedBuffer data)
+ {
+ return new DataTerm(data, termSize, getBlockIndex());
+ }
+
+ public RangeIterator getRange(int start, int end)
+ {
+ RangeUnionIterator.Builder builder = RangeUnionIterator.builder();
+ NavigableMap sparse = new TreeMap<>();
+
+ for (int i = start; i < end; i++)
+ {
+ DataTerm term = getTerm(i);
+
+ if (term.isSparse())
+ {
+ NavigableMap tokens = term.getSparseTokens();
+ for (Map.Entry t : tokens.entrySet())
+ {
+ Token token = sparse.get(t.getKey());
+ if (token == null)
+ sparse.put(t.getKey(), t.getValue());
+ else
+ token.merge(t.getValue());
+ }
+ }
+ else
+ {
+ builder.add(term.getTokens());
+ }
+ }
+
+ PrefetchedTokensIterator prefetched = sparse.isEmpty() ? null : new PrefetchedTokensIterator(sparse);
+
+ if (builder.rangeCount() == 0)
+ return prefetched;
+
+ builder.add(prefetched);
+ return builder.build();
+ }
+ }
+
+ protected class PointerBlock extends OnDiskBlock
+ {
+ public PointerBlock(MappedBuffer block)
+ {
+ super(descriptor, block, BlockType.POINTER);
+ }
+
+ protected PointerTerm cast(MappedBuffer data)
+ {
+ return new PointerTerm(data, termSize);
+ }
+ }
+
+ public class DataTerm extends Term implements Comparable
+ {
+ private final TokenTree perBlockIndex;
+
+ protected DataTerm(MappedBuffer content, OnDiskIndexBuilder.TermSize size, TokenTree perBlockIndex)
+ {
+ super(content, size);
+ this.perBlockIndex = perBlockIndex;
+ }
+
+ public RangeIterator getTokens()
+ {
+ final long blockEnd = FBUtilities.align(content.position(), OnDiskIndexBuilder.BLOCK_SIZE);
+
+ if (isSparse())
+ return new PrefetchedTokensIterator(getSparseTokens());
+
+ long offset = blockEnd + 4 + content.getInt(getDataOffset() + 1);
+ return new TokenTree(descriptor, indexFile.duplicate().position(offset)).iterator(keyFetcher);
+ }
+
+ public boolean isSparse()
+ {
+ return content.get(getDataOffset()) > 0;
+ }
+
+ public NavigableMap getSparseTokens()
+ {
+ long ptrOffset = getDataOffset();
+
+ byte size = content.get(ptrOffset);
+
+ assert size > 0;
+
+ NavigableMap individualTokens = new TreeMap<>();
+ for (int i = 0; i < size; i++)
+ {
+ Token token = perBlockIndex.get(content.getLong(ptrOffset + 1 + (8 * i)), keyFetcher);
+
+ assert token != null;
+ individualTokens.put(token.get(), token);
+ }
+
+ return individualTokens;
+ }
+
+ public int compareTo(DataTerm other)
+ {
+ return other == null ? 1 : compareTo(comparator, other.getTerm());
+ }
+ }
+
+ protected static class PointerTerm extends Term
+ {
+ public PointerTerm(MappedBuffer content, OnDiskIndexBuilder.TermSize size)
+ {
+ super(content, size);
+ }
+
+ public int getBlock()
+ {
+ return content.getInt(getDataOffset());
+ }
+ }
+
+ private static class PrefetchedTokensIterator extends RangeIterator
+ {
+ private final NavigableMap tokens;
+ private PeekingIterator currentIterator;
+
+ public PrefetchedTokensIterator(NavigableMap tokens)
+ {
+ super(tokens.firstKey(), tokens.lastKey(), tokens.size());
+ this.tokens = tokens;
+ this.currentIterator = Iterators.peekingIterator(tokens.values().iterator());
+ }
+
+ protected Token computeNext()
+ {
+ return currentIterator != null && currentIterator.hasNext()
+ ? currentIterator.next()
+ : endOfData();
+ }
+
+ protected void performSkipTo(Long nextToken)
+ {
+ currentIterator = Iterators.peekingIterator(tokens.tailMap(nextToken, true).values().iterator());
+ }
+
+ public void close() throws IOException
+ {
+ endOfData();
+ }
+ }
+
+ public AbstractType getComparator()
+ {
+ return comparator;
+ }
+
+ public String getIndexPath()
+ {
+ return indexPath;
+ }
+
+ private class TermIterator extends AbstractIterator
+ {
+ private final Expression e;
+ private final IteratorOrder order;
+
+ protected OnDiskBlock currentBlock;
+ protected int blockIndex, offset;
+
+ private boolean checkLower = true, checkUpper = true;
+
+ public TermIterator(int startBlock, Expression expression, IteratorOrder order)
+ {
+ this.e = expression;
+ this.order = order;
+ this.blockIndex = startBlock;
+
+ nextBlock();
+ }
+
+ protected DataTerm computeNext()
+ {
+ for (;;)
+ {
+ if (currentBlock == null)
+ return endOfData();
+
+ if (offset >= 0 && offset < currentBlock.termCount())
+ {
+ DataTerm currentTerm = currentBlock.getTerm(nextOffset());
+
+ if (checkLower && !e.isLowerSatisfiedBy(currentTerm))
+ continue;
+
+ // flip the flag right on the first bounds match
+ // to avoid expensive comparisons
+ checkLower = false;
+
+ if (checkUpper && !e.isUpperSatisfiedBy(currentTerm))
+ return endOfData();
+
+ return currentTerm;
+ }
+
+ nextBlock();
+ }
+ }
+
+ protected void nextBlock()
+ {
+ currentBlock = null;
+
+ if (blockIndex < 0 || blockIndex >= dataLevel.blockCount)
+ return;
+
+ currentBlock = dataLevel.getBlock(nextBlockIndex());
+ offset = checkLower ? order.startAt(currentBlock, e) : currentBlock.minOffset(order);
+
+ // let's check the last term of the new block right away
+ // if expression's upper bound is satisfied by it such means that we can avoid
+ // doing any expensive upper bound checks for that block.
+ checkUpper = e.hasUpper() && !e.isUpperSatisfiedBy(currentBlock.getTerm(currentBlock.maxOffset(order)));
+ }
+
+ protected int nextBlockIndex()
+ {
+ int current = blockIndex;
+ blockIndex += order.step;
+ return current;
+ }
+
+ protected int nextOffset()
+ {
+ int current = offset;
+ offset += order.step;
+ return current;
+ }
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/disk/OnDiskIndexBuilder.java b/src/java/org/apache/cassandra/index/sasi/disk/OnDiskIndexBuilder.java
new file mode 100644
index 0000000000..7b8f5c9e19
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/disk/OnDiskIndexBuilder.java
@@ -0,0 +1,627 @@
+/*
+ * 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.index.sasi.disk;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.*;
+
+import org.apache.cassandra.db.DecoratedKey;
+import org.apache.cassandra.index.sasi.sa.IntegralSA;
+import org.apache.cassandra.index.sasi.sa.SA;
+import org.apache.cassandra.index.sasi.sa.TermIterator;
+import org.apache.cassandra.index.sasi.sa.SuffixSA;
+import org.apache.cassandra.db.marshal.*;
+import org.apache.cassandra.io.FSWriteError;
+import org.apache.cassandra.io.compress.BufferType;
+import org.apache.cassandra.io.util.*;
+import org.apache.cassandra.utils.ByteBufferUtil;
+import org.apache.cassandra.utils.FBUtilities;
+import org.apache.cassandra.utils.Pair;
+
+import com.carrotsearch.hppc.LongArrayList;
+import com.carrotsearch.hppc.LongSet;
+import com.carrotsearch.hppc.ShortArrayList;
+import com.google.common.annotations.VisibleForTesting;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class OnDiskIndexBuilder
+{
+ private static final Logger logger = LoggerFactory.getLogger(OnDiskIndexBuilder.class);
+
+ public enum Mode
+ {
+ PREFIX, CONTAINS, SPARSE;
+
+ public static Mode mode(String mode)
+ {
+ return Mode.valueOf(mode.toUpperCase());
+ }
+ }
+
+ public enum TermSize
+ {
+ INT(4), LONG(8), UUID(16), VARIABLE(-1);
+
+ public final int size;
+
+ TermSize(int size)
+ {
+ this.size = size;
+ }
+
+ public boolean isConstant()
+ {
+ return this != VARIABLE;
+ }
+
+ public static TermSize of(int size)
+ {
+ switch (size)
+ {
+ case -1:
+ return VARIABLE;
+
+ case 4:
+ return INT;
+
+ case 8:
+ return LONG;
+
+ case 16:
+ return UUID;
+
+ default:
+ throw new IllegalStateException("unknown state: " + size);
+ }
+ }
+
+ public static TermSize sizeOf(AbstractType comparator)
+ {
+ if (comparator instanceof Int32Type || comparator instanceof FloatType)
+ return INT;
+
+ if (comparator instanceof LongType || comparator instanceof DoubleType
+ || comparator instanceof TimestampType || comparator instanceof DateType)
+ return LONG;
+
+ if (comparator instanceof TimeUUIDType || comparator instanceof UUIDType)
+ return UUID;
+
+ return VARIABLE;
+ }
+ }
+
+ public static final int BLOCK_SIZE = 4096;
+ public static final int MAX_TERM_SIZE = 1024;
+ public static final int SUPER_BLOCK_SIZE = 64;
+
+ private final List> levels = new ArrayList<>();
+ private MutableLevel dataLevel;
+
+ private final TermSize termSize;
+
+ private final AbstractType keyComparator, termComparator;
+
+ private final Map terms;
+ private final Mode mode;
+
+ private ByteBuffer minKey, maxKey;
+ private long estimatedBytes;
+
+ public OnDiskIndexBuilder(AbstractType keyComparator, AbstractType comparator, Mode mode)
+ {
+ this.keyComparator = keyComparator;
+ this.termComparator = comparator;
+ this.terms = new HashMap<>();
+ this.termSize = TermSize.sizeOf(comparator);
+ this.mode = mode;
+ }
+
+ public OnDiskIndexBuilder add(ByteBuffer term, DecoratedKey key, long keyPosition)
+ {
+ if (term.remaining() >= MAX_TERM_SIZE)
+ {
+ logger.error("Rejecting value (value size {}, maximum size {} bytes).", term.remaining(), Short.MAX_VALUE);
+ return this;
+ }
+
+ TokenTreeBuilder tokens = terms.get(term);
+ if (tokens == null)
+ {
+ terms.put(term, (tokens = new TokenTreeBuilder()));
+
+ // on-heap size estimates from jol
+ // 64 bytes for TTB + 48 bytes for TreeMap in TTB + size bytes for the term (map key)
+ estimatedBytes += 64 + 48 + term.remaining();
+ }
+
+ tokens.add((Long) key.getToken().getTokenValue(), keyPosition);
+
+ // calculate key range (based on actual key values) for current index
+ minKey = (minKey == null || keyComparator.compare(minKey, key.getKey()) > 0) ? key.getKey() : minKey;
+ maxKey = (maxKey == null || keyComparator.compare(maxKey, key.getKey()) < 0) ? key.getKey() : maxKey;
+
+ // 60 ((boolean(1)*4) + (long(8)*4) + 24) bytes for the LongOpenHashSet created when the keyPosition was added
+ // + 40 bytes for the TreeMap.Entry + 8 bytes for the token (key).
+ // in the case of hash collision for the token we may overestimate but this is extremely rare
+ estimatedBytes += 60 + 40 + 8;
+
+ return this;
+ }
+
+ public long estimatedMemoryUse()
+ {
+ return estimatedBytes;
+ }
+
+ private void addTerm(InMemoryDataTerm term, SequentialWriter out) throws IOException
+ {
+ InMemoryPointerTerm ptr = dataLevel.add(term);
+ if (ptr == null)
+ return;
+
+ int levelIdx = 0;
+ for (;;)
+ {
+ MutableLevel level = getIndexLevel(levelIdx++, out);
+ if ((ptr = level.add(ptr)) == null)
+ break;
+ }
+ }
+
+ public boolean isEmpty()
+ {
+ return terms.isEmpty();
+ }
+
+ public void finish(Pair range, File file, TermIterator terms)
+ {
+ finish(Descriptor.CURRENT, range, file, terms);
+ }
+
+ /**
+ * Finishes up index building process by creating/populating index file.
+ *
+ * @param indexFile The file to write index contents to.
+ *
+ * @return true if index was written successfully, false otherwise (e.g. if index was empty).
+ *
+ * @throws FSWriteError on I/O error.
+ */
+ public boolean finish(File indexFile) throws FSWriteError
+ {
+ return finish(Descriptor.CURRENT, indexFile);
+ }
+
+ @VisibleForTesting
+ protected boolean finish(Descriptor descriptor, File file) throws FSWriteError
+ {
+ // no terms means there is nothing to build
+ if (terms.isEmpty())
+ return false;
+
+ // split terms into suffixes only if it's text, otherwise (even if CONTAINS is set) use terms in original form
+ SA sa = ((termComparator instanceof UTF8Type || termComparator instanceof AsciiType) && mode == Mode.CONTAINS)
+ ? new SuffixSA(termComparator, mode) : new IntegralSA(termComparator, mode);
+
+ for (Map.Entry term : terms.entrySet())
+ sa.add(term.getKey(), term.getValue());
+
+ finish(descriptor, Pair.create(minKey, maxKey), file, sa.finish());
+ return true;
+ }
+
+ protected void finish(Descriptor descriptor, Pair range, File file, TermIterator terms)
+ {
+ SequentialWriter out = null;
+
+ try
+ {
+ out = new SequentialWriter(file, BLOCK_SIZE, BufferType.ON_HEAP);
+
+ out.writeUTF(descriptor.version.toString());
+
+ out.writeShort(termSize.size);
+
+ // min, max term (useful to find initial scan range from search expressions)
+ ByteBufferUtil.writeWithShortLength(terms.minTerm(), out);
+ ByteBufferUtil.writeWithShortLength(terms.maxTerm(), out);
+
+ // min, max keys covered by index (useful when searching across multiple indexes)
+ ByteBufferUtil.writeWithShortLength(range.left, out);
+ ByteBufferUtil.writeWithShortLength(range.right, out);
+
+ out.writeUTF(mode.toString());
+
+ out.skipBytes((int) (BLOCK_SIZE - out.position()));
+
+ dataLevel = mode == Mode.SPARSE ? new DataBuilderLevel(out, new MutableDataBlock(mode))
+ : new MutableLevel<>(out, new MutableDataBlock(mode));
+ while (terms.hasNext())
+ {
+ Pair term = terms.next();
+ addTerm(new InMemoryDataTerm(term.left, term.right), out);
+ }
+
+ dataLevel.finalFlush();
+ for (MutableLevel l : levels)
+ l.flush(); // flush all of the buffers
+
+ // and finally write levels index
+ final long levelIndexPosition = out.position();
+
+ out.writeInt(levels.size());
+ for (int i = levels.size() - 1; i >= 0; i--)
+ levels.get(i).flushMetadata();
+
+ dataLevel.flushMetadata();
+
+ out.writeLong(levelIndexPosition);
+
+ // sync contents of the output and disk,
+ // since it's not done implicitly on close
+ out.sync();
+ }
+ catch (IOException e)
+ {
+ throw new FSWriteError(e, file);
+ }
+ finally
+ {
+ FileUtils.closeQuietly(out);
+ }
+ }
+
+ private MutableLevel getIndexLevel(int idx, SequentialWriter out)
+ {
+ if (levels.size() == 0)
+ levels.add(new MutableLevel<>(out, new MutableBlock<>()));
+
+ if (levels.size() - 1 < idx)
+ {
+ int toAdd = idx - (levels.size() - 1);
+ for (int i = 0; i < toAdd; i++)
+ levels.add(new MutableLevel<>(out, new MutableBlock<>()));
+ }
+
+ return levels.get(idx);
+ }
+
+ protected static void alignToBlock(SequentialWriter out) throws IOException
+ {
+ long endOfBlock = out.position();
+ if ((endOfBlock & (BLOCK_SIZE - 1)) != 0) // align on the block boundary if needed
+ out.skipBytes((int) (FBUtilities.align(endOfBlock, BLOCK_SIZE) - endOfBlock));
+ }
+
+ private class InMemoryTerm
+ {
+ protected final ByteBuffer term;
+
+ public InMemoryTerm(ByteBuffer term)
+ {
+ this.term = term;
+ }
+
+ public int serializedSize()
+ {
+ return (termSize.isConstant() ? 0 : 2) + term.remaining();
+ }
+
+ public void serialize(DataOutputPlus out) throws IOException
+ {
+ if (termSize.isConstant())
+ out.write(term);
+ else
+ ByteBufferUtil.writeWithShortLength(term, out);
+ }
+ }
+
+ private class InMemoryPointerTerm extends InMemoryTerm
+ {
+ protected final int blockCnt;
+
+ public InMemoryPointerTerm(ByteBuffer term, int blockCnt)
+ {
+ super(term);
+ this.blockCnt = blockCnt;
+ }
+
+ public int serializedSize()
+ {
+ return super.serializedSize() + 4;
+ }
+
+ public void serialize(DataOutputPlus out) throws IOException
+ {
+ super.serialize(out);
+ out.writeInt(blockCnt);
+ }
+ }
+
+ private class InMemoryDataTerm extends InMemoryTerm
+ {
+ private final TokenTreeBuilder keys;
+
+ public InMemoryDataTerm(ByteBuffer term, TokenTreeBuilder keys)
+ {
+ super(term);
+ this.keys = keys;
+ }
+ }
+
+ private class MutableLevel
+ {
+ private final LongArrayList blockOffsets = new LongArrayList();
+
+ protected final SequentialWriter out;
+
+ private final MutableBlock inProcessBlock;
+ private InMemoryPointerTerm lastTerm;
+
+ public MutableLevel(SequentialWriter out, MutableBlock block)
+ {
+ this.out = out;
+ this.inProcessBlock = block;
+ }
+
+ /**
+ * @return If we flushed a block, return the last term of that block; else, null.
+ */
+ public InMemoryPointerTerm add(T term) throws IOException
+ {
+ InMemoryPointerTerm toPromote = null;
+
+ if (!inProcessBlock.hasSpaceFor(term))
+ {
+ flush();
+ toPromote = lastTerm;
+ }
+
+ inProcessBlock.add(term);
+
+ lastTerm = new InMemoryPointerTerm(term.term, blockOffsets.size());
+ return toPromote;
+ }
+
+ public void flush() throws IOException
+ {
+ blockOffsets.add(out.position());
+ inProcessBlock.flushAndClear(out);
+ }
+
+ public void finalFlush() throws IOException
+ {
+ flush();
+ }
+
+ public void flushMetadata() throws IOException
+ {
+ flushMetadata(blockOffsets);
+ }
+
+ protected void flushMetadata(LongArrayList longArrayList) throws IOException
+ {
+ out.writeInt(longArrayList.size());
+ for (int i = 0; i < longArrayList.size(); i++)
+ out.writeLong(longArrayList.get(i));
+ }
+ }
+
+ /** builds standard data blocks and super blocks, as well */
+ private class DataBuilderLevel extends MutableLevel
+ {
+ private final LongArrayList superBlockOffsets = new LongArrayList();
+
+ /** count of regular data blocks written since current super block was init'd */
+ private int dataBlocksCnt;
+ private TokenTreeBuilder superBlockTree;
+
+ public DataBuilderLevel(SequentialWriter out, MutableBlock block)
+ {
+ super(out, block);
+ superBlockTree = new TokenTreeBuilder();
+ }
+
+ public InMemoryPointerTerm add(InMemoryDataTerm term) throws IOException
+ {
+ InMemoryPointerTerm ptr = super.add(term);
+ if (ptr != null)
+ {
+ dataBlocksCnt++;
+ flushSuperBlock(false);
+ }
+ superBlockTree.add(term.keys.getTokens());
+ return ptr;
+ }
+
+ public void flushSuperBlock(boolean force) throws IOException
+ {
+ if (dataBlocksCnt == SUPER_BLOCK_SIZE || (force && !superBlockTree.getTokens().isEmpty()))
+ {
+ superBlockOffsets.add(out.position());
+ superBlockTree.finish().write(out);
+ alignToBlock(out);
+
+ dataBlocksCnt = 0;
+ superBlockTree = new TokenTreeBuilder();
+ }
+ }
+
+ public void finalFlush() throws IOException
+ {
+ super.flush();
+ flushSuperBlock(true);
+ }
+
+ public void flushMetadata() throws IOException
+ {
+ super.flushMetadata();
+ flushMetadata(superBlockOffsets);
+ }
+ }
+
+ private static class MutableBlock
+ {
+ protected final DataOutputBufferFixed buffer;
+ protected final ShortArrayList offsets;
+
+ public MutableBlock()
+ {
+ buffer = new DataOutputBufferFixed(BLOCK_SIZE);
+ offsets = new ShortArrayList();
+ }
+
+ public final void add(T term) throws IOException
+ {
+ offsets.add((short) buffer.position());
+ addInternal(term);
+ }
+
+ protected void addInternal(T term) throws IOException
+ {
+ term.serialize(buffer);
+ }
+
+ public boolean hasSpaceFor(T element)
+ {
+ return sizeAfter(element) < BLOCK_SIZE;
+ }
+
+ protected int sizeAfter(T element)
+ {
+ return getWatermark() + 4 + element.serializedSize();
+ }
+
+ protected int getWatermark()
+ {
+ return 4 + offsets.size() * 2 + (int) buffer.position();
+ }
+
+ public void flushAndClear(SequentialWriter out) throws IOException
+ {
+ out.writeInt(offsets.size());
+ for (int i = 0; i < offsets.size(); i++)
+ out.writeShort(offsets.get(i));
+
+ out.write(buffer.buffer());
+
+ alignToBlock(out);
+
+ offsets.clear();
+ buffer.clear();
+ }
+ }
+
+ private static class MutableDataBlock extends MutableBlock
+ {
+ private final Mode mode;
+
+ private int offset = 0;
+ private int sparseValueTerms = 0;
+
+ private final List containers = new ArrayList<>();
+ private TokenTreeBuilder combinedIndex;
+
+ public MutableDataBlock(Mode mode)
+ {
+ this.mode = mode;
+ this.combinedIndex = new TokenTreeBuilder();
+ }
+
+ protected void addInternal(InMemoryDataTerm term) throws IOException
+ {
+ TokenTreeBuilder keys = term.keys;
+
+ if (mode == Mode.SPARSE && keys.getTokenCount() <= 5)
+ {
+ writeTerm(term, keys);
+ sparseValueTerms++;
+ }
+ else
+ {
+ writeTerm(term, offset);
+
+ offset += keys.serializedSize();
+ containers.add(keys);
+ }
+
+ if (mode == Mode.SPARSE)
+ combinedIndex.add(keys.getTokens());
+ }
+
+ protected int sizeAfter(InMemoryDataTerm element)
+ {
+ return super.sizeAfter(element) + ptrLength(element);
+ }
+
+ public void flushAndClear(SequentialWriter out) throws IOException
+ {
+ super.flushAndClear(out);
+
+ out.writeInt((sparseValueTerms == 0) ? -1 : offset);
+
+ if (containers.size() > 0)
+ {
+ for (TokenTreeBuilder tokens : containers)
+ tokens.write(out);
+ }
+
+ if (sparseValueTerms > 0)
+ {
+ combinedIndex.finish().write(out);
+ }
+
+ alignToBlock(out);
+
+ containers.clear();
+ combinedIndex = new TokenTreeBuilder();
+
+ offset = 0;
+ sparseValueTerms = 0;
+ }
+
+ private int ptrLength(InMemoryDataTerm term)
+ {
+ return (term.keys.getTokenCount() > 5)
+ ? 5 // 1 byte type + 4 byte offset to the tree
+ : 1 + (8 * (int) term.keys.getTokenCount()); // 1 byte size + n 8 byte tokens
+ }
+
+ private void writeTerm(InMemoryTerm term, TokenTreeBuilder keys) throws IOException
+ {
+ term.serialize(buffer);
+ buffer.writeByte((byte) keys.getTokenCount());
+
+ Iterator> tokens = keys.iterator();
+ while (tokens.hasNext())
+ buffer.writeLong(tokens.next().left);
+ }
+
+ private void writeTerm(InMemoryTerm term, int offset) throws IOException
+ {
+ term.serialize(buffer);
+ buffer.writeByte(0x0);
+ buffer.writeInt(offset);
+ }
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/disk/PerSSTableIndexWriter.java b/src/java/org/apache/cassandra/index/sasi/disk/PerSSTableIndexWriter.java
new file mode 100644
index 0000000000..6e63c71526
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/disk/PerSSTableIndexWriter.java
@@ -0,0 +1,361 @@
+/*
+ * 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.index.sasi.disk;
+
+import java.io.File;
+import java.nio.ByteBuffer;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.*;
+
+import org.apache.cassandra.concurrent.JMXEnabledThreadPoolExecutor;
+import org.apache.cassandra.concurrent.NamedThreadFactory;
+import org.apache.cassandra.config.ColumnDefinition;
+import org.apache.cassandra.db.DecoratedKey;
+import org.apache.cassandra.db.compaction.OperationType;
+import org.apache.cassandra.db.rows.Row;
+import org.apache.cassandra.db.rows.Unfiltered;
+import org.apache.cassandra.index.sasi.analyzer.AbstractAnalyzer;
+import org.apache.cassandra.index.sasi.conf.ColumnIndex;
+import org.apache.cassandra.index.sasi.utils.CombinedTermIterator;
+import org.apache.cassandra.index.sasi.utils.TypeUtil;
+import org.apache.cassandra.db.marshal.AbstractType;
+import org.apache.cassandra.io.sstable.Descriptor;
+import org.apache.cassandra.io.sstable.format.SSTableFlushObserver;
+import org.apache.cassandra.io.util.FileUtils;
+import org.apache.cassandra.utils.FBUtilities;
+import org.apache.cassandra.utils.Pair;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.Uninterruptibles;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class PerSSTableIndexWriter implements SSTableFlushObserver
+{
+ private static final Logger logger = LoggerFactory.getLogger(PerSSTableIndexWriter.class);
+
+ private static final ThreadPoolExecutor INDEX_FLUSHER_MEMTABLE;
+ private static final ThreadPoolExecutor INDEX_FLUSHER_GENERAL;
+
+ static
+ {
+ INDEX_FLUSHER_GENERAL = new JMXEnabledThreadPoolExecutor(1, 8, 60, TimeUnit.SECONDS,
+ new LinkedBlockingQueue<>(),
+ new NamedThreadFactory("SASI-General"),
+ "internal");
+ INDEX_FLUSHER_GENERAL.allowCoreThreadTimeOut(true);
+
+ INDEX_FLUSHER_MEMTABLE = new JMXEnabledThreadPoolExecutor(1, 8, 60, TimeUnit.SECONDS,
+ new LinkedBlockingQueue<>(),
+ new NamedThreadFactory("SASI-Memtable"),
+ "internal");
+ INDEX_FLUSHER_MEMTABLE.allowCoreThreadTimeOut(true);
+ }
+
+ private final int nowInSec = FBUtilities.nowInSeconds();
+
+ private final Descriptor descriptor;
+ private final OperationType source;
+
+ private final AbstractType keyValidator;
+ private final Map supportedIndexes;
+
+ @VisibleForTesting
+ protected final Map indexes;
+
+ private DecoratedKey currentKey;
+ private long currentKeyPosition;
+ private boolean isComplete;
+
+ public PerSSTableIndexWriter(AbstractType keyValidator,
+ Descriptor descriptor,
+ OperationType source,
+ Map supportedIndexes)
+ {
+ this.keyValidator = keyValidator;
+ this.descriptor = descriptor;
+ this.source = source;
+ this.supportedIndexes = supportedIndexes;
+ this.indexes = new HashMap<>();
+ }
+
+ public void begin()
+ {}
+
+ public void startPartition(DecoratedKey key, long curPosition)
+ {
+ currentKey = key;
+ currentKeyPosition = curPosition;
+ }
+
+ public void nextUnfilteredCluster(Unfiltered unfiltered)
+ {
+ if (!unfiltered.isRow())
+ return;
+
+ Row row = (Row) unfiltered;
+
+ supportedIndexes.keySet().forEach((column) -> {
+ ByteBuffer value = ColumnIndex.getValueOf(column, row, nowInSec);
+ if (value == null)
+ return;
+
+ ColumnIndex columnIndex = supportedIndexes.get(column);
+ if (columnIndex == null)
+ return;
+
+ Index index = indexes.get(column);
+ if (index == null)
+ indexes.put(column, (index = new Index(columnIndex)));
+
+ index.add(value.duplicate(), currentKey, currentKeyPosition);
+ });
+ }
+
+ public void complete()
+ {
+ if (isComplete)
+ return;
+
+ currentKey = null;
+
+ try
+ {
+ CountDownLatch latch = new CountDownLatch(indexes.size());
+ for (Index index : indexes.values())
+ index.complete(latch);
+
+ Uninterruptibles.awaitUninterruptibly(latch);
+ }
+ finally
+ {
+ indexes.clear();
+ isComplete = true;
+ }
+ }
+
+ public Index getIndex(ColumnDefinition columnDef)
+ {
+ return indexes.get(columnDef);
+ }
+
+ public Descriptor getDescriptor()
+ {
+ return descriptor;
+ }
+
+ @VisibleForTesting
+ protected class Index
+ {
+ private final ColumnIndex columnIndex;
+ private final String outputFile;
+ private final AbstractAnalyzer analyzer;
+ private final long maxMemorySize;
+
+ @VisibleForTesting
+ protected final Set> segments;
+ private int segmentNumber = 0;
+
+ private OnDiskIndexBuilder currentBuilder;
+
+ public Index(ColumnIndex columnIndex)
+ {
+ this.columnIndex = columnIndex;
+ this.outputFile = descriptor.filenameFor(columnIndex.getComponent());
+ this.analyzer = columnIndex.getAnalyzer();
+ this.segments = new HashSet<>();
+ this.maxMemorySize = maxMemorySize(columnIndex);
+ this.currentBuilder = newIndexBuilder();
+ }
+
+ public void add(ByteBuffer term, DecoratedKey key, long keyPosition)
+ {
+ if (term.remaining() == 0)
+ return;
+
+ boolean isAdded = false;
+
+ analyzer.reset(term);
+ while (analyzer.hasNext())
+ {
+ ByteBuffer token = analyzer.next();
+ int size = token.remaining();
+
+ if (token.remaining() >= OnDiskIndexBuilder.MAX_TERM_SIZE)
+ {
+ logger.info("Rejecting value (size {}, maximum {} bytes) for column {} (analyzed {}) at {} SSTable.",
+ term.remaining(),
+ OnDiskIndexBuilder.MAX_TERM_SIZE,
+ columnIndex.getColumnName(),
+ columnIndex.getMode().isAnalyzed,
+ descriptor);
+ continue;
+ }
+
+ if (!TypeUtil.isValid(token, columnIndex.getValidator()))
+ {
+ if ((token = TypeUtil.tryUpcast(token, columnIndex.getValidator())) == null)
+ {
+ logger.info("({}) Failed to add {} to index for key: {}, value size was {} bytes, validator is {}.",
+ outputFile,
+ columnIndex.getColumnName(),
+ keyValidator.getString(key.getKey()),
+ size,
+ columnIndex.getValidator());
+ continue;
+ }
+ }
+
+ currentBuilder.add(token, key, keyPosition);
+ isAdded = true;
+ }
+
+ if (!isAdded || currentBuilder.estimatedMemoryUse() < maxMemorySize)
+ return; // non of the generated tokens were added to the index or memory size wasn't reached
+
+ segments.add(getExecutor().submit(scheduleSegmentFlush(false)));
+ }
+
+ @VisibleForTesting
+ protected Callable scheduleSegmentFlush(final boolean isFinal)
+ {
+ final OnDiskIndexBuilder builder = currentBuilder;
+ currentBuilder = newIndexBuilder();
+
+ final String segmentFile = filename(isFinal);
+
+ return () -> {
+ long start1 = System.nanoTime();
+
+ try
+ {
+ File index = new File(segmentFile);
+ return builder.finish(index) ? new OnDiskIndex(index, columnIndex.getValidator(), null) : null;
+ }
+ finally
+ {
+ if (!isFinal)
+ logger.info("Flushed index segment {}, took {} ms.", segmentFile, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start1));
+ }
+ };
+ }
+
+ public void complete(final CountDownLatch latch)
+ {
+ logger.info("Scheduling index flush to {}", outputFile);
+
+ getExecutor().submit((Runnable) () -> {
+ long start1 = System.nanoTime();
+
+ OnDiskIndex[] parts = new OnDiskIndex[segments.size() + 1];
+
+ try
+ {
+ // no parts present, build entire index from memory
+ if (segments.isEmpty())
+ {
+ scheduleSegmentFlush(true).call();
+ return;
+ }
+
+ // parts are present but there is something still in memory, let's flush that inline
+ if (!currentBuilder.isEmpty())
+ {
+ OnDiskIndex last = scheduleSegmentFlush(false).call();
+ segments.add(Futures.immediateFuture(last));
+ }
+
+ int index = 0;
+ ByteBuffer combinedMin = null, combinedMax = null;
+
+ for (Future f : segments)
+ {
+ OnDiskIndex part = Futures.getUnchecked(f);
+ if (part == null)
+ continue;
+
+ parts[index++] = part;
+ combinedMin = (combinedMin == null || keyValidator.compare(combinedMin, part.minKey()) > 0) ? part.minKey() : combinedMin;
+ combinedMax = (combinedMax == null || keyValidator.compare(combinedMax, part.maxKey()) < 0) ? part.maxKey() : combinedMax;
+ }
+
+ OnDiskIndexBuilder builder = newIndexBuilder();
+ builder.finish(Pair.create(combinedMin, combinedMax),
+ new File(outputFile),
+ new CombinedTermIterator(parts));
+ }
+ catch (Exception e)
+ {
+ logger.error("Failed to flush index {}.", outputFile, e);
+ FileUtils.delete(outputFile);
+ }
+ finally
+ {
+ logger.info("Index flush to {} took {} ms.", outputFile, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start1));
+
+ for (OnDiskIndex part : parts)
+ {
+ if (part == null)
+ continue;
+
+ FileUtils.closeQuietly(part);
+ FileUtils.delete(part.getIndexPath());
+ }
+
+ latch.countDown();
+ }
+ });
+ }
+
+ private ExecutorService getExecutor()
+ {
+ return source == OperationType.FLUSH ? INDEX_FLUSHER_MEMTABLE : INDEX_FLUSHER_GENERAL;
+ }
+
+ private OnDiskIndexBuilder newIndexBuilder()
+ {
+ return new OnDiskIndexBuilder(keyValidator, columnIndex.getValidator(), columnIndex.getMode().mode);
+ }
+
+ public String filename(boolean isFinal)
+ {
+ return outputFile + (isFinal ? "" : "_" + segmentNumber++);
+ }
+ }
+
+ protected long maxMemorySize(ColumnIndex columnIndex)
+ {
+ // 1G for memtable and configuration for compaction
+ return source == OperationType.FLUSH ? 1073741824L : columnIndex.getMode().maxCompactionFlushMemoryInMb;
+ }
+
+ public int hashCode()
+ {
+ return descriptor.hashCode();
+ }
+
+ public boolean equals(Object o)
+ {
+ return !(o == null || !(o instanceof PerSSTableIndexWriter)) && descriptor.equals(((PerSSTableIndexWriter) o).descriptor);
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/disk/Token.java b/src/java/org/apache/cassandra/index/sasi/disk/Token.java
new file mode 100644
index 0000000000..02130a370b
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/disk/Token.java
@@ -0,0 +1,42 @@
+/*
+ * 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.index.sasi.disk;
+
+import com.google.common.primitives.Longs;
+import org.apache.cassandra.db.DecoratedKey;
+import org.apache.cassandra.index.sasi.utils.CombinedValue;
+
+public abstract class Token implements CombinedValue, Iterable
+{
+ protected final long token;
+
+ public Token(long token)
+ {
+ this.token = token;
+ }
+
+ public Long get()
+ {
+ return token;
+ }
+
+ public int compareTo(CombinedValue o)
+ {
+ return Longs.compare(token, ((Token) o).token);
+ }
+}
diff --git a/src/java/org/apache/cassandra/index/sasi/disk/TokenTree.java b/src/java/org/apache/cassandra/index/sasi/disk/TokenTree.java
new file mode 100644
index 0000000000..5d85d00c6b
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/disk/TokenTree.java
@@ -0,0 +1,519 @@
+/*
+ * 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.index.sasi.disk;
+
+import java.io.IOException;
+import java.util.*;
+
+import org.apache.cassandra.db.DecoratedKey;
+import org.apache.cassandra.index.sasi.utils.AbstractIterator;
+import org.apache.cassandra.index.sasi.utils.CombinedValue;
+import org.apache.cassandra.index.sasi.utils.MappedBuffer;
+import org.apache.cassandra.index.sasi.utils.RangeIterator;
+import org.apache.cassandra.utils.MergeIterator;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.collect.Iterators;
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+
+import static org.apache.cassandra.index.sasi.disk.TokenTreeBuilder.EntryType;
+
+// Note: all of the seek-able offsets contained in TokenTree should be sizeof(long)
+// even if currently only lower int portion of them if used, because that makes
+// it possible to switch to mmap implementation which supports long positions
+// without any on-disk format changes and/or re-indexing if one day we'll have a need to.
+public class TokenTree
+{
+ private static final int LONG_BYTES = Long.SIZE / 8;
+ private static final int SHORT_BYTES = Short.SIZE / 8;
+
+ private final Descriptor descriptor;
+ private final MappedBuffer file;
+ private final long startPos;
+ private final long treeMinToken;
+ private final long treeMaxToken;
+ private final long tokenCount;
+
+ @VisibleForTesting
+ protected TokenTree(MappedBuffer tokenTree)
+ {
+ this(Descriptor.CURRENT, tokenTree);
+ }
+
+ public TokenTree(Descriptor d, MappedBuffer tokenTree)
+ {
+ descriptor = d;
+ file = tokenTree;
+ startPos = file.position();
+
+ file.position(startPos + TokenTreeBuilder.SHARED_HEADER_BYTES);
+
+ if (!validateMagic())
+ throw new IllegalArgumentException("invalid token tree");
+
+ tokenCount = file.getLong();
+ treeMinToken = file.getLong();
+ treeMaxToken = file.getLong();
+ }
+
+ public long getCount()
+ {
+ return tokenCount;
+ }
+
+ public RangeIterator iterator(Function keyFetcher)
+ {
+ return new TokenTreeIterator(file.duplicate(), keyFetcher);
+ }
+
+ public OnDiskToken get(final long searchToken, Function keyFetcher)
+ {
+ seekToLeaf(searchToken, file);
+ long leafStart = file.position();
+ short leafSize = file.getShort(leafStart + 1); // skip the info byte
+
+ file.position(leafStart + TokenTreeBuilder.BLOCK_HEADER_BYTES); // skip to tokens
+ short tokenIndex = searchLeaf(searchToken, leafSize);
+
+ file.position(leafStart + TokenTreeBuilder.BLOCK_HEADER_BYTES);
+
+ OnDiskToken token = OnDiskToken.getTokenAt(file, tokenIndex, leafSize, keyFetcher);
+ return token.get().equals(searchToken) ? token : null;
+ }
+
+ private boolean validateMagic()
+ {
+ switch (descriptor.version.toString())
+ {
+ case Descriptor.VERSION_AA:
+ return true;
+ case Descriptor.VERSION_AB:
+ return TokenTreeBuilder.AB_MAGIC == file.getShort();
+ default:
+ return false;
+ }
+ }
+
+ // finds leaf that *could* contain token
+ private void seekToLeaf(long token, MappedBuffer file)
+ {
+ // this loop always seeks forward except for the first iteration
+ // where it may seek back to the root
+ long blockStart = startPos;
+ while (true)
+ {
+ file.position(blockStart);
+
+ byte info = file.get();
+ boolean isLeaf = (info & 1) == 1;
+
+ if (isLeaf)
+ {
+ file.position(blockStart);
+ break;
+ }
+
+ short tokenCount = file.getShort();
+
+ long minToken = file.getLong();
+ long maxToken = file.getLong();
+
+ long seekBase = blockStart + TokenTreeBuilder.BLOCK_HEADER_BYTES;
+ if (minToken > token)
+ {
+ // seek to beginning of child offsets to locate first child
+ file.position(seekBase + tokenCount * LONG_BYTES);
+ blockStart = (startPos + (int) file.getLong());
+ }
+ else if (maxToken < token)
+ {
+ // seek to end of child offsets to locate last child
+ file.position(seekBase + (2 * tokenCount) * LONG_BYTES);
+ blockStart = (startPos + (int) file.getLong());
+ }
+ else
+ {
+ // skip to end of block header/start of interior block tokens
+ file.position(seekBase);
+
+ short offsetIndex = searchBlock(token, tokenCount, file);
+
+ // file pointer is now at beginning of offsets
+ if (offsetIndex == tokenCount)
+ file.position(file.position() + (offsetIndex * LONG_BYTES));
+ else
+ file.position(file.position() + ((tokenCount - offsetIndex - 1) + offsetIndex) * LONG_BYTES);
+
+ blockStart = (startPos + (int) file.getLong());
+ }
+ }
+ }
+
+ private short searchBlock(long searchToken, short tokenCount, MappedBuffer file)
+ {
+ short offsetIndex = 0;
+ for (int i = 0; i < tokenCount; i++)
+ {
+ long readToken = file.getLong();
+ if (searchToken < readToken)
+ break;
+
+ offsetIndex++;
+ }
+
+ return offsetIndex;
+ }
+
+ private short searchLeaf(long searchToken, short tokenCount)
+ {
+ long base = file.position();
+
+ int start = 0;
+ int end = tokenCount;
+ int middle = 0;
+
+ while (start <= end)
+ {
+ middle = start + ((end - start) >> 1);
+
+ // each entry is 16 bytes wide, token is in bytes 4-11
+ long token = file.getLong(base + (middle * (2 * LONG_BYTES) + 4));
+
+ if (token == searchToken)
+ break;
+
+ if (token < searchToken)
+ start = middle + 1;
+ else
+ end = middle - 1;
+ }
+
+ return (short) middle;
+ }
+
+ public class TokenTreeIterator extends RangeIterator
+ {
+ private final Function keyFetcher;
+ private final MappedBuffer file;
+
+ private long currentLeafStart;
+ private int currentTokenIndex;
+
+ private long leafMinToken;
+ private long leafMaxToken;
+ private short leafSize;
+
+ protected boolean firstIteration = true;
+ private boolean lastLeaf;
+
+ TokenTreeIterator(MappedBuffer file, Function keyFetcher)
+ {
+ super(treeMinToken, treeMaxToken, tokenCount);
+
+ this.file = file;
+ this.keyFetcher = keyFetcher;
+ }
+
+ protected Token computeNext()
+ {
+ maybeFirstIteration();
+
+ if (currentTokenIndex >= leafSize && lastLeaf)
+ return endOfData();
+
+ if (currentTokenIndex < leafSize) // tokens remaining in this leaf
+ {
+ return getTokenAt(currentTokenIndex++);
+ }
+ else // no more tokens remaining in this leaf
+ {
+ assert !lastLeaf;
+
+ seekToNextLeaf();
+ setupBlock();
+ return computeNext();
+ }
+ }
+
+ protected void performSkipTo(Long nextToken)
+ {
+ maybeFirstIteration();
+
+ if (nextToken <= leafMaxToken) // next is in this leaf block
+ {
+ searchLeaf(nextToken);
+ }
+ else // next is in a leaf block that needs to be found
+ {
+ seekToLeaf(nextToken, file);
+ setupBlock();
+ findNearest(nextToken);
+ }
+ }
+
+ private void setupBlock()
+ {
+ currentLeafStart = file.position();
+ currentTokenIndex = 0;
+
+ lastLeaf = (file.get() & (1 << TokenTreeBuilder.LAST_LEAF_SHIFT)) > 0;
+ leafSize = file.getShort();
+
+ leafMinToken = file.getLong();
+ leafMaxToken = file.getLong();
+
+ // seek to end of leaf header/start of data
+ file.position(currentLeafStart + TokenTreeBuilder.BLOCK_HEADER_BYTES);
+ }
+
+ private void findNearest(Long next)
+ {
+ if (next > leafMaxToken && !lastLeaf)
+ {
+ seekToNextLeaf();
+ setupBlock();
+ findNearest(next);
+ }
+ else if (next > leafMinToken)
+ searchLeaf(next);
+ }
+
+ private void searchLeaf(long next)
+ {
+ for (int i = currentTokenIndex; i < leafSize; i++)
+ {
+ if (compareTokenAt(currentTokenIndex, next) >= 0)
+ break;
+
+ currentTokenIndex++;
+ }
+ }
+
+ private int compareTokenAt(int idx, long toToken)
+ {
+ return Long.compare(file.getLong(getTokenPosition(idx)), toToken);
+ }
+
+ private Token getTokenAt(int idx)
+ {
+ return OnDiskToken.getTokenAt(file, idx, leafSize, keyFetcher);
+ }
+
+ private long getTokenPosition(int idx)
+ {
+ // skip 4 byte entry header to get position pointing directly at the entry's token
+ return OnDiskToken.getEntryPosition(idx, file) + (2 * SHORT_BYTES);
+ }
+
+ private void seekToNextLeaf()
+ {
+ file.position(currentLeafStart + TokenTreeBuilder.BLOCK_BYTES);
+ }
+
+ public void close() throws IOException
+ {
+ // nothing to do here
+ }
+
+ private void maybeFirstIteration()
+ {
+ // seek to the first token only when requested for the first time,
+ // highly predictable branch and saves us a lot by not traversing the tree
+ // on creation time because it's not at all required.
+ if (!firstIteration)
+ return;
+
+ seekToLeaf(treeMinToken, file);
+ setupBlock();
+ firstIteration = false;
+ }
+ }
+
+ public static class OnDiskToken extends Token
+ {
+ private final Set info = new HashSet<>(2);
+ private final Set loadedKeys = new TreeSet<>(DecoratedKey.comparator);
+
+ public OnDiskToken(MappedBuffer buffer, long position, short leafSize, Function keyFetcher)
+ {
+ super(buffer.getLong(position + (2 * SHORT_BYTES)));
+ info.add(new TokenInfo(buffer, position, leafSize, keyFetcher));
+ }
+
+ public void merge(CombinedValue other)
+ {
+ if (!(other instanceof Token))
+ return;
+
+ Token o = (Token) other;
+ if (token != o.token)
+ throw new IllegalArgumentException(String.format("%s != %s", token, o.token));
+
+ if (o instanceof OnDiskToken)
+ {
+ info.addAll(((OnDiskToken) other).info);
+ }
+ else
+ {
+ Iterators.addAll(loadedKeys, o.iterator());
+ }
+ }
+
+ public Iterator iterator()
+ {
+ List> keys = new ArrayList<>(info.size());
+
+ for (TokenInfo i : info)
+ keys.add(i.iterator());
+
+ if (!loadedKeys.isEmpty())
+ keys.add(loadedKeys.iterator());
+
+ return MergeIterator.get(keys, DecoratedKey.comparator, new MergeIterator.Reducer()
+ {
+ DecoratedKey reduced = null;
+
+ public boolean trivialReduceIsTrivial()
+ {
+ return true;
+ }
+
+ public void reduce(int idx, DecoratedKey current)
+ {
+ reduced = current;
+ }
+
+ protected DecoratedKey getReduced()
+ {
+ return reduced;
+ }
+ });
+ }
+
+ public Set getOffsets()
+ {
+ Set offsets = new HashSet<>();
+ for (TokenInfo i : info)
+ {
+ for (long offset : i.fetchOffsets())
+ offsets.add(offset);
+ }
+
+ return offsets;
+ }
+
+ public static OnDiskToken getTokenAt(MappedBuffer buffer, int idx, short leafSize, Function keyFetcher)
+ {
+ return new OnDiskToken(buffer, getEntryPosition(idx, buffer), leafSize, keyFetcher);
+ }
+
+ private static long getEntryPosition(int idx, MappedBuffer file)
+ {
+ // info (4 bytes) + token (8 bytes) + offset (4 bytes) = 16 bytes
+ return file.position() + (idx * (2 * LONG_BYTES));
+ }
+ }
+
+ private static class TokenInfo
+ {
+ private final MappedBuffer buffer;
+ private final Function keyFetcher;
+
+ private final long position;
+ private final short leafSize;
+
+ public TokenInfo(MappedBuffer buffer, long position, short leafSize, Function keyFetcher)
+ {
+ this.keyFetcher = keyFetcher;
+ this.buffer = buffer;
+ this.position = position;
+ this.leafSize = leafSize;
+ }
+
+ public Iterator iterator()
+ {
+ return new KeyIterator(keyFetcher, fetchOffsets());
+ }
+
+ public int hashCode()
+ {
+ return new HashCodeBuilder().append(keyFetcher).append(position).append(leafSize).build();
+ }
+
+ public boolean equals(Object other)
+ {
+ if (!(other instanceof TokenInfo))
+ return false;
+
+ TokenInfo o = (TokenInfo) other;
+ return keyFetcher == o.keyFetcher && position == o.position;
+ }
+
+ private long[] fetchOffsets()
+ {
+ short info = buffer.getShort(position);
+ short offsetShort = buffer.getShort(position + SHORT_BYTES);
+ int offsetInt = buffer.getInt(position + (2 * SHORT_BYTES) + LONG_BYTES);
+
+ EntryType type = EntryType.of(info & TokenTreeBuilder.ENTRY_TYPE_MASK);
+
+ switch (type)
+ {
+ case SIMPLE:
+ return new long[] { offsetInt };
+
+ case OVERFLOW:
+ long[] offsets = new long[offsetShort]; // offsetShort contains count of tokens
+ long offsetPos = (buffer.position() + (2 * (leafSize * LONG_BYTES)) + (offsetInt * LONG_BYTES));
+
+ for (int i = 0; i < offsetShort; i++)
+ offsets[i] = buffer.getLong(offsetPos + (i * LONG_BYTES));
+
+ return offsets;
+
+ case FACTORED:
+ return new long[] { (((long) offsetInt) << Short.SIZE) + offsetShort };
+
+ case PACKED:
+ return new long[] { offsetShort, offsetInt };
+
+ default:
+ throw new IllegalStateException("Unknown entry type: " + type);
+ }
+ }
+ }
+
+ private static class KeyIterator extends AbstractIterator
+ {
+ private final Function keyFetcher;
+ private final long[] offsets;
+ private int index = 0;
+
+ public KeyIterator(Function keyFetcher, long[] offsets)
+ {
+ this.keyFetcher = keyFetcher;
+ this.offsets = offsets;
+ }
+
+ public DecoratedKey computeNext()
+ {
+ return index < offsets.length ? keyFetcher.apply(offsets[index++]) : endOfData();
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/java/org/apache/cassandra/index/sasi/disk/TokenTreeBuilder.java b/src/java/org/apache/cassandra/index/sasi/disk/TokenTreeBuilder.java
new file mode 100644
index 0000000000..e10b057e21
--- /dev/null
+++ b/src/java/org/apache/cassandra/index/sasi/disk/TokenTreeBuilder.java
@@ -0,0 +1,839 @@
+/*
+ * 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.index.sasi.disk;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.*;
+
+import org.apache.cassandra.io.util.DataOutputPlus;
+import org.apache.cassandra.utils.FBUtilities;
+import org.apache.cassandra.utils.Pair;
+
+import com.carrotsearch.hppc.LongArrayList;
+import com.carrotsearch.hppc.LongSet;
+import com.carrotsearch.hppc.cursors.LongCursor;
+import com.carrotsearch.hppc.LongOpenHashSet;
+import com.google.common.collect.AbstractIterator;
+
+public class TokenTreeBuilder
+{
+ // note: ordinal positions are used here, do not change order
+ enum EntryType
+ {
+ SIMPLE, FACTORED, PACKED, OVERFLOW;
+
+ public static EntryType of(int ordinal)
+ {
+ if (ordinal == SIMPLE.ordinal())
+ return SIMPLE;
+
+ if (ordinal == FACTORED.ordinal())
+ return FACTORED;
+
+ if (ordinal == PACKED.ordinal())
+ return PACKED;
+
+ if (ordinal == OVERFLOW.ordinal())
+ return OVERFLOW;
+
+ throw new IllegalArgumentException("Unknown ordinal: " + ordinal);
+ }
+ }
+
+ public static final int BLOCK_BYTES = 4096;
+ public static final int BLOCK_HEADER_BYTES = 64;
+ public static final int OVERFLOW_TRAILER_BYTES = 64;
+ public static final int OVERFLOW_TRAILER_CAPACITY = OVERFLOW_TRAILER_BYTES / 8;
+ public static final int TOKENS_PER_BLOCK = (BLOCK_BYTES - BLOCK_HEADER_BYTES - OVERFLOW_TRAILER_BYTES) / 16;
+ public static final long MAX_OFFSET = (1L << 47) - 1; // 48 bits for (signed) offset
+ public static final byte LAST_LEAF_SHIFT = 1;
+ public static final byte SHARED_HEADER_BYTES = 19;
+ public static final byte ENTRY_TYPE_MASK = 0x03;
+ public static final short AB_MAGIC = 0x5A51;
+
+ private final SortedMap tokens = new TreeMap<>();
+ private int numBlocks;
+
+ private Node root;
+ private InteriorNode rightmostParent;
+ private Leaf leftmostLeaf;
+ private Leaf rightmostLeaf;
+ private long tokenCount = 0;
+ private long treeMinToken;
+ private long treeMaxToken;
+
+ public TokenTreeBuilder()
+ {}
+
+ public TokenTreeBuilder(SortedMap data)
+ {
+ add(data);
+ }
+
+ public void add(Long token, long keyPosition)
+ {
+ LongSet found = tokens.get(token);
+ if (found == null)
+ tokens.put(token, (found = new LongOpenHashSet(2)));
+
+ found.add(keyPosition);
+ }
+
+ public void add(SortedMap data)
+ {
+ for (Map.Entry newEntry : data.entrySet())
+ {
+ LongSet found = tokens.get(newEntry.getKey());
+ if (found == null)
+ tokens.put(newEntry.getKey(), (found = new LongOpenHashSet(4)));
+
+ for (LongCursor offset : newEntry.getValue())
+ found.add(offset.value);
+ }
+ }
+
+ public TokenTreeBuilder finish()
+ {
+ maybeBulkLoad();
+ return this;
+ }
+
+ public SortedMap getTokens()
+ {
+ return tokens;
+ }
+
+ public long getTokenCount()
+ {
+ return tokenCount;
+ }
+
+ public int serializedSize()
+ {
+ if (numBlocks == 1)
+ return (BLOCK_HEADER_BYTES + ((int) tokenCount * 16));
+ else
+ return numBlocks * BLOCK_BYTES;
+ }
+
+ public void write(DataOutputPlus out) throws IOException
+ {
+ ByteBuffer blockBuffer = ByteBuffer.allocate(BLOCK_BYTES);
+ Iterator levelIterator = root.levelIterator();
+ long childBlockIndex = 1;
+
+ while (levelIterator != null)
+ {
+
+ Node firstChild = null;
+ while (levelIterator.hasNext())
+ {
+ Node block = levelIterator.next();
+
+ if (firstChild == null && !block.isLeaf())
+ firstChild = ((InteriorNode) block).children.get(0);
+
+ block.serialize(childBlockIndex, blockBuffer);
+ flushBuffer(blockBuffer, out, numBlocks != 1);
+
+ childBlockIndex += block.childCount();
+ }
+
+ levelIterator = (firstChild == null) ? null : firstChild.levelIterator();
+ }
+ }
+
+ public Iterator> iterator()
+ {
+ return new TokenIterator(leftmostLeaf.levelIterator());
+ }
+
+ private void maybeBulkLoad()
+ {
+ if (root == null)
+ bulkLoad();
+ }
+
+ private void flushBuffer(ByteBuffer buffer, DataOutputPlus o, boolean align) throws IOException
+ {
+ // seek to end of last block before flushing
+ if (align)
+ alignBuffer(buffer, BLOCK_BYTES);
+
+ buffer.flip();
+ o.write(buffer);
+ buffer.clear();
+ }
+
+ private static void alignBuffer(ByteBuffer buffer, int blockSize)
+ {
+ long curPos = buffer.position();
+ if ((curPos & (blockSize - 1)) != 0) // align on the block boundary if needed
+ buffer.position((int) FBUtilities.align(curPos, blockSize));
+ }
+
+ private void bulkLoad()
+ {
+ tokenCount = tokens.size();
+ treeMinToken = tokens.firstKey();
+ treeMaxToken = tokens.lastKey();
+ numBlocks = 1;
+
+ // special case the tree that only has a single block in it (so we don't create a useless root)
+ if (tokenCount <= TOKENS_PER_BLOCK)
+ {
+ leftmostLeaf = new Leaf(tokens);
+ rightmostLeaf = leftmostLeaf;
+ root = leftmostLeaf;
+ }
+ else
+ {
+ root = new InteriorNode();
+ rightmostParent = (InteriorNode) root;
+
+ int i = 0;
+ Leaf lastLeaf = null;
+ Long firstToken = tokens.firstKey();
+ Long finalToken = tokens.lastKey();
+ Long lastToken;
+ for (Long token : tokens.keySet())
+ {
+ if (i == 0 || (i % TOKENS_PER_BLOCK != 0 && i != (tokenCount - 1)))
+ {
+ i++;
+ continue;
+ }
+
+ lastToken = token;
+ Leaf leaf = (i != (tokenCount - 1) || token.equals(finalToken)) ?
+ new Leaf(tokens.subMap(firstToken, lastToken)) : new Leaf(tokens.tailMap(firstToken));
+
+ if (i == TOKENS_PER_BLOCK)
+ leftmostLeaf = leaf;
+ else
+ lastLeaf.next = leaf;
+
+ rightmostParent.add(leaf);
+ lastLeaf = leaf;
+ rightmostLeaf = leaf;
+ firstToken = lastToken;
+ i++;
+ numBlocks++;
+
+ if (token.equals(finalToken))
+ {
+ Leaf finalLeaf = new Leaf(tokens.tailMap(token));
+ lastLeaf.next = finalLeaf;
+ rightmostParent.add(finalLeaf);
+ rightmostLeaf = finalLeaf;
+ numBlocks++;
+ }
+ }
+
+ }
+ }
+
+ private abstract class Node
+ {
+ protected InteriorNode parent;
+ protected Node next;
+ protected Long nodeMinToken, nodeMaxToken;
+
+ public abstract void serialize(long childBlockIndex, ByteBuffer buf);
+ public abstract int childCount();
+ public abstract int tokenCount();
+ public abstract Long smallestToken();
+
+ public Iterator levelIterator()
+ {
+ return new LevelIterator(this);
+ }
+
+ public boolean isLeaf()
+ {
+ return (this instanceof Leaf);
+ }
+
+ protected boolean isLastLeaf()
+ {
+ return this == rightmostLeaf;
+ }
+
+ protected boolean isRoot()
+ {
+ return this == root;
+ }
+
+ protected void updateTokenRange(long token)
+ {
+ nodeMinToken = nodeMinToken == null ? token : Math.min(nodeMinToken, token);
+ nodeMaxToken = nodeMaxToken == null ? token : Math.max(nodeMaxToken, token);
+ }
+
+ protected void serializeHeader(ByteBuffer buf)
+ {
+ Header header;
+ if (isRoot())
+ header = new RootHeader();
+ else if (!isLeaf())
+ header = new InteriorNodeHeader();
+ else
+ header = new LeafHeader();
+
+ header.serialize(buf);
+ alignBuffer(buf, BLOCK_HEADER_BYTES);
+ }
+
+ private abstract class Header
+ {
+ public void serialize(ByteBuffer buf)
+ {
+ buf.put(infoByte())
+ .putShort((short) (tokenCount()))
+ .putLong(nodeMinToken)
+ .putLong(nodeMaxToken);
+ }
+
+ protected abstract byte infoByte();
+ }
+
+ private class RootHeader extends Header
+ {
+ public void serialize(ByteBuffer buf)
+ {
+ super.serialize(buf);
+ writeMagic(buf);
+ buf.putLong(tokenCount)
+ .putLong(treeMinToken)
+ .putLong(treeMaxToken);
+ }
+
+ protected byte infoByte()
+ {
+ // if leaf, set leaf indicator and last leaf indicator (bits 0 & 1)
+ // if not leaf, clear both bits
+ return (byte) ((isLeaf()) ? 3 : 0);
+ }
+
+ protected void writeMagic(ByteBuffer buf)
+ {
+ switch (Descriptor.CURRENT_VERSION)
+ {
+ case Descriptor.VERSION_AB:
+ buf.putShort(AB_MAGIC);
+ break;
+ default:
+ break;
+ }
+
+ }
+ }
+
+ private class InteriorNodeHeader extends Header
+ {
+ // bit 0 (leaf indicator) & bit 1 (last leaf indicator) cleared
+ protected byte infoByte()
+ {
+ return 0;
+ }
+ }
+
+ private class LeafHeader extends Header
+ {
+ // bit 0 set as leaf indicator
+ // bit 1 set if this is last leaf of data
+ protected byte infoByte()
+ {
+ byte infoByte = 1;
+ infoByte |= (isLastLeaf()) ? (1 << LAST_LEAF_SHIFT) : 0;
+
+ return infoByte;
+ }
+ }
+
+ }
+
+ private class Leaf extends Node
+ {
+ private final SortedMap tokens;
+ private LongArrayList overflowCollisions;
+
+ Leaf(SortedMap data)
+ {
+ nodeMinToken = data.firstKey();
+ nodeMaxToken = data.lastKey();
+ tokens = data;
+ }
+
+ public Long largestToken()
+ {
+ return nodeMaxToken;
+ }
+
+ public void serialize(long childBlockIndex, ByteBuffer buf)
+ {
+ serializeHeader(buf);
+ serializeData(buf);
+ serializeOverflowCollisions(buf);
+ }
+
+ public int childCount()
+ {
+ return 0;
+ }
+
+ public int tokenCount()
+ {
+ return tokens.size();
+ }
+
+ public Long smallestToken()
+ {
+ return nodeMinToken;
+ }
+
+ public Iterator> tokenIterator()
+ {
+ return tokens.entrySet().iterator();
+ }
+
+ private void serializeData(ByteBuffer buf)
+ {
+ for (Map.Entry entry : tokens.entrySet())
+ createEntry(entry.getKey(), entry.getValue()).serialize(buf);
+ }
+
+ private void serializeOverflowCollisions(ByteBuffer buf)
+ {
+ if (overflowCollisions != null)
+ for (LongCursor offset : overflowCollisions)
+ buf.putLong(offset.value);
+ }
+
+
+ private LeafEntry createEntry(final long tok, final LongSet offsets)
+ {
+ int offsetCount = offsets.size();
+ switch (offsetCount)
+ {
+ case 0:
+ throw new AssertionError("no offsets for token " + tok);
+ case 1:
+ long offset = offsets.toArray()[0];
+ if (offset > MAX_OFFSET)
+ throw new AssertionError("offset " + offset + " cannot be greater than " + MAX_OFFSET);
+ else if (offset <= Integer.MAX_VALUE)
+ return new SimpleLeafEntry(tok, offset);
+ else
+ return new FactoredOffsetLeafEntry(tok, offset);
+ case 2:
+ long[] rawOffsets = offsets.toArray();
+ if (rawOffsets[0] <= Integer.MAX_VALUE && rawOffsets[1] <= Integer.MAX_VALUE &&
+ (rawOffsets[0] <= Short.MAX_VALUE || rawOffsets[1] <= Short.MAX_VALUE))
+ return new PackedCollisionLeafEntry(tok, rawOffsets);
+ else
+ return createOverflowEntry(tok, offsetCount, offsets);
+ default:
+ return createOverflowEntry(tok, offsetCount, offsets);
+ }
+ }
+
+ private LeafEntry createOverflowEntry(final long tok, final int offsetCount, final LongSet offsets)
+ {
+ if (overflowCollisions == null)
+ overflowCollisions = new LongArrayList();
+
+ LeafEntry entry = new OverflowCollisionLeafEntry(tok, (short) overflowCollisions.size(), (short) offsetCount);
+ for (LongCursor o : offsets) {
+ if (overflowCollisions.size() == OVERFLOW_TRAILER_CAPACITY)
+ throw new AssertionError("cannot have more than " + OVERFLOW_TRAILER_CAPACITY + " overflow collisions per leaf");
+ else
+ overflowCollisions.add(o.value);
+ }
+ return entry;
+ }
+
+ private abstract class LeafEntry
+ {
+ protected final long token;
+
+ abstract public EntryType type();
+ abstract public int offsetData();
+ abstract public short offsetExtra();
+
+ public LeafEntry(final long tok)
+ {
+ token = tok;
+ }
+
+ public void serialize(ByteBuffer buf)
+ {
+ buf.putShort((short) type().ordinal())
+ .putShort(offsetExtra())
+ .putLong(token)
+ .putInt(offsetData());
+ }
+
+ }
+
+
+ // assumes there is a single offset and the offset is <= Integer.MAX_VALUE
+ private class SimpleLeafEntry extends LeafEntry
+ {
+ private final long offset;
+
+ public SimpleLeafEntry(final long tok, final long off)
+ {
+ super(tok);
+ offset = off;
+ }
+
+ public EntryType type()
+ {
+ return EntryType.SIMPLE;
+ }
+
+ public int offsetData()
+ {
+ return (int) offset;
+ }
+
+ public short offsetExtra()
+ {
+ return 0;
+ }
+ }
+
+ // assumes there is a single offset and Integer.MAX_VALUE < offset <= MAX_OFFSET
+ // take the middle 32 bits of offset (or the top 32 when considering offset is max 48 bits)
+ // and store where offset is normally stored. take bottom 16 bits of offset and store in entry header
+ private class FactoredOffsetLeafEntry extends LeafEntry
+ {
+ private final long offset;
+
+ public FactoredOffsetLeafEntry(final long tok, final long off)
+ {
+ super(tok);
+ offset = off;
+ }
+
+ public EntryType type()
+ {
+ return EntryType.FACTORED;
+ }
+
+ public int offsetData()
+ {
+ return (int) (offset >>> Short.SIZE);
+ }
+
+ public short offsetExtra()
+ {
+ return (short) offset;
+ }
+ }
+
+ // holds an entry with two offsets that can be packed in an int & a short
+ // the int offset is stored where offset is normally stored. short offset is
+ // stored in entry header
+ private class PackedCollisionLeafEntry extends LeafEntry
+ {
+ private short smallerOffset;
+ private int largerOffset;
+
+ public PackedCollisionLeafEntry(final long tok, final long[] offs)
+ {
+ super(tok);
+
+ smallerOffset = (short) Math.min(offs[0], offs[1]);
+ largerOffset = (int) Math.max(offs[0], offs[1]);
+ }
+
+ public EntryType type()
+ {
+ return EntryType.PACKED;
+ }
+
+ public int offsetData()
+ {
+ return largerOffset;
+ }
+
+ public short offsetExtra()
+ {
+ return smallerOffset;
+ }
+ }
+
+ // holds an entry with three or more offsets, or two offsets that cannot
+ // be packed into an int & a short. the index into the overflow list
+ // is stored where the offset is normally stored. the number of overflowed offsets
+ // for the entry is stored in the entry header
+ private class OverflowCollisionLeafEntry extends LeafEntry
+ {
+ private final short startIndex;
+ private final short count;
+
+ public OverflowCollisionLeafEntry(final long tok, final short collisionStartIndex, final short collisionCount)
+ {
+ super(tok);
+ startIndex = collisionStartIndex;
+ count = collisionCount;
+ }
+
+ public EntryType type()
+ {
+ return EntryType.OVERFLOW;
+ }
+
+ public int offsetData()
+ {
+ return startIndex;
+ }
+
+ public short offsetExtra()
+ {
+ return count;
+ }
+
+ }
+
+ }
+
+ private class InteriorNode extends Node
+ {
+ private List tokens = new ArrayList<>(TOKENS_PER_BLOCK);
+ private List children = new ArrayList<>(TOKENS_PER_BLOCK + 1);
+ private int position = 0; // TODO (jwest): can get rid of this and use array size
+
+
+ public void serialize(long childBlockIndex, ByteBuffer buf)
+ {
+ serializeHeader(buf);
+ serializeTokens(buf);
+ serializeChildOffsets(childBlockIndex, buf);
+ }
+
+ public int childCount()
+ {
+ return children.size();
+ }
+
+ public int tokenCount()
+ {
+ return tokens.size();
+ }
+
+ public Long smallestToken()
+ {
+ return tokens.get(0);
+ }
+
+ protected void add(Long token, InteriorNode leftChild, InteriorNode rightChild)
+ {
+ int pos = tokens.size();
+ if (pos == TOKENS_PER_BLOCK)
+ {
+ InteriorNode sibling = split();
+ sibling.add(token, leftChild, rightChild);
+
+ }
+ else {
+ if (leftChild != null)
+ children.add(pos, leftChild);
+
+ if (rightChild != null)
+ {
+ children.add(pos + 1, rightChild);
+ rightChild.parent = this;
+ }
+
+ updateTokenRange(token);
+ tokens.add(pos, token);
+ }
+ }
+
+ protected void add(Leaf node)
+ {
+
+ if (position == (TOKENS_PER_BLOCK + 1))
+ {
+ rightmostParent = split();
+ rightmostParent.add(node);
+ }
+ else
+ {
+
+ node.parent = this;
+ children.add(position, node);
+ position++;
+
+ // the first child is referenced only during bulk load. we don't take a value
+ // to store into the tree, one is subtracted since position has already been incremented
+ // for the next node to be added
+ if (position - 1 == 0)
+ return;
+
+
+ // tokens are inserted one behind the current position, but 2 is subtracted because
+ // position has already been incremented for the next add
+ Long smallestToken = node.smallestToken();
+ updateTokenRange(smallestToken);
+ tokens.add(position - 2, smallestToken);
+ }
+
+ }
+
+ protected InteriorNode split()
+ {
+ Pair splitResult = splitBlock();
+ Long middleValue = splitResult.left;
+ InteriorNode sibling = splitResult.right;
+ InteriorNode leftChild = null;
+
+ // create a new root if necessary
+ if (parent == null)
+ {
+ parent = new InteriorNode();
+ root = parent;
+ sibling.parent = parent;
+ leftChild = this;
+ numBlocks++;
+ }
+
+ parent.add(middleValue, leftChild, sibling);
+
+ return sibling;
+ }
+
+ protected Pair splitBlock()
+ {
+ final int splitPosition = TOKENS_PER_BLOCK - 2;
+ InteriorNode sibling = new InteriorNode();
+ sibling.parent = parent;
+ next = sibling;
+
+ Long middleValue = tokens.get(splitPosition);
+
+ for (int i = splitPosition; i < TOKENS_PER_BLOCK; i++)
+ {
+ if (i != TOKENS_PER_BLOCK && i != splitPosition)
+ {
+ long token = tokens.get(i);
+ sibling.updateTokenRange(token);
+ sibling.tokens.add(token);
+ }
+
+ Node child = children.get(i + 1);
+ child.parent = sibling;
+ sibling.children.add(child);
+ sibling.position++;
+ }
+
+ for (int i = TOKENS_PER_BLOCK; i >= splitPosition; i--)
+ {
+ if (i != TOKENS_PER_BLOCK)
+ tokens.remove(i);
+
+ if (i != splitPosition)
+ children.remove(i);
+ }
+
+ nodeMinToken = smallestToken();
+ nodeMaxToken = tokens.get(tokens.size() - 1);
+ numBlocks++;
+
+ return Pair.create(middleValue, sibling);
+ }
+
+ protected boolean isFull()
+ {
+ return (position >= TOKENS_PER_BLOCK + 1);
+ }
+
+ private void serializeTokens(ByteBuffer buf)
+ {
+ for (Long token : tokens)
+ buf.putLong(token);
+ }
+
+
+ private void serializeChildOffsets(long childBlockIndex, ByteBuffer buf)
+ {
+ for (int i = 0; i < children.size(); i++)
+ buf.putLong((childBlockIndex + i) * BLOCK_BYTES);
+ }
+ }
+
+ public static class LevelIterator extends AbstractIterator
+ {
+ private Node currentNode;
+
+ LevelIterator(Node first)
+ {
+ currentNode = first;
+ }
+
+ public Node computeNext()
+ {
+ if (currentNode == null)
+ return endOfData();
+
+ Node returnNode = currentNode;
+ currentNode = returnNode.next;
+
+ return returnNode;
+ }
+
+
+ }
+
+ public static class TokenIterator extends AbstractIterator>
+ {
+ private Iterator levelIterator;
+ private Iterator> currentIterator;
+
+ TokenIterator(Iterator