This is an automated email from the ASF dual-hosted git repository.
jackie pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/pinot.git
The following commit(s) were added to refs/heads/master by this push:
new 7965e042eb8 Refactor set operator tests to use
BlockListMultiStageOperator instead of mocks (#16601)
7965e042eb8 is described below
commit 7965e042eb809846aad795bd9ea8764af361b4b9
Author: Yash Mayya <[email protected]>
AuthorDate: Sat Aug 16 03:04:33 2025 +0530
Refactor set operator tests to use BlockListMultiStageOperator instead of
mocks (#16601)
---
.../operator/set/IntersectAllOperatorTest.java | 72 ++++++--------
.../operator/set/IntersectOperatorTest.java | 100 +++++++++-----------
.../runtime/operator/set/MinusAllOperatorTest.java | 73 ++++++--------
.../runtime/operator/set/MinusOperatorTest.java | 105 +++++++++------------
.../runtime/operator/set/UnionAllOperatorTest.java | 73 +++++---------
.../runtime/operator/set/UnionOperatorTest.java | 75 +++++----------
6 files changed, 196 insertions(+), 302 deletions(-)
diff --git
a/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/IntersectAllOperatorTest.java
b/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/IntersectAllOperatorTest.java
index b052d532650..2c3f53c19f9 100644
---
a/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/IntersectAllOperatorTest.java
+++
b/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/IntersectAllOperatorTest.java
@@ -22,59 +22,34 @@ import com.google.common.collect.ImmutableList;
import java.util.Arrays;
import java.util.List;
import org.apache.pinot.common.utils.DataSchema;
-import org.apache.pinot.query.routing.VirtualServerAddress;
import org.apache.pinot.query.runtime.blocks.MseBlock;
-import org.apache.pinot.query.runtime.blocks.SuccessMseBlock;
+import org.apache.pinot.query.runtime.operator.BlockListMultiStageOperator;
import org.apache.pinot.query.runtime.operator.MultiStageOperator;
import org.apache.pinot.query.runtime.operator.OperatorTestUtil;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
import org.testng.Assert;
-import org.testng.annotations.AfterMethod;
-import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class IntersectAllOperatorTest {
- private AutoCloseable _mocks;
-
- @Mock
- private MultiStageOperator _leftOperator;
-
- @Mock
- private MultiStageOperator _rightOperator;
-
- @Mock
- private VirtualServerAddress _serverAddress;
-
- @BeforeMethod
- public void setUp() {
- _mocks = MockitoAnnotations.openMocks(this);
- Mockito.when(_serverAddress.toString()).thenReturn(new
VirtualServerAddress("mock", 80, 0).toString());
- }
-
- @AfterMethod
- public void tearDown()
- throws Exception {
- _mocks.close();
- }
-
@Test
public void testIntersectAllOperator() {
DataSchema schema = new DataSchema(new String[]{"int_col"},
new DataSchema.ColumnDataType[]{DataSchema.ColumnDataType.INT});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{1}, new
Object[]{2}, new Object[]{3}))
- .thenReturn(SuccessMseBlock.INSTANCE);
- Mockito.when(_rightOperator.nextBlock()).thenReturn(
- OperatorTestUtil.block(schema, new Object[]{1}, new Object[]{2},
new Object[]{4}))
- .thenReturn(SuccessMseBlock.INSTANCE);
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1)
+ .addRow(2)
+ .addRow(3)
+ .buildWithEos();
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1)
+ .addRow(2)
+ .addRow(4)
+ .buildWithEos();
IntersectAllOperator intersectOperator =
- new IntersectAllOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new IntersectAllOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = intersectOperator.nextBlock();
@@ -94,16 +69,23 @@ public class IntersectAllOperatorTest {
DataSchema schema = new DataSchema(new String[]{"int_col"},
new DataSchema.ColumnDataType[]{DataSchema.ColumnDataType.INT});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{1}, new
Object[]{2}, new Object[]{2}, new Object[]{3},
- new Object[]{3}, new Object[]{3}))
- .thenReturn(SuccessMseBlock.INSTANCE);
- Mockito.when(_rightOperator.nextBlock()).thenReturn(
- OperatorTestUtil.block(schema, new Object[]{2}, new Object[]{3},
new Object[]{3}, new Object[]{4}))
- .thenReturn(SuccessMseBlock.INSTANCE);
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1)
+ .addRow(2)
+ .addRow(2)
+ .addRow(3)
+ .addRow(3)
+ .addRow(3)
+ .buildWithEos();
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(2)
+ .addRow(3)
+ .addRow(3)
+ .addRow(4)
+ .buildWithEos();
IntersectAllOperator intersectOperator =
- new IntersectAllOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new IntersectAllOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = intersectOperator.nextBlock();
diff --git
a/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/IntersectOperatorTest.java
b/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/IntersectOperatorTest.java
index 4252d0a895a..648c76f8b71 100644
---
a/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/IntersectOperatorTest.java
+++
b/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/IntersectOperatorTest.java
@@ -22,59 +22,35 @@ import com.google.common.collect.ImmutableList;
import java.util.Arrays;
import java.util.List;
import org.apache.pinot.common.utils.DataSchema;
-import org.apache.pinot.query.routing.VirtualServerAddress;
import org.apache.pinot.query.runtime.blocks.ErrorMseBlock;
import org.apache.pinot.query.runtime.blocks.MseBlock;
-import org.apache.pinot.query.runtime.blocks.SuccessMseBlock;
+import org.apache.pinot.query.runtime.operator.BlockListMultiStageOperator;
import org.apache.pinot.query.runtime.operator.MultiStageOperator;
import org.apache.pinot.query.runtime.operator.OperatorTestUtil;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
import org.testng.Assert;
-import org.testng.annotations.AfterMethod;
-import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class IntersectOperatorTest {
- private AutoCloseable _mocks;
-
- @Mock
- private MultiStageOperator _leftOperator;
-
- @Mock
- private MultiStageOperator _rightOperator;
-
- @Mock
- private VirtualServerAddress _serverAddress;
-
- @BeforeMethod
- public void setUp() {
- _mocks = MockitoAnnotations.openMocks(this);
- Mockito.when(_serverAddress.toString()).thenReturn(new
VirtualServerAddress("mock", 80, 0).toString());
- }
-
- @AfterMethod
- public void tearDown()
- throws Exception {
- _mocks.close();
- }
@Test
public void testIntersectOperator() {
DataSchema schema = new DataSchema(new String[]{"int_col", "string_col"},
new DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{1, "AA"}, new
Object[]{2, "BB"}, new Object[]{3, "CC"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
- Mockito.when(_rightOperator.nextBlock()).thenReturn(
- OperatorTestUtil.block(schema, new Object[]{1, "AA"}, new
Object[]{2, "BB"}, new Object[]{4, "DD"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .addRow(3, "CC")
+ .buildWithEos();
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .addRow(4, "DD")
+ .buildWithEos();
IntersectOperator intersectOperator =
- new IntersectOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new IntersectOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = intersectOperator.nextBlock();
@@ -94,17 +70,25 @@ public class IntersectOperatorTest {
DataSchema schema = new DataSchema(new String[]{"int_col", "string_col"},
new DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{1, "AA"}, new
Object[]{2, "BB"}, new Object[]{3, "CC"},
- new Object[]{1, "AA"}, new Object[]{2, "BB"}, new Object[]{3,
"CC"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
- Mockito.when(_rightOperator.nextBlock()).thenReturn(
- OperatorTestUtil.block(schema, new Object[]{1, "AA"}, new
Object[]{2, "BB"}, new Object[]{4, "DD"},
- new Object[]{1, "AA"}, new Object[]{2, "BB"}, new Object[]{4,
"DD"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .addRow(3, "CC")
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .addRow(3, "CC")
+ .buildWithEos();
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .addRow(4, "CC")
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .addRow(4, "DD")
+ .buildWithEos();
IntersectOperator intersectOperator =
- new IntersectOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new IntersectOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = intersectOperator.nextBlock();
@@ -124,14 +108,15 @@ public class IntersectOperatorTest {
DataSchema schema = new DataSchema(new String[]{"int_col", "string_col"},
new DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{1, "AA"}, new
Object[]{2, "BB"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
- Mockito.when(_rightOperator.nextBlock())
- .thenReturn(ErrorMseBlock.fromException(new RuntimeException("Error in
right operator")));
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .buildWithEos();
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .buildWithError(ErrorMseBlock.fromException(new
RuntimeException("Error in right operator")));
IntersectOperator intersectOperator =
- new IntersectOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new IntersectOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = intersectOperator.nextBlock();
// Keep calling nextBlock until we get an EoS block
@@ -146,14 +131,15 @@ public class IntersectOperatorTest {
DataSchema schema = new DataSchema(new String[]{"int_col", "string_col"},
new DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(ErrorMseBlock.fromException(new RuntimeException("Error in
left operator")));
- Mockito.when(_rightOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{3, "aa"}, new
Object[]{4, "bb"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .buildWithError(ErrorMseBlock.fromException(new
RuntimeException("Error in left operator")));
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(3, "aa")
+ .addRow(4, "bb")
+ .buildWithEos();
IntersectOperator intersectOperator =
- new IntersectOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new IntersectOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = intersectOperator.nextBlock();
// Keep calling nextBlock until we get an EoS block
diff --git
a/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/MinusAllOperatorTest.java
b/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/MinusAllOperatorTest.java
index 869c4277b39..00a975faf15 100644
---
a/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/MinusAllOperatorTest.java
+++
b/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/MinusAllOperatorTest.java
@@ -22,58 +22,35 @@ import com.google.common.collect.ImmutableList;
import java.util.Arrays;
import java.util.List;
import org.apache.pinot.common.utils.DataSchema;
-import org.apache.pinot.query.routing.VirtualServerAddress;
import org.apache.pinot.query.runtime.blocks.MseBlock;
-import org.apache.pinot.query.runtime.blocks.SuccessMseBlock;
+import org.apache.pinot.query.runtime.operator.BlockListMultiStageOperator;
import org.apache.pinot.query.runtime.operator.MultiStageOperator;
import org.apache.pinot.query.runtime.operator.OperatorTestUtil;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
import org.testng.Assert;
-import org.testng.annotations.AfterMethod;
-import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class MinusAllOperatorTest {
- private AutoCloseable _mocks;
-
- @Mock
- private MultiStageOperator _leftOperator;
-
- @Mock
- private MultiStageOperator _rightOperator;
-
- @Mock
- private VirtualServerAddress _serverAddress;
-
- @BeforeMethod
- public void setUp() {
- _mocks = MockitoAnnotations.openMocks(this);
- Mockito.when(_serverAddress.toString()).thenReturn(new
VirtualServerAddress("mock", 80, 0).toString());
- }
-
- @AfterMethod
- public void tearDown()
- throws Exception {
- _mocks.close();
- }
@Test
public void testExceptAllOperator() {
DataSchema schema = new DataSchema(new String[]{"int_col"}, new
DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{1}, new
Object[]{2}, new Object[]{3}, new Object[]{4}))
- .thenReturn(SuccessMseBlock.INSTANCE);
- Mockito.when(_rightOperator.nextBlock()).thenReturn(
- OperatorTestUtil.block(schema, new Object[]{1}, new Object[]{2},
new Object[]{5}))
- .thenReturn(SuccessMseBlock.INSTANCE);
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1)
+ .addRow(2)
+ .addRow(3)
+ .addRow(4)
+ .buildWithEos();
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1)
+ .addRow(2)
+ .addRow(5)
+ .buildWithEos();
MinusAllOperator minusOperator =
- new MinusAllOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new MinusAllOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = minusOperator.nextBlock();
@@ -93,16 +70,24 @@ public class MinusAllOperatorTest {
DataSchema schema = new DataSchema(new String[]{"int_col"}, new
DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{1}, new
Object[]{2}, new Object[]{2}, new Object[]{2},
- new Object[]{3}, new Object[]{3}, new Object[]{3}))
- .thenReturn(SuccessMseBlock.INSTANCE);
- Mockito.when(_rightOperator.nextBlock()).thenReturn(
- OperatorTestUtil.block(schema, new Object[]{2}, new Object[]{3},
new Object[]{3}, new Object[]{4}))
- .thenReturn(SuccessMseBlock.INSTANCE);
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1)
+ .addRow(2)
+ .addRow(2)
+ .addRow(2)
+ .addRow(3)
+ .addRow(3)
+ .addRow(3)
+ .buildWithEos();
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(2)
+ .addRow(3)
+ .addRow(3)
+ .addRow(4)
+ .buildWithEos();
MinusAllOperator minusOperator =
- new MinusAllOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new MinusAllOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = minusOperator.nextBlock();
diff --git
a/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/MinusOperatorTest.java
b/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/MinusOperatorTest.java
index 967164eb126..28ac9dd15fe 100644
---
a/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/MinusOperatorTest.java
+++
b/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/MinusOperatorTest.java
@@ -22,60 +22,36 @@ import com.google.common.collect.ImmutableList;
import java.util.Arrays;
import java.util.List;
import org.apache.pinot.common.utils.DataSchema;
-import org.apache.pinot.query.routing.VirtualServerAddress;
import org.apache.pinot.query.runtime.blocks.ErrorMseBlock;
import org.apache.pinot.query.runtime.blocks.MseBlock;
-import org.apache.pinot.query.runtime.blocks.SuccessMseBlock;
+import org.apache.pinot.query.runtime.operator.BlockListMultiStageOperator;
import org.apache.pinot.query.runtime.operator.MultiStageOperator;
import org.apache.pinot.query.runtime.operator.OperatorTestUtil;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
import org.testng.Assert;
-import org.testng.annotations.AfterMethod;
-import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class MinusOperatorTest {
- private AutoCloseable _mocks;
-
- @Mock
- private MultiStageOperator _leftOperator;
-
- @Mock
- private MultiStageOperator _rightOperator;
-
- @Mock
- private VirtualServerAddress _serverAddress;
-
- @BeforeMethod
- public void setUp() {
- _mocks = MockitoAnnotations.openMocks(this);
- Mockito.when(_serverAddress.toString()).thenReturn(new
VirtualServerAddress("mock", 80, 0).toString());
- }
-
- @AfterMethod
- public void tearDown()
- throws Exception {
- _mocks.close();
- }
@Test
public void testExceptOperator() {
DataSchema schema = new DataSchema(new String[]{"int_col", "string_col"},
new DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{1, "AA"}, new
Object[]{2, "BB"}, new Object[]{3, "CC"},
- new Object[]{4, "DD"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
- Mockito.when(_rightOperator.nextBlock()).thenReturn(
- OperatorTestUtil.block(schema, new Object[]{1, "AA"}, new
Object[]{2, "BB"}, new Object[]{5, "EE"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .addRow(3, "CC")
+ .addRow(4, "DD")
+ .buildWithEos();
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .addRow(5, "EE")
+ .buildWithEos();
MinusOperator minusOperator =
- new MinusOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new MinusOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = minusOperator.nextBlock();
@@ -95,18 +71,27 @@ public class MinusOperatorTest {
DataSchema schema = new DataSchema(new String[]{"int_col", "string_col"},
new DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{1, "AA"}, new
Object[]{2, "BB"}, new Object[]{3, "CC"},
- new Object[]{4, "DD"}, new Object[]{1, "AA"}, new Object[]{2,
"BB"}, new Object[]{3, "CC"},
- new Object[]{4, "DD"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
- Mockito.when(_rightOperator.nextBlock()).thenReturn(
- OperatorTestUtil.block(schema, new Object[]{1, "AA"}, new
Object[]{2, "BB"}, new Object[]{5, "EE"},
- new Object[]{1, "AA"}, new Object[]{2, "BB"}, new Object[]{5,
"EE"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .addRow(3, "CC")
+ .addRow(4, "DD")
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .addRow(3, "CC")
+ .addRow(4, "DD")
+ .buildWithEos();
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .addRow(5, "EE")
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .addRow(5, "EE")
+ .buildWithEos();
MinusOperator minusOperator =
- new MinusOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new MinusOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = minusOperator.nextBlock();
@@ -126,14 +111,15 @@ public class MinusOperatorTest {
DataSchema schema = new DataSchema(new String[]{"int_col", "string_col"},
new DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{1, "AA"}, new
Object[]{2, "BB"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
- Mockito.when(_rightOperator.nextBlock())
- .thenReturn(ErrorMseBlock.fromException(new RuntimeException("Error in
right operator")));
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .buildWithEos();
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .buildWithError(ErrorMseBlock.fromException(new
RuntimeException("Error in right operator")));
MinusOperator minusOperator =
- new MinusOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new MinusOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = minusOperator.nextBlock();
// Keep calling nextBlock until we get an EoS block
@@ -148,14 +134,15 @@ public class MinusOperatorTest {
DataSchema schema = new DataSchema(new String[]{"int_col", "string_col"},
new DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(ErrorMseBlock.fromException(new RuntimeException("Error in
left operator")));
- Mockito.when(_rightOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{3, "aa"}, new
Object[]{4, "bb"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .buildWithError(ErrorMseBlock.fromException(new
RuntimeException("Error in left operator")));
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(3, "aa")
+ .addRow(4, "bb")
+ .buildWithEos();
MinusOperator minusOperator =
- new MinusOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new MinusOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = minusOperator.nextBlock();
// Keep calling nextBlock until we get an EoS block
diff --git
a/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/UnionAllOperatorTest.java
b/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/UnionAllOperatorTest.java
index 3299a84fee7..fdfc494c1a9 100644
---
a/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/UnionAllOperatorTest.java
+++
b/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/UnionAllOperatorTest.java
@@ -23,59 +23,34 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.apache.pinot.common.utils.DataSchema;
-import org.apache.pinot.query.routing.VirtualServerAddress;
import org.apache.pinot.query.runtime.blocks.ErrorMseBlock;
import org.apache.pinot.query.runtime.blocks.MseBlock;
-import org.apache.pinot.query.runtime.blocks.SuccessMseBlock;
+import org.apache.pinot.query.runtime.operator.BlockListMultiStageOperator;
import org.apache.pinot.query.runtime.operator.MultiStageOperator;
import org.apache.pinot.query.runtime.operator.OperatorTestUtil;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
import org.testng.Assert;
-import org.testng.annotations.AfterMethod;
-import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class UnionAllOperatorTest {
- private AutoCloseable _mocks;
-
- @Mock
- private MultiStageOperator _leftOperator;
-
- @Mock
- private MultiStageOperator _rightOperator;
-
- @Mock
- private VirtualServerAddress _serverAddress;
-
- @BeforeMethod
- public void setUp() {
- _mocks = MockitoAnnotations.openMocks(this);
- Mockito.when(_serverAddress.toString()).thenReturn(new
VirtualServerAddress("mock", 80, 0).toString());
- }
-
- @AfterMethod
- public void tearDown()
- throws Exception {
- _mocks.close();
- }
@Test
public void testUnionOperator() {
DataSchema schema = new DataSchema(new String[]{"int_col", "string_col"},
new DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{1, "AA"}, new
Object[]{2, "BB"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
- Mockito.when(_rightOperator.nextBlock()).thenReturn(
- OperatorTestUtil.block(schema, new Object[]{3, "aa"}, new
Object[]{4, "bb"}, new Object[]{5, "cc"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .buildWithEos();
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(3, "aa")
+ .addRow(4, "bb")
+ .addRow(5, "cc")
+ .buildWithEos();
UnionAllOperator unionAllOperator =
- new UnionAllOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new UnionAllOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
List<Object[]> resultRows = new ArrayList<>();
MseBlock result = unionAllOperator.nextBlock();
@@ -99,14 +74,15 @@ public class UnionAllOperatorTest {
DataSchema schema = new DataSchema(new String[]{"int_col", "string_col"},
new DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{1, "AA"}, new
Object[]{2, "BB"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
- Mockito.when(_rightOperator.nextBlock())
- .thenReturn(ErrorMseBlock.fromException(new RuntimeException("Error in
right operator")));
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .buildWithEos();
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .buildWithError(ErrorMseBlock.fromException(new
RuntimeException("Error in right operator")));
UnionAllOperator unionAllOperator =
- new UnionAllOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new UnionAllOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = unionAllOperator.nextBlock();
// Keep calling nextBlock until we get an EoS block
@@ -121,14 +97,15 @@ public class UnionAllOperatorTest {
DataSchema schema = new DataSchema(new String[]{"int_col", "string_col"},
new DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(ErrorMseBlock.fromException(new RuntimeException("Error in
left operator")));
- Mockito.when(_rightOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{3, "aa"}, new
Object[]{4, "bb"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .buildWithError(ErrorMseBlock.fromException(new
RuntimeException("Error in left operator")));
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(3, "aa")
+ .addRow(4, "bb")
+ .buildWithEos();
UnionAllOperator unionAllOperator =
- new UnionAllOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new UnionAllOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = unionAllOperator.nextBlock();
// Keep calling nextBlock until we get an EoS block
diff --git
a/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/UnionOperatorTest.java
b/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/UnionOperatorTest.java
index cfb9f55ed49..971bbb34062 100644
---
a/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/UnionOperatorTest.java
+++
b/pinot-query-runtime/src/test/java/org/apache/pinot/query/runtime/operator/set/UnionOperatorTest.java
@@ -23,60 +23,35 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.apache.pinot.common.utils.DataSchema;
-import org.apache.pinot.query.routing.VirtualServerAddress;
import org.apache.pinot.query.runtime.blocks.ErrorMseBlock;
import org.apache.pinot.query.runtime.blocks.MseBlock;
-import org.apache.pinot.query.runtime.blocks.SuccessMseBlock;
+import org.apache.pinot.query.runtime.operator.BlockListMultiStageOperator;
import org.apache.pinot.query.runtime.operator.MultiStageOperator;
import org.apache.pinot.query.runtime.operator.OperatorTestUtil;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
import org.testng.Assert;
-import org.testng.annotations.AfterMethod;
-import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class UnionOperatorTest {
- private AutoCloseable _mocks;
-
- @Mock
- private MultiStageOperator _leftOperator;
-
- @Mock
- private MultiStageOperator _rightOperator;
-
- @Mock
- private VirtualServerAddress _serverAddress;
-
- @BeforeMethod
- public void setUp() {
- _mocks = MockitoAnnotations.openMocks(this);
- Mockito.when(_serverAddress.toString()).thenReturn(new
VirtualServerAddress("mock", 80, 0).toString());
- }
-
- @AfterMethod
- public void tearDown()
- throws Exception {
- _mocks.close();
- }
@Test
public void testUnionOperator() {
DataSchema schema = new DataSchema(new String[]{"int_col", "string_col"},
new DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{1, "AA"}, new
Object[]{2, "BB"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
- Mockito.when(_rightOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{3, "aa"}, new
Object[]{4, "bb"}, new Object[]{5, "cc"},
- new Object[]{2, "BB"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .buildWithEos();
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(3, "aa")
+ .addRow(4, "bb")
+ .addRow(5, "cc")
+ .addRow(2, "BB")
+ .buildWithEos();
UnionOperator unionOperator =
- new UnionOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new UnionOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
List<Object[]> resultRows = new ArrayList<>();
MseBlock result = unionOperator.nextBlock();
@@ -98,14 +73,15 @@ public class UnionOperatorTest {
DataSchema schema = new DataSchema(new String[]{"int_col", "string_col"},
new DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{1, "AA"}, new
Object[]{2, "BB"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
- Mockito.when(_rightOperator.nextBlock())
- .thenReturn(ErrorMseBlock.fromException(new RuntimeException("Error in
right operator")));
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .buildWithEos();
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .buildWithError(ErrorMseBlock.fromException(new
RuntimeException("Error in right operator")));
UnionOperator unionOperator =
- new UnionOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new UnionOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = unionOperator.nextBlock();
// Keep calling nextBlock until we get an EoS block
@@ -120,14 +96,15 @@ public class UnionOperatorTest {
DataSchema schema = new DataSchema(new String[]{"int_col", "string_col"},
new DataSchema.ColumnDataType[]{
DataSchema.ColumnDataType.INT, DataSchema.ColumnDataType.STRING
});
- Mockito.when(_leftOperator.nextBlock())
- .thenReturn(ErrorMseBlock.fromException(new RuntimeException("Error in
left operator")));
- Mockito.when(_rightOperator.nextBlock())
- .thenReturn(OperatorTestUtil.block(schema, new Object[]{3, "aa"}, new
Object[]{4, "bb"}))
- .thenReturn(SuccessMseBlock.INSTANCE);
+ MultiStageOperator leftOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .buildWithError(ErrorMseBlock.fromException(new
RuntimeException("Error in left operator")));
+ MultiStageOperator rightOperator = new
BlockListMultiStageOperator.Builder(schema)
+ .addRow(1, "AA")
+ .addRow(2, "BB")
+ .buildWithEos();
UnionOperator unionOperator =
- new UnionOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(_leftOperator, _rightOperator),
+ new UnionOperator(OperatorTestUtil.getTracingContext(),
ImmutableList.of(leftOperator, rightOperator),
schema);
MseBlock result = unionOperator.nextBlock();
// Keep calling nextBlock until we get an EoS block
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
