Skip to content

GH-1421: reject negative FieldNode length during deserialization #1422

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
andygrove wants to merge 5 commits into
base: main
Choose a base branch
from
Open

GH-1421: reject negative FieldNode length during deserialization #1422

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
ad2f9b9
fix(vector): reject negative FieldNode length during deserialization
andygrove Oct 31, 2026
e593bb3
fix(vector): reject truncated FieldNode values and negative JSON counts
andygrove Nov 1, 2026
23609d6
fix(vector): release the record batch body when deserialization fails
andygrove Nov 2, 2026
6f2c26e
fix(vector): throw IOException for invalid FieldNode values in IPC reads
andygrove Nov 3, 2026
d5bc951
fix(c): name the field and avoid leaks on invalid import lengths
andygrove Nov 9, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
26 changes: 14 additions & 12 deletions c/src/main/java/org/apache/arrow/c/ArrayImporter.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -128,19 +128,21 @@ private void doImport(ArrowArray.Snapshot snapshot) {
}

// Import main data
ArrowFieldNode fieldNode = new ArrowFieldNode(snapshot.length, snapshot.null_count);
long[] bufferPointers =
NativeUtil.toJavaArray(snapshot.buffers, checkedCastToInt(snapshot.n_buffers));

try (final BufferImportTypeVisitor visitor =
new BufferImportTypeVisitor(allocator, underlyingAllocation, fieldNode, bufferPointers)) {
final List<ArrowBuf> buffers;
if (bufferPointers == null || bufferPointers.length == 0) {
buffers = Collections.emptyList();
} else {
buffers = vector.getField().getType().accept(visitor);
try {
ArrowFieldNode fieldNode = new ArrowFieldNode(snapshot.length, snapshot.null_count);
long[] bufferPointers =
NativeUtil.toJavaArray(snapshot.buffers, checkedCastToInt(snapshot.n_buffers));

try (final BufferImportTypeVisitor visitor =
new BufferImportTypeVisitor(allocator, underlyingAllocation, fieldNode, bufferPointers)) {
final List<ArrowBuf> buffers;
if (bufferPointers == null || bufferPointers.length == 0) {
buffers = Collections.emptyList();
} else {
buffers = vector.getField().getType().accept(visitor);
}
vector.loadFieldBuffers(fieldNode, buffers);
}
vector.loadFieldBuffers(fieldNode, buffers);
} catch (Exception e) {
throw new IllegalArgumentException(
"Could not load buffers for field "
Expand Down
7 changes: 6 additions & 1 deletion c/src/main/java/org/apache/arrow/c/Data.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -407,7 +407,12 @@ public static FieldVector importVector(
boolean closeImportedStructs) {
Field field = importField(allocator, schema, provider, closeImportedStructs);
FieldVector vector = field.createVector(allocator);
importIntoVector(allocator, array, vector, provider, closeImportedStructs);
try {
importIntoVector(allocator, array, vector, provider, closeImportedStructs);
} catch (Exception e) {
vector.close();
throw e;
}
return vector;
}

Expand Down
70 changes: 70 additions & 0 deletions c/src/test/java/org/apache/arrow/c/RoundtripTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -29,6 +29,7 @@
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
Expand Down Expand Up @@ -115,6 +116,7 @@
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;

public class RoundtripTest {
private static final String EMPTY_SCHEMA_PATH = "";
Expand Down Expand Up @@ -1060,6 +1062,74 @@ public void testSchemaStructReuse() {
}
}

@ParameterizedTest
@ValueSource(longs = {-1L, Long.MIN_VALUE, Integer.MAX_VALUE + 1L, (1L << 32) - 100})
public void testImportRejectsInvalidLength(long length) {
try (IntVector vector = new IntVector("ints", allocator)) {
setVector(vector, 1, 2, 3);
assertImportRejected(vector, "ints", array -> setLength(array, length));
}
}

@ParameterizedTest
@ValueSource(longs = {-1L, Long.MIN_VALUE, Integer.MAX_VALUE + 1L, (1L << 32) - 100})
public void testImportRejectsInvalidStructLength(long length) {
try (StructVector vector = createStructWithTwoChildren()) {
assertImportRejected(vector, "struct", array -> setLength(array, length));
}
}

@ParameterizedTest
@ValueSource(longs = {-1L, Long.MIN_VALUE, Integer.MAX_VALUE + 1L, (1L << 32) - 100})
public void testImportRejectsInvalidChildLength(long length) {
try (StructVector vector = createStructWithTwoChildren()) {
assertImportRejected(
vector,
"second",
array -> {
long[] children = NativeUtil.toJavaArray(array.snapshot().children, 2);
setLength(ArrowArray.wrap(children[1]), length);
});
}
}

private StructVector createStructWithTwoChildren() {
StructVector vector = StructVector.empty("struct", allocator);
FieldType type = FieldType.nullable(new ArrowType.Int(32, true));
IntVector first = vector.addOrGet("first", type, IntVector.class);
IntVector second = vector.addOrGet("second", type, IntVector.class);
vector.allocateNew();
for (int i = 0; i < 3; i++) {
first.setSafe(i, i);
second.setSafe(i, i);
vector.setIndexDefined(i);
}
vector.setValueCount(3);
return vector;
}

private static void setLength(ArrowArray array, long length) {
ArrowArray.Snapshot snapshot = array.snapshot();
snapshot.length = length;
array.save(snapshot);
}

/** Exports the vector, corrupts the export and checks that the import fails cleanly. */
private void assertImportRejected(
FieldVector vector, String expectedField, Consumer<ArrowArray> corrupt) {
try (ArrowSchema arrowSchema = ArrowSchema.allocateNew(allocator);
ArrowArray arrowArray = ArrowArray.allocateNew(allocator)) {
Data.exportVector(allocator, vector, null, arrowArray, arrowSchema);
corrupt.accept(arrowArray);
IllegalArgumentException e =
assertThrows(
IllegalArgumentException.class,
() -> Data.importVector(childAllocator, arrowArray, arrowSchema, null));
assertTrue(e.getMessage().contains(expectedField), e.getMessage());
}
assertEquals(0, childAllocator.getAllocatedMemory());
}

private void exportSchema(Schema schema, ArrowSchema targetArrowSchema) {
try (ArrowSchema arrowSchema = ArrowSchema.wrap(targetArrowSchema.memoryAddress())) {
Data.exportSchema(allocator, schema, null, arrowSchema);
Expand Down
14 changes: 11 additions & 3 deletions vector/src/main/java/org/apache/arrow/vector/ipc/JsonFileReader.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -196,7 +196,7 @@ public boolean read(VectorSchemaRoot root) throws IOException {
JsonToken t = parser.nextToken();
if (t == START_OBJECT) {
{
int count = readNextField("count", Integer.class);
int count = readCount();
nextFieldIs("columns");
readToken(START_ARRAY);
{
Expand Down Expand Up @@ -224,7 +224,7 @@ public VectorSchemaRoot read() throws IOException {
if (t == START_OBJECT) {
VectorSchemaRoot recordBatch = VectorSchemaRoot.create(schema, allocator);
{
int count = readNextField("count", Integer.class);
int count = readCount();
recordBatch.setRowCount(count);
nextFieldIs("columns");
readToken(START_ARRAY);
Expand Down Expand Up @@ -885,7 +885,7 @@ private void readFromJsonIntoVector(Field field, FieldVector vector) throws IOEx
/* Initialize the vector with required capacity but don't allocateNew since we would
* be doing loadFieldBuffers.
*/
int valueCount = readNextField("count", Integer.class);
int valueCount = readCount();

vector.setInitialCapacity(valueCount);

Expand Down Expand Up @@ -975,6 +975,14 @@ private <T> T readNextField(String expectedFieldName, Class<T> c)
return parser.readValueAs(c);
}

private int readCount() throws IOException {
int count = readNextField("count", Integer.class);
if (count < 0) {
throw new IllegalArgumentException("Expected count >= 0, got " + count);
}
return count;
}

private void nextFieldIs(String expectedFieldName) throws IOException, JsonParseException {
String name = parser.nextFieldName();
if (name == null || !name.equals(expectedFieldName)) {
Expand Down
11 changes: 6 additions & 5 deletions vector/src/main/java/org/apache/arrow/vector/ipc/message/ArrowFieldNode.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,10 +16,9 @@
*/
package org.apache.arrow.vector.ipc.message;

import static org.apache.arrow.memory.util.LargeMemoryUtil.checkedCastToInt;

import com.google.flatbuffers.FlatBufferBuilder;
import org.apache.arrow.flatbuf.FieldNode;
import org.apache.arrow.util.Preconditions;

/** Metadata about Vectors/Arrays that is written to a channel. */
public class ArrowFieldNode implements FBSerializable {
Expand All @@ -31,12 +30,14 @@ public class ArrowFieldNode implements FBSerializable {
* Constructs a new instance.
*
* @param length The number of values written.
* @param nullCount The number of null values.
* @param nullCount The number of null values, or -1 if unknown.
*/
public ArrowFieldNode(long length, long nullCount) {
super();
this.length = checkedCastToInt(length);
this.nullCount = checkedCastToInt(nullCount);
Preconditions.checkArgument(length >= 0, "Expected length >= 0, got %s", length);

@jbonofre jbonofre Nov 1, 2026

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This check runs on the long before it's narrowed, but the checkedCastToInt only uses Math.toIntExact when bounds checking is on.
With arrow.enable_unsafe_memory_access=true it's a plain (int) cast. A positive long whose low 32 bits are negative passes the check and is stored as a negative int, in the same mode this PR is supposed to protect.

IPC is safe because MessageSerializer.deserializeRecordBatch rejects values outside int range before it calls this. C Data is not: ArrayImporter passes snapshot.length, an int64 from the producer, straight in.
For example length = 4294967196 (2^32 - 100) passes the check and becomes -100.

Narrowing unconditionally should fixes it. Doing the same for nullCount still allows the -1 sentinel:

Suggested change
Preconditions.checkArgument(length >= 0, "Expected length >= 0, got %s", length);
Preconditions.checkArgument(length >= 0, "Expected length >= 0, got %s", length);
this.length = Math.toIntExact(length);
this.nullCount = Math.toIntExact(nullCount);

The static import of checkedCastToInt becomes unused after this.

@andygrove andygrove Nov 1, 2026

Copy link
Copy Markdown
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Same as the thread above (#1422 (comment)); addressed there.

@jbonofre jbonofre Nov 1, 2026

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This check now throws inside MessageSerializer.deserializeRecordBatch(RecordBath, ArrowBuf), before that method releases body at the end. A negative node length now leaks the body buffer. Before this change the same input loaded without error and didn't leak.

I reproduced it with a stream whose FieldNode.length is patched to -100. ArrowStreamReader and ArrowFileReader both throw and leave 8192 bytes allocated, and allocator.close() fails with "Memory was leaked". Flight goes through the same call: ArrowMessage.asRecordBatch() retains underlying and relies on deserializeRecordBatch to release it.

Could we release body in a finally? ArrowRecordBatch retains the slices it keeps, so the release is correct on both paths:

  public static ArrowRecordBatch deserializeRecordBatch(RecordBatch recordBatchFB, ArrowBuf body)
      throws IOException {
    try {
      // ... existing node/buffer/compression/variadic parsing, unchanged ...
      return new ArrowRecordBatch(
          checkedCastToInt(recordBatchFB.length()),
          nodes,
          buffers,
          bodyCompression,
          variadicBufferCounts,
          /*alignBuffers*/ true);
    } finally {
      body.getReferenceManager().release();
    }
  }

This also fixes the same leak on the existing IOException paths in that method (for example node length > INT_MAX), and covers the dictionary batch and Flight callers. ArrowMessage doesn't need a change. Releasing there too would release the buffer twice.

@andygrove andygrove Nov 2, 2026

Copy link
Copy Markdown
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Applied in 23609d6: deserializeRecordBatch(RecordBatch, ArrowBuf) now releases body in a finally, and ArrowMessage is unchanged. Before the change I reproduced your repro: ArrowStreamReader and ArrowFileReader each left 8192 bytes allocated for a stream whose node length was patched to -100. Both now release everything.

@parthchandra parthchandra Nov 3, 2026

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The PR description says this also fixes the C Data path. C Data imports reach this check through ArrayImporter.java:131, which calls new ArrowFieldNode(snapshot.length, snapshot.null_count). But no test covers that path. Could you add a test in the c module that imports an array with a length of -1 and another with a length larger than Integer.MAX_VALUE?
Each test should check the error and check that no memory leaks. Also, ArrayImporter.java:131 is outside the try block that adds the field name to errors. So a bad length from C Data gives an error that does not say which field was bad.

@andygrove andygrove Nov 9, 2026

Copy link
Copy Markdown
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Added in d5bc95194. ArrayImporter now builds the ArrowFieldNode inside the try, so a bad length or null count reports the field name. New RoundtripTest cases import a flat vector, a struct and a struct child with a length of -1, Long.MIN_VALUE, above INT_MAX and 2^32 - 100, and check the error and that nothing leaks. The leak check also showed Data.importVector leaking children that had already loaded when a later length was bad, so it now closes the vector on failure.

Preconditions.checkArgument(nullCount >= -1, "Expected nullCount >= -1, got %s", nullCount);
this.length = Math.toIntExact(length);
this.nullCount = Math.toIntExact(nullCount);
}

@Override
Expand Down
86 changes: 47 additions & 39 deletions vector/src/main/java/org/apache/arrow/vector/ipc/message/MessageSerializer.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -411,50 +411,58 @@ public static ArrowRecordBatch deserializeRecordBatch(
*/
public static ArrowRecordBatch deserializeRecordBatch(RecordBatch recordBatchFB, ArrowBuf body)
throws IOException {
// Now read the body
int nodesLength = recordBatchFB.nodesLength();
List<ArrowFieldNode> nodes = new ArrayList<>();
for (int i = 0; i < nodesLength; ++i) {
FieldNode node = recordBatchFB.nodes(i);
if ((int) node.length() != node.length() || (int) node.nullCount() != node.nullCount()) {
throw new IOException(
"Cannot currently deserialize record batches with "
+ "node length larger than INT_MAX records.");
try {
// Now read the body
int nodesLength = recordBatchFB.nodesLength();
List<ArrowFieldNode> nodes = new ArrayList<>();
for (int i = 0; i < nodesLength; ++i) {
FieldNode node = recordBatchFB.nodes(i);
if (node.length() < 0) {
throw new IOException("Record batch node " + i + " has negative length " + node.length());
}
if (node.nullCount() < -1) {
throw new IOException(
"Record batch node " + i + " has invalid null count " + node.nullCount());
}
if ((int) node.length() != node.length() || (int) node.nullCount() != node.nullCount()) {

@parthchandra parthchandra Nov 3, 2026

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This catches lengths that are too large but not negative lengths.
Maybe add node.length() < 0 and node.nullCount() < -1

@andygrove andygrove Nov 3, 2026

Copy link
Copy Markdown
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Added in 6f2c26e. The ArrowFieldNode constructor called right after this check already rejected these, but with an IllegalArgumentException, so the IPC readers failed on a malformed node with an unchecked exception instead of the IOException they declare. The loop now rejects a negative length and a null count below -1 with an IOException. The new checks run before the int-range check, so a length of Long.MIN_VALUE is reported as negative, not as larger than INT_MAX.

throw new IOException(
"Cannot currently deserialize record batches with "
+ "node length larger than INT_MAX records.");
}
nodes.add(new ArrowFieldNode(node.length(), node.nullCount()));
}
List<ArrowBuf> buffers = new ArrayList<>();
for (int i = 0; i < recordBatchFB.buffersLength(); ++i) {
Buffer bufferFB = recordBatchFB.buffers(i);
ArrowBuf vectorBuffer = body.slice(bufferFB.offset(), bufferFB.length());
buffers.add(vectorBuffer);
}
nodes.add(new ArrowFieldNode(node.length(), node.nullCount()));
}
List<ArrowBuf> buffers = new ArrayList<>();
for (int i = 0; i < recordBatchFB.buffersLength(); ++i) {
Buffer bufferFB = recordBatchFB.buffers(i);
ArrowBuf vectorBuffer = body.slice(bufferFB.offset(), bufferFB.length());
buffers.add(vectorBuffer);
}

ArrowBodyCompression bodyCompression =
recordBatchFB.compression() == null
? NoCompressionCodec.DEFAULT_BODY_COMPRESSION
: new ArrowBodyCompression(
recordBatchFB.compression().codec(), recordBatchFB.compression().method());
ArrowBodyCompression bodyCompression =
recordBatchFB.compression() == null
? NoCompressionCodec.DEFAULT_BODY_COMPRESSION
: new ArrowBodyCompression(
recordBatchFB.compression().codec(), recordBatchFB.compression().method());

List<Long> variadicBufferCounts = new ArrayList<>();
for (int i = 0; i < recordBatchFB.variadicBufferCountsLength(); i++) {
variadicBufferCounts.add(recordBatchFB.variadicBufferCounts(i));
}
List<Long> variadicBufferCounts = new ArrayList<>();
for (int i = 0; i < recordBatchFB.variadicBufferCountsLength(); i++) {
variadicBufferCounts.add(recordBatchFB.variadicBufferCounts(i));
}

if ((int) recordBatchFB.length() != recordBatchFB.length()) {
throw new IOException(
"Cannot currently deserialize record batches with more than INT_MAX records.");
if ((int) recordBatchFB.length() != recordBatchFB.length()) {
throw new IOException(
"Cannot currently deserialize record batches with more than INT_MAX records.");
}
Comment on lines +452 to +455

@jbonofre jbonofre Nov 4, 2026

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The node checks above reject negative lengths, but a negative recordBatchFB.length() still gets through: (int) x != x only catches values above INT_MAX. A batch with length = -100 reaches VectorLoader.load, which calls root.setRowCount(-100) and then setValueCount(-100) on every vector, where only an assert stands in the way.

Could we reject it here too?

Suggested change
if ((int) recordBatchFB.length() != recordBatchFB.length()) {
throw new IOException(
"Cannot currently deserialize record batches with more than INT_MAX records.");
}
if (recordBatchFB.length() < 0) {
throw new IOException("Record batch has negative length " + recordBatchFB.length());
}
if ((int) recordBatchFB.length() != recordBatchFB.length()) {
throw new IOException(
"Cannot currently deserialize record batches with more than INT_MAX records.");
}

return new ArrowRecordBatch(
checkedCastToInt(recordBatchFB.length()),
nodes,
buffers,
bodyCompression,
variadicBufferCounts,
/*alignBuffers*/ true);
} finally {
body.getReferenceManager().release();

@jbonofre jbonofre Nov 4, 2026

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

body can be null here: deserializeMessageBatch(MessageChannelReader) passes result.getBodyBuffer(), which stays null when the message has no body (MessageChannelReader#readNext). This already threw NPE on main, but now that it's in a finally, the NPE also replaces the new IOException for a malformed batch, so callers get a NPE instead of the declared exception.

Suggested change
body.getReferenceManager().release();
if (body != null) {
body.getReferenceManager().release();
}

}
ArrowRecordBatch arrowRecordBatch =
new ArrowRecordBatch(
checkedCastToInt(recordBatchFB.length()),
nodes,
buffers,
bodyCompression,
variadicBufferCounts,
/*alignBuffers*/ true);
body.getReferenceManager().release();
return arrowRecordBatch;
}

/**
Expand Down
63 changes: 63 additions & 0 deletions vector/src/test/java/org/apache/arrow/vector/ipc/MessageSerializerTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,6 +23,7 @@
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import com.google.flatbuffers.FlatBufferBuilder;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
Expand All @@ -32,6 +33,9 @@
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;
import org.apache.arrow.flatbuf.FieldNode;
import org.apache.arrow.flatbuf.RecordBatch;
import org.apache.arrow.memory.ArrowBuf;
import org.apache.arrow.memory.BufferAllocator;
import org.apache.arrow.memory.RootAllocator;
Expand All @@ -47,6 +51,9 @@
import org.apache.arrow.vector.types.pojo.FieldType;
import org.apache.arrow.vector.types.pojo.Schema;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

public class MessageSerializerTest {

Expand Down Expand Up @@ -220,6 +227,62 @@ public void testSerializeRecordBatchV5() throws Exception {
alloc.close();
}

@ParameterizedTest
@MethodSource("invalidFieldNodes")
public void testInvalidFieldNodeRejectedWithoutLeakingBody(long length, long nullCount) {
RecordBatch recordBatchFB = recordBatchWithNode(length, nullCount);
try (BufferAllocator allocator = new RootAllocator()) {
ArrowBuf body = allocator.buffer(8);
assertThrows(
IOException.class, () -> MessageSerializer.deserializeRecordBatch(recordBatchFB, body));
assertEquals(0, allocator.getAllocatedMemory());
}
}

static Stream<Arguments> invalidFieldNodes() {
return Stream.of(
Arguments.of(-100L, 0L),
Arguments.of(Long.MIN_VALUE, 0L),
Arguments.of(Integer.MAX_VALUE + 1L, 0L),
Arguments.of(1L << 32, 0L),
Arguments.of(10L, -2L));
}

@ParameterizedTest
@MethodSource("validFieldNodes")
public void testValidFieldNodeDeserialized(long length, long nullCount) throws IOException {
RecordBatch recordBatchFB = recordBatchWithNode(length, nullCount);
try (BufferAllocator allocator = new RootAllocator()) {
ArrowBuf body = allocator.buffer(8);
try (ArrowRecordBatch batch = MessageSerializer.deserializeRecordBatch(recordBatchFB, body)) {
ArrowFieldNode node = batch.getNodes().get(0);
assertEquals(length, node.getLength());
assertEquals(nullCount, node.getNullCount());
}
assertEquals(0, allocator.getAllocatedMemory());
}
}

static Stream<Arguments> validFieldNodes() {
return Stream.of(
Arguments.of(0L, 0L), Arguments.of(10L, -1L), Arguments.of((long) Integer.MAX_VALUE, 0L));
}

private static RecordBatch recordBatchWithNode(long length, long nullCount) {
FlatBufferBuilder builder = new FlatBufferBuilder();
RecordBatch.startNodesVector(builder, 1);
FieldNode.createFieldNode(builder, length, nullCount);
int nodes = builder.endVector();
RecordBatch.startBuffersVector(builder, 0);
int buffers = builder.endVector();
RecordBatch.startRecordBatch(builder);
RecordBatch.addLength(builder, 0);
RecordBatch.addNodes(builder, nodes);
RecordBatch.addBuffers(builder, buffers);
builder.finish(RecordBatch.endRecordBatch(builder));
return RecordBatch.getRootAsRecordBatch(builder.dataBuffer());
}

public static Schema testSchema() {
return new Schema(
asList(
Expand Down
Loading
Loading