This is an automated email from the ASF dual-hosted git repository. amashenkov pushed a commit to branch ignite-18875 in repository https://gitbox.apache.org/repos/asf/ignite-3.git
commit 493ef3c36da7036dec6b52d4b2e3467aa255c2f8 Merge: bbc1cc9a20 172b772470 Author: amashenkov <andrey.mashen...@gmail.com> AuthorDate: Fri Jul 28 18:04:14 2023 +0300 Merge branch 'main' into ignite-18875 # Conflicts: # modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverSelfTest.java # modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/AbstractPlannerTest.java # modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/IndexSearchBoundsPlannerTest.java # modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/PlannerTest.java build.gradle | 3 +- gradle/libs.versions.toml | 1 - .../internal/catalog/CatalogManagerSelfTest.java | 3 +- .../internal/cli/commands/ProfileMixinTest.java | 3 +- .../internal/cli/sql/SqlSchemaProviderTest.java | 3 +- .../handler/JdbcQueryEventHandlerImplTest.java | 3 +- modules/client/build.gradle | 2 - .../apache/ignite/client/AbstractClientTest.java | 3 +- .../ignite/client/ClientAuthenticationTest.java | 3 +- .../apache/ignite/client/ClientComputeTest.java | 3 +- .../apache/ignite/client/ClientLoggingTest.java | 3 +- .../apache/ignite/client/ClientMetricsTest.java | 3 +- .../org/apache/ignite/client/HeartbeatTest.java | 3 +- .../org/apache/ignite/client/MultiClusterTest.java | 3 +- .../org/apache/ignite/client/ReconnectTest.java | 3 +- .../apache/ignite/client/RequestBalancingTest.java | 3 +- .../org/apache/ignite/client/RetryPolicyTest.java | 3 +- .../org/apache/ignite/client/SchemaUpdateTest.java | 3 +- .../ignite/client/fakes/FakeInternalTable.java | 4 +- .../RepeatedFinishClientTransactionTest.java | 3 +- .../cluster/management/ItClusterManagerTest.java | 2 +- .../cluster/management/ClusterInitializerTest.java | 3 +- .../management/raft/CmgRaftGroupListenerTest.java | 3 +- .../topology/LogicalTopologyImplTest.java | 3 +- .../topology/LogicalTopologyServiceImplTest.java | 3 +- .../deployunit/DeploymentManagerImplTest.java | 3 +- .../internal/compute/ComputeComponentImplTest.java | 3 +- .../internal/compute/IgniteComputeImplTest.java | 3 +- .../compute/loader/JobContextManagerTest.java | 3 +- .../ignite/internal/util/TransformingIterator.java | 12 + .../internal/util/RefCountedObjectPoolTest.java | 3 - .../internal/marshaller/FieldAccessorTest.java | 3 +- .../metastorage/impl/ItMetaStorageServiceTest.java | 3 +- .../metastorage/impl/CursorPublisherTest.java | 3 +- .../metastorage/server/AndConditionTest.java | 3 +- .../metastorage/server/WatchProcessorTest.java | 3 +- .../internal/network/netty/ConnectionManager.java | 46 ++- .../recovery/RecoveryClientHandshakeManager.java | 50 ++- .../recovery/RecoveryServerHandshakeManager.java | 50 ++- .../recovery/message/HandshakeRejectedMessage.java | 6 + .../scalecube/ScaleCubeClusterServiceFactory.java | 2 + .../internal/network/netty/InboundDecoderTest.java | 3 +- .../internal/network/netty/NettyClientTest.java | 3 +- .../internal/network/netty/NettyServerTest.java | 3 +- .../network/netty/RecoveryHandshakeTest.java | 20 +- .../network/DefaultMessagingServiceTest.java | 3 +- modules/runner/build.gradle | 28 ++ .../configuration/generator/DefaultsGenerator.java | 116 +++++++ .../storage/ItRebalanceDistributedTest.java | 3 +- .../marshaller/reflection/ColumnBindingTest.java | 3 +- .../internal/sql/engine/exec/ExecutableTable.java | 8 + .../engine/exec/ExecutableTableRegistryImpl.java | 26 +- .../engine/exec/ExecutionDependencyResolver.java | 5 +- .../exec/ExecutionDependencyResolverImpl.java | 6 +- .../sql/engine/exec/ExecutionServiceImpl.java | 55 +++- .../sql/engine/exec/ResolvedDependencies.java | 15 + .../sql/engine/metadata/FragmentMapping.java | 127 ++++++++ .../sql/engine/metadata/IgniteFragmentMapping.java | 361 +++++++++++---------- .../internal/sql/engine/metadata/NodeWithTerm.java | 27 ++ .../sql/engine/prepare/AbstractMultiStepPlan.java | 109 ------- .../internal/sql/engine/prepare/ExecutionPlan.java | 36 -- .../internal/sql/engine/prepare/Fragment.java | 58 +--- .../sql/engine/prepare/MappingQueryContext.java | 2 +- .../sql/engine/prepare/MultiStepDmlPlan.java | 54 --- .../internal/sql/engine/prepare/MultiStepPlan.java | 115 +++++-- .../sql/engine/prepare/MultiStepQueryPlan.java | 46 --- .../sql/engine/prepare/PrepareServiceImpl.java | 15 +- .../internal/sql/engine/prepare/QueryTemplate.java | 132 -------- .../sql/engine/schema/IgniteSchemaTable.java | 8 - .../internal/sql/engine/schema/IgniteTable.java | 10 - .../sql/engine/schema/IgniteTableImpl.java | 33 +- .../sql/engine/schema/SqlSchemaManagerImpl.java | 4 - .../internal/sql/engine/StopCalciteModuleTest.java | 2 +- .../sql/engine/exec/AsyncWrapperSelfTest.java | 3 +- .../exec/ExecutionDependencyResolverSelfTest.java | 72 +++- .../sql/engine/exec/ExecutionServiceImplTest.java | 21 +- ...istry.java => TestExecutableTableRegistry.java} | 42 ++- .../engine/exec/exp/ExpressionFactoryImplTest.java | 3 +- .../engine/exec/schema/SqlSchemaManagerTest.java | 3 +- .../sql/engine/framework/TestBuilders.java | 43 ++- .../sql/engine/framework/TestClusterTest.java | 10 +- .../internal/sql/engine/framework/TestNode.java | 10 +- .../internal/sql/engine/framework/TestTable.java | 6 +- .../internal/sql/engine/planner/PlannerTest.java | 96 ++++-- .../sql/engine/prepare/TypeCoercionTest.java | 6 - .../sql/engine/util/StatementCheckerTest.java | 3 +- .../ignite/internal/table/ItColocationTest.java | 3 +- .../ignite/internal/table/InternalTable.java | 2 +- .../distributed/storage/InternalTableImpl.java | 25 +- .../internal/table/InteropOperationsTest.java | 3 +- .../table/KeyValueBinaryViewOperationsTest.java | 3 +- .../KeyValueViewOperationsSimpleSchemaTest.java | 3 +- .../internal/table/KeyValueViewOperationsTest.java | 3 +- .../table/RecordBinaryViewOperationsTest.java | 3 +- .../internal/table/RecordViewOperationsTest.java | 3 +- .../internal/table/SchemaValidationTest.java | 3 +- .../state/rocksdb/RocksDbTxStateStorageTest.java | 25 +- .../storage/state/AbstractTxStateStorageTest.java | 6 +- packaging/build.gradle | 4 +- packaging/db/build.gradle | 53 ++- 100 files changed, 1274 insertions(+), 887 deletions(-) diff --cc modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverSelfTest.java index 0620046f9a,e93cb0b8d3..5a05bb9225 --- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverSelfTest.java +++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutionDependencyResolverSelfTest.java @@@ -28,22 -28,27 +28,28 @@@ import static org.mockito.Mockito.times import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; + import java.util.ArrayList; import java.util.HashMap; + import java.util.List; import java.util.Map; -import java.util.Objects; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionException; -import org.apache.calcite.rel.type.RelDataType; -import org.apache.calcite.rel.type.RelDataTypeFactory; -import org.apache.calcite.sql.type.SqlTypeName; +import java.util.function.UnaryOperator; +import org.apache.ignite.internal.schema.NativeTypes; +import org.apache.ignite.internal.sql.engine.framework.TestBuilders; +import org.apache.ignite.internal.sql.engine.framework.TestBuilders.TableBuilder; +import org.apache.ignite.internal.sql.engine.framework.TestTable; + import org.apache.ignite.internal.sql.engine.metadata.ColocationGroup; import org.apache.ignite.internal.sql.engine.planner.AbstractPlannerTest; import org.apache.ignite.internal.sql.engine.rel.IgniteRel; -import org.apache.ignite.internal.sql.engine.schema.IgniteIndex; import org.apache.ignite.internal.sql.engine.schema.IgniteSchema; import org.apache.ignite.internal.sql.engine.schema.IgniteTable; import org.apache.ignite.internal.sql.engine.schema.TableDescriptor; import org.apache.ignite.internal.sql.engine.trait.IgniteDistributions; + import org.apache.ignite.internal.utils.PrimaryReplica; + import org.apache.ignite.network.ClusterNode; + import org.apache.ignite.network.NetworkAddress; +import org.jetbrains.annotations.Nullable; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; @@@ -187,14 -205,72 +193,60 @@@ public class ExecutionDependencyResolve assertSame(err, wrapped.getCause()); } + /** Fetch colocation group succeeds. */ + @Test + public void testFetchColocationGroup() { - Tester tester = new Tester(); ++ TestTable table = createTestTable("TEST1"); ++ ++ int t1Id = table.id(); + - RelDataType tableType = new RelDataTypeFactory.Builder(TYPE_FACTORY) - .add("ID", SqlTypeName.INTEGER) - .build(); ++ Tester tester = new Tester(createSchema(table)); + - int t1Id = tester.addTable("TEST1", tableType); + ColocationGroup g1 = ColocationGroup.forNodes(List.of("n1")); + + tester.setColocationGroup(t1Id, CompletableFuture.completedFuture(g1)); + tester.setDependencies(t1Id, table1, update1); + + ResolvedDependencies deps = tester.resolveDependencies("SELECT * FROM test1").join(); + + ColocationGroup actual = deps.fetchColocationGroup(t1Id).join(); + assertSame(g1, actual); + } + + /** Fetch colocation group propagates an error. */ + @Test + public void testFetchColocationGroupErrorIsReturned() { - Tester tester = new Tester(); ++ TestTable table = createTestTable("TEST1"); + - RelDataType tableType = new RelDataTypeFactory.Builder(TYPE_FACTORY) - .add("ID", SqlTypeName.INTEGER) - .build(); ++ int t1Id = table.id(); + - int t1Id = tester.addTable("TEST1", tableType); ++ Tester tester = new Tester(createSchema(table)); + + ClusterNode node1 = new ClusterNode("1", "node1", new NetworkAddress("host", 1234)); + + List<PrimaryReplica> rs = new ArrayList<>(); + rs.add(new PrimaryReplica(node1, 5)); + + IllegalStateException error = new IllegalStateException("Not available"); + tester.setColocationGroup(t1Id, CompletableFuture.failedFuture(error)); + tester.setDependencies(t1Id, table1, update1); + + ResolvedDependencies deps = tester.resolveDependencies("SELECT * FROM test1").join(); + + CompletionException err = assertThrows(CompletionException.class, () -> deps.fetchColocationGroup(t1Id).join()); + assertSame(error, err.getCause()); + } + private class Tester { - final IgniteSchema igniteSchema = new IgniteSchema("PUBLIC"); + final IgniteSchema igniteSchema; final Map<Integer, TestExecutableTable> deps = new HashMap<>(); + final Map<Integer, CompletableFuture<ColocationGroup>> colocationGroups = new HashMap<>(); + - int addTable(String name, RelDataType rowType) { - IgniteTable table = createTable(igniteSchema, name, rowType, IgniteDistributions.single()); - igniteSchema.addTable(table); - - return table.id(); - } - - void addIndex(String tableName, IgniteIndex index) { - IgniteTable table = (IgniteTable) igniteSchema.getTable(tableName); - Objects.requireNonNull(table, "No table"); - table.addIndex(index); + Tester(IgniteSchema schema) { + igniteSchema = schema; } void setDependencies(int tableId, ScannableTable table, UpdatableTable updates) { @@@ -262,23 -347,9 +324,27 @@@ return updates; } + @Override + public CompletableFuture<ColocationGroup> fetchColocationGroup() { + return colocationGroup; + } } + + private static TestTable createTestTable(String tableName) { + return createTestTable(tableName, null); + } + + private static TestTable createTestTable(String tableName, @Nullable UnaryOperator<TableBuilder> changer) { + TableBuilder testTable = TestBuilders.table() + .name(tableName) + .addColumn("ID", NativeTypes.INT32) + .addColumn("VAL", NativeTypes.STRING) + .distribution(IgniteDistributions.single()); + + if (changer != null) { + changer.apply(testTable); + } + + return testTable.build(); + } } diff --cc modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestTable.java index 434a776ef1,ec46c53ae6..e267965264 --- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestTable.java +++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/framework/TestTable.java @@@ -187,12 -225,6 +186,11 @@@ public class TestTable implements Ignit throw new AssertionError(); } - /** {@inheritDoc} */ - @Override - public ColocationGroup colocationGroup(MappingQueryContext ctx) { ++ /** Returns colocation group for table. */ ++ public ColocationGroup colocationGroup() { + return colocationGroup; + } + /** {@inheritDoc} */ @Override public IgniteDistribution distribution() { diff --cc modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/PlannerTest.java index 3dd217976e,774436963a..1ee9955516 --- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/PlannerTest.java +++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/PlannerTest.java @@@ -26,22 -26,29 +26,28 @@@ import static org.junit.jupiter.api.Ass import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; + import java.util.HashMap; import java.util.List; + import java.util.Map; -import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Predicate; +import java.util.function.UnaryOperator; import org.apache.calcite.plan.RelOptUtil; import org.apache.calcite.plan.RelTraitSet; -import org.apache.calcite.rel.RelCollations; import org.apache.calcite.rel.RelNode; import org.apache.calcite.rel.RelRoot; -import org.apache.calcite.rel.RelVisitor; import org.apache.calcite.rel.core.TableScan; import org.apache.calcite.rel.hint.HintStrategyTable; -import org.apache.calcite.rel.type.RelDataType; -import org.apache.calcite.rel.type.RelDataTypeFactory; import org.apache.calcite.schema.SchemaPlus; import org.apache.calcite.sql.SqlNode; -import org.apache.calcite.util.ImmutableIntList; import org.apache.calcite.util.Util; +import org.apache.ignite.internal.schema.NativeTypes; + import org.apache.ignite.internal.sql.api.ResultSetMetadataImpl; + import org.apache.ignite.internal.sql.engine.SqlQueryType; +import org.apache.ignite.internal.sql.engine.framework.TestBuilders; +import org.apache.ignite.internal.sql.engine.framework.TestBuilders.TableBuilder; ++import org.apache.ignite.internal.sql.engine.framework.TestTable; import org.apache.ignite.internal.sql.engine.metadata.ColocationGroup; + import org.apache.ignite.internal.sql.engine.metadata.FragmentMapping; import org.apache.ignite.internal.sql.engine.metadata.MappingService; import org.apache.ignite.internal.sql.engine.metadata.NodeWithTerm; import org.apache.ignite.internal.sql.engine.metadata.cost.IgniteCostFactory; @@@ -54,9 -62,11 +61,10 @@@ import org.apache.ignite.internal.sql.e import org.apache.ignite.internal.sql.engine.prepare.Splitter; import org.apache.ignite.internal.sql.engine.rel.IgniteConvention; import org.apache.ignite.internal.sql.engine.rel.IgniteFilter; + import org.apache.ignite.internal.sql.engine.rel.IgniteIndexScan; import org.apache.ignite.internal.sql.engine.rel.IgniteRel; + import org.apache.ignite.internal.sql.engine.rel.IgniteTableModify; import org.apache.ignite.internal.sql.engine.rel.IgniteTableScan; -import org.apache.ignite.internal.sql.engine.schema.IgniteIndex; import org.apache.ignite.internal.sql.engine.schema.IgniteSchema; import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution; import org.apache.ignite.internal.sql.engine.trait.IgniteDistributions; @@@ -556,57 -916,62 +553,92 @@@ public class PlannerTest extends Abstra return new MappingQueryContext(locNodeName, mappingService); } - abstract static class TestTable extends AbstractPlannerTest.TestTable { - - private ColocationGroup colocationGroup; - - TestTable(RelDataType type, String name) { - super(type, name); - } - - TestTable(String name, RelDataType type, double rowCnt) { - super(name, type, rowCnt); - } - - public ColocationGroup colocationGroup() { - throw new IllegalStateException("Colocation group has not been specified"); - } - - ColocationGroup getColocationGroup() { - if (colocationGroup == null) { - this.colocationGroup = colocationGroup(); - } - return colocationGroup; - } - } - + private static final class CollectColocationGroups extends IgniteRelShuttle { + + private final Map<Integer, ColocationGroup> colocationGroups = new HashMap<>(); + + @Override + public IgniteRel visit(IgniteTableModify rel) { + TestTable testTable = rel.getTable().unwrapOrThrow(TestTable.class); - ColocationGroup group = testTable.getColocationGroup(); ++ ColocationGroup group = testTable.colocationGroup(); + + colocationGroups.put(testTable.id(), group); + + return super.visit(rel); + } + + @Override + public IgniteRel visit(IgniteIndexScan rel) { + TestTable testTable = rel.getTable().unwrapOrThrow(TestTable.class); - ColocationGroup group = testTable.getColocationGroup(); ++ ColocationGroup group = testTable.colocationGroup(); + + colocationGroups.put(testTable.id(), group); + + return super.visit(rel); + } + + @Override + public IgniteRel visit(IgniteTableScan rel) { + TestTable testTable = rel.getTable().unwrapOrThrow(TestTable.class); - ColocationGroup group = testTable.getColocationGroup(); ++ ColocationGroup group = testTable.colocationGroup(); + + colocationGroups.put(testTable.id(), group); + + return super.visit(rel); + } + } ++ + private static PlanningContext plannerContext(SchemaPlus schema, String sql, Object... params) { + return PlanningContext.builder() + .parentContext(BaseQueryContext.builder() + .logger(log) + .parameters(params) + .frameworkConfig(newConfigBuilder(FRAMEWORK_CONFIG) + .defaultSchema(schema) + .build()) + .build()) + .query(sql) + .build(); + } + + private static UnaryOperator<TableBuilder> employerTable(IgniteDistribution distribution) { + return tableBuilder -> tableBuilder + .name("EMP") + .addColumn("ID", NativeTypes.INT32) + .addColumn("NAME", NativeTypes.STRING) + .addColumn("DEPTNO", NativeTypes.INT32) + .size(100) + .distribution(distribution); + } + + private static UnaryOperator<TableBuilder> departmentTable(IgniteDistribution distribution) { + return tableBuilder -> tableBuilder + .name("DEPT") + .addColumn("DEPTNO", NativeTypes.INT32) + .addColumn("NAME", NativeTypes.STRING) + .size(100) + .distribution(distribution); + } + + private static UnaryOperator<TableBuilder> developerTable(ColocationGroup colocationGroup, IgniteDistribution distribution) { + return tableBuilder -> tableBuilder + .name("DEVELOPER") + .addColumn("ID", NativeTypes.INT32) + .addColumn("NAME", NativeTypes.STRING) + .addColumn("PROJECTID", NativeTypes.INT32) + .size(100) + .distribution(distribution) + .colocationGroup(colocationGroup); + } + + private static UnaryOperator<TableBuilder> projectsTable(ColocationGroup colocationGroup, IgniteDistribution distribution) { + return tableBuilder -> tableBuilder + .name("PROJECT") + .addColumn("ID", NativeTypes.INT32) + .addColumn("NAME", NativeTypes.STRING) + .addColumn("VER", NativeTypes.INT32) + .size(100) + .distribution(distribution) + .colocationGroup(colocationGroup); + } } diff --cc modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/prepare/TypeCoercionTest.java index b009376046,27dd399b4e..1d69733523 --- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/prepare/TypeCoercionTest.java +++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/prepare/TypeCoercionTest.java @@@ -55,17 -45,8 +55,16 @@@ import org.apache.calcite.sql.parser.Sq import org.apache.calcite.sql.parser.SqlParserPos; import org.apache.calcite.sql.type.SqlTypeName; import org.apache.calcite.sql.validate.SqlValidator; +import org.apache.calcite.util.ImmutableBitSet; +import org.apache.ignite.internal.sql.engine.framework.TestStatistic; - import org.apache.ignite.internal.sql.engine.metadata.ColocationGroup; import org.apache.ignite.internal.sql.engine.planner.AbstractPlannerTest; +import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalIndexScan; +import org.apache.ignite.internal.sql.engine.rel.logical.IgniteLogicalTableScan; +import org.apache.ignite.internal.sql.engine.schema.IgniteIndex; import org.apache.ignite.internal.sql.engine.schema.IgniteSchema; +import org.apache.ignite.internal.sql.engine.schema.IgniteTable; +import org.apache.ignite.internal.sql.engine.schema.TableDescriptor; +import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution; import org.apache.ignite.internal.sql.engine.trait.IgniteDistributions; import org.apache.ignite.internal.sql.engine.type.IgniteCustomType; import org.apache.ignite.internal.sql.engine.type.IgniteCustomTypeCoercionRules; @@@ -582,135 -569,4 +581,130 @@@ public class TypeCoercionTest extends A private static RelDataType nullable(RelDataType relDataType) { return TYPE_FACTORY.createTypeWithNullability(relDataType, true); } + + //TODO https://issues.apache.org/jira/browse/IGNITE-15200 Replace with TestTable from test framework. + // This class allows to verify some negative type-coercion tests, and can be dropped when INTERVAL type will be supported natively. + + /** Test table. */ + @Deprecated + private static class TestTable implements IgniteTable { + private final String name; + + private final RelProtoDataType protoType; + + private final int id = nextTableId(); + private final IgniteDistribution distribution; + + /** Constructor. */ + private TestTable(String name, RelDataType type, IgniteDistribution distribution) { + protoType = RelDataTypeImpl.proto(type); + this.name = name; + this.distribution = distribution; + } + + @Override + public int id() { + return id; + } + + @Override + public int version() { + return 0; + } + + @Override + public IgniteLogicalTableScan toRel( + RelOptCluster cluster, + RelOptTable relOptTbl, + List<RelHint> hints, + @Nullable List<RexNode> proj, + @Nullable RexNode cond, + @Nullable ImmutableBitSet requiredColumns + ) { + return IgniteLogicalTableScan.create(cluster, cluster.traitSet(), hints, relOptTbl, proj, cond, requiredColumns); + } + + @Override + public IgniteLogicalIndexScan toRel( + RelOptCluster cluster, + RelOptTable relOptTbl, + String idxName, + @Nullable List<RexNode> proj, + @Nullable RexNode cond, + @Nullable ImmutableBitSet requiredColumns + ) { + return IgniteLogicalIndexScan.create(cluster, cluster.traitSet(), relOptTbl, idxName, proj, cond, requiredColumns); + } + + /** {@inheritDoc} */ + @Override + public RelDataType getRowType(RelDataTypeFactory typeFactory, ImmutableBitSet bitSet) { + RelDataType rowType = protoType.apply(typeFactory); + + if (bitSet != null) { + RelDataTypeFactory.Builder b = new RelDataTypeFactory.Builder(typeFactory); + for (int i = bitSet.nextSetBit(0); i != -1; i = bitSet.nextSetBit(i + 1)) { + b.add(rowType.getFieldList().get(i)); + } + rowType = b.build(); + } + + return rowType; + } + + @Override + public Statistic getStatistic() { + return new TestStatistic(100.0); + } + + @Override + public Schema.TableType getJdbcTableType() { + throw new AssertionError(); + } + + @Override + public boolean isRolledUp(String col) { + return false; + } + + @Override + public boolean rolledUpColumnValidInsideAgg(String column, SqlCall call, SqlNode parent, CalciteConnectionConfig config) { + throw new AssertionError(); + } + - @Override - public ColocationGroup colocationGroup(MappingQueryContext ctx) { - throw new AssertionError(); - } - + @Override + public IgniteDistribution distribution() { + return distribution; + } + + @Override + public TableDescriptor descriptor() { + throw new AssertionError(); + } + + @Override + public Map<String, IgniteIndex> indexes() { + return Map.of(); + } + + @Override + public void addIndex(IgniteIndex idxTbl) { + throw new AssertionError(); + } + + @Override + public IgniteIndex getIndex(String idxName) { + throw new AssertionError(); + } + + @Override + public void removeIndex(String idxName) { + throw new AssertionError(); + } + + @Override + public String name() { + return name; + } + } }