diff --git a/CONTRIBUTORS b/CONTRIBUTORS index 5cfea65d..b14f3722 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -1,5 +1,6 @@ # Please keep the list sorted. +Alexander Sergeev Andrey Korzinev Irina Kamalova Svyatoslav Demidov diff --git a/core/src/main/java/com/yandex/yoctodb/immutable/DocumentProvider.java b/core/src/main/java/com/yandex/yoctodb/immutable/DocumentProvider.java index 0bc53011..75c36de7 100644 --- a/core/src/main/java/com/yandex/yoctodb/immutable/DocumentProvider.java +++ b/core/src/main/java/com/yandex/yoctodb/immutable/DocumentProvider.java @@ -36,7 +36,7 @@ public interface DocumentProvider { /** * Get {@code document} document {@code fieldName} field value. * - * The field must be sortable. + * The field must be sortable, stored or full. * * @see com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption#SORTABLE * @see com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption#FULL @@ -50,4 +50,89 @@ Buffer getFieldValue( int document, @NotNull String fieldName); + + /** + * Get {@code document} document {@code fieldName} field value as long. + * + * The field must be sortable, stored or full. + * + * @see com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption#SORTABLE + * @see com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption#FULL + * @see com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption#STORED + * @param document document index + * @param fieldName field name + * @return document field value as long + */ + long getLongValue( + int document, + @NotNull + String fieldName); + + /** + * Get {@code document} document {@code fieldName} field value as int. + * + * The field must be sortable, stored or full. + * + * @see com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption#SORTABLE + * @see com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption#FULL + * @see com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption#STORED + * @param document document index + * @param fieldName field name + * @return document field value as int + */ + int getIntValue( + int document, + @NotNull + String fieldName); + + /** + * Get {@code document} document {@code fieldName} field value as short. + * + * The field must be sortable, stored or full. + * + * @param document document index + * @param fieldName field name + * @return document field value as short + */ + short getShortValue( + int document, + @NotNull + String fieldName + ); + + /** + * Get {@code document} document {@code fieldName} field value as char. + * + * The field must be sortable, stored or full. + * + * @see com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption#SORTABLE + * @see com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption#FULL + * @see com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption#STORED + * @param document document index + * @param fieldName field name + * @return document field value as char + */ + char getCharValue( + int document, + @NotNull + String fieldName + ); + + /** + * Get {@code document} document {@code fieldName} field value as byte. + * + * The field must be sortable, stored or full. + * + * @see com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption#SORTABLE + * @see com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption#FULL + * @see com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption#STORED + * @param document document index + * @param fieldName field name + * @return document field value as byte + */ + byte getByteValue( + int document, + @NotNull + String fieldName + ); } diff --git a/core/src/main/java/com/yandex/yoctodb/immutable/StoredIndex.java b/core/src/main/java/com/yandex/yoctodb/immutable/StoredIndex.java index 91597e7f..5a8d4ade 100644 --- a/core/src/main/java/com/yandex/yoctodb/immutable/StoredIndex.java +++ b/core/src/main/java/com/yandex/yoctodb/immutable/StoredIndex.java @@ -29,4 +29,44 @@ public interface StoredIndex extends Index { */ @NotNull Buffer getStoredValue(int document); + + /** + * Get stored value as long by document ID + * + * @param document document ID + * @return stored value as long + */ + long getLongValue(int document); + + /** + * Get stored value as int by document ID + * + * @param document document ID + * @return stored value as int + */ + int getIntValue(int document); + + /** + * Get stored value as short by document ID + * + * @param document document ID + * @return stored value as short + */ + short getShortValue(int document); + + /** + * Get stored value as char by document ID + * + * @param document document ID + * @return stored value as char + */ + char getCharValue(int document); + + /** + * Get stored value as byte by document ID + * + * @param document document ID + * @return stored value as byte + */ + byte getByteValue(int document); } diff --git a/core/src/main/java/com/yandex/yoctodb/mutable/AbstractDocumentBuilder.java b/core/src/main/java/com/yandex/yoctodb/mutable/AbstractDocumentBuilder.java index 24795626..998e05f3 100644 --- a/core/src/main/java/com/yandex/yoctodb/mutable/AbstractDocumentBuilder.java +++ b/core/src/main/java/com/yandex/yoctodb/mutable/AbstractDocumentBuilder.java @@ -85,14 +85,22 @@ public DocumentBuilder withField( @Override public DocumentBuilder withField( @NotNull - final - String name, + final String name, final long value, @NotNull final IndexOption index) { return withField(name, UnsignedByteArrays.from(value), index, IndexType.FIXED_LENGTH); } + public DocumentBuilder withField( + @NotNull + final String name, + final char value, + @NotNull + final IndexOption index) { + return withField(name, UnsignedByteArrays.from(value), index, IndexType.FIXED_LENGTH); + } + @NotNull @Override public DocumentBuilder withField( diff --git a/core/src/main/java/com/yandex/yoctodb/mutable/DocumentBuilder.java b/core/src/main/java/com/yandex/yoctodb/mutable/DocumentBuilder.java index 4be5102a..ed88ec17 100644 --- a/core/src/main/java/com/yandex/yoctodb/mutable/DocumentBuilder.java +++ b/core/src/main/java/com/yandex/yoctodb/mutable/DocumentBuilder.java @@ -113,6 +113,15 @@ DocumentBuilder withField( @NotNull IndexOption index); + @NotNull + DocumentBuilder withField( + @NotNull + String name, + char c, + @NotNull + IndexOption index + ); + @NotNull DocumentBuilder withField( @NotNull diff --git a/core/src/main/java/com/yandex/yoctodb/util/UnsignedByteArrays.java b/core/src/main/java/com/yandex/yoctodb/util/UnsignedByteArrays.java index 30bcb5c2..86638736 100644 --- a/core/src/main/java/com/yandex/yoctodb/util/UnsignedByteArrays.java +++ b/core/src/main/java/com/yandex/yoctodb/util/UnsignedByteArrays.java @@ -82,6 +82,11 @@ public static UnsignedByteArray from(final int i) { return from(Ints.toByteArray(i ^ Integer.MIN_VALUE)); } + @NotNull + public static UnsignedByteArray from(final char c) { + return from(Chars.toByteArray(c)); + } + public static int toInt( @NotNull final UnsignedByteArray bytes) { diff --git a/core/src/main/java/com/yandex/yoctodb/util/buf/Buffer.java b/core/src/main/java/com/yandex/yoctodb/util/buf/Buffer.java index 1b1368da..6b24a01a 100644 --- a/core/src/main/java/com/yandex/yoctodb/util/buf/Buffer.java +++ b/core/src/main/java/com/yandex/yoctodb/util/buf/Buffer.java @@ -120,6 +120,10 @@ public byte[] toByteArray() { public abstract long getLong(long index); + public abstract char getChar(); + + public abstract char getChar(long index); + public abstract short getShort(); public abstract short getShort(long index); diff --git a/core/src/main/java/com/yandex/yoctodb/util/buf/ByteBufferWrapper.java b/core/src/main/java/com/yandex/yoctodb/util/buf/ByteBufferWrapper.java index 1512a5c7..90182692 100644 --- a/core/src/main/java/com/yandex/yoctodb/util/buf/ByteBufferWrapper.java +++ b/core/src/main/java/com/yandex/yoctodb/util/buf/ByteBufferWrapper.java @@ -117,6 +117,18 @@ public long getLong(final long index) { return delegate.getLong((int) index); } + @Override + public char getChar() { + return delegate.getChar(); + } + + @Override + public char getChar(long index) { + assert index <= Integer.MAX_VALUE; + + return delegate.getChar((int) index); + } + @Override public short getShort() { return delegate.getShort(); diff --git a/core/src/main/java/com/yandex/yoctodb/util/buf/FileChannelBuffer.java b/core/src/main/java/com/yandex/yoctodb/util/buf/FileChannelBuffer.java index 569a09d4..b9fbc129 100644 --- a/core/src/main/java/com/yandex/yoctodb/util/buf/FileChannelBuffer.java +++ b/core/src/main/java/com/yandex/yoctodb/util/buf/FileChannelBuffer.java @@ -141,7 +141,7 @@ public byte get() { final ByteBuffer byteBuf = byteBufCache.get(); try { final int c = ch.read(byteBuf, this.offset + this.position); - assert c == 1; + assert c == Byte.BYTES; } catch (IOException e) { throw new RuntimeException(e); } @@ -158,7 +158,7 @@ public byte get(final long index) { final ByteBuffer byteBuf = byteBufCache.get(); try { final int c = ch.read(byteBuf, this.offset + index); - assert c == 1; + assert c == Byte.BYTES; } catch (IOException e) { throw new RuntimeException(e); } @@ -167,101 +167,132 @@ public byte get(final long index) { } @Override - public short getShort() { - assert remaining() >= Short.BYTES; + public int getInt() { + assert remaining() >= Integer.BYTES;; - final ByteBuffer shortBuf = shortBufCache.get(); - shortBuf.rewind(); + final ByteBuffer intBuf = intBufCache.get(); + intBuf.rewind(); try { - final int c = ch.read(shortBuf, this.offset + this.position); - assert c == Short.BYTES; + final int c = ch.read(intBuf, this.offset + this.position); + assert c == Integer.BYTES;; } catch (IOException e) { throw new RuntimeException(e); } - this.position += Short.BYTES; + this.position += Integer.BYTES; - return shortBuf.getShort(0); + return intBuf.getInt(0); } @Override - public short getShort(long index) { - assert index + Short.BYTES <= limit; + public int getInt(final long index) { + assert index + Integer.BYTES <= limit; - final ByteBuffer shortBuf = shortBufCache.get(); + final ByteBuffer intBuf = intBufCache.get(); try { - final int c = ch.read(shortBuf, this.offset + index); - assert c == Short.BYTES; + final int c = ch.read(intBuf, this.offset + index); + assert c == Integer.BYTES; } catch (IOException e) { throw new RuntimeException(e); } - return shortBuf.getShort(0); + return intBuf.getInt(0); } @Override - public int getInt() { - assert remaining() >= 4; + public long getLong() { + assert remaining() >= Long.BYTES; - final ByteBuffer intBuf = intBufCache.get(); - intBuf.rewind(); + final ByteBuffer longBuf = longBufCache.get(); try { - final int c = ch.read(intBuf, this.offset + this.position); - assert c == 4; + final int c = ch.read(longBuf, this.offset + this.position); + assert c == Long.BYTES; } catch (IOException e) { throw new RuntimeException(e); } - this.position += 4; + this.position += Long.BYTES; - return intBuf.getInt(0); + return longBuf.getLong(0); } @Override - public int getInt(final long index) { - assert index + 4 <= limit; + public long getLong(final long index) { + assert index + 8 <= limit; - final ByteBuffer intBuf = intBufCache.get(); + final ByteBuffer longBuf = longBufCache.get(); try { - final int c = ch.read(intBuf, this.offset + index); - assert c == 4; + final int c = ch.read(longBuf, this.offset + index); + assert c == Long.BYTES; } catch (IOException e) { throw new RuntimeException(e); } - return intBuf.getInt(0); + return longBuf.getLong(0); } @Override - public long getLong() { - assert remaining() >= 8; + public char getChar() { + assert remaining() >= Character.BYTES; - final ByteBuffer longBuf = longBufCache.get(); + final ByteBuffer charBuf = charBufCache.get(); try { - final int c = ch.read(longBuf, this.offset + this.position); - assert c == 8; + final int c = ch.read(charBuf, this.offset + this.position); + assert c == Character.BYTES; } catch (IOException e) { throw new RuntimeException(e); } - this.position += 8; + this.position += Character.BYTES; - return longBuf.getLong(0); + return charBuf.getChar(0); } @Override - public long getLong(final long index) { - assert index + 8 <= limit; + public char getChar(final long index) { + assert index + Character.BYTES <= limit; - final ByteBuffer longBuf = longBufCache.get(); + final ByteBuffer charBuf = charBufCache.get(); try { - final int c = ch.read(longBuf, this.offset + index); - assert c == 8; + final int c = ch.read(charBuf, this.offset + index); + assert c == Character.BYTES; } catch (IOException e) { throw new RuntimeException(e); } - return longBuf.getLong(0); + return charBuf.getChar(0); + } + + @Override + public short getShort() { + assert remaining() >= Short.BYTES; + + final ByteBuffer shortBuf = shortBufCache.get(); + try { + final int c = ch.read(shortBuf, this.offset + this.position); + assert c == Short.BYTES; + } catch (IOException e) { + throw new RuntimeException(e); + } + + this.position += Short.BYTES; + + return shortBuf.getShort(0); + } + + @Override + public short getShort(final long index) { + assert index + Short.BYTES <= limit; + + final ByteBuffer shortBuf = shortBufCache.get(); + try { + final int c = ch.read(shortBuf, this.offset + index); + assert c == Short.BYTES; + } catch (IOException e) { + throw new RuntimeException(e); + } + + return shortBuf.getShort(0); } @Override @@ -329,6 +360,21 @@ protected ByteBuffer initialValue() { return ByteBuffer.allocate(8); } + @Override + public ByteBuffer get() { + final ByteBuffer result = super.get(); + result.rewind(); + return result; + } + }; + + private final ThreadLocal charBufCache = + new ThreadLocal() { + @Override + protected ByteBuffer initialValue() { + return ByteBuffer.allocate(Character.BYTES); + } + @Override public ByteBuffer get() { final ByteBuffer result = super.get(); diff --git a/core/src/main/java/com/yandex/yoctodb/util/immutable/ByteArrayIndexedList.java b/core/src/main/java/com/yandex/yoctodb/util/immutable/ByteArrayIndexedList.java index 85a9c861..0cfe8b7c 100644 --- a/core/src/main/java/com/yandex/yoctodb/util/immutable/ByteArrayIndexedList.java +++ b/core/src/main/java/com/yandex/yoctodb/util/immutable/ByteArrayIndexedList.java @@ -22,7 +22,17 @@ @ThreadSafe public interface ByteArrayIndexedList { @NotNull - Buffer get(int i); + Buffer get(final int docId); + + long getLongUnsafe(final int docId); + + int getIntUnsafe(final int docId); + + short getShortUnsafe(final int docId); + + char getCharUnsafe(final int docId); + + byte getByteUnsafe(final int docId); int size(); } diff --git a/core/src/main/java/com/yandex/yoctodb/util/immutable/ByteArraySortedSet.java b/core/src/main/java/com/yandex/yoctodb/util/immutable/ByteArraySortedSet.java index b3ebc4a2..dbf1464a 100644 --- a/core/src/main/java/com/yandex/yoctodb/util/immutable/ByteArraySortedSet.java +++ b/core/src/main/java/com/yandex/yoctodb/util/immutable/ByteArraySortedSet.java @@ -26,6 +26,16 @@ public interface ByteArraySortedSet { @NotNull Buffer get(int i); + long getLongUnsafe(int i); + + int getIntUnsafe(int i); + + short getShortUnsafe(int i); + + char getCharUnsafe(int i); + + byte getByteUnsafe(int i); + /** * Get index of the element * diff --git a/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/FixedLengthByteArrayIndexedList.java b/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/FixedLengthByteArrayIndexedList.java index a704533a..735ceb53 100644 --- a/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/FixedLengthByteArrayIndexedList.java +++ b/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/FixedLengthByteArrayIndexedList.java @@ -10,10 +10,11 @@ package com.yandex.yoctodb.util.immutable.impl; +import com.google.common.primitives.Shorts; import com.yandex.yoctodb.util.buf.Buffer; +import com.yandex.yoctodb.util.immutable.ByteArrayIndexedList; import net.jcip.annotations.Immutable; import org.jetbrains.annotations.NotNull; -import com.yandex.yoctodb.util.immutable.ByteArrayIndexedList; /** * Fixed length immutable implementation of {@link ByteArrayIndexedList} @@ -60,6 +61,52 @@ public Buffer get(final int i) { return elements.slice(((long) i) * elementSize, elementSize); } + @Override + public long getLongUnsafe(final int i) { + assert 0 <= i && i < elementCount; + assert elementSize == Long.BYTES; + + return elements.getLong() ^ Long.MIN_VALUE; + } + + @Override + public int getIntUnsafe(final int i) { + assert 0 <= i && i < elementCount; + assert elementSize == Integer.BYTES; + + return elements.getInt() ^ Integer.MIN_VALUE; + } + + @Override + public short getShortUnsafe(final int i) { + assert 0 <= i && i < elementCount; + assert elementSize == Short.BYTES; + + final int res = elements.getShort() ^ Short.MIN_VALUE; + + return Shorts.checkedCast(res); + } + + @Override + public char getCharUnsafe(final int i) { + assert 0 <= i && i < elementCount; + assert elementSize == Character.BYTES; + + return elements.getChar(); + } + + @Override + public byte getByteUnsafe(final int i) { + assert 0 <= i && i < elementCount; + assert elementSize == Byte.BYTES; + + final int res = elements.get() ^ Byte.MIN_VALUE; + + assert Byte.MIN_VALUE <= res && res <= Byte.MAX_VALUE; + + return (byte) res; + } + @Override public int size() { return elementCount; diff --git a/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/FixedLengthByteArraySortedSet.java b/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/FixedLengthByteArraySortedSet.java index 7005dfad..75af5da0 100644 --- a/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/FixedLengthByteArraySortedSet.java +++ b/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/FixedLengthByteArraySortedSet.java @@ -10,11 +10,12 @@ package com.yandex.yoctodb.util.immutable.impl; +import com.google.common.primitives.Chars; +import com.google.common.primitives.Shorts; +import com.yandex.yoctodb.util.UnsignedByteArrays; import com.yandex.yoctodb.util.buf.Buffer; import net.jcip.annotations.Immutable; import org.jetbrains.annotations.NotNull; -import com.yandex.yoctodb.util.UnsignedByteArrays; -import com.yandex.yoctodb.util.immutable.ByteArraySortedSet; /** * {@link com.yandex.yoctodb.util.immutable.ByteArraySortedSet} with fixed size @@ -81,6 +82,57 @@ public Buffer get(final int i) { return elements.slice(((long) i) * elementSize, elementSize); } + @Override + public long getLongUnsafe(final int i) { + assert 0 <= i && i < size; + + assert elementSize == Long.BYTES; + + return elements.getLong(((long) i) << 3) ^ Long.MIN_VALUE; + } + + @Override + public int getIntUnsafe(final int i) { + assert 0 <= i && i < size; + + assert elementSize == Integer.BYTES; + + return elements.getInt(((long) i) << 2) ^ Integer.MIN_VALUE; + } + + @Override + public short getShortUnsafe(final int i) { + assert 0 <= i && i < size; + + assert elementSize == Short.BYTES; + + final int res = elements.getShort(((long) i) << 1) ^ Short.MIN_VALUE; + + return Shorts.checkedCast(res); + } + + @Override + public char getCharUnsafe(final int i) { + assert 0 <= i && i < size; + + assert elementSize == Chars.BYTES; + + return elements.getChar(((long) i) << 1); + } + + @Override + public byte getByteUnsafe(final int i) { + assert 0 <= i && i < size; + + assert elementSize == Byte.BYTES; + + final int res = elements.get(((long) i)) ^ Byte.MIN_VALUE; + + assert Byte.MIN_VALUE <= res && res <= Byte.MAX_VALUE; + + return (byte) res; + } + @Override public String toString() { return "FixedLengthByteArraySortedSet{" + diff --git a/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/FoldedByteArrayIndexedList.java b/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/FoldedByteArrayIndexedList.java index 82aefaf9..80702d27 100644 --- a/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/FoldedByteArrayIndexedList.java +++ b/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/FoldedByteArrayIndexedList.java @@ -1,3 +1,13 @@ +/* + * (C) YANDEX LLC, 2014-2019 + * + * The Source Code called "YoctoDB" available at + * https://github.com/yandex/yoctodb is subject to the terms of the + * Mozilla Public License, v. 2.0 (hereinafter referred to as the "License"). + * + * A copy of the License is also available at http://mozilla.org/MPL/2.0/. + */ + package com.yandex.yoctodb.util.immutable.impl; import com.yandex.yoctodb.util.buf.Buffer; @@ -92,6 +102,56 @@ public Buffer get(final int docId) { return elements.slice(start, end - start); } + @Override + public long getLongUnsafe(final int docId) { + assert 0 <= docId && docId < elementCount; + + final long offsetIndex = getOffsetIndex.apply(docId) * Long.BYTES; + final long start = offsets.getLong(offsetIndex); + + return elements.getLong(start) ^ Long.MIN_VALUE; + } + + @Override + public int getIntUnsafe(final int docId) { + assert 0 <= docId && docId < elementCount; + + final long offsetIndex = getOffsetIndex.apply(docId) * Long.BYTES; + final long start = offsets.getLong(offsetIndex); + + return elements.getInt(start) ^ Integer.MIN_VALUE; + } + + @Override + public short getShortUnsafe(final int docId) { + assert 0 <= docId && docId < elementCount; + + final long offsetIndex = getOffsetIndex.apply(docId) * Long.BYTES; + final long start = offsets.getLong(offsetIndex); + + return (short) (elements.getShort(start) ^ Short.MIN_VALUE); + } + + @Override + public char getCharUnsafe(final int docId) { + assert 0 <= docId && docId < elementCount; + + final long offsetIndex = getOffsetIndex.apply(docId) * Long.BYTES; + final long start = offsets.getLong(offsetIndex); + + return elements.getChar(start); + } + + @Override + public byte getByteUnsafe(final int docId) { + assert 0 <= docId && docId < elementCount; + + final long offsetIndex = getOffsetIndex.apply(docId) * Long.BYTES; + final long start = offsets.getLong(offsetIndex); + + return (byte) (elements.get(start) ^ Byte.MIN_VALUE); + } + @Override public int size() { return elementCount; diff --git a/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/TrieByteArraySortedSet.java b/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/TrieByteArraySortedSet.java index 072dfbb8..8204aa6c 100644 --- a/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/TrieByteArraySortedSet.java +++ b/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/TrieByteArraySortedSet.java @@ -69,6 +69,66 @@ public Buffer get(int i) { throw new UnsupportedOperationException(); } + /** + * We unable to provide getLongUnsafe() implementation since + * there is no continuous buffer with key value. + * + * @param i index of key + * @throws UnsupportedOperationException + */ + @Override + public long getLongUnsafe(int i) { + throw new UnsupportedOperationException(); + } + + /** + * We unable to provide getIntUnsafe() implementation since + * there is no continuous buffer with key value. + * + * @param i index of key + * @throws UnsupportedOperationException + */ + @Override + public int getIntUnsafe(int i) { + throw new UnsupportedOperationException(); + } + + /** + * We unable to provide getShortUnsafe() implementation since + * there is no continuous buffer with key value. + * + * @param i index of key + * @throws UnsupportedOperationException + */ + @Override + public short getShortUnsafe(int i) { + throw new UnsupportedOperationException(); + } + + /** + * We unable to provide getCharUnsafe() implementation since + * there is no continuous buffer with key value. + * + * @param i index of key + * @throws UnsupportedOperationException + */ + @Override + public char getCharUnsafe(int i) { + throw new UnsupportedOperationException(); + } + + /** + * We unable to provide getByteUnsafe() implementation since + * there is no continuous buffer with key value. + * + * @param i index of key + * @throws UnsupportedOperationException + */ + @Override + public byte getByteUnsafe(int i) { + throw new UnsupportedOperationException(); + } + /** * Look up for key in trie. * Complexity: O(|key|) diff --git a/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/VariableLengthByteArrayIndexedList.java b/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/VariableLengthByteArrayIndexedList.java index adb9e298..eb212403 100644 --- a/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/VariableLengthByteArrayIndexedList.java +++ b/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/VariableLengthByteArrayIndexedList.java @@ -10,10 +10,11 @@ package com.yandex.yoctodb.util.immutable.impl; +import com.google.common.primitives.Shorts; import com.yandex.yoctodb.util.buf.Buffer; +import com.yandex.yoctodb.util.immutable.ByteArrayIndexedList; import net.jcip.annotations.Immutable; import org.jetbrains.annotations.NotNull; -import com.yandex.yoctodb.util.immutable.ByteArrayIndexedList; /** * Variable length immutable implementation of @@ -79,6 +80,69 @@ public Buffer get(final int i) { return elements.slice(start, end - start); } + @Override + public long getLongUnsafe(final int i) { + assert 0 <= i && i < elementCount; + + final long base = ((long) i) << 3; + final long start = offsets.getLong(base); + + return elements.getLong(start) ^ Long.MIN_VALUE; + } + + @Override + public int getIntUnsafe(final int i) { + assert 0 <= i && i < elementCount; + + final long base = ((long) i) << 3; + final long start = offsets.getLong(base); + + return elements.getInt(start) ^ Integer.MIN_VALUE; + } + + @Override + public short getShortUnsafe(final int i) { + assert 0 <= i && i < elementCount; + + final long base = ((long) i) << 3; + final long start = offsets.getLong(base); + final long end = offsets.getLong(base + 8L); + + assert end - start == Short.BYTES; + final int res = elements.getShort(start) ^ Short.MIN_VALUE; + + return Shorts.checkedCast(res); + } + + @Override + public char getCharUnsafe(final int i) { + assert 0 <= i && i < elementCount; + + final long base = ((long) i) << 3; + final long start = offsets.getLong(base); + final long end = offsets.getLong(base + 8L); + + assert end - start == Character.BYTES; + + return elements.getChar(start); + } + + @Override + public byte getByteUnsafe(final int i) { + assert 0 <= i && i < elementCount; + + final long base = ((long) i) << 3; + final long start = offsets.getLong(base); + final long end = offsets.getLong(base + 8L); + + assert end - start == Byte.BYTES; + final int res = elements.get(start) ^ Byte.MIN_VALUE; + + assert Byte.MIN_VALUE <= res && res <= Byte.MAX_VALUE; + + return (byte) res; + } + @Override public int size() { return elementCount; diff --git a/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/VariableLengthByteArraySortedSet.java b/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/VariableLengthByteArraySortedSet.java index 1e693056..4c417317 100644 --- a/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/VariableLengthByteArraySortedSet.java +++ b/core/src/main/java/com/yandex/yoctodb/util/immutable/impl/VariableLengthByteArraySortedSet.java @@ -10,11 +10,11 @@ package com.yandex.yoctodb.util.immutable.impl; +import com.google.common.primitives.Shorts; +import com.yandex.yoctodb.util.UnsignedByteArrays; import com.yandex.yoctodb.util.buf.Buffer; import net.jcip.annotations.Immutable; import org.jetbrains.annotations.NotNull; -import com.yandex.yoctodb.util.UnsignedByteArrays; -import com.yandex.yoctodb.util.immutable.ByteArraySortedSet; /** * {@link com.yandex.yoctodb.util.immutable.ByteArraySortedSet} with variable @@ -97,6 +97,73 @@ public Buffer get(final int i) { return elements.slice(start, end - start); } + @Override + public long getLongUnsafe(final int i) { + assert 0 <= i && i < size; + + final long base = ((long) i) << 3; + final long start = offsets.getLong(base); + final long end = offsets.getLong(base + 8L); + + assert end - start == Long.BYTES; + + return elements.getLong(start) ^ Long.MIN_VALUE; + } + + @Override + public int getIntUnsafe(final int i) { + assert 0 <= i && i < size; + + final long base = ((long) i) << 3; + final long start = offsets.getLong(base); + final long end = offsets.getLong(base + 8L); + + assert end - start == Integer.BYTES; + + return elements.getInt(start) ^ Integer.MIN_VALUE; + } + + @Override + public short getShortUnsafe(final int i) { + assert 0 <= i && i < size; + + final long base = ((long) i) << 3; + final long start = offsets.getLong(base); + final long end = offsets.getLong(base + 8L); + + assert end - start == Short.BYTES; + final int res = elements.getShort(start) ^ Short.MIN_VALUE; + + return Shorts.checkedCast(res); + } + + @Override + public char getCharUnsafe(final int i) { + assert 0 <= i && i < size; + + final long base = ((long) i) << 3; + final long start = offsets.getLong(base); + final long end = offsets.getLong(base + 8L); + + assert end - start == Character.BYTES; + + return elements.getChar(start); + } + + @Override + public byte getByteUnsafe(final int i) { + assert 0 <= i && i < size; + + final long base = ((long) i) << 3; + final long start = offsets.getLong(base); + final long end = offsets.getLong(base + 8L); + + assert end - start == Byte.BYTES; + + final int res = elements.get(start) ^ Byte.MIN_VALUE; + return (byte) res; + } + @Override public String toString() { return "VariableLengthByteArraySortedSet{" + diff --git a/core/src/main/java/com/yandex/yoctodb/util/mutable/impl/FoldedByteArrayIndexedList.java b/core/src/main/java/com/yandex/yoctodb/util/mutable/impl/FoldedByteArrayIndexedList.java index 78676680..832a52a4 100644 --- a/core/src/main/java/com/yandex/yoctodb/util/mutable/impl/FoldedByteArrayIndexedList.java +++ b/core/src/main/java/com/yandex/yoctodb/util/mutable/impl/FoldedByteArrayIndexedList.java @@ -1,3 +1,13 @@ +/* + * (C) YANDEX LLC, 2014-2019 + * + * The Source Code called "YoctoDB" available at + * https://github.com/yandex/yoctodb is subject to the terms of the + * Mozilla Public License, v. 2.0 (hereinafter referred to as the "License"). + * + * A copy of the License is also available at http://mozilla.org/MPL/2.0/. + */ + package com.yandex.yoctodb.util.mutable.impl; import com.google.common.primitives.Ints; diff --git a/core/src/main/java/com/yandex/yoctodb/v1/immutable/V1CompositeDatabase.java b/core/src/main/java/com/yandex/yoctodb/v1/immutable/V1CompositeDatabase.java index 9b7508f5..5b2a7b09 100644 --- a/core/src/main/java/com/yandex/yoctodb/v1/immutable/V1CompositeDatabase.java +++ b/core/src/main/java/com/yandex/yoctodb/v1/immutable/V1CompositeDatabase.java @@ -101,6 +101,70 @@ public Buffer getFieldValue( fieldName); } + @Override + public long getLongValue( + final int document, + @NotNull + final String fieldName) { + final int dbIndex = databaseByDocIndex(document); + return databases.get(dbIndex) + .getLongValue( + document - documentOffsets[dbIndex], + fieldName); + } + + @Override + public int getIntValue( + final int document, + @NotNull + final String fieldName) { + final int dbIndex = databaseByDocIndex(document); + return databases.get(dbIndex) + .getIntValue( + document - documentOffsets[dbIndex], + fieldName + ); + } + + @Override + public short getShortValue( + final int document, + @NotNull + final String fieldName) { + final int dbIndex = databaseByDocIndex(document); + return databases.get(dbIndex) + .getShortValue( + document - documentOffsets[dbIndex], + fieldName + ); + } + + @Override + public char getCharValue( + final int document, + @NotNull + final String fieldName) { + final int dbIndex = databaseByDocIndex(document); + return databases.get(dbIndex) + .getCharValue( + document - documentOffsets[dbIndex], + fieldName + ); + } + + @Override + public byte getByteValue( + final int document, + @NotNull + final String fieldName) { + final int dbIndex = databaseByDocIndex(document); + return databases.get(dbIndex) + .getByteValue( + document - documentOffsets[dbIndex], + fieldName + ); + } + @Override public void execute( @NotNull diff --git a/core/src/main/java/com/yandex/yoctodb/v1/immutable/V1Database.java b/core/src/main/java/com/yandex/yoctodb/v1/immutable/V1Database.java index bbd66cd5..4b318c2e 100644 --- a/core/src/main/java/com/yandex/yoctodb/v1/immutable/V1Database.java +++ b/core/src/main/java/com/yandex/yoctodb/v1/immutable/V1Database.java @@ -113,6 +113,56 @@ public Buffer getFieldValue( return storers.get(fieldName).getStoredValue(document); } + @Override + public long getLongValue( + final int document, + @NotNull + final String fieldName) { + assert storers.containsKey(fieldName); + + return storers.get(fieldName).getLongValue(document); + } + + @Override + public int getIntValue( + final int document, + @NotNull + final String fieldName) { + assert storers.containsKey(fieldName); + + return storers.get(fieldName).getIntValue(document); + } + + @Override + public short getShortValue( + final int document, + @NotNull + final String fieldName) { + assert storers.containsKey(fieldName); + + return storers.get(fieldName).getShortValue(document); + } + + @Override + public char getCharValue( + final int document, + @NotNull + final String fieldName) { + assert storers.containsKey(fieldName); + + return storers.get(fieldName).getCharValue(document); + } + + @Override + public byte getByteValue( + final int document, + @NotNull + final String fieldName) { + assert storers.containsKey(fieldName); + + return storers.get(fieldName).getByteValue(document); + } + @Override public void execute( @NotNull diff --git a/core/src/main/java/com/yandex/yoctodb/v1/immutable/segment/V1FullIndex.java b/core/src/main/java/com/yandex/yoctodb/v1/immutable/segment/V1FullIndex.java index cc2a54d3..49572397 100644 --- a/core/src/main/java/com/yandex/yoctodb/v1/immutable/segment/V1FullIndex.java +++ b/core/src/main/java/com/yandex/yoctodb/v1/immutable/segment/V1FullIndex.java @@ -147,6 +147,31 @@ public Buffer getStoredValue(final int document) { return sortableDelegate.getStoredValue(document); } + @Override + public long getLongValue(final int document) { + return sortableDelegate.getLongValue(document); + } + + @Override + public int getIntValue(final int document) { + return sortableDelegate.getIntValue(document); + } + + @Override + public short getShortValue(final int document) { + return sortableDelegate.getShortValue(document); + } + + @Override + public char getCharValue(final int document) { + return sortableDelegate.getCharValue(document); + } + + @Override + public byte getByteValue(final int document) { + return sortableDelegate.getByteValue(document); + } + @NotNull @Override public Iterator ascending( diff --git a/core/src/main/java/com/yandex/yoctodb/v1/immutable/segment/V1SortableIndex.java b/core/src/main/java/com/yandex/yoctodb/v1/immutable/segment/V1SortableIndex.java index 7dc1e99e..58bcbb1c 100644 --- a/core/src/main/java/com/yandex/yoctodb/v1/immutable/segment/V1SortableIndex.java +++ b/core/src/main/java/com/yandex/yoctodb/v1/immutable/segment/V1SortableIndex.java @@ -83,6 +83,31 @@ public Buffer getStoredValue(final int document) { return values.get(documentToValue.get(document)); } + @Override + public long getLongValue(final int document) { + return values.getLongUnsafe(document); + } + + @Override + public int getIntValue(final int document) { + return values.getIntUnsafe(document); + } + + @Override + public short getShortValue(final int document) { + return values.getShortUnsafe(document); + } + + @Override + public char getCharValue(final int document) { + return values.getCharUnsafe(document); + } + + @Override + public byte getByteValue(final int document) { + return values.getByteUnsafe(document); + } + @NotNull @Override public Iterator ascending( diff --git a/core/src/main/java/com/yandex/yoctodb/v1/immutable/segment/V1StoredIndex.java b/core/src/main/java/com/yandex/yoctodb/v1/immutable/segment/V1StoredIndex.java index 9088d3ff..5e08f7c0 100644 --- a/core/src/main/java/com/yandex/yoctodb/v1/immutable/segment/V1StoredIndex.java +++ b/core/src/main/java/com/yandex/yoctodb/v1/immutable/segment/V1StoredIndex.java @@ -39,6 +39,31 @@ public Buffer getStoredValue(final int document) { return values.get(document); } + @Override + public long getLongValue(final int document) { + return values.getLongUnsafe(document); + } + + @Override + public int getIntValue(final int document) { + return values.getIntUnsafe(document); + } + + @Override + public short getShortValue(final int document) { + return values.getShortUnsafe(document); + } + + @Override + public char getCharValue(final int document) { + return values.getCharUnsafe(document); + } + + @Override + public byte getByteValue(final int document) { + return values.getByteUnsafe(document); + } + static void registerReader() { SegmentRegistry.register( V1DatabaseFormat.SegmentType diff --git a/core/src/test/java/com/yandex/yoctodb/CompositeFileDatabaseTest.java b/core/src/test/java/com/yandex/yoctodb/CompositeFileDatabaseTest.java index dbae4fcc..560c4d5e 100644 --- a/core/src/test/java/com/yandex/yoctodb/CompositeFileDatabaseTest.java +++ b/core/src/test/java/com/yandex/yoctodb/CompositeFileDatabaseTest.java @@ -45,6 +45,12 @@ public class CompositeFileDatabaseTest { private static final String BASE; + private static final String LONG_STORED_FILED_NAME = "stored_long_value"; + private static final String INT_STORED_FILED_NAME = "stored_int_value"; + private static final String SHORT_STORED_FILED_NAME = "stored_short_value"; + private static final String CHAR_STORED_FILED_NAME = "stored_char_value"; + private static final String BYTE_STORED_FIELD_NAME = "stored_byte_value"; + static { try { BASE = Files.createTempDirectory("indices").toString(); @@ -73,6 +79,11 @@ private static File buildDatabase1(final String name) throws IOException { .withField("field2", "2", FILTERABLE) .withField("index", i, FULL) .withField("relevance", -i, SORTABLE) + .withField(LONG_STORED_FILED_NAME, Long.valueOf(i), STORED) + .withField(INT_STORED_FILED_NAME, i, STORED) + .withField(SHORT_STORED_FILED_NAME, (short) i, STORED) + .withField(CHAR_STORED_FILED_NAME, (char) i, STORED) + .withField(BYTE_STORED_FIELD_NAME, (byte) i, STORED) .withPayload(("payload1=" + i).getBytes()) ); } @@ -96,6 +107,11 @@ private static File buildDatabase2(final String name) throws IOException { .withField("field2", "1", FILTERABLE) .withField("index", i, FULL) .withField("relevance", i, SORTABLE) + .withField(LONG_STORED_FILED_NAME, Long.valueOf(i), STORED) + .withField(INT_STORED_FILED_NAME, i, STORED) + .withField(SHORT_STORED_FILED_NAME, (short) i, STORED) + .withField(CHAR_STORED_FILED_NAME, (char) i, STORED) + .withField(BYTE_STORED_FIELD_NAME, (byte) i, STORED) .withPayload(("payload2=" + i).getBytes()) ); } @@ -530,7 +546,7 @@ public void unindexedFieldSearch() { @Test public void emptyCompositeDatabaseFieldSearch() { - final Database db = READER.composite(new ArrayList()); + final Database db = READER.composite(new ArrayList<>()); final Query query = select().where( @@ -594,4 +610,54 @@ public void extractFieldValues() { db.getFieldValue(id, "relevance")); } } + + @Test + public void extractFieldValuesAsLong() { + for (int i = 0; i < 2 * DOCS; i++) { + final int id = i % DOCS; + assertEquals( + id, + db.getLongValue(id, LONG_STORED_FILED_NAME)); + } + } + + @Test + public void extractFieldValueAsInt() { + for (int i = 0; i < 2 * DOCS; i++) { + final int id = i % DOCS; + assertEquals( + id, + db.getIntValue(id, INT_STORED_FILED_NAME)); + } + } + + @Test + public void extractFieldValuesAsShort() { + for (int i = 0; i < 2 * DOCS; i++) { + final int id = i % DOCS; + assertEquals( + id, + db.getShortValue(id, SHORT_STORED_FILED_NAME)); + } + } + + @Test + public void extractFieldValueAsChar() { + for (int i = 0; i < 2 * DOCS; i++) { + final int id = i % DOCS; + assertEquals( + id, + db.getCharValue(id, CHAR_STORED_FILED_NAME)); + } + } + + @Test + public void extractFieldValueAsByte() { + for (int i = 0; i < 2 * DOCS; i++) { + final int id = i % DOCS; + assertEquals( + id, + db.getByteValue((byte) id, BYTE_STORED_FIELD_NAME)); + } + } } diff --git a/core/src/test/java/com/yandex/yoctodb/FieldValueExtractionTest.java b/core/src/test/java/com/yandex/yoctodb/FieldValueExtractionTest.java index 23dc2586..eee4ceaf 100644 --- a/core/src/test/java/com/yandex/yoctodb/FieldValueExtractionTest.java +++ b/core/src/test/java/com/yandex/yoctodb/FieldValueExtractionTest.java @@ -29,6 +29,18 @@ */ public class FieldValueExtractionTest { private static final String FIELD_NAME = "id"; + private static final String INT_FIELD_NAME = "int_id"; + private static final String LONG_FIELD_NAME = "long_id"; + private static final String SHORT_FIELD_NAME = "short_id"; + private static final String CHAR_FIELD_NAME = "char_id"; + private static final String BYTE_FIELD_NAME = "byte_is"; + + private static final int INT_FIELD_VALUE = 25; + private static final long LONG_FIELD_VALUE = 25L; + private static final short SHORT_FIELD_VALUE = 25; + private static final char CHAR_FIELD_VALUE = 'a'; + private static final byte BYTE_FIELD_VALUE = 23; + private DocumentProvider build( final IndexOption indexOption) throws IOException { @@ -43,6 +55,11 @@ private DocumentProvider build( FIELD_NAME, 0, indexOption) + .withField(INT_FIELD_NAME, INT_FIELD_VALUE, indexOption) + .withField(LONG_FIELD_NAME, LONG_FIELD_VALUE, indexOption) + .withField(SHORT_FIELD_NAME, SHORT_FIELD_VALUE, indexOption) + .withField(CHAR_FIELD_NAME, CHAR_FIELD_VALUE, indexOption) + .withField(BYTE_FIELD_NAME, BYTE_FIELD_VALUE, indexOption) .withPayload("payload".getBytes()) ); @@ -68,6 +85,47 @@ public void extractSortableFieldValue() throws IOException { assertEquals(from(0).toByteBuffer(), db.getFieldValue(0, FIELD_NAME)); } + @Test + public void extractStoredFieldValue() throws IOException { + final DocumentProvider db = build(IndexOption.STORED); + assertEquals(from(0).toByteBuffer(), db.getFieldValue(0, FIELD_NAME)); + } + + @Test + public void extractStoredLong() throws IOException { + final DocumentProvider db = build(IndexOption.STORED); + final long storedValue = db.getLongValue(0, LONG_FIELD_NAME); + assertEquals(LONG_FIELD_VALUE, storedValue); + } + + @Test + public void extractStoredInt() throws IOException { + final DocumentProvider db = build(IndexOption.STORED); + final int storedValue = db.getIntValue(0, INT_FIELD_NAME); + assertEquals(INT_FIELD_VALUE, storedValue); + } + + @Test + public void extractStoredShort() throws IOException { + final DocumentProvider db = build(IndexOption.STORED); + final short storedValue = db.getShortValue(0, SHORT_FIELD_NAME); + assertEquals(SHORT_FIELD_VALUE, storedValue); + } + + @Test + public void extractStoredChar() throws IOException { + final DocumentProvider db = build(IndexOption.STORED); + final char storedValue = db.getCharValue(0, CHAR_FIELD_NAME); + assertEquals(CHAR_FIELD_VALUE, storedValue); + } + + @Test + public void extractStoredByte() throws IOException { + final DocumentProvider db = build(IndexOption.STORED); + final byte storedValue = db.getByteValue(0, BYTE_FIELD_NAME); + assertEquals(BYTE_FIELD_VALUE, storedValue); + } + @Test(expected = AssertionError.class) public void notExtractFilterableFieldValue() throws IOException { final DocumentProvider db = build(IndexOption.FILTERABLE); diff --git a/core/src/test/java/com/yandex/yoctodb/FoldedIndexTest.java b/core/src/test/java/com/yandex/yoctodb/FoldedIndexTest.java index 769630ca..2552e0c1 100644 --- a/core/src/test/java/com/yandex/yoctodb/FoldedIndexTest.java +++ b/core/src/test/java/com/yandex/yoctodb/FoldedIndexTest.java @@ -1,3 +1,13 @@ +/* + * (C) YANDEX LLC, 2014-2019 + * + * The Source Code called "YoctoDB" available at + * https://github.com/yandex/yoctodb is subject to the terms of the + * Mozilla Public License, v. 2.0 (hereinafter referred to as the "License"). + * + * A copy of the License is also available at http://mozilla.org/MPL/2.0/. + */ + package com.yandex.yoctodb; import com.yandex.yoctodb.immutable.Database; @@ -21,6 +31,13 @@ */ public class FoldedIndexTest { + String BYTE_FIELD_NAME = "byte"; + String SHORT_FIELD_NAME = "short"; + String INT_FIELD_NAME = "int"; + String LONG_FIELD_NAME = "long"; + String CHAR_FIELD_NAME = "char"; + String STATE_FIELD_NAME = "state"; + @Test public void buildDatabase() throws IOException { final DatabaseBuilder dbBuilder = @@ -31,17 +48,37 @@ public void buildDatabase() throws IOException { DatabaseFormat .getCurrent() .newDocumentBuilder() - .withField("state", "NEW", STORED)); + .withField(STATE_FIELD_NAME, "NEW", STORED) + .withField(BYTE_FIELD_NAME, (byte) 1, STORED) + .withField(SHORT_FIELD_NAME, (short) 1, STORED) + .withField(INT_FIELD_NAME, 1, STORED) + .withField(LONG_FIELD_NAME, 1L, STORED) + .withField(CHAR_FIELD_NAME, 'a', STORED) + ); + // Document 2 dbBuilder.merge( DatabaseFormat .getCurrent() .newDocumentBuilder() - .withField("state", "USED", STORED)); + .withField(STATE_FIELD_NAME, "USED", STORED) + .withField(BYTE_FIELD_NAME, (byte) 2, STORED) + .withField(SHORT_FIELD_NAME, (short) 2, STORED) + .withField(INT_FIELD_NAME, 2, STORED) + .withField(LONG_FIELD_NAME, 2L, STORED) + .withField(CHAR_FIELD_NAME, 'b', STORED) + ); + // Document 3 dbBuilder.merge( DatabaseFormat .getCurrent() .newDocumentBuilder() - .withField("state", "NEW", STORED)); + .withField(STATE_FIELD_NAME, "NEW", STORED) + .withField(BYTE_FIELD_NAME, (byte) 1, STORED) + .withField(SHORT_FIELD_NAME, (short) 1, STORED) + .withField(INT_FIELD_NAME, 1, STORED) + .withField(LONG_FIELD_NAME, 1L, STORED) + .withField(CHAR_FIELD_NAME, 'a', STORED) + ); final ByteArrayOutputStream os = new ByteArrayOutputStream(); dbBuilder.buildWritable().writeTo(os); @@ -51,9 +88,31 @@ public void buildDatabase() throws IOException { .getDatabaseReader() .from(Buffer.from(os.toByteArray())); - assertEquals("NEW",getValueFromBuffer(db.getFieldValue(0, "state"))); - assertEquals("USED",getValueFromBuffer(db.getFieldValue(1, "state"))); - assertEquals("NEW",getValueFromBuffer(db.getFieldValue(2, "state"))); + assertEquals("NEW", getValueFromBuffer(db.getFieldValue(0, STATE_FIELD_NAME))); + assertEquals("USED", getValueFromBuffer(db.getFieldValue(1, STATE_FIELD_NAME))); + assertEquals("NEW", getValueFromBuffer(db.getFieldValue(2, STATE_FIELD_NAME))); + + assertEquals((byte) 1, db.getByteValue(0, BYTE_FIELD_NAME)); + assertEquals((byte) 2, db.getByteValue(1, BYTE_FIELD_NAME)); + assertEquals((byte) 1, db.getByteValue(2, BYTE_FIELD_NAME)); + + assertEquals((short) 1, db.getShortValue(0, SHORT_FIELD_NAME)); + assertEquals((short) 2, db.getShortValue(1, SHORT_FIELD_NAME)); + assertEquals((short) 1, db.getShortValue(2, SHORT_FIELD_NAME)); + + assertEquals(1, db.getIntValue(0, INT_FIELD_NAME)); + assertEquals(2, db.getIntValue(1, INT_FIELD_NAME)); + assertEquals(1, db.getIntValue(2, INT_FIELD_NAME)); + + assertEquals(1L, db.getLongValue(0, LONG_FIELD_NAME)); + assertEquals(2L, db.getLongValue(1, LONG_FIELD_NAME)); + assertEquals(1L, db.getLongValue(2, LONG_FIELD_NAME)); + + assertEquals('a', db.getCharValue(0, CHAR_FIELD_NAME)); + assertEquals('b', db.getCharValue(1, CHAR_FIELD_NAME)); + assertEquals('a', db.getCharValue(2, CHAR_FIELD_NAME)); + + } private String getValueFromBuffer(Buffer buffer) { diff --git a/core/src/test/java/com/yandex/yoctodb/FoldedIndexWithEmptyTest.java b/core/src/test/java/com/yandex/yoctodb/FoldedIndexWithEmptyTest.java index 0a29661e..1448abb5 100644 --- a/core/src/test/java/com/yandex/yoctodb/FoldedIndexWithEmptyTest.java +++ b/core/src/test/java/com/yandex/yoctodb/FoldedIndexWithEmptyTest.java @@ -1,3 +1,13 @@ +/* + * (C) YANDEX LLC, 2014-2019 + * + * The Source Code called "YoctoDB" available at + * https://github.com/yandex/yoctodb is subject to the terms of the + * Mozilla Public License, v. 2.0 (hereinafter referred to as the "License"). + * + * A copy of the License is also available at http://mozilla.org/MPL/2.0/. + */ + package com.yandex.yoctodb; import com.yandex.yoctodb.immutable.Database; diff --git a/core/src/test/java/com/yandex/yoctodb/SimpleDatabaseTest.java b/core/src/test/java/com/yandex/yoctodb/SimpleDatabaseTest.java index d0e42f21..4db13a2a 100644 --- a/core/src/test/java/com/yandex/yoctodb/SimpleDatabaseTest.java +++ b/core/src/test/java/com/yandex/yoctodb/SimpleDatabaseTest.java @@ -10,25 +10,40 @@ package com.yandex.yoctodb; -import com.google.common.primitives.Ints; import com.yandex.yoctodb.immutable.Database; import com.yandex.yoctodb.mutable.DatabaseBuilder; import com.yandex.yoctodb.query.DocumentProcessor; import com.yandex.yoctodb.query.Query; import com.yandex.yoctodb.query.simple.SimpleDescendingOrder; import com.yandex.yoctodb.query.simple.SimpleRangeCondition; -import com.yandex.yoctodb.util.UnsignedByteArrays; import com.yandex.yoctodb.util.buf.Buffer; import org.jetbrains.annotations.NotNull; import org.junit.Test; import java.io.ByteArrayOutputStream; import java.io.IOException; -import java.util.*; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; import java.util.concurrent.atomic.AtomicInteger; -import static com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption.*; -import static com.yandex.yoctodb.query.QueryBuilder.*; +import static com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption.FILTERABLE; +import static com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption.FULL; +import static com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption.SORTABLE; +import static com.yandex.yoctodb.mutable.DocumentBuilder.IndexOption.STORED; +import static com.yandex.yoctodb.query.QueryBuilder.asc; +import static com.yandex.yoctodb.query.QueryBuilder.desc; +import static com.yandex.yoctodb.query.QueryBuilder.eq; +import static com.yandex.yoctodb.query.QueryBuilder.gt; +import static com.yandex.yoctodb.query.QueryBuilder.gte; +import static com.yandex.yoctodb.query.QueryBuilder.in; +import static com.yandex.yoctodb.query.QueryBuilder.lt; +import static com.yandex.yoctodb.query.QueryBuilder.lte; +import static com.yandex.yoctodb.query.QueryBuilder.not; +import static com.yandex.yoctodb.query.QueryBuilder.or; +import static com.yandex.yoctodb.query.QueryBuilder.select; import static com.yandex.yoctodb.util.UnsignedByteArrays.from; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; @@ -42,6 +57,31 @@ public class SimpleDatabaseTest { private final int DOCS = 128; + private final String LONG_STORED_FIELD_NAME = "long_stored"; + private final String LONG_FULL_FIELD_NAME = "long_full"; + private final String LONG_SORTABLE_FIELD_NAME = "long_sortable"; + private final long LONG_FIELD_VALUE = 25L; + + private final String INT_STORED_FIELD_NAME = "int_stored"; + private final String INT_FULL_FIELD_NAME = "int_full"; + private final String INT_SORTABLE_FIELD_NAME = "int_sortable"; + private final int INT_FIELD_VALUE = 15; + + private final String SHORT_STORED_FIELD_NAME = "short_stored"; + private final String SHORT_FULL_FIELD_NAME = "short_full"; + private final String SHORT_SORTABLE_FIELD_NAME = "short_sortable"; + private final short SHORT_FIELD_VALUE = 13; + + private final String CHAR_STORED_FIELD_NAME = "char_stored"; + private final String CHAR_FULL_FIELD_NAME = "char_full"; + private final String CHAR_SORTABLE_FIELD_NAME = "char_sortable"; + private final char CHAR_FIELD_VALUE = 'a'; + + private final String BYTE_STORED_FIELD_NAME = "byte_stored"; + private final String BYTE_FULL_FIELD_NAME = "byte_full"; + private final String BYTE_SORTABLE_FIELD_NAME = "byte_sortable"; + private final byte BYTE_FIELD_VALUE = -128; + @Test public void buildDatabase() throws IOException { final DatabaseBuilder dbBuilder = @@ -435,6 +475,27 @@ public void stored() throws IOException { .withField("sorted", 12, SORTABLE) .withField("stored", 13, STORED) .withField("first", 14, STORED) + + .withField(LONG_STORED_FIELD_NAME, LONG_FIELD_VALUE, STORED) + .withField(LONG_FULL_FIELD_NAME, LONG_FIELD_VALUE, FULL) + .withField(LONG_SORTABLE_FIELD_NAME, LONG_FIELD_VALUE, SORTABLE) + + .withField(INT_STORED_FIELD_NAME, INT_FIELD_VALUE, STORED) + .withField(INT_FULL_FIELD_NAME, INT_FIELD_VALUE, FULL) + .withField(INT_SORTABLE_FIELD_NAME, INT_FIELD_VALUE, SORTABLE) + + .withField(SHORT_STORED_FIELD_NAME, SHORT_FIELD_VALUE, STORED) + .withField(SHORT_FULL_FIELD_NAME, SHORT_FIELD_VALUE, FULL) + .withField(SHORT_SORTABLE_FIELD_NAME, SHORT_FIELD_VALUE, SORTABLE) + + .withField(CHAR_STORED_FIELD_NAME, CHAR_FIELD_VALUE, STORED) + .withField(CHAR_FULL_FIELD_NAME, CHAR_FIELD_VALUE, FULL) + .withField(CHAR_SORTABLE_FIELD_NAME, CHAR_FIELD_VALUE, SORTABLE) + + .withField(BYTE_STORED_FIELD_NAME, BYTE_FIELD_VALUE, STORED) + .withField(BYTE_FULL_FIELD_NAME, BYTE_FIELD_VALUE, FULL) + .withField(BYTE_SORTABLE_FIELD_NAME, BYTE_FIELD_VALUE, SORTABLE) + .withPayload(("payload1").getBytes()) ); @@ -465,6 +526,26 @@ public void stored() throws IOException { assertEquals(from("payload1").toByteBuffer(), db.getDocument(0)); assertFalse(db.getFieldValue(0, "second").hasRemaining()); + assertEquals(LONG_FIELD_VALUE, db.getLongValue(0, LONG_STORED_FIELD_NAME)); + assertEquals(LONG_FIELD_VALUE, db.getLongValue(0, LONG_FULL_FIELD_NAME)); + assertEquals(LONG_FIELD_VALUE, db.getLongValue(0, LONG_SORTABLE_FIELD_NAME)); + + assertEquals(INT_FIELD_VALUE, db.getIntValue(0, INT_STORED_FIELD_NAME)); + assertEquals(INT_FIELD_VALUE, db.getIntValue(0, INT_FULL_FIELD_NAME)); + assertEquals(INT_FIELD_VALUE, db.getIntValue(0, INT_SORTABLE_FIELD_NAME)); + + assertEquals(SHORT_FIELD_VALUE, db.getShortValue(0, SHORT_STORED_FIELD_NAME)); + assertEquals(SHORT_FIELD_VALUE, db.getShortValue(0, SHORT_FULL_FIELD_NAME)); + assertEquals(SHORT_FIELD_VALUE, db.getShortValue(0, SHORT_SORTABLE_FIELD_NAME)); + + assertEquals(CHAR_FIELD_VALUE, db.getCharValue(0, CHAR_STORED_FIELD_NAME)); + assertEquals(CHAR_FIELD_VALUE, db.getCharValue(0, CHAR_FULL_FIELD_NAME)); + assertEquals(CHAR_FIELD_VALUE, db.getCharValue(0, CHAR_SORTABLE_FIELD_NAME)); + + assertEquals(BYTE_FIELD_VALUE, db.getByteValue(0, BYTE_STORED_FIELD_NAME)); + assertEquals(BYTE_FIELD_VALUE, db.getByteValue(0, BYTE_FULL_FIELD_NAME)); + assertEquals(BYTE_FIELD_VALUE, db.getByteValue(0, BYTE_SORTABLE_FIELD_NAME)); + // Document 2 assertEquals(from(21).toByteBuffer(), db.getFieldValue(1, "full")); diff --git a/core/src/test/java/com/yandex/yoctodb/query/simple/IdScoredDocumentTest.java b/core/src/test/java/com/yandex/yoctodb/query/simple/IdScoredDocumentTest.java index b03712e8..99d114bf 100644 --- a/core/src/test/java/com/yandex/yoctodb/query/simple/IdScoredDocumentTest.java +++ b/core/src/test/java/com/yandex/yoctodb/query/simple/IdScoredDocumentTest.java @@ -49,6 +49,31 @@ public Buffer getFieldValue( throw new IllegalStateException(); } + @Override + public long getLongValue(int document, @NotNull String fieldName) { + throw new IllegalStateException(); + } + + @Override + public int getIntValue(int document, @NotNull String fieldName) { + throw new IllegalArgumentException(); + } + + @Override + public short getShortValue(int document, @NotNull String fieldName) { + throw new IllegalArgumentException(); + } + + @Override + public char getCharValue(int document, @NotNull String fieldName) { + throw new IllegalArgumentException(); + } + + @Override + public byte getByteValue(int document, @NotNull String fieldName) { + throw new IllegalArgumentException(); + } + @Override public void execute( @NotNull diff --git a/core/src/test/java/com/yandex/yoctodb/util/buf/FileChannelBufferTest.java b/core/src/test/java/com/yandex/yoctodb/util/buf/FileChannelBufferTest.java index d125ecb9..316d43b5 100644 --- a/core/src/test/java/com/yandex/yoctodb/util/buf/FileChannelBufferTest.java +++ b/core/src/test/java/com/yandex/yoctodb/util/buf/FileChannelBufferTest.java @@ -10,6 +10,8 @@ package com.yandex.yoctodb.util.buf; +import com.google.common.primitives.Chars; +import com.google.common.primitives.Shorts; import org.junit.Test; import java.io.File; @@ -194,7 +196,7 @@ public void getLongByIndex() throws IOException { } @Test(expected = RuntimeException.class) - public void getShort() throws IOException { + public void getShortBroken() throws IOException { final FileChannel broken = mock(FileChannel.class); when(broken.size()).thenReturn(1024L); when(broken.read(any(ByteBuffer.class), anyLong())) @@ -203,11 +205,85 @@ public void getShort() throws IOException { } @Test(expected = RuntimeException.class) - public void getShortByIndex() throws IOException { + public void getShortByIndexBroken() throws IOException { final FileChannel broken = mock(FileChannel.class); when(broken.size()).thenReturn(1024L); when(broken.read(any(ByteBuffer.class), anyLong())) .thenThrow(new IOException("Test")); new FileChannelBuffer(broken).getShort(0L); } + + @Test(expected = RuntimeException.class) + public void getCharBroken() throws IOException { + final FileChannel broken = mock(FileChannel.class); + when(broken.size()).thenReturn(1024L); + when(broken.read(any(ByteBuffer.class), anyLong())) + .thenThrow(new IOException("Test")); + new FileChannelBuffer(broken).getChar(); + } + + @Test(expected = RuntimeException.class) + public void getCharByIndexBroken() throws IOException { + final FileChannel broken = mock(FileChannel.class); + when(broken.size()).thenReturn(1024L); + when(broken.read(any(ByteBuffer.class), anyLong())) + .thenThrow(new IOException("Test")); + new FileChannelBuffer(broken).getChar(0L); + } + + @Test + public void getShort() throws IOException { + final short snum = 123; + final byte[] bytes = Shorts.toByteArray(snum); + final Path path = nextTempFile(bytes); + final FileChannel read = FileChannel.open( + path, + StandardOpenOption.READ, + StandardOpenOption.DELETE_ON_CLOSE); + final Buffer buf = Buffer.from(read); + + assertEquals(snum, buf.getShort()); + } + + @Test + public void getShortByIndex() throws IOException { + final short snum = 123; + final byte[] bytes = Shorts.toByteArray(snum); + final Path path = nextTempFile(bytes); + final FileChannel read = FileChannel.open( + path, + StandardOpenOption.READ, + StandardOpenOption.DELETE_ON_CLOSE); + final Buffer buf = Buffer.from(read); + + assertEquals(snum, buf.getShort(0)); + } + + @Test + public void getChar() throws IOException { + final char ch = 'a'; + final byte[] bytes = Chars.toByteArray(ch); + final Path path = nextTempFile(bytes); + final FileChannel read = FileChannel.open( + path, + StandardOpenOption.READ, + StandardOpenOption.DELETE_ON_CLOSE); + final Buffer buf = Buffer.from(read); + + assertEquals(ch, buf.getChar()); + } + + @Test + public void getCharByIndex() throws IOException { + final char ch = 'a'; + final byte[] bytes = Chars.toByteArray(ch); + final Path path = nextTempFile(bytes); + final FileChannel read = FileChannel.open( + path, + StandardOpenOption.READ, + StandardOpenOption.DELETE_ON_CLOSE); + final Buffer buf = Buffer.from(read); + + assertEquals(ch, buf.getChar(0)); + } } diff --git a/core/src/test/java/com/yandex/yoctodb/util/immutable/ByteArrayIndexedListTest.java b/core/src/test/java/com/yandex/yoctodb/util/immutable/ByteArrayIndexedListTest.java index b36f85cb..f0503948 100644 --- a/core/src/test/java/com/yandex/yoctodb/util/immutable/ByteArrayIndexedListTest.java +++ b/core/src/test/java/com/yandex/yoctodb/util/immutable/ByteArrayIndexedListTest.java @@ -53,6 +53,126 @@ public void buildingFromFixedLengthByteArrayIndexedListTest() } } + @Test + public void buildingFromFixedLengthByteArrayIndexedListTestLongUnsafe() + throws IOException { + //elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from(0L)); + elements.add(UnsignedByteArrays.from(1L)); + elements.add(UnsignedByteArrays.from(2L)); + elements.add(UnsignedByteArrays.from(3L)); + elements.add(UnsignedByteArrays.from(4L)); + + final Buffer bb = + prepareDataFromFixedLengthByteArrayIndexedList(elements); + final ByteArrayIndexedList list = + FixedLengthByteArrayIndexedList.from(bb); + + Assert.assertEquals(elements.size(), list.size()); + + for (int i = 0; i < elements.size(); ++i) { + final long puttedValue = elements.get(i).toByteBuffer().getLong() ^ Long.MIN_VALUE; + Assert.assertEquals(puttedValue, list.getLongUnsafe(i)); + } + } + + @Test + public void buildingFromFixedLengthByteArrayIndexedListTestIntUnsafe() + throws IOException { + //elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from(0)); + elements.add(UnsignedByteArrays.from(1)); + elements.add(UnsignedByteArrays.from(2)); + elements.add(UnsignedByteArrays.from(3)); + elements.add(UnsignedByteArrays.from(4)); + + final Buffer bb = + prepareDataFromFixedLengthByteArrayIndexedList(elements); + final ByteArrayIndexedList list = + FixedLengthByteArrayIndexedList.from(bb); + + Assert.assertEquals(elements.size(), list.size()); + + for (int i = 0; i < elements.size(); ++i) { + final long puttedValue = elements.get(i).toByteBuffer().getInt() ^ Integer.MIN_VALUE; + Assert.assertEquals(puttedValue, list.getIntUnsafe(i)); + } + } + + @Test + public void buildingFromFixedLengthByteArrayIndexedListTestShortUnsafe() + throws IOException { + //elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from((short) 0)); + elements.add(UnsignedByteArrays.from((short) 1)); + elements.add(UnsignedByteArrays.from((short) 2)); + elements.add(UnsignedByteArrays.from((short) 3)); + elements.add(UnsignedByteArrays.from((short) 4)); + + final Buffer bb = + prepareDataFromFixedLengthByteArrayIndexedList(elements); + final ByteArrayIndexedList list = + FixedLengthByteArrayIndexedList.from(bb); + + Assert.assertEquals(elements.size(), list.size()); + + for (int i = 0; i < elements.size(); ++i) { + final long puttedValue = elements.get(i).toByteBuffer().getShort() ^ Short.MIN_VALUE; + Assert.assertEquals(puttedValue, list.getShortUnsafe(i)); + } + } + + @Test + public void buildingFromFixedLengthByteArrayIndexedListTestCharUnsafe() + throws IOException { + //elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from('a')); + elements.add(UnsignedByteArrays.from('b')); + elements.add(UnsignedByteArrays.from('c')); + elements.add(UnsignedByteArrays.from('d')); + elements.add(UnsignedByteArrays.from('e')); + + final Buffer bb = + prepareDataFromFixedLengthByteArrayIndexedList(elements); + final ByteArrayIndexedList list = + FixedLengthByteArrayIndexedList.from(bb); + + Assert.assertEquals(elements.size(), list.size()); + + for (int i = 0; i < elements.size(); ++i) { + final long puttedValue = elements.get(i).toByteBuffer().getChar(); + Assert.assertEquals(puttedValue, list.getCharUnsafe(i)); + } + } + + @Test + public void buildingFromFixedLengthByteArrayIndexedListTestByteUnsafe() + throws IOException { + //elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from((byte) 0)); + elements.add(UnsignedByteArrays.from((byte) 1)); + elements.add(UnsignedByteArrays.from((byte) 2)); + elements.add(UnsignedByteArrays.from((byte) 3)); + elements.add(UnsignedByteArrays.from((byte) 4)); + + final Buffer bb = + prepareDataFromFixedLengthByteArrayIndexedList(elements); + final ByteArrayIndexedList list = + FixedLengthByteArrayIndexedList.from(bb); + + Assert.assertEquals(elements.size(), list.size()); + + for (int i = 0; i < elements.size(); ++i) { + final long puttedValue = elements.get(i).toByteBuffer().get() ^ Byte.MIN_VALUE; + Assert.assertEquals(puttedValue, list.getByteUnsafe(i)); + } + } + private Buffer prepareDataFromFixedLengthByteArrayIndexedList( final Collection elements) throws IOException { final com.yandex.yoctodb.util.mutable.impl.FixedLengthByteArrayIndexedList fixedLengthByteArrayIndexedList = @@ -90,6 +210,116 @@ public void buildingFromVariableLengthByteArrayIndexedListTest() } } + @Test + public void buildingFromVariableLengthByteArrayIndexedListTestLongUnsafe() + throws IOException { + //elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from(0L)); + elements.add(UnsignedByteArrays.from(1L)); + elements.add(UnsignedByteArrays.from(2L)); + elements.add(UnsignedByteArrays.from(3L)); + elements.add(UnsignedByteArrays.from(4L)); + + final Buffer bb = + prepareDataFromVariableLengthByteArrayIndexedLength(elements); + final ByteArrayIndexedList list = + VariableLengthByteArrayIndexedList.from(bb); + + for (int i = 0; i < elements.size(); i++) { + final long puttedValue = elements.get(i).toByteBuffer().getLong() ^ Long.MIN_VALUE; + Assert.assertEquals(puttedValue, list.getLongUnsafe(i)); + } + } + + @Test + public void buildingFromVariableLengthByteArrayIndexedListTestIntUnsafe() + throws IOException { + //elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from(0)); + elements.add(UnsignedByteArrays.from(1)); + elements.add(UnsignedByteArrays.from(2)); + elements.add(UnsignedByteArrays.from(3)); + elements.add(UnsignedByteArrays.from(4)); + + final Buffer bb = + prepareDataFromVariableLengthByteArrayIndexedLength(elements); + final ByteArrayIndexedList list = + VariableLengthByteArrayIndexedList.from(bb); + + for (int i = 0; i < elements.size(); i++) { + final long puttedValue = elements.get(i).toByteBuffer().getInt() ^ Integer.MIN_VALUE; + Assert.assertEquals(puttedValue, list.getIntUnsafe(i)); + } + } + + @Test + public void buildingFromVariableLengthByteArrayIndexedListTestShortUnsafe() + throws IOException { + //elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from((short) 0)); + elements.add(UnsignedByteArrays.from((short) 1)); + elements.add(UnsignedByteArrays.from((short) 2)); + elements.add(UnsignedByteArrays.from((short) 3)); + elements.add(UnsignedByteArrays.from((short) 4)); + + final Buffer bb = + prepareDataFromVariableLengthByteArrayIndexedLength(elements); + final ByteArrayIndexedList list = + VariableLengthByteArrayIndexedList.from(bb); + + for (int i = 0; i < elements.size(); i++) { + final long puttedValue = elements.get(i).toByteBuffer().getShort() ^ Short.MIN_VALUE; + Assert.assertEquals(puttedValue, list.getShortUnsafe(i)); + } + } + + @Test + public void buildingFromVariableLengthByteArrayIndexedListTestCharUnsafe() + throws IOException { + //elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from('a')); + elements.add(UnsignedByteArrays.from('b')); + elements.add(UnsignedByteArrays.from('c')); + elements.add(UnsignedByteArrays.from('d')); + elements.add(UnsignedByteArrays.from('e')); + + final Buffer bb = + prepareDataFromVariableLengthByteArrayIndexedLength(elements); + final ByteArrayIndexedList list = + VariableLengthByteArrayIndexedList.from(bb); + + for (int i = 0; i < elements.size(); i++) { + final long puttedValue = elements.get(i).toByteBuffer().getChar(); + Assert.assertEquals(puttedValue, list.getCharUnsafe(i)); + } + } + + @Test + public void buildingFromVariableLengthByteArrayIndexedListTestByteUnsafe() + throws IOException { + //elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from((byte) 0)); + elements.add(UnsignedByteArrays.from((byte) -2)); + elements.add(UnsignedByteArrays.from((byte) 34)); + elements.add(UnsignedByteArrays.from((byte) 21)); + elements.add(UnsignedByteArrays.from((byte) 13)); + + final Buffer bb = + prepareDataFromVariableLengthByteArrayIndexedLength(elements); + final ByteArrayIndexedList list = + VariableLengthByteArrayIndexedList.from(bb); + + for (int i = 0; i < elements.size(); i++) { + final long puttedValue = elements.get(i).toByteBuffer().get() ^ Byte.MIN_VALUE; + Assert.assertEquals(puttedValue, list.getByteUnsafe(i)); + } + } + private Buffer prepareDataFromVariableLengthByteArrayIndexedLength( final Collection elements) throws IOException { final com.yandex.yoctodb.util.mutable.impl.VariableLengthByteArrayIndexedList variableLengthByteArrayIndexedList = diff --git a/core/src/test/java/com/yandex/yoctodb/util/immutable/ByteArraySortedSetTest.java b/core/src/test/java/com/yandex/yoctodb/util/immutable/ByteArraySortedSetTest.java index 32f9c9de..60a6053e 100644 --- a/core/src/test/java/com/yandex/yoctodb/util/immutable/ByteArraySortedSetTest.java +++ b/core/src/test/java/com/yandex/yoctodb/util/immutable/ByteArraySortedSetTest.java @@ -58,6 +58,141 @@ public void buildingFromFixedLengthByteArraySortedSetTest() } } + @Test + public void buildingFromFixedLengthByteArraySortedSetTestLongUnsafe() + throws IOException { + //unsorted elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from(0L)); + elements.add(UnsignedByteArrays.from(1L)); + elements.add(UnsignedByteArrays.from(2L)); + elements.add(UnsignedByteArrays.from(3L)); + elements.add(UnsignedByteArrays.from(4L)); + + final Buffer bb = + prepareDataFromFixedLengthByteArraySortedSet(elements); + final ByteArraySortedSet ss = + FixedLengthByteArraySortedSet.from(bb); + + assertEquals(elements.size(), ss.size()); + + //sorting to compare + Collections.sort(elements); + + for (int i = 0; i < elements.size(); i++) { + final long puttedValue = elements.get(i).toByteBuffer().getLong() ^ Long.MIN_VALUE; + assertEquals(puttedValue, ss.getLongUnsafe(i)); + } + } + + @Test + public void buildingFromFixedLengthByteArraySortedSetTestIntUnsafe() + throws IOException { + //unsorted elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from(0)); + elements.add(UnsignedByteArrays.from(1)); + elements.add(UnsignedByteArrays.from(2)); + elements.add(UnsignedByteArrays.from(3)); + elements.add(UnsignedByteArrays.from(4)); + + final Buffer bb = + prepareDataFromFixedLengthByteArraySortedSet(elements); + final ByteArraySortedSet ss = + FixedLengthByteArraySortedSet.from(bb); + + assertEquals(elements.size(), ss.size()); + + //sorting to compare + Collections.sort(elements); + + for (int i = 0; i < elements.size(); i++) { + final long puttedValue = elements.get(i).toByteBuffer().getInt() ^ Integer.MIN_VALUE; + assertEquals(puttedValue, ss.getIntUnsafe(i)); + } + } + + @Test + public void buildingFromFixedLengthByteArraySortedSetTestShortUnsafe() + throws IOException { + //unsorted elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from((short) 0)); + elements.add(UnsignedByteArrays.from((short) 1)); + elements.add(UnsignedByteArrays.from((short) 2)); + elements.add(UnsignedByteArrays.from((short) 3)); + elements.add(UnsignedByteArrays.from((short) 4)); + + final Buffer bb = + prepareDataFromFixedLengthByteArraySortedSet(elements); + final ByteArraySortedSet ss = + FixedLengthByteArraySortedSet.from(bb); + + assertEquals(elements.size(), ss.size()); + + //sorting to compare + Collections.sort(elements); + + for (int i = 0; i < elements.size(); i++) { + final long puttedValue = elements.get(i).toByteBuffer().getShort() ^ Short.MIN_VALUE; + assertEquals(puttedValue, ss.getShortUnsafe(i)); + } + } + + @Test + public void buildingFromFixedLengthByteArraySortedSetTestCharUnsafe() + throws IOException { + //unsorted elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from('a')); + elements.add(UnsignedByteArrays.from('b')); + elements.add(UnsignedByteArrays.from('c')); + elements.add(UnsignedByteArrays.from('d')); + elements.add(UnsignedByteArrays.from('e')); + + final Buffer bb = + prepareDataFromFixedLengthByteArraySortedSet(elements); + final ByteArraySortedSet ss = + FixedLengthByteArraySortedSet.from(bb); + + assertEquals(elements.size(), ss.size()); + + //sorting to compare + Collections.sort(elements); + + for (int i = 0; i < elements.size(); i++) { + final long puttedValue = elements.get(i).toByteBuffer().getChar(); + assertEquals(puttedValue, ss.getCharUnsafe(i)); + } + } + + @Test + public void buildingFromFixedLengthByteArraySortedSetTestByteUnsafe() + throws IOException { + //unsorted elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from((byte) -128)); + elements.add(UnsignedByteArrays.from((byte) 123)); + elements.add(UnsignedByteArrays.from((byte) 2)); + elements.add(UnsignedByteArrays.from((byte) 3)); + elements.add(UnsignedByteArrays.from((byte) 127)); + + final Buffer bb = + prepareDataFromFixedLengthByteArraySortedSet(elements); + final ByteArraySortedSet ss = + FixedLengthByteArraySortedSet.from(bb); + + assertEquals(elements.size(), ss.size()); + + //sorting to compare + Collections.sort(elements); + + for (int i = 0; i < elements.size(); i++) { + final long puttedValue = elements.get(i).toByteBuffer().get() ^ Byte.MIN_VALUE; + assertEquals(puttedValue, ss.getByteUnsafe(i)); + } + } + private Buffer prepareDataFromFixedLengthByteArraySortedSet( final Collection items) throws IOException { final SortedSet elements = @@ -105,6 +240,141 @@ public void buildingFromVariableLengthByteArraySortedSetTest() } } + @Test + public void buildingFromVariableLengthByteArraySortedSetTestLongUnsafe() + throws IOException { + //elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from(0L)); + elements.add(UnsignedByteArrays.from(1L)); + elements.add(UnsignedByteArrays.from(2L)); + elements.add(UnsignedByteArrays.from(3L)); + elements.add(UnsignedByteArrays.from(4L)); + + final Buffer bb = + prepareDataFromVariableLengthByteArraySortedSet(elements); + final ByteArraySortedSet ss = + VariableLengthByteArraySortedSet.from(bb); + + assertEquals(elements.size(), ss.size()); + + //sorting to compare + Collections.sort(elements); + + for (int i = 0; i < elements.size(); i++) { + final long puttedValue = elements.get(i).toByteBuffer().getLong() ^ Long.MIN_VALUE; + assertEquals(puttedValue, ss.getLongUnsafe(i)); + } + } + + @Test + public void buildingFromVariableLengthByteArraySortedSetTestIntUnsafe() + throws IOException { + //elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from(0)); + elements.add(UnsignedByteArrays.from(1)); + elements.add(UnsignedByteArrays.from(2)); + elements.add(UnsignedByteArrays.from(3)); + elements.add(UnsignedByteArrays.from(4)); + + final Buffer bb = + prepareDataFromVariableLengthByteArraySortedSet(elements); + final ByteArraySortedSet ss = + VariableLengthByteArraySortedSet.from(bb); + + assertEquals(elements.size(), ss.size()); + + //sorting to compare + Collections.sort(elements); + + for (int i = 0; i < elements.size(); i++) { + final long puttedValue = elements.get(i).toByteBuffer().getInt() ^ Integer.MIN_VALUE; + assertEquals(puttedValue, ss.getIntUnsafe(i)); + } + } + + @Test + public void buildingFromVariableLengthByteArraySortedSetTestShortUnsafe() + throws IOException { + //elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from((short) 0)); + elements.add(UnsignedByteArrays.from((short) 1)); + elements.add(UnsignedByteArrays.from((short) 2)); + elements.add(UnsignedByteArrays.from((short) 3)); + elements.add(UnsignedByteArrays.from((short) 4)); + + final Buffer bb = + prepareDataFromVariableLengthByteArraySortedSet(elements); + final ByteArraySortedSet ss = + VariableLengthByteArraySortedSet.from(bb); + + assertEquals(elements.size(), ss.size()); + + //sorting to compare + Collections.sort(elements); + + for (int i = 0; i < elements.size(); i++) { + final long puttedValue = elements.get(i).toByteBuffer().getShort() ^ Short.MIN_VALUE; + assertEquals(puttedValue, ss.getShortUnsafe(i)); + } + } + + @Test + public void buildingFromVariableLengthByteArraySortedSetTestCharUnsafe() + throws IOException { + //elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from('a')); + elements.add(UnsignedByteArrays.from('b')); + elements.add(UnsignedByteArrays.from('c')); + elements.add(UnsignedByteArrays.from('d')); + elements.add(UnsignedByteArrays.from('e')); + + final Buffer bb = + prepareDataFromVariableLengthByteArraySortedSet(elements); + final ByteArraySortedSet ss = + VariableLengthByteArraySortedSet.from(bb); + + assertEquals(elements.size(), ss.size()); + + //sorting to compare + Collections.sort(elements); + + for (int i = 0; i < elements.size(); i++) { + final long puttedValue = elements.get(i).toByteBuffer().getChar(); + assertEquals(puttedValue, ss.getCharUnsafe(i)); + } + } + + @Test + public void buildingFromVariableLengthByteArraySortedSetTestByteUnsafe() + throws IOException { + //elements + final List elements = new ArrayList<>(); + elements.add(UnsignedByteArrays.from((byte) 0)); + elements.add(UnsignedByteArrays.from((byte) 1)); + elements.add(UnsignedByteArrays.from((byte) 2)); + elements.add(UnsignedByteArrays.from((byte) 3)); + elements.add(UnsignedByteArrays.from((byte) 4)); + + final Buffer bb = + prepareDataFromVariableLengthByteArraySortedSet(elements); + final ByteArraySortedSet ss = + VariableLengthByteArraySortedSet.from(bb); + + assertEquals(elements.size(), ss.size()); + + //sorting to compare + Collections.sort(elements); + + for (int i = 0; i < elements.size(); i++) { + final long puttedValue = elements.get(i).toByteBuffer().get() ^ Byte.MIN_VALUE; + assertEquals(puttedValue, ss.getByteUnsafe(i)); + } + } + private Buffer prepareDataFromVariableLengthByteArraySortedSet( final Collection items) throws IOException { final SortedSet elements = diff --git a/core/src/test/java/com/yandex/yoctodb/util/immutable/impl/FoldedByteArrayIndexedListTest.java b/core/src/test/java/com/yandex/yoctodb/util/immutable/impl/FoldedByteArrayIndexedListTest.java index b3f2cdbc..d0b291b6 100644 --- a/core/src/test/java/com/yandex/yoctodb/util/immutable/impl/FoldedByteArrayIndexedListTest.java +++ b/core/src/test/java/com/yandex/yoctodb/util/immutable/impl/FoldedByteArrayIndexedListTest.java @@ -1,3 +1,13 @@ +/* + * (C) YANDEX LLC, 2014-2016 + * + * The Source Code called "YoctoDB" available at + * https://github.com/yandex/yoctodb is subject to the terms of the + * Mozilla Public License, v. 2.0 (hereinafter referred to as the "License"). + * + * A copy of the License is also available at http://mozilla.org/MPL/2.0/. + */ + package com.yandex.yoctodb.util.immutable.impl; import com.yandex.yoctodb.util.UnsignedByteArray; @@ -56,7 +66,7 @@ public void testBytesFolding() throws IOException { } @Test - public void tesShortFolding() throws IOException { + public void testShortFolding() throws IOException { assertTrue(build(1000).toString().contains(Integer.toString(1000))); } diff --git a/core/src/test/java/com/yandex/yoctodb/util/immutable/impl/TrieByteArraySortedSetTest.java b/core/src/test/java/com/yandex/yoctodb/util/immutable/impl/TrieByteArraySortedSetTest.java index 87d021e6..1a3a6abf 100644 --- a/core/src/test/java/com/yandex/yoctodb/util/immutable/impl/TrieByteArraySortedSetTest.java +++ b/core/src/test/java/com/yandex/yoctodb/util/immutable/impl/TrieByteArraySortedSetTest.java @@ -156,6 +156,31 @@ public void get() { trieSet.get(0); } + @Test(expected = UnsupportedOperationException.class) + public void getLongUnsafe() { + trieSet.getLongUnsafe(0); + } + + @Test(expected = UnsupportedOperationException.class) + public void getIntUnsafe() { + trieSet.getIntUnsafe(0); + } + + @Test(expected = UnsupportedOperationException.class) + public void getShortUnsafe() { + trieSet.getShortUnsafe(0); + } + + @Test(expected = UnsupportedOperationException.class) + public void getCharUnsafe() { + trieSet.getCharUnsafe(0); + } + + @Test(expected = UnsupportedOperationException.class) + public void getByteUnsafe() { + trieSet.getByteUnsafe(0); + } + @Test public void indexOfMutable() { for (String q : keys) {