This is an automated email from the ASF dual-hosted git repository. tkalkirill pushed a commit to branch main in repository https://gitbox.apache.org/repos/asf/ignite-3.git
The following commit(s) were added to refs/heads/main by this push: new 05c2c0fc85 IGNITE-20636 Add to the MakeIndexAvailableCommand the ability to use only the indexId (#2691) 05c2c0fc85 is described below commit 05c2c0fc8573b3bce8893588b573db6a3844663d Author: Kirill Tkalenko <tkalkir...@yandex.ru> AuthorDate: Tue Oct 17 09:20:08 2023 +0300 IGNITE-20636 Add to the MakeIndexAvailableCommand the ability to use only the indexId (#2691) --- .../apache/ignite/internal/catalog/Catalog.java | 13 +++- .../IndexAlreadyAvailableValidationException.java | 3 +- .../catalog/IndexNotFoundValidationException.java | 2 + .../internal/catalog/commands/CatalogUtils.java | 22 +++++- .../catalog/commands/CreateTableCommand.java | 1 + .../commands/MakeIndexAvailableCommand.java | 86 +++++----------------- .../commands/MakeIndexAvailableCommandBuilder.java | 8 +- .../descriptors/CatalogHashIndexDescriptor.java | 9 ++- .../descriptors/CatalogIndexDescriptor.java | 20 +++-- .../descriptors/CatalogSortedIndexDescriptor.java | 9 ++- .../descriptors/CatalogTableDescriptor.java | 8 ++ .../internal/catalog/events/CatalogEvent.java | 2 +- .../internal/catalog/storage/AlterColumnEntry.java | 1 + .../internal/catalog/storage/DropColumnsEntry.java | 1 + .../catalog/storage/MakeIndexAvailableEntry.java | 79 +++++++++++++++----- .../internal/catalog/storage/NewColumnsEntry.java | 1 + .../internal/catalog/CatalogManagerSelfTest.java | 22 ++++-- .../MakeIndexAvailableCommandValidationTest.java | 80 ++++++++++---------- .../RebalanceUtilUpdateAssignmentsTest.java | 1 + .../index/IndexAvailabilityController.java | 17 ++--- .../index/IndexAvailabilityControllerTest.java | 4 +- .../internal/schema/CatalogSchemaManagerTest.java | 8 +- .../CatalogToSchemaDescriptorConverterTest.java | 1 + .../engine/schema/CatalogSqlSchemaManagerTest.java | 5 +- .../storage/AbstractMvTableStorageTest.java | 6 +- .../index/AbstractHashIndexStorageTest.java | 2 +- .../storage/index/AbstractIndexStorageTest.java | 2 + .../index/AbstractSortedIndexStorageTest.java | 2 +- .../replication/PartitionReplicaListenerTest.java | 2 +- .../distributed/schema/FullTableSchemaTest.java | 2 +- 30 files changed, 236 insertions(+), 183 deletions(-) diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/Catalog.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/Catalog.java index c52416f0f9..f214260376 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/Catalog.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/Catalog.java @@ -57,6 +57,8 @@ public class Catalog { private final Map<String, CatalogSchemaDescriptor> schemasByName; private final Map<String, CatalogZoneDescriptor> zonesByName; + @IgniteToStringExclude + private final Int2ObjectMap<CatalogSchemaDescriptor> schemasById; @IgniteToStringExclude private final Int2ObjectMap<CatalogTableDescriptor> tablesById; @IgniteToStringExclude @@ -88,9 +90,10 @@ public class Catalog { Objects.requireNonNull(schemas, "schemas"); Objects.requireNonNull(zones, "zones"); - this.schemasByName = schemas.stream().collect(toMapByName()); - this.zonesByName = zones.stream().collect(toMapByName()); + schemasByName = schemas.stream().collect(toMapByName()); + zonesByName = zones.stream().collect(toMapByName()); + schemasById = schemas.stream().collect(toMapById()); tablesById = schemas.stream().flatMap(s -> Arrays.stream(s.tables())).collect(toMapById()); indexesById = schemas.stream().flatMap(s -> Arrays.stream(s.indexes())).collect(toMapById()); zonesById = zones.stream().collect(toMapById()); @@ -108,10 +111,14 @@ public class Catalog { return objectIdGen; } - public CatalogSchemaDescriptor schema(String name) { + public @Nullable CatalogSchemaDescriptor schema(String name) { return schemasByName.get(name); } + public @Nullable CatalogSchemaDescriptor schema(int schemaId) { + return schemasById.get(schemaId); + } + public Collection<CatalogSchemaDescriptor> schemas() { return schemasByName.values(); } diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/IndexAlreadyAvailableValidationException.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/IndexAlreadyAvailableValidationException.java index 7d1f28ff3c..7c5302cbcc 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/IndexAlreadyAvailableValidationException.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/IndexAlreadyAvailableValidationException.java @@ -20,8 +20,7 @@ package org.apache.ignite.internal.catalog; import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor; /** - * This exception is thrown when an attempt is made to make an index available a second time - * ({@link CatalogIndexDescriptor#writeOnly() read-write} state). + * This exception is thrown when an attempt is made to make an index {@link CatalogIndexDescriptor#available() available} a second time. */ public class IndexAlreadyAvailableValidationException extends CatalogValidationException { private static final long serialVersionUID = 5482919822886169473L; diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/IndexNotFoundValidationException.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/IndexNotFoundValidationException.java index 00ad321e8d..e3878ead25 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/IndexNotFoundValidationException.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/IndexNotFoundValidationException.java @@ -23,6 +23,8 @@ package org.apache.ignite.internal.catalog; * <p>Example: This exception is used to properly handle IF EXISTS flag in ddl command handler.</p> */ public class IndexNotFoundValidationException extends CatalogValidationException { + private static final long serialVersionUID = -9202116446922771598L; + public IndexNotFoundValidationException(String message) { super(message); } diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/CatalogUtils.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/CatalogUtils.java index c65beaa16c..ff9828f5b0 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/CatalogUtils.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/CatalogUtils.java @@ -367,12 +367,11 @@ public class CatalogUtils { } /** - * Returns index with given name. + * Returns index descriptor. * * @param schema Schema to look up index in. * @param name Name of the index of interest. - * @return Table with given name. - * @throws IndexNotFoundValidationException If index with given name is not exists. + * @throws IndexNotFoundValidationException If index does not exist. */ static CatalogIndexDescriptor indexOrThrow(CatalogSchemaDescriptor schema, String name) throws IndexNotFoundValidationException { CatalogIndexDescriptor index = schema.index(name); @@ -383,4 +382,21 @@ public class CatalogUtils { return index; } + + /** + * Returns index descriptor. + * + * @param catalog Catalog to look up index in. + * @param indexId ID of the index of interest. + * @throws IndexNotFoundValidationException If index does not exist. + */ + static CatalogIndexDescriptor indexOrThrow(Catalog catalog, int indexId) throws IndexNotFoundValidationException { + CatalogIndexDescriptor index = catalog.index(indexId); + + if (index == null) { + throw new IndexNotFoundValidationException(format("Index with ID '{}' not found", indexId)); + } + + return index; + } } diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/CreateTableCommand.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/CreateTableCommand.java index 8edac3cd81..a4cd3123af 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/CreateTableCommand.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/CreateTableCommand.java @@ -106,6 +106,7 @@ public class CreateTableCommand extends AbstractTableCommand { CatalogTableDescriptor table = new CatalogTableDescriptor( tableId, + schema.id(), pkIndexId, tableName, zone.id(), diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/MakeIndexAvailableCommand.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/MakeIndexAvailableCommand.java index ea3481ed07..5180d009c8 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/MakeIndexAvailableCommand.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/MakeIndexAvailableCommand.java @@ -18,113 +18,61 @@ package org.apache.ignite.internal.catalog.commands; import static org.apache.ignite.internal.catalog.commands.CatalogUtils.indexOrThrow; -import static org.apache.ignite.internal.catalog.commands.CatalogUtils.schemaOrThrow; import static org.apache.ignite.internal.lang.IgniteStringFormatter.format; import java.util.List; import org.apache.ignite.internal.catalog.Catalog; import org.apache.ignite.internal.catalog.CatalogCommand; -import org.apache.ignite.internal.catalog.CatalogValidationException; import org.apache.ignite.internal.catalog.IndexAlreadyAvailableValidationException; import org.apache.ignite.internal.catalog.IndexNotFoundValidationException; -import org.apache.ignite.internal.catalog.descriptors.CatalogHashIndexDescriptor; import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor; -import org.apache.ignite.internal.catalog.descriptors.CatalogSchemaDescriptor; -import org.apache.ignite.internal.catalog.descriptors.CatalogSortedIndexDescriptor; import org.apache.ignite.internal.catalog.storage.MakeIndexAvailableEntry; import org.apache.ignite.internal.catalog.storage.UpdateEntry; /** - * Makes the index available for read-write, switches from the write-only to the read-write state in the catalog. + * Makes the index available, switches from the registered to the available state in the catalog. * - * @see CatalogIndexDescriptor#writeOnly() + * @see CatalogIndexDescriptor#available() * @see IndexNotFoundValidationException * @see IndexAlreadyAvailableValidationException */ -public class MakeIndexAvailableCommand extends AbstractIndexCommand { - /** Returns builder to make an index available for read-write. */ +public class MakeIndexAvailableCommand implements CatalogCommand { + /** Returns builder to make an index available. */ public static MakeIndexAvailableCommandBuilder builder() { return new Builder(); } - /** - * Constructor. - * - * @param schemaName Schema name. - * @param indexName Index name. - * @throws CatalogValidationException If any of the parameters fails validation. - */ - private MakeIndexAvailableCommand(String schemaName, String indexName) throws CatalogValidationException { - super(schemaName, indexName); + private final int indexId; + + /** Constructor. */ + private MakeIndexAvailableCommand(int indexId) { + this.indexId = indexId; } @Override public List<UpdateEntry> get(Catalog catalog) { - CatalogSchemaDescriptor schema = schemaOrThrow(catalog, schemaName); - - CatalogIndexDescriptor index = indexOrThrow(schema, indexName); - - if (!index.writeOnly()) { - throw new IndexAlreadyAvailableValidationException(format("Index is already available '{}.{}'", schemaName, indexName)); - } + CatalogIndexDescriptor index = indexOrThrow(catalog, indexId); - CatalogIndexDescriptor updatedIndex; - - if (index instanceof CatalogHashIndexDescriptor) { - updatedIndex = createReadWriteIndex((CatalogHashIndexDescriptor) index); - } else if (index instanceof CatalogSortedIndexDescriptor) { - updatedIndex = createReadWriteIndex((CatalogSortedIndexDescriptor) index); - } else { - throw new CatalogValidationException(format("Unsupported index type '{}.{}' {}", schemaName, indexName, index)); + if (index.available()) { + throw new IndexAlreadyAvailableValidationException(format("Index is already available '{}'", indexId)); } - return List.of(new MakeIndexAvailableEntry(schemaName, updatedIndex)); - } - - private static CatalogIndexDescriptor createReadWriteIndex(CatalogHashIndexDescriptor index) { - return new CatalogHashIndexDescriptor( - index.id(), - index.name(), - index.tableId(), - index.unique(), - index.columns(), - false - ); - } - - private static CatalogIndexDescriptor createReadWriteIndex(CatalogSortedIndexDescriptor index) { - return new CatalogSortedIndexDescriptor( - index.id(), - index.name(), - index.tableId(), - index.unique(), - index.columns(), - false - ); + return List.of(new MakeIndexAvailableEntry(indexId)); } private static class Builder implements MakeIndexAvailableCommandBuilder { - private String schemaName; - - private String indexName; - - @Override - public Builder schemaName(String schemaName) { - this.schemaName = schemaName; - - return this; - } + private int indexId; @Override - public Builder indexName(String indexName) { - this.indexName = indexName; + public Builder indexId(int indexId) { + this.indexId = indexId; return this; } @Override public CatalogCommand build() { - return new MakeIndexAvailableCommand(schemaName, indexName); + return new MakeIndexAvailableCommand(indexId); } } } diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/MakeIndexAvailableCommandBuilder.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/MakeIndexAvailableCommandBuilder.java index 7fadf5a931..aafb705b5d 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/MakeIndexAvailableCommandBuilder.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/commands/MakeIndexAvailableCommandBuilder.java @@ -17,6 +17,12 @@ package org.apache.ignite.internal.catalog.commands; +import org.apache.ignite.internal.catalog.CatalogCommand; + /** Builder for {@link MakeIndexAvailableCommand}. */ -public interface MakeIndexAvailableCommandBuilder extends AbstractIndexCommandBuilder<MakeIndexAvailableCommandBuilder> { +public interface MakeIndexAvailableCommandBuilder { + /** Index ID. */ + MakeIndexAvailableCommandBuilder indexId(int indexId); + + CatalogCommand build(); } diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogHashIndexDescriptor.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogHashIndexDescriptor.java index e5e61749af..2f92890e5e 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogHashIndexDescriptor.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogHashIndexDescriptor.java @@ -38,7 +38,7 @@ public class CatalogHashIndexDescriptor extends CatalogIndexDescriptor { * @throws IllegalArgumentException If columns list contains duplicates. */ public CatalogHashIndexDescriptor(int id, String name, int tableId, boolean unique, List<String> columns) { - this(id, name, tableId, unique, columns, true); + this(id, name, tableId, unique, columns, false); } /** @@ -49,11 +49,12 @@ public class CatalogHashIndexDescriptor extends CatalogIndexDescriptor { * @param tableId Id of the table index belongs to. * @param unique Unique flag. * @param columns A list of indexed columns. Must not contains duplicates. - * @param writeOnly State of the index, {@code true} when index is building, {@code false} when the index is built. + * @param available Availability flag, {@code true} means it is available (the index has been built), otherwise it is registered + * (the index has not yet been built). * @throws IllegalArgumentException If columns list contains duplicates. */ - public CatalogHashIndexDescriptor(int id, String name, int tableId, boolean unique, List<String> columns, boolean writeOnly) { - super(id, name, tableId, unique, writeOnly); + public CatalogHashIndexDescriptor(int id, String name, int tableId, boolean unique, List<String> columns, boolean available) { + super(id, name, tableId, unique, available); this.columns = List.copyOf(Objects.requireNonNull(columns, "columns")); } diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogIndexDescriptor.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogIndexDescriptor.java index be6d6d5fb9..3a6720efe4 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogIndexDescriptor.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogIndexDescriptor.java @@ -31,14 +31,17 @@ public abstract class CatalogIndexDescriptor extends CatalogObjectDescriptor { /** Unique constraint flag. */ private final boolean unique; - /** Write only flag. {@code True} when the index is being built, {@code false} when it is built. */ - private final boolean writeOnly; + /** + * Index availability flag, {@code true} means it is available (the index has been built), otherwise it is registered + * (the index has not yet been built). + */ + private final boolean available; - CatalogIndexDescriptor(int id, String name, int tableId, boolean unique, boolean writeOnly) { + CatalogIndexDescriptor(int id, String name, int tableId, boolean unique, boolean available) { super(id, Type.INDEX, name, INITIAL_CAUSALITY_TOKEN); this.tableId = tableId; this.unique = unique; - this.writeOnly = writeOnly; + this.available = available; } /** Gets table id. */ @@ -51,9 +54,12 @@ public abstract class CatalogIndexDescriptor extends CatalogObjectDescriptor { return unique; } - /** Returns the state of the index, {@code true} when the index is being built, {@code false} when it is built. */ - public boolean writeOnly() { - return writeOnly; + /** + * Returns index availability flag, {@code true} means it is available (the index has been built), otherwise it is + * registered (the index has not yet been built). + */ + public boolean available() { + return available; } @Override diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogSortedIndexDescriptor.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogSortedIndexDescriptor.java index 1adce3a338..e73302e8a5 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogSortedIndexDescriptor.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogSortedIndexDescriptor.java @@ -45,7 +45,7 @@ public class CatalogSortedIndexDescriptor extends CatalogIndexDescriptor { boolean unique, List<CatalogIndexColumnDescriptor> columns ) { - this(id, name, tableId, unique, columns, true); + this(id, name, tableId, unique, columns, false); } /** @@ -56,7 +56,8 @@ public class CatalogSortedIndexDescriptor extends CatalogIndexDescriptor { * @param tableId Id of the table index belongs to. * @param unique Unique flag. * @param columns A list of columns descriptors. - * @param writeOnly State of the index, {@code true} when index is building, {@code false} when the index is built. + * @param available Availability flag, {@code true} means it is available (the index has been built), otherwise it is registered + * (the index has not yet been built). * @throws IllegalArgumentException If columns list contains duplicates or columns size doesn't match the collations size. */ public CatalogSortedIndexDescriptor( @@ -65,9 +66,9 @@ public class CatalogSortedIndexDescriptor extends CatalogIndexDescriptor { int tableId, boolean unique, List<CatalogIndexColumnDescriptor> columns, - boolean writeOnly + boolean available ) { - super(id, name, tableId, unique, writeOnly); + super(id, name, tableId, unique, available); this.columns = Objects.requireNonNull(columns, "columns"); } diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogTableDescriptor.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogTableDescriptor.java index 65134ae8db..9949dc2bf8 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogTableDescriptor.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/descriptors/CatalogTableDescriptor.java @@ -39,6 +39,8 @@ public class CatalogTableDescriptor extends CatalogObjectDescriptor { private final int zoneId; + private final int schemaId; + private final int pkIndexId; private final int tableVersion; @@ -64,6 +66,7 @@ public class CatalogTableDescriptor extends CatalogObjectDescriptor { */ public CatalogTableDescriptor( int id, + int schemaId, int pkIndexId, String name, int zoneId, @@ -75,6 +78,7 @@ public class CatalogTableDescriptor extends CatalogObjectDescriptor { ) { super(id, Type.TABLE, name, causalityToken); + this.schemaId = schemaId; this.pkIndexId = pkIndexId; this.zoneId = zoneId; this.tableVersion = tableVersion; @@ -98,6 +102,10 @@ public class CatalogTableDescriptor extends CatalogObjectDescriptor { return columnsMap.get(columnName); } + public int schemaId() { + return schemaId; + } + public int zoneId() { return zoneId; } diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/events/CatalogEvent.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/events/CatalogEvent.java index 23842bb38a..444aa30ffd 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/events/CatalogEvent.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/events/CatalogEvent.java @@ -38,7 +38,7 @@ public enum CatalogEvent implements Event { /** This event is fired, when an index was dropped in Catalog. */ INDEX_DROP, - /** This event is fired when the index becomes available for read-write, i.e. the index has been built. */ + /** This event is fired when the index becomes available, i.e. the index has been built. */ INDEX_AVAILABLE, /** This event is fired, when a distribution zone was created in Catalog. */ diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/AlterColumnEntry.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/AlterColumnEntry.java index 553c0e4bdf..bd0d04b818 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/AlterColumnEntry.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/AlterColumnEntry.java @@ -93,6 +93,7 @@ public class AlterColumnEntry implements UpdateEntry, Fireable { ? table : new CatalogTableDescriptor( table.id(), + table.schemaId(), table.primaryKeyIndexId(), table.name(), table.zoneId(), diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/DropColumnsEntry.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/DropColumnsEntry.java index 0d193453f9..6dae7b0075 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/DropColumnsEntry.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/DropColumnsEntry.java @@ -89,6 +89,7 @@ public class DropColumnsEntry implements UpdateEntry, Fireable { Arrays.stream(schema.tables()) .map(table -> table.id() == tableId ? new CatalogTableDescriptor( table.id(), + table.schemaId(), table.primaryKeyIndexId(), table.name(), table.zoneId(), diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/MakeIndexAvailableEntry.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/MakeIndexAvailableEntry.java index 49a38fd4f5..1e1c18efa5 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/MakeIndexAvailableEntry.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/MakeIndexAvailableEntry.java @@ -17,12 +17,18 @@ package org.apache.ignite.internal.catalog.storage; +import static org.apache.ignite.internal.lang.IgniteStringFormatter.format; + import java.util.Arrays; import org.apache.ignite.internal.catalog.Catalog; +import org.apache.ignite.internal.catalog.CatalogValidationException; import org.apache.ignite.internal.catalog.commands.CatalogUtils; import org.apache.ignite.internal.catalog.commands.MakeIndexAvailableCommand; +import org.apache.ignite.internal.catalog.descriptors.CatalogHashIndexDescriptor; import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor; import org.apache.ignite.internal.catalog.descriptors.CatalogSchemaDescriptor; +import org.apache.ignite.internal.catalog.descriptors.CatalogSortedIndexDescriptor; +import org.apache.ignite.internal.catalog.descriptors.CatalogTableDescriptor; import org.apache.ignite.internal.catalog.events.CatalogEvent; import org.apache.ignite.internal.catalog.events.CatalogEventParameters; import org.apache.ignite.internal.catalog.events.MakeIndexAvailableEventParameters; @@ -31,21 +37,16 @@ import org.apache.ignite.internal.catalog.events.MakeIndexAvailableEventParamete public class MakeIndexAvailableEntry implements UpdateEntry, Fireable { private static final long serialVersionUID = -5686678143537999594L; - private final String schemaName; - - private final CatalogIndexDescriptor descriptor; + private final int indexId; /** Constructor. */ - public MakeIndexAvailableEntry(String schemaName, CatalogIndexDescriptor descriptor) { - this.schemaName = schemaName; - this.descriptor = descriptor; + public MakeIndexAvailableEntry(int indexId) { + this.indexId = indexId; } @Override public Catalog applyUpdate(Catalog catalog, long causalityToken) { - descriptor.updateToken(causalityToken); - - CatalogSchemaDescriptor schema = catalog.schema(schemaName); + CatalogSchemaDescriptor schema = schemaByIndexId(catalog, indexId); return new Catalog( catalog.version(), @@ -57,7 +58,7 @@ public class MakeIndexAvailableEntry implements UpdateEntry, Fireable { schema.name(), schema.tables(), Arrays.stream(schema.indexes()) - .map(source -> source.id() == descriptor.id() ? descriptor : source) + .map(source -> source.id() == indexId ? createAvailableIndex(source, causalityToken) : source) .toArray(CatalogIndexDescriptor[]::new), schema.systemViews(), causalityToken @@ -72,16 +73,60 @@ public class MakeIndexAvailableEntry implements UpdateEntry, Fireable { @Override public CatalogEventParameters createEventParameters(long causalityToken, int catalogVersion) { - return new MakeIndexAvailableEventParameters(causalityToken, catalogVersion, descriptor.id()); + return new MakeIndexAvailableEventParameters(causalityToken, catalogVersion, indexId); + } + + private static CatalogSchemaDescriptor schemaByIndexId(Catalog catalog, int indexId) { + CatalogIndexDescriptor index = catalog.index(indexId); + + assert index != null : indexId; + + CatalogTableDescriptor table = catalog.table(index.tableId()); + + assert table != null : index.tableId(); + + CatalogSchemaDescriptor schema = catalog.schema(table.schemaId()); + + assert schema != null : table.schemaId(); + + return schema; } - /** Returns schema name. */ - public String schemaName() { - return schemaName; + private static CatalogIndexDescriptor createAvailableIndex(CatalogIndexDescriptor source, long causalityToken) { + CatalogIndexDescriptor updateIndexDescriptor; + + if (source instanceof CatalogHashIndexDescriptor) { + updateIndexDescriptor = createAvailableIndex((CatalogHashIndexDescriptor) source); + } else if (source instanceof CatalogSortedIndexDescriptor) { + updateIndexDescriptor = createAvailableIndex((CatalogSortedIndexDescriptor) source); + } else { + throw new CatalogValidationException(format("Unsupported index type '{}' {}", source.id(), source)); + } + + updateIndexDescriptor.updateToken(causalityToken); + + return updateIndexDescriptor; } - /** Returns descriptor of the available to read-write index. */ - public CatalogIndexDescriptor descriptor() { - return descriptor; + private static CatalogIndexDescriptor createAvailableIndex(CatalogHashIndexDescriptor index) { + return new CatalogHashIndexDescriptor( + index.id(), + index.name(), + index.tableId(), + index.unique(), + index.columns(), + true + ); + } + + private static CatalogIndexDescriptor createAvailableIndex(CatalogSortedIndexDescriptor index) { + return new CatalogSortedIndexDescriptor( + index.id(), + index.name(), + index.tableId(), + index.unique(), + index.columns(), + true + ); } } diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/NewColumnsEntry.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/NewColumnsEntry.java index 84acafa38b..5581fc1458 100644 --- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/NewColumnsEntry.java +++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/storage/NewColumnsEntry.java @@ -88,6 +88,7 @@ public class NewColumnsEntry implements UpdateEntry, Fireable { Arrays.stream(schema.tables()) .map(table -> table.id() == tableId ? new CatalogTableDescriptor( table.id(), + table.schemaId(), table.primaryKeyIndexId(), table.name(), table.zoneId(), diff --git a/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/CatalogManagerSelfTest.java b/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/CatalogManagerSelfTest.java index e38cbad407..01f78d5125 100644 --- a/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/CatalogManagerSelfTest.java +++ b/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/CatalogManagerSelfTest.java @@ -962,7 +962,7 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest { assertEquals(schema.table(TABLE_NAME).id(), index.tableId()); assertEquals(List.of("VAL", "ID"), index.columns()); assertFalse(index.unique()); - assertTrue(index.writeOnly()); + assertFalse(index.available()); } @Test @@ -1003,7 +1003,7 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest { assertEquals(DESC_NULLS_FIRST, index.columns().get(0).collation()); assertEquals(ASC_NULLS_LAST, index.columns().get(1).collation()); assertTrue(index.unique()); - assertTrue(index.writeOnly()); + assertFalse(index.available()); } @Test @@ -1868,13 +1868,13 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest { ); assertThat( - manager.execute(MakeIndexAvailableCommand.builder().schemaName(DEFAULT_SCHEMA_NAME).indexName(INDEX_NAME).build()), + manager.execute(MakeIndexAvailableCommand.builder().indexId(indexId(INDEX_NAME)).build()), willBe(nullValue()) ); CatalogHashIndexDescriptor index = (CatalogHashIndexDescriptor) index(manager.latestCatalogVersion(), INDEX_NAME); - assertFalse(index.writeOnly()); + assertTrue(index.available()); } @Test @@ -1887,13 +1887,13 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest { ); assertThat( - manager.execute(MakeIndexAvailableCommand.builder().schemaName(DEFAULT_SCHEMA_NAME).indexName(INDEX_NAME).build()), + manager.execute(MakeIndexAvailableCommand.builder().indexId(indexId(INDEX_NAME)).build()), willBe(nullValue()) ); CatalogSortedIndexDescriptor index = (CatalogSortedIndexDescriptor) index(manager.latestCatalogVersion(), INDEX_NAME); - assertFalse(index.writeOnly()); + assertTrue(index.available()); } @Test @@ -1926,7 +1926,7 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest { }); assertThat( - manager.execute(MakeIndexAvailableCommand.builder().schemaName(DEFAULT_SCHEMA_NAME).indexName(INDEX_NAME).build()), + manager.execute(MakeIndexAvailableCommand.builder().indexId(indexId(INDEX_NAME)).build()), willBe(nullValue()) ); @@ -2001,4 +2001,12 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest { private @Nullable CatalogIndexDescriptor index(int catalogVersion, String indexName) { return manager.schema(catalogVersion).index(indexName); } + + private int indexId(String indexName) { + CatalogIndexDescriptor index = manager.index(indexName, clock.nowLong()); + + assertNotNull(index, indexName); + + return index.id(); + } } diff --git a/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/commands/MakeIndexAvailableCommandValidationTest.java b/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/commands/MakeIndexAvailableCommandValidationTest.java index 1b321f583d..9fd0569074 100644 --- a/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/commands/MakeIndexAvailableCommandValidationTest.java +++ b/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/commands/MakeIndexAvailableCommandValidationTest.java @@ -17,90 +17,90 @@ package org.apache.ignite.internal.catalog.commands; +import static org.apache.ignite.internal.catalog.commands.CatalogUtils.DEFAULT_LENGTH; +import static org.apache.ignite.internal.catalog.commands.CatalogUtils.DEFAULT_PRECISION; +import static org.apache.ignite.internal.catalog.commands.CatalogUtils.DEFAULT_SCALE; +import static org.apache.ignite.internal.catalog.descriptors.CatalogTableDescriptor.INITIAL_TABLE_VERSION; +import static org.apache.ignite.internal.lang.IgniteStringFormatter.format; import static org.apache.ignite.internal.testframework.IgniteTestUtils.assertThrowsWithCause; +import static org.apache.ignite.sql.ColumnType.INT32; import java.util.List; import org.apache.ignite.internal.catalog.Catalog; import org.apache.ignite.internal.catalog.CatalogCommand; -import org.apache.ignite.internal.catalog.CatalogValidationException; import org.apache.ignite.internal.catalog.IndexAlreadyAvailableValidationException; import org.apache.ignite.internal.catalog.IndexNotFoundValidationException; import org.apache.ignite.internal.catalog.descriptors.CatalogHashIndexDescriptor; import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor; import org.apache.ignite.internal.catalog.descriptors.CatalogSystemViewDescriptor; +import org.apache.ignite.internal.catalog.descriptors.CatalogTableColumnDescriptor; import org.apache.ignite.internal.catalog.descriptors.CatalogTableDescriptor; import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.MethodSource; /** Tests to verify validation of {@link MakeIndexAvailableCommand}. */ @SuppressWarnings("ThrowableNotThrown") public class MakeIndexAvailableCommandValidationTest extends AbstractCommandValidationTest { - @ParameterizedTest(name = "[{index}] ''{argumentsWithNames}''") - @MethodSource("nullAndBlankStrings") - void schemaNameMustNotBeNullOrBlank(String name) { - MakeIndexAvailableCommandBuilder builder = MakeIndexAvailableCommand.builder(); - - builder.indexName("TEST").schemaName(name); - - assertThrowsWithCause( - builder::build, - CatalogValidationException.class, - "Name of the schema can't be null or blank" - ); - } - - @ParameterizedTest(name = "[{index}] ''{argumentsWithNames}''") - @MethodSource("nullAndBlankStrings") - void indexNameMustNotBeNullOrBlank(String name) { - MakeIndexAvailableCommandBuilder builder = MakeIndexAvailableCommand.builder(); - - builder.schemaName(SCHEMA_NAME).indexName(name); - - assertThrowsWithCause( - builder::build, - CatalogValidationException.class, - "Name of the index can't be null or blank" - ); - } - @Test void exceptionIsThrownIfIndexWithGivenNameNotFound() { Catalog catalog = emptyCatalog(); CatalogCommand command = MakeIndexAvailableCommand.builder() - .schemaName(SCHEMA_NAME) - .indexName("TEST") + .indexId(1) .build(); assertThrowsWithCause( () -> command.get(catalog), IndexNotFoundValidationException.class, - "Index with name 'PUBLIC.TEST' not found" + "Index with ID '1' not found" ); } @Test void exceptionIsThrownIfIndexIsAlreadyAvailable() { - String indexName = "TEST"; + int id = 0; + + int tableId = id++; + int indexId = id++; + + String columnName = "c"; Catalog catalog = catalog( - new CatalogTableDescriptor[]{}, + new CatalogTableDescriptor[]{ + table(tableId, id++, id++, id++, columnName) + }, new CatalogIndexDescriptor[]{ - new CatalogHashIndexDescriptor(10, indexName, 1, false, List.of("c"), false) + new CatalogHashIndexDescriptor(indexId, "TEST_INDEX", tableId, false, List.of(columnName), true) }, new CatalogSystemViewDescriptor[]{} ); CatalogCommand command = MakeIndexAvailableCommand.builder() - .schemaName(SCHEMA_NAME) - .indexName(indexName) + .indexId(indexId) .build(); assertThrowsWithCause( () -> command.get(catalog), IndexAlreadyAvailableValidationException.class, - "Index is already available 'PUBLIC.TEST'" + format("Index is already available '{}'", indexId) ); } + + private static CatalogTableDescriptor table(int tableId, int schemaId, int zoneId, int pkIndexId, String columnName) { + return new CatalogTableDescriptor( + tableId, + schemaId, + pkIndexId, + "TEST_TABLE", + zoneId, + INITIAL_TABLE_VERSION, + List.of(tableColumn(columnName)), + List.of(columnName), + null, + 1 + ); + } + + private static CatalogTableColumnDescriptor tableColumn(String columnName) { + return new CatalogTableColumnDescriptor(columnName, INT32, false, DEFAULT_PRECISION, DEFAULT_SCALE, DEFAULT_LENGTH, null); + } } diff --git a/modules/distribution-zones/src/test/java/org/apache/ignite/internal/distributionzones/rebalance/RebalanceUtilUpdateAssignmentsTest.java b/modules/distribution-zones/src/test/java/org/apache/ignite/internal/distributionzones/rebalance/RebalanceUtilUpdateAssignmentsTest.java index 5dea3ed336..daf0d4d36b 100644 --- a/modules/distribution-zones/src/test/java/org/apache/ignite/internal/distributionzones/rebalance/RebalanceUtilUpdateAssignmentsTest.java +++ b/modules/distribution-zones/src/test/java/org/apache/ignite/internal/distributionzones/rebalance/RebalanceUtilUpdateAssignmentsTest.java @@ -87,6 +87,7 @@ public class RebalanceUtilUpdateAssignmentsTest extends IgniteAbstractTest { private final CatalogTableDescriptor tableDescriptor = new CatalogTableDescriptor( 1, -1, + -1, "table1", 0, 1, diff --git a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexAvailabilityController.java b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexAvailabilityController.java index 633d0cf133..8f135af85a 100644 --- a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexAvailabilityController.java +++ b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexAvailabilityController.java @@ -22,7 +22,6 @@ import static java.util.concurrent.CompletableFuture.completedFuture; import static java.util.concurrent.CompletableFuture.failedFuture; import static java.util.function.Predicate.not; import static java.util.stream.Collectors.toList; -import static org.apache.ignite.internal.catalog.CatalogService.DEFAULT_SCHEMA_NAME; import static org.apache.ignite.internal.metastorage.dsl.Conditions.exists; import static org.apache.ignite.internal.metastorage.dsl.Conditions.notExists; import static org.apache.ignite.internal.metastorage.dsl.Operations.noop; @@ -70,9 +69,9 @@ import org.apache.ignite.internal.util.IgniteSpinBusyLock; /** * This component is responsible for ensuring that an index, upon completion of a distributed index building for all partitions, becomes - * available for read-write. + * available. * - * <p>An approximate algorithm for making an index available for read-write:</p> + * <p>An approximate algorithm for making an index available:</p> * <ul> * <li>On {@link CatalogEvent#INDEX_CREATE}, keys are created in the metastore: {@code indexBuild.inProgress.<indexId>} and * {@code indexBuild.partition.<indexId>.<partitionId_0>}...{@code indexBuild.partition.<indexId>.<partitionId_N>}.</li> @@ -94,7 +93,7 @@ import org.apache.ignite.internal.util.IgniteSpinBusyLock; * {@link IndexBuildCompletionListener#onBuildCompletion} (form {@link IndexBuilder#listen}) event.</li> * </ul> * - * @see CatalogIndexDescriptor#writeOnly() + * @see CatalogIndexDescriptor#available() */ // TODO: IGNITE-20637 Recovery needs to be implemented // TODO: IGNITE-20637 Need integration with the IgniteImpl @@ -243,13 +242,10 @@ public class IndexAvailabilityController implements ManuallyCloseable { return completedFuture(null); } - // We can use the latest version of the catalog since we are on the metastore thread. - CatalogIndexDescriptor indexDescriptor = getIndexDescriptorStrict(indexId, catalogManager.latestCatalogVersion()); - // We will not wait for the command to be executed, since we will then find ourselves in a dead lock since we will not be able // to free the metastore thread. catalogManager - .execute(buildMakeIndexAvailableCommand(indexDescriptor)) + .execute(buildMakeIndexAvailableCommand(indexId)) .whenComplete((unused, throwable) -> { if (throwable != null) { Throwable unwrapCause = unwrapCause(throwable); @@ -354,8 +350,7 @@ public class IndexAvailabilityController implements ManuallyCloseable { return Integer.parseInt(key.substring(indexIdFromIndex, indexIdToIndex)); } - private static CatalogCommand buildMakeIndexAvailableCommand(CatalogIndexDescriptor indexDescriptor) { - // TODO: IGNITE-20636 Use only indexId - return MakeIndexAvailableCommand.builder().schemaName(DEFAULT_SCHEMA_NAME).indexName(indexDescriptor.name()).build(); + private static CatalogCommand buildMakeIndexAvailableCommand(int indexId) { + return MakeIndexAvailableCommand.builder().indexId(indexId).build(); } } diff --git a/modules/index/src/test/java/org/apache/ignite/internal/index/IndexAvailabilityControllerTest.java b/modules/index/src/test/java/org/apache/ignite/internal/index/IndexAvailabilityControllerTest.java index 805692aa7e..12a40a5463 100644 --- a/modules/index/src/test/java/org/apache/ignite/internal/index/IndexAvailabilityControllerTest.java +++ b/modules/index/src/test/java/org/apache/ignite/internal/index/IndexAvailabilityControllerTest.java @@ -172,7 +172,7 @@ public class IndexAvailabilityControllerTest extends BaseIgniteAbstractTest { assertPartitionBuildIndexKeyExists(indexId, partitionId); } - assertTrue(indexDescriptor(INDEX_NAME).writeOnly()); + assertFalse(indexDescriptor(INDEX_NAME).available()); } @Test @@ -196,7 +196,7 @@ public class IndexAvailabilityControllerTest extends BaseIgniteAbstractTest { assertPartitionBuildIndexKeyAbsent(indexId, partitionId); } - assertFalse(indexDescriptor(INDEX_NAME).writeOnly()); + assertTrue(indexDescriptor(INDEX_NAME).available()); } @Test diff --git a/modules/schema/src/test/java/org/apache/ignite/internal/schema/CatalogSchemaManagerTest.java b/modules/schema/src/test/java/org/apache/ignite/internal/schema/CatalogSchemaManagerTest.java index ff2ada58f1..f543fb2db1 100644 --- a/modules/schema/src/test/java/org/apache/ignite/internal/schema/CatalogSchemaManagerTest.java +++ b/modules/schema/src/test/java/org/apache/ignite/internal/schema/CatalogSchemaManagerTest.java @@ -174,7 +174,7 @@ class CatalogSchemaManagerTest extends BaseIgniteAbstractTest { new CatalogTableColumnDescriptor("v1", ColumnType.INT32, false, 0, 0, 0, null) ); CatalogTableDescriptor tableDescriptor = new CatalogTableDescriptor( - TABLE_ID, -1, TABLE_NAME, 0, 1, columns, List.of("k1", "k2"), null, INITIAL_CAUSALITY_TOKEN + TABLE_ID, -1, -1, TABLE_NAME, 0, 1, columns, List.of("k1", "k2"), null, INITIAL_CAUSALITY_TOKEN ); CompletableFuture<Boolean> future = tableCreatedListener() @@ -244,7 +244,7 @@ class CatalogSchemaManagerTest extends BaseIgniteAbstractTest { new CatalogTableColumnDescriptor("v2", ColumnType.STRING, false, 0, 0, 0, null) ); - return new CatalogTableDescriptor(TABLE_ID, -1, TABLE_NAME, 0, 2, columns, List.of("k1", "k2"), null, INITIAL_CAUSALITY_TOKEN); + return new CatalogTableDescriptor(TABLE_ID, -1, -1, TABLE_NAME, 0, 2, columns, List.of("k1", "k2"), null, INITIAL_CAUSALITY_TOKEN); } private void completeCausalityToken(long causalityToken) { @@ -280,7 +280,7 @@ class CatalogSchemaManagerTest extends BaseIgniteAbstractTest { new CatalogTableColumnDescriptor("k2", ColumnType.STRING, false, 0, 0, 0, null) ); - return new CatalogTableDescriptor(TABLE_ID, -1, TABLE_NAME, 0, 2, columns, List.of("k1", "k2"), null, INITIAL_CAUSALITY_TOKEN); + return new CatalogTableDescriptor(TABLE_ID, -1, -1, TABLE_NAME, 0, 2, columns, List.of("k1", "k2"), null, INITIAL_CAUSALITY_TOKEN); } @Test @@ -318,7 +318,7 @@ class CatalogSchemaManagerTest extends BaseIgniteAbstractTest { new CatalogTableColumnDescriptor("v1", ColumnType.INT64, false, 0, 0, 0, null) ); - return new CatalogTableDescriptor(TABLE_ID, -1, TABLE_NAME, 0, 2, columns, List.of("k1", "k2"), null, INITIAL_CAUSALITY_TOKEN); + return new CatalogTableDescriptor(TABLE_ID, -1, -1, TABLE_NAME, 0, 2, columns, List.of("k1", "k2"), null, INITIAL_CAUSALITY_TOKEN); } @Test diff --git a/modules/schema/src/test/java/org/apache/ignite/internal/schema/catalog/CatalogToSchemaDescriptorConverterTest.java b/modules/schema/src/test/java/org/apache/ignite/internal/schema/catalog/CatalogToSchemaDescriptorConverterTest.java index e53253fd9f..5478e96eee 100644 --- a/modules/schema/src/test/java/org/apache/ignite/internal/schema/catalog/CatalogToSchemaDescriptorConverterTest.java +++ b/modules/schema/src/test/java/org/apache/ignite/internal/schema/catalog/CatalogToSchemaDescriptorConverterTest.java @@ -131,6 +131,7 @@ public class CatalogToSchemaDescriptorConverterTest extends AbstractSchemaConver CatalogTableDescriptor tableDescriptor = new CatalogTableDescriptor( 1, -1, + -1, "test", 0, 1, diff --git a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/schema/CatalogSqlSchemaManagerTest.java b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/schema/CatalogSqlSchemaManagerTest.java index cf0b2198f1..c5582a2e69 100644 --- a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/schema/CatalogSqlSchemaManagerTest.java +++ b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/schema/CatalogSqlSchemaManagerTest.java @@ -695,6 +695,7 @@ public class CatalogSqlSchemaManagerTest extends BaseIgniteAbstractTest { return new CatalogTableDescriptor( id, -1, + -1, name, zoneId, CatalogTableDescriptor.INITIAL_TABLE_VERSION, @@ -726,13 +727,13 @@ public class CatalogSqlSchemaManagerTest extends BaseIgniteAbstractTest { CatalogIndexDescriptor newDescriptor(int tableId) { if (hashColumns != null) { - return new CatalogHashIndexDescriptor(id, name, tableId, false, hashColumns, false); + return new CatalogHashIndexDescriptor(id, name, tableId, false, hashColumns, true); } else if (sortedColumns != null) { List<CatalogIndexColumnDescriptor> indexColumns = sortedColumns.stream() .map((e) -> new CatalogIndexColumnDescriptor(e.getKey(), e.getValue())) .collect(Collectors.toList()); - return new CatalogSortedIndexDescriptor(id, name, tableId, false, indexColumns, false); + return new CatalogSortedIndexDescriptor(id, name, tableId, false, indexColumns, true); } else { throw new IllegalStateException("Unable to create index"); } diff --git a/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/AbstractMvTableStorageTest.java b/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/AbstractMvTableStorageTest.java index ee88f8613e..3d0a054112 100644 --- a/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/AbstractMvTableStorageTest.java +++ b/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/AbstractMvTableStorageTest.java @@ -763,6 +763,7 @@ public abstract class AbstractMvTableStorageTest extends BaseMvStoragesTest { private static void createTestTableAndIndexes(CatalogService catalogService) { int id = 0; + int schemaId = id++; int tableId = id++; int zoneId = id++; int sortedIndexId = id++; @@ -770,6 +771,7 @@ public abstract class AbstractMvTableStorageTest extends BaseMvStoragesTest { CatalogTableDescriptor tableDescriptor = new CatalogTableDescriptor( tableId, + schemaId, hashIndexId, TABLE_NAME, zoneId, @@ -791,7 +793,7 @@ public abstract class AbstractMvTableStorageTest extends BaseMvStoragesTest { tableId, false, List.of(new CatalogIndexColumnDescriptor("STRKEY", ASC_NULLS_LAST)), - false + true ); CatalogHashIndexDescriptor hashIndex = new CatalogHashIndexDescriptor( @@ -800,7 +802,7 @@ public abstract class AbstractMvTableStorageTest extends BaseMvStoragesTest { tableId, true, List.of("STRKEY"), - false + true ); when(catalogService.table(eq(TABLE_NAME), anyLong())).thenReturn(tableDescriptor); diff --git a/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractHashIndexStorageTest.java b/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractHashIndexStorageTest.java index 70ffd65e05..d33a33e753 100644 --- a/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractHashIndexStorageTest.java +++ b/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractHashIndexStorageTest.java @@ -50,7 +50,7 @@ public abstract class AbstractHashIndexStorageTest extends AbstractIndexStorageT catalogTableDescriptor.id(), false, Stream.of(columnTypes).map(AbstractIndexStorageTest::columnName).collect(toList()), - false + true ); when(catalogService.index(eq(name), anyLong())).thenReturn(catalogHashIndexDescriptor); diff --git a/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractIndexStorageTest.java b/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractIndexStorageTest.java index 042b110214..e0f97a2b7b 100644 --- a/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractIndexStorageTest.java +++ b/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractIndexStorageTest.java @@ -148,11 +148,13 @@ public abstract class AbstractIndexStorageTest<S extends IndexStorage, D extends private static void createTestTable(CatalogService catalogService, AtomicInteger catalogId) { ColumnParams pkColumn = ColumnParams.builder().name("pk").type(ColumnType.INT32).nullable(false).build(); + int schemaId = catalogId.getAndIncrement(); int tableId = catalogId.getAndIncrement(); int zoneId = catalogId.getAndIncrement(); CatalogTableDescriptor tableDescriptor = new CatalogTableDescriptor( tableId, + schemaId, 1, TABLE_NAME, zoneId, diff --git a/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractSortedIndexStorageTest.java b/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractSortedIndexStorageTest.java index c33bf5602d..d419a22d2c 100644 --- a/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractSortedIndexStorageTest.java +++ b/modules/storage-api/src/testFixtures/java/org/apache/ignite/internal/storage/index/AbstractSortedIndexStorageTest.java @@ -120,7 +120,7 @@ public abstract class AbstractSortedIndexStorageTest extends AbstractIndexStorag catalogTableDescriptor.id(), false, List.of(columns), - false + true ); when(catalogService.index(eq(catalogSortedIndexDescriptor.name()), anyLong())).thenReturn(catalogSortedIndexDescriptor); diff --git a/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerTest.java b/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerTest.java index 0a2f5f321f..6bc1de3b8e 100644 --- a/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerTest.java +++ b/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerTest.java @@ -311,7 +311,7 @@ public class PartitionReplicaListenerTest extends IgniteAbstractTest { private KvMarshaller<TestKey, TestValue> kvMarshallerVersion2; private final CatalogTableDescriptor tableDescriptor = new CatalogTableDescriptor( - TABLE_ID, 1, "table", 1, CURRENT_SCHEMA_VERSION, + TABLE_ID, 1, 2, "table", 1, CURRENT_SCHEMA_VERSION, List.of( new CatalogTableColumnDescriptor("intKey", ColumnType.INT32, false, 0, 0, 0, null), new CatalogTableColumnDescriptor("strKey", ColumnType.STRING, false, 0, 0, 0, null), diff --git a/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/schema/FullTableSchemaTest.java b/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/schema/FullTableSchemaTest.java index 8a0fdf642b..6347435d75 100644 --- a/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/schema/FullTableSchemaTest.java +++ b/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/schema/FullTableSchemaTest.java @@ -45,7 +45,7 @@ class FullTableSchemaTest { } private static CatalogHashIndexDescriptor someIndex(int id, String name) { - return new CatalogHashIndexDescriptor(id, name, 1, true, List.of("a"), false); + return new CatalogHashIndexDescriptor(id, name, 1, true, List.of("a"), true); } private static CatalogTableColumnDescriptor someColumn(String columnName) {