Row.java
/*
* 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.arrow.vector.table;
import java.math.BigDecimal;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.time.LocalDateTime;
import java.time.Period;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import org.apache.arrow.memory.ArrowBuf;
import org.apache.arrow.vector.BigIntVector;
import org.apache.arrow.vector.BitVector;
import org.apache.arrow.vector.DateDayVector;
import org.apache.arrow.vector.DateMilliVector;
import org.apache.arrow.vector.DecimalVector;
import org.apache.arrow.vector.DurationVector;
import org.apache.arrow.vector.FieldVector;
import org.apache.arrow.vector.FixedSizeBinaryVector;
import org.apache.arrow.vector.Float4Vector;
import org.apache.arrow.vector.Float8Vector;
import org.apache.arrow.vector.IntVector;
import org.apache.arrow.vector.IntervalDayVector;
import org.apache.arrow.vector.IntervalMonthDayNanoVector;
import org.apache.arrow.vector.IntervalYearVector;
import org.apache.arrow.vector.LargeVarBinaryVector;
import org.apache.arrow.vector.LargeVarCharVector;
import org.apache.arrow.vector.PeriodDuration;
import org.apache.arrow.vector.SmallIntVector;
import org.apache.arrow.vector.TimeMicroVector;
import org.apache.arrow.vector.TimeMilliVector;
import org.apache.arrow.vector.TimeNanoVector;
import org.apache.arrow.vector.TimeSecVector;
import org.apache.arrow.vector.TimeStampMicroTZVector;
import org.apache.arrow.vector.TimeStampMicroVector;
import org.apache.arrow.vector.TimeStampMilliTZVector;
import org.apache.arrow.vector.TimeStampMilliVector;
import org.apache.arrow.vector.TimeStampNanoTZVector;
import org.apache.arrow.vector.TimeStampNanoVector;
import org.apache.arrow.vector.TimeStampSecTZVector;
import org.apache.arrow.vector.TimeStampSecVector;
import org.apache.arrow.vector.TinyIntVector;
import org.apache.arrow.vector.UInt1Vector;
import org.apache.arrow.vector.UInt2Vector;
import org.apache.arrow.vector.UInt4Vector;
import org.apache.arrow.vector.UInt8Vector;
import org.apache.arrow.vector.ValueVector;
import org.apache.arrow.vector.VarBinaryVector;
import org.apache.arrow.vector.VarCharVector;
import org.apache.arrow.vector.complex.DenseUnionVector;
import org.apache.arrow.vector.complex.ListVector;
import org.apache.arrow.vector.complex.StructVector;
import org.apache.arrow.vector.complex.UnionVector;
import org.apache.arrow.vector.holders.NullableBigIntHolder;
import org.apache.arrow.vector.holders.NullableBitHolder;
import org.apache.arrow.vector.holders.NullableDateDayHolder;
import org.apache.arrow.vector.holders.NullableDateMilliHolder;
import org.apache.arrow.vector.holders.NullableDecimalHolder;
import org.apache.arrow.vector.holders.NullableDurationHolder;
import org.apache.arrow.vector.holders.NullableFloat4Holder;
import org.apache.arrow.vector.holders.NullableFloat8Holder;
import org.apache.arrow.vector.holders.NullableIntHolder;
import org.apache.arrow.vector.holders.NullableIntervalDayHolder;
import org.apache.arrow.vector.holders.NullableIntervalMonthDayNanoHolder;
import org.apache.arrow.vector.holders.NullableIntervalYearHolder;
import org.apache.arrow.vector.holders.NullableSmallIntHolder;
import org.apache.arrow.vector.holders.NullableTimeMicroHolder;
import org.apache.arrow.vector.holders.NullableTimeMilliHolder;
import org.apache.arrow.vector.holders.NullableTimeNanoHolder;
import org.apache.arrow.vector.holders.NullableTimeSecHolder;
import org.apache.arrow.vector.holders.NullableTimeStampMicroHolder;
import org.apache.arrow.vector.holders.NullableTimeStampMicroTZHolder;
import org.apache.arrow.vector.holders.NullableTimeStampMilliHolder;
import org.apache.arrow.vector.holders.NullableTimeStampMilliTZHolder;
import org.apache.arrow.vector.holders.NullableTimeStampNanoHolder;
import org.apache.arrow.vector.holders.NullableTimeStampNanoTZHolder;
import org.apache.arrow.vector.holders.NullableTimeStampSecHolder;
import org.apache.arrow.vector.holders.NullableTimeStampSecTZHolder;
import org.apache.arrow.vector.holders.NullableTinyIntHolder;
import org.apache.arrow.vector.holders.NullableUInt1Holder;
import org.apache.arrow.vector.holders.NullableUInt2Holder;
import org.apache.arrow.vector.holders.NullableUInt4Holder;
import org.apache.arrow.vector.holders.NullableUInt8Holder;
/**
* Row is a positionable, immutable cursor backed by a {@link Table}.
*
* <p>Getters are provided for most vector types. The exceptions being {@link
* org.apache.arrow.vector.NullVector}, which only contains null values and has no getter, and
* {@link org.apache.arrow.vector.ZeroVector}, which is a zero-length vector of any type
*
* <p>This API is EXPERIMENTAL.
*/
public class Row implements Iterator<Row> {
/**
* Returns the standard character set to use for decoding strings. The Arrow format only supports
* UTF-8.
*/
private static final Charset DEFAULT_CHARACTER_SET = StandardCharsets.UTF_8;
/** The table we're enumerating. */
protected final BaseTable table;
/** the current row number. */
protected int rowNumber = -1;
/** Indicates whether the next non-deleted row has been determined yet. */
private boolean nextRowSet;
/**
* An iterator that returns every row in the table, deleted or not. The implemented next() and
* hasNext() methods in Row wrap it with a filter to get only the non-deleted ones.
*/
private final Iterator<Integer> iterator = intIterator();
/**
* Constructs a new Row backed by the given table.
*
* @param table the table that this Row object represents
*/
public Row(BaseTable table) {
this.table = table;
}
/** Resets the current row to -1 and returns this object. */
public Row resetPosition() {
rowNumber = -1;
return this;
}
/**
* Moves this Row to the given 0-based row index.
*
* @return this Row for chaining
*/
public Row setPosition(int rowNumber) {
this.rowNumber = rowNumber;
this.nextRowSet = false;
return this;
}
/**
* For vectors other than Union and DenseUnion, returns true if the value at columnName is null,
* and false otherwise.
*
* <p>UnionVector#isNull always returns false, but the underlying vector may hold null values.
*/
public boolean isNull(String columnName) {
ValueVector vector = table.getVector(columnName);
return vector.isNull(rowNumber);
}
/**
* For vectors other than Union and DenseUnion, returns true if the value at columnIndex is null,
* and false otherwise.
*
* <p>UnionVector#isNull always returns false, but the underlying vector may hold null values.
*/
public boolean isNull(int columnIndex) {
ValueVector vector = table.getVector(columnIndex);
return vector.isNull(rowNumber);
}
/**
* Returns an object representing the value in the ExtensionTypeVector at the currentRow and
* vectorIndex. An IllegalArgumentException is thrown if the column is not present in the Row and
* a ClassCastException is thrown if the type is incorrect.
*/
public Object getExtensionType(int vectorIndex) {
FieldVector vector = table.getVector(vectorIndex);
return vector.getObject(rowNumber);
}
/**
* Returns an object representing the value in the named ExtensionTypeVector at the currentRow. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type.
*
* @param columnName The name of the vector providing the result
* @return The object in the named column at the current row
*/
public Object getExtensionType(String columnName) {
FieldVector vector = table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns a Map from the column of the given vectorIndex at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type.
*/
public List<?> getMap(int vectorIndex) {
ListVector vector = (ListVector) table.getVector(vectorIndex);
return vector.getObject(rowNumber);
}
/**
* Returns a Map from the column of the given name at the current row. An IllegalArgumentException
* is thrown if the column is not present in the Row and a ClassCastException is thrown if it has
* a different type
*/
public List<?> getMap(String columnName) {
ListVector vector = (ListVector) table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns an Object from the column at vectorIndex at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*/
public Object getStruct(int vectorIndex) {
StructVector vector = (StructVector) table.getVector(vectorIndex);
return vector.getObject(rowNumber);
}
/**
* Returns an Object from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*/
public Object getStruct(String columnName) {
StructVector vector = (StructVector) table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns an Object from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*/
public Object getUnion(int vectorIndex) {
UnionVector vector = (UnionVector) table.getVector(vectorIndex);
return vector.getObject(rowNumber);
}
/**
* Returns an Object from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*/
public Object getUnion(String columnName) {
UnionVector vector = (UnionVector) table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns an Object from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*/
public Object getDenseUnion(String columnName) {
DenseUnionVector vector = (DenseUnionVector) table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns an Object from the column with the given vectorIndex at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*/
public Object getDenseUnion(int vectorIndex) {
DenseUnionVector vector = (DenseUnionVector) table.getVector(vectorIndex);
return vector.getObject(rowNumber);
}
/**
* Returns a List from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*/
public List<?> getList(String columnName) {
ListVector vector = (ListVector) table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns a List from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present and a ClassCastException is
* thrown if it has a different type
*/
public List<?> getList(int columnIndex) {
ListVector vector = (ListVector) table.getVector(columnIndex);
return vector.getObject(rowNumber);
}
/**
* Returns an int from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*/
public int getInt(String columnName) {
IntVector vector = (IntVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns an int from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present and a ClassCastException is
* thrown if it has a different type
*/
public int getInt(int columnIndex) {
IntVector vector = (IntVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value in the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*/
public void getInt(String columnName, NullableIntHolder holder) {
IntVector vector = (IntVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value in the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present and a ClassCastException is
* thrown if it has a different type
*/
public void getInt(int columnIndex, NullableIntHolder holder) {
IntVector vector = (IntVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns an int from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*/
public int getUInt4(String columnName) {
UInt4Vector vector = (UInt4Vector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns an int from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present and a ClassCastException is
* thrown if it has a different type
*/
public int getUInt4(int columnIndex) {
UInt4Vector vector = (UInt4Vector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value at the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*/
public void getUInt4(String columnName, NullableUInt4Holder holder) {
UInt4Vector vector = (UInt4Vector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value at the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present and a ClassCastException is
* thrown if it has a different type
*/
public void getUInt4(int columnIndex, NullableUInt4Holder holder) {
UInt4Vector vector = (UInt4Vector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a short from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public short getSmallInt(String columnName) {
SmallIntVector vector = (SmallIntVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a short from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public short getSmallInt(int columnIndex) {
SmallIntVector vector = (SmallIntVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value in the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getSmallInt(String columnName, NullableSmallIntHolder holder) {
SmallIntVector vector = (SmallIntVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value in the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getSmallInt(int columnIndex, NullableSmallIntHolder holder) {
SmallIntVector vector = (SmallIntVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a char from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public char getUInt2(String columnName) {
UInt2Vector vector = (UInt2Vector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a char from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public char getUInt2(int columnIndex) {
UInt2Vector vector = (UInt2Vector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value in the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getUInt2(String columnName, NullableUInt2Holder holder) {
UInt2Vector vector = (UInt2Vector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value in the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getUInt2(int columnIndex, NullableUInt2Holder holder) {
UInt2Vector vector = (UInt2Vector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a byte from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public byte getTinyInt(String columnName) {
TinyIntVector vector = (TinyIntVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a byte from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public byte getTinyInt(int columnIndex) {
TinyIntVector vector = (TinyIntVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value in the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTinyInt(String columnName, NullableTinyIntHolder holder) {
TinyIntVector vector = (TinyIntVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value in the column at the given index and current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTinyInt(int columnIndex, NullableTinyIntHolder holder) {
TinyIntVector vector = (TinyIntVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a byte from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public byte getUInt1(String columnName) {
UInt1Vector vector = (UInt1Vector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a byte from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public byte getUInt1(int columnIndex) {
UInt1Vector vector = (UInt1Vector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value in the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getUInt1(String columnName, NullableUInt1Holder holder) {
UInt1Vector vector = (UInt1Vector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value in the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getUInt1(int columnIndex, NullableUInt1Holder holder) {
UInt1Vector vector = (UInt1Vector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a long from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getBigInt(String columnName) {
BigIntVector vector = (BigIntVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a long from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getBigInt(int columnIndex) {
BigIntVector vector = (BigIntVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value in the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getBigInt(String columnName, NullableBigIntHolder holder) {
BigIntVector vector = (BigIntVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value in the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getBigInt(int columnIndex, NullableBigIntHolder holder) {
BigIntVector vector = (BigIntVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a long from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getUInt8(String columnName) {
UInt8Vector vector = (UInt8Vector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a long from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getUInt8(int columnIndex) {
UInt8Vector vector = (UInt8Vector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value in the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getUInt8(String columnName, NullableUInt8Holder holder) {
UInt8Vector vector = (UInt8Vector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value in the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getUInt8(int columnIndex, NullableUInt8Holder holder) {
UInt8Vector vector = (UInt8Vector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a float from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public float getFloat4(String columnName) {
Float4Vector vector = (Float4Vector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a float from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public float getFloat4(int columnIndex) {
Float4Vector vector = (Float4Vector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value in the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getFloat4(String columnName, NullableFloat4Holder holder) {
Float4Vector vector = (Float4Vector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value in the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getFloat4(int columnIndex, NullableFloat4Holder holder) {
Float4Vector vector = (Float4Vector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a double from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public double getFloat8(String columnName) {
Float8Vector vector = (Float8Vector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a double from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public double getFloat8(int columnIndex) {
Float8Vector vector = (Float8Vector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value in the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getFloat8(String columnName, NullableFloat8Holder holder) {
Float8Vector vector = (Float8Vector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value in the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getFloat8(int columnIndex, NullableFloat8Holder holder) {
Float8Vector vector = (Float8Vector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns an int from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public int getBit(String columnName) {
BitVector vector = (BitVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns an int from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public int getBit(int columnIndex) {
BitVector vector = (BitVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value in the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getBit(String columnName, NullableBitHolder holder) {
BitVector vector = (BitVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value in the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getBit(int columnIndex, NullableBitHolder holder) {
BitVector vector = (BitVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a long from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public long getDateMilli(String columnName) {
DateMilliVector vector = (DateMilliVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a long from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public long getDateMilli(int columnIndex) {
DateMilliVector vector = (DateMilliVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value in the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getDateMilli(String columnName, NullableDateMilliHolder holder) {
DateMilliVector vector = (DateMilliVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value in the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getDateMilli(int columnIndex, NullableDateMilliHolder holder) {
DateMilliVector vector = (DateMilliVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns an int from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public int getDateDay(String columnName) {
DateDayVector vector = (DateDayVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns an int from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public int getDateDay(int columnIndex) {
DateDayVector vector = (DateDayVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value in the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getDateDay(String columnName, NullableDateDayHolder holder) {
DateDayVector vector = (DateDayVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value in the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getDateDay(int columnIndex, NullableDateDayHolder holder) {
DateDayVector vector = (DateDayVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a long from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeNano(String columnName) {
TimeNanoVector vector = (TimeNanoVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a long from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeNano(int columnIndex) {
TimeNanoVector vector = (TimeNanoVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value in the column with the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeNano(String columnName, NullableTimeNanoHolder holder) {
TimeNanoVector vector = (TimeNanoVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value in the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public void getTimeNano(int columnIndex, NullableTimeNanoHolder holder) {
TimeNanoVector vector = (TimeNanoVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a long from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public long getTimeMicro(String columnName) {
TimeMicroVector vector = (TimeMicroVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a long from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public long getTimeMicro(int columnIndex) {
TimeMicroVector vector = (TimeMicroVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public void getTimeMicro(String columnName, NullableTimeMicroHolder holder) {
TimeMicroVector vector = (TimeMicroVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public void getTimeMicro(int columnIndex, NullableTimeMicroHolder holder) {
TimeMicroVector vector = (TimeMicroVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns an int from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public int getTimeMilli(String columnName) {
TimeMilliVector vector = (TimeMilliVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns an int from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public int getTimeMilli(int columnIndex) {
TimeMilliVector vector = (TimeMilliVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public void getTimeMilli(String columnName, NullableTimeMilliHolder holder) {
TimeMilliVector vector = (TimeMilliVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public void getTimeMilli(int columnIndex, NullableTimeMilliHolder holder) {
TimeMilliVector vector = (TimeMilliVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a LocalDateTime from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public LocalDateTime getTimeMilliObj(String columnName) {
TimeMilliVector vector = (TimeMilliVector) table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns a LocalDateTime from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public LocalDateTime getTimeMilliObj(int columnIndex) {
TimeMilliVector vector = (TimeMilliVector) table.getVector(columnIndex);
return vector.getObject(rowNumber);
}
/**
* Returns an int from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public int getTimeSec(String columnName) {
TimeSecVector vector = (TimeSecVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns an int from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public int getTimeSec(int columnIndex) {
TimeSecVector vector = (TimeSecVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public void getTimeSec(String columnName, NullableTimeSecHolder holder) {
TimeSecVector vector = (TimeSecVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public void getTimeSec(int columnIndex, NullableTimeSecHolder holder) {
TimeSecVector vector = (TimeSecVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a long from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type.
*/
public long getTimeStampSec(String columnName) {
TimeStampSecVector vector = (TimeStampSecVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a long from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeStampSec(int columnIndex) {
TimeStampSecVector vector = (TimeStampSecVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeStampSec(String columnName, NullableTimeStampSecHolder holder) {
TimeStampSecVector vector = (TimeStampSecVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeStampSec(int columnIndex, NullableTimeStampSecHolder holder) {
TimeStampSecVector vector = (TimeStampSecVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a LocalDateTime from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public LocalDateTime getTimeStampSecObj(String columnName) {
TimeStampSecVector vector = (TimeStampSecVector) table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns a LocalDateTime from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public LocalDateTime getTimeStampSecObj(int columnIndex) {
TimeStampSecVector vector = (TimeStampSecVector) table.getVector(columnIndex);
return vector.getObject(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeStampSecTZ(String columnName) {
TimeStampSecTZVector vector = (TimeStampSecTZVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a long from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeStampSecTZ(int columnIndex) {
TimeStampSecTZVector vector = (TimeStampSecTZVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeStampSecTZ(String columnName, NullableTimeStampSecTZHolder holder) {
TimeStampSecTZVector vector = (TimeStampSecTZVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeStampSecTZ(int columnIndex, NullableTimeStampSecTZHolder holder) {
TimeStampSecTZVector vector = (TimeStampSecTZVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a long from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeStampNano(String columnName) {
TimeStampNanoVector vector = (TimeStampNanoVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a long from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeStampNano(int columnIndex) {
TimeStampNanoVector vector = (TimeStampNanoVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeStampNano(String columnName, NullableTimeStampNanoHolder holder) {
TimeStampNanoVector vector = (TimeStampNanoVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeStampNano(int columnIndex, NullableTimeStampNanoHolder holder) {
TimeStampNanoVector vector = (TimeStampNanoVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a LocalDateTime from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public LocalDateTime getTimeStampNanoObj(String columnName) {
TimeStampNanoVector vector = (TimeStampNanoVector) table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns a LocalDateTime from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public LocalDateTime getTimeStampNanoObj(int columnIndex) {
TimeStampNanoVector vector = (TimeStampNanoVector) table.getVector(columnIndex);
return vector.getObject(rowNumber);
}
/**
* Returns a long from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeStampNanoTZ(String columnName) {
TimeStampNanoTZVector vector = (TimeStampNanoTZVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a long from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeStampNanoTZ(int columnIndex) {
TimeStampNanoTZVector vector = (TimeStampNanoTZVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeStampNanoTZ(String columnName, NullableTimeStampNanoTZHolder holder) {
TimeStampNanoTZVector vector = (TimeStampNanoTZVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeStampNanoTZ(int columnIndex, NullableTimeStampNanoTZHolder holder) {
TimeStampNanoTZVector vector = (TimeStampNanoTZVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a long from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeStampMilli(String columnName) {
TimeStampMilliVector vector = (TimeStampMilliVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a long from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeStampMilli(int columnIndex) {
TimeStampMilliVector vector = (TimeStampMilliVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeStampMilli(String columnName, NullableTimeStampMilliHolder holder) {
TimeStampMilliVector vector = (TimeStampMilliVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeStampMilli(int columnIndex, NullableTimeStampMilliHolder holder) {
TimeStampMilliVector vector = (TimeStampMilliVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a LocalDateTime from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public LocalDateTime getTimeStampMilliObj(String columnName) {
TimeStampMilliVector vector = (TimeStampMilliVector) table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns a LocalDateTime from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public LocalDateTime getTimeStampMilliObj(int columnIndex) {
TimeStampMilliVector vector = (TimeStampMilliVector) table.getVector(columnIndex);
return vector.getObject(rowNumber);
}
/**
* Returns a long from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeStampMilliTZ(String columnName) {
TimeStampMilliTZVector vector = (TimeStampMilliTZVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a long from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeStampMilliTZ(int columnIndex) {
TimeStampMilliTZVector vector = (TimeStampMilliTZVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different types
*/
public void getTimeStampMilliTZ(String columnName, NullableTimeStampMilliTZHolder holder) {
TimeStampMilliTZVector vector = (TimeStampMilliTZVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeStampMilliTZ(int columnIndex, NullableTimeStampMilliTZHolder holder) {
TimeStampMilliTZVector vector = (TimeStampMilliTZVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a long from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeStampMicro(String columnName) {
TimeStampMicroVector vector = (TimeStampMicroVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a long from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeStampMicro(int columnIndex) {
TimeStampMicroVector vector = (TimeStampMicroVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeStampMicro(String columnName, NullableTimeStampMicroHolder holder) {
TimeStampMicroVector vector = (TimeStampMicroVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeStampMicro(int columnIndex, NullableTimeStampMicroHolder holder) {
TimeStampMicroVector vector = (TimeStampMicroVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a LocalDateTime from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public LocalDateTime getTimeStampMicroObj(String columnName) {
TimeStampMicroVector vector = (TimeStampMicroVector) table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns a LocalDateTime from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public LocalDateTime getTimeStampMicroObj(int columnIndex) {
TimeStampMicroVector vector = (TimeStampMicroVector) table.getVector(columnIndex);
return vector.getObject(rowNumber);
}
/**
* Returns a long from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeStampMicroTZ(String columnName) {
TimeStampMicroTZVector vector = (TimeStampMicroTZVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a long from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public long getTimeStampMicroTZ(int columnIndex) {
TimeStampMicroTZVector vector = (TimeStampMicroTZVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeStampMicroTZ(String columnName, NullableTimeStampMicroTZHolder holder) {
TimeStampMicroTZVector vector = (TimeStampMicroTZVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getTimeStampMicroTZ(int columnIndex, NullableTimeStampMicroTZHolder holder) {
TimeStampMicroTZVector vector = (TimeStampMicroTZVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a Duration from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public Duration getDurationObj(String columnName) {
DurationVector vector = (DurationVector) table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns a Duration from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public Duration getDurationObj(int columnIndex) {
DurationVector vector = (DurationVector) table.getVector(columnIndex);
return vector.getObject(rowNumber);
}
/**
* Returns an ArrowBuf from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public ArrowBuf getDuration(String columnName) {
DurationVector vector = (DurationVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns an ArrowBuf from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public ArrowBuf getDuration(int columnIndex) {
DurationVector vector = (DurationVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getDuration(String columnName, NullableDurationHolder holder) {
DurationVector vector = (DurationVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getDuration(int columnIndex, NullableDurationHolder holder) {
DurationVector vector = (DurationVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a PeriodDuration from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public PeriodDuration getIntervalMonthDayNanoObj(String columnName) {
IntervalMonthDayNanoVector vector = (IntervalMonthDayNanoVector) table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns a PeriodDuration from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public PeriodDuration getIntervalMonthDayNanoObj(int columnIndex) {
IntervalMonthDayNanoVector vector = (IntervalMonthDayNanoVector) table.getVector(columnIndex);
return vector.getObject(rowNumber);
}
/**
* Returns an ArrowBuf from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public ArrowBuf getIntervalMonthDayNano(String columnName) {
IntervalMonthDayNanoVector vector = (IntervalMonthDayNanoVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns an ArrowBuf from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public ArrowBuf getIntervalMonthDayNano(int columnIndex) {
IntervalMonthDayNanoVector vector = (IntervalMonthDayNanoVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getIntervalMonthDayNano(
String columnName, NullableIntervalMonthDayNanoHolder holder) {
IntervalMonthDayNanoVector vector = (IntervalMonthDayNanoVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getIntervalMonthDayNano(int columnIndex, NullableIntervalMonthDayNanoHolder holder) {
IntervalMonthDayNanoVector vector = (IntervalMonthDayNanoVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns an ArrowBuf from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public ArrowBuf getIntervalDay(String columnName) {
IntervalDayVector vector = (IntervalDayVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns an ArrowBuf from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public ArrowBuf getIntervalDay(int columnIndex) {
IntervalDayVector vector = (IntervalDayVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getIntervalDay(String columnName, NullableIntervalDayHolder holder) {
IntervalDayVector vector = (IntervalDayVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getIntervalDay(int columnIndex, NullableIntervalDayHolder holder) {
IntervalDayVector vector = (IntervalDayVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Returns a Duration from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public Duration getIntervalDayObj(int columnIndex) {
IntervalDayVector vector = (IntervalDayVector) table.getVector(columnIndex);
return vector.getObject(rowNumber);
}
/**
* Returns a Duration from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public Duration getIntervalDayObj(String columnName) {
IntervalDayVector vector = (IntervalDayVector) table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns a Period from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*
* @return a Period of n MONTHS, not YEARS
*/
public Period getIntervalYearObj(String columnName) {
IntervalYearVector vector = (IntervalYearVector) table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns a Period from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*
* @return a Period of n MONTHS, not YEARS
*/
public Period getIntervalYearObj(int columnIndex) {
IntervalYearVector vector = (IntervalYearVector) table.getVector(columnIndex);
return vector.getObject(rowNumber);
}
/**
* Returns an int from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*
* @return the number of MONTHS in the interval (not YEARS)
*/
public int getIntervalYear(String columnName) {
IntervalYearVector vector = (IntervalYearVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns an int from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*
* @return the number of MONTHS in the interval (not YEARS)
*/
public int getIntervalYear(int columnIndex) {
IntervalYearVector vector = (IntervalYearVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Updates the holder with the value from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*
* @param holder a holder to store the interval. Note that the value of the holder represents
* MONTHS not years
*/
public void getIntervalYear(String columnName, NullableIntervalYearHolder holder) {
IntervalYearVector vector = (IntervalYearVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Updates the holder with the value from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*
* @param holder a holder to store the interval. Note that the value of the holder represents
* MONTHS not years
*/
public void getIntervalYear(int columnIndex, NullableIntervalYearHolder holder) {
IntervalYearVector vector = (IntervalYearVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Updates the value of the holder with data from vector at the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getDecimal(int columnIndex, NullableDecimalHolder holder) {
DecimalVector vector = (DecimalVector) table.getVector(columnIndex);
vector.get(rowNumber, holder);
}
/**
* Updates the value of the holder with data from the vector with given name at the current row.
* An IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public void getDecimal(String columnName, NullableDecimalHolder holder) {
DecimalVector vector = (DecimalVector) table.getVector(columnName);
vector.get(rowNumber, holder);
}
/**
* Returns a BigDecimal from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public BigDecimal getDecimalObj(String columnName) {
DecimalVector vector = (DecimalVector) table.getVector(columnName);
return vector.getObject(rowNumber);
}
/**
* Returns a BigDecimal from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public BigDecimal getDecimalObj(int columnIndex) {
DecimalVector vector = (DecimalVector) table.getVector(columnIndex);
return vector.getObject(rowNumber);
}
/**
* Returns an ArrowBuf from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public ArrowBuf getDecimal(String columnName) {
DecimalVector vector = (DecimalVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns an ArrowBuf from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public ArrowBuf getDecimal(int columnIndex) {
DecimalVector vector = (DecimalVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Returns a byte[] from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public byte[] getVarBinary(String columnName) {
VarBinaryVector vector = (VarBinaryVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a byte[] from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public byte[] getVarBinary(int columnIndex) {
VarBinaryVector vector = (VarBinaryVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Returns a byte[] from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public byte[] getFixedSizeBinary(String columnName) {
FixedSizeBinaryVector vector = (FixedSizeBinaryVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a byte[] from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public byte[] getFixedSizeBinary(int columnIndex) {
FixedSizeBinaryVector vector = (FixedSizeBinaryVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Returns a byte[] from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public byte[] getLargeVarBinary(String columnName) {
LargeVarBinaryVector vector = (LargeVarBinaryVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a byte[] from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present, and a ClassCastException is
* thrown if it is present but has a different type
*/
public byte[] getLargeVarBinary(int columnIndex) {
LargeVarBinaryVector vector = (LargeVarBinaryVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Returns a String from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*
* <p>StandardCharsets.UTF_8 is used as the charset
*/
public String getVarCharObj(String columnName) {
VarCharVector vector = (VarCharVector) table.getVector(columnName);
return new String(vector.get(rowNumber), getDefaultCharacterSet());
}
/**
* Returns a String from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*
* @param columnIndex the index of the FieldVector holding the value
*/
public String getVarCharObj(int columnIndex) {
VarCharVector vector = (VarCharVector) table.getVector(columnIndex);
return new String(vector.get(rowNumber), getDefaultCharacterSet());
}
/**
* Returns a byte[] from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*
* <p>StandardCharsets.UTF_8 is used as the charset
*/
public byte[] getVarChar(String columnName) {
VarCharVector vector = (VarCharVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a byte[] from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*
* @param columnIndex the index of the FieldVector holding the value
*/
public byte[] getVarChar(int columnIndex) {
VarCharVector vector = (VarCharVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Returns a String from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*
* <p>StandardCharsets.UTF_8 is used as the charset, unless this cursor was created with a default
* Charset
*/
public String getLargeVarCharObj(String columnName) {
LargeVarCharVector vector = (LargeVarCharVector) table.getVector(columnName);
return new String(vector.get(rowNumber), getDefaultCharacterSet());
}
/**
* Returns a String from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*/
public String getLargeVarCharObj(int columnIndex) {
LargeVarCharVector vector = (LargeVarCharVector) table.getVector(columnIndex);
return new String(vector.get(rowNumber), getDefaultCharacterSet());
}
/**
* Returns a byte[] from the column of the given name at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*
* <p>StandardCharsets.UTF_8 is used as the charset, unless this cursor was created with a default
* Charset
*/
public byte[] getLargeVarChar(String columnName) {
LargeVarCharVector vector = (LargeVarCharVector) table.getVector(columnName);
return vector.get(rowNumber);
}
/**
* Returns a byte[] from the column with the given index at the current row. An
* IllegalArgumentException is thrown if the column is not present in the Row and a
* ClassCastException is thrown if it has a different type
*/
public byte[] getLargeVarChar(int columnIndex) {
LargeVarCharVector vector = (LargeVarCharVector) table.getVector(columnIndex);
return vector.get(rowNumber);
}
/**
* Returns true if there is at least one more non-deleted row in the table that has yet to be
* processed.
*/
@Override
public boolean hasNext() {
return nextRowSet || setNextObject();
}
/**
* Returns the next non-deleted row in the table.
*
* @throws NoSuchElementException if there are no more rows
*/
@Override
public Row next() {
if (!nextRowSet && !setNextObject()) {
throw new NoSuchElementException();
}
nextRowSet = false;
return this;
}
/**
* Set rowNumber to the next non-deleted row. If there are no more rows return false. Otherwise,
* return true.
*/
private boolean setNextObject() {
while (iterator.hasNext()) {
final int row = iterator.next();
if (!rowIsDeleted(row)) {
rowNumber = row;
nextRowSet = true;
return true;
}
}
return false;
}
/**
* Returns new internal iterator that processes every row, deleted or not. Use the wrapping next()
* and hasNext() methods rather than using this iterator directly, unless you want to see any
* deleted rows.
*/
private Iterator<Integer> intIterator() {
return new Iterator<Integer>() {
@Override
public boolean hasNext() {
return rowNumber < table.getRowCount() - 1;
}
@Override
public Integer next() {
rowNumber++;
return rowNumber;
}
};
}
public int getRowNumber() {
return rowNumber;
}
private boolean rowIsDeleted(int rowNumber) {
return table.isRowDeleted(rowNumber);
}
/** Returns the default character set for use with character vectors. */
public Charset getDefaultCharacterSet() {
return DEFAULT_CHARACTER_SET;
}
}