org.apache.ignite.internal.processors.query

## Class GridQueryProcessor

- java.lang.Object
- - org.apache.ignite.internal.processors.GridProcessorAdapter
  - - org.apache.ignite.internal.processors.query.GridQueryProcessor

All Implemented Interfaces:
  GridComponent, GridProcessor

    public class GridQueryProcessor
    extends GridProcessorAdapter

Indexing processor.

### Nested Class Summary

### Nested classes/interfaces inherited from interface org.apache.ignite.internal.GridComponent

`GridComponent.DiscoveryDataExchangeType`

### Field Summary

Fields
`static Class<? extends GridQueryIndexing>` `idxCls` For tests.

### Fields inherited from class org.apache.ignite.internal.processors.GridProcessorAdapter

`ctx, diagnosticLog, log`

### Constructor Summary

Constructors
Constructor and Description
`GridQueryProcessor(GridKernalContext ctx)`

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`boolean` `belongsToTable(GridCacheContext cctx, String expCacheName, String expTblName, KeyCacheObject key, CacheObject val)` Check whether provided key and value belongs to expected cache and table.
`void` `cancelQueries(Collection<Long> queries)` Cancel specified queries.
`void` `collectGridNodeData(DiscoveryDataBag dataBag)` Collects discovery data on nodes already in grid on receiving `TcpDiscoveryNodeAddedMessage`.
`GridComponent.DiscoveryDataExchangeType` `discoveryDataType()` Gets unique component type to distinguish components providing discovery data.
`IgniteInternalFuture<?>` `dynamicColumnAdd(String cacheName, String schemaName, String tblName, List<QueryField> cols, boolean ifTblExists, boolean ifNotExists)` Entry point for add column procedure.
`IgniteInternalFuture<?>` `dynamicColumnRemove(String cacheName, String schemaName, String tblName, List<String> cols, boolean ifTblExists, boolean ifExists)` Entry point for drop column procedure.
`IgniteInternalFuture<?>` `dynamicIndexCreate(String cacheName, String schemaName, String tblName, QueryIndex idx, boolean ifNotExists, int parallel)` Entry point for index procedure.
`IgniteInternalFuture<?>` `dynamicIndexDrop(String cacheName, String schemaName, String idxName, boolean ifExists)` Entry point for index drop procedure
`void` `dynamicTableCreate(String schemaName, QueryEntity entity, String templateName, String cacheName, String cacheGroup, String dataRegion, String affinityKey, CacheAtomicityMode atomicityMode, CacheWriteSynchronizationMode writeSyncMode, int backups, boolean ifNotExists)` Create cache and table from given query entity.
`void` `dynamicTableDrop(String cacheName, String tblName, boolean ifExists)` Drop table by destroying its cache if it's an 1:1 per cache table.
`<R> R` `executeQuery(GridCacheQueryType qryType, String qry, GridCacheContext<?,?> cctx, IgniteOutClosureX<R> clo, boolean complete)`
`GridQueryIndexing` `getIndexing()`
`static AffinityTopologyVersion` `getRequestAffinityTopologyVersion()`
`boolean` `moduleEnabled()`
`CacheQueryObjectValueContext` `objectContext()`
`void` `onCacheKernalStart()` Handle cache kernal start.
`void` `onCacheReconnect()` Handle cache reconnect.
`void` `onCacheStart(GridCacheContext cctx, QuerySchema schema)` Handle cache start.
`void` `onCacheStart0(GridCacheContext<?,?> cctx, QuerySchema schema)` Create type descriptors from schema and initialize indexing for given cache.
`void` `onCacheStop(GridCacheContext cctx, boolean removeIdx)`
`void` `onCacheStop0(GridCacheContext cctx, boolean destroy)` Unregister cache.
`void` `onCoordinatorFinished(SchemaAbstractOperation op, SchemaOperationException err)` Invoked when coordinator finished ensuring that all participants are ready.
`void` `onDisconnected(IgniteFuture<?> reconnectFut)` Client disconnected callback.
`void` `onDiscovery(SchemaAbstractDiscoveryMessage msg)` Handle custom discovery message.
`void` `onGridDataReceived(DiscoveryDataBag.GridDiscoveryData data)` Receives discovery data object from remote nodes (called on new node during discovery process).
`void` `onKernalStop(boolean cancel)` Callback to notify that kernal is about to stop.
`void` `onLocalOperationFinished(SchemaAbstractOperation op, QueryTypeDescriptorImpl type)` Apply positive index operation result.
`void` `onNodeLeave(ClusterNode node)` Handle node leave.
`void` `onSchemaPropose(SchemaProposeDiscoveryMessage msg)` Handle schema propose from exchange thread.
`PreparedStatement` `prepareNativeStatement(String schemaName, String sql)`
`void` `processSchemaOperationLocal(SchemaAbstractOperation op, QueryTypeDescriptorImpl type, IgniteUuid depId, SchemaIndexOperationCancellationToken cancelTok)` Process schema operation.
`<K,V> QueryCursor<javax.cache.Cache.Entry<K,V>>` `querySql(GridCacheContext<?,?> cctx, SqlQuery qry, boolean keepBinary)` Execute distributed SQL query.
`FieldsQueryCursor<List<?>>` `querySqlFields(GridCacheContext<?,?> cctx, SqlFieldsQuery qry, boolean keepBinary)`
`List<FieldsQueryCursor<List<?>>>` `querySqlFields(GridCacheContext<?,?> cctx, SqlFieldsQuery qry, boolean keepBinary, boolean failOnMultipleStmts)` Query SQL fields.
`FieldsQueryCursor<List<?>>` `querySqlFields(SqlFieldsQuery qry, boolean keepBinary)` Query SQL fields.
`List<FieldsQueryCursor<List<?>>>` `querySqlFields(SqlFieldsQuery qry, boolean keepBinary, boolean failOnMultipleStmts)` Query SQL fields.
`<K,V> GridCloseableIterator<IgniteBiTuple<K,V>>` `queryText(String cacheName, String clause, String resType, IndexingQueryFilter filters)`
`IgniteInternalFuture<?>` `rebuildIndexesFromHash(Collection<Integer> cacheIds)` Rebuilds indexes for provided caches from corresponding hash indexes.
`void` `remove(GridCacheContext cctx, CacheDataRow val)`
`Collection<GridRunningQueryInfo>` `runningQueries(long duration)` Collect queries that already running more than specified duration.
`void` `sendStatusMessage(UUID destNodeId, UUID opId, SchemaOperationException err)` Send status message to coordinator node.
`static void` `setRequestAffinityTopologyVersion(AffinityTopologyVersion ver)`
`boolean` `skipFieldLookup()`
`void` `skipFieldLookup(boolean skipFieldLookup)`
`void` `start()` Starts grid component.
`void` `stop(boolean cancel)` Stops grid component.
`void` `store(GridCacheContext cctx, CacheDataRow newRow, CacheDataRow prevRow, boolean prevRowAvailable)`
`long` `streamUpdateQuery(String cacheName, String schemaName, IgniteDataStreamer<?,?> streamer, String qry, Object[] args)`
`Collection<GridQueryTypeDescriptor>` `types(String cacheName)` Gets types for cache.
`void` `validateKeyAndValue(CacheObjectContext coctx, KeyCacheObject key, CacheObject val)` Performs validation of provided key and value against configured constraints.

### Methods inherited from class org.apache.ignite.internal.processors.GridProcessorAdapter

`assertParameter, collectJoiningNodeData, onJoiningNodeDataReceived, onKernalStart, onReconnected, printMemoryStats, toString, validateNode, validateNode`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

### Field Detail

#### idxCls

    public static Class<? extends GridQueryIndexing> idxCls

For tests.

### Constructor Detail

#### GridQueryProcessor

    public GridQueryProcessor(GridKernalContext ctx)
                       throws IgniteCheckedException

Parameters:
  `ctx` - Kernal context.
Throws:
  `IgniteCheckedException`

### Method Detail

#### start

    public void start()
               throws IgniteCheckedException

Starts grid component.

Specified by:
  `start` in interface `GridComponent`
Overrides:
  `start` in class `GridProcessorAdapter`
Throws:
  `IgniteCheckedException` - Throws in case of any errors.

#### onKernalStop

    public void onKernalStop(boolean cancel)

Callback to notify that kernal is about to stop.

Specified by:
  `onKernalStop` in interface `GridComponent`
Overrides:
  `onKernalStop` in class `GridProcessorAdapter`
Parameters:
  `cancel` - Flag indicating whether jobs should be canceled.

#### stop

    public void stop(boolean cancel)
              throws IgniteCheckedException

Stops grid component.

Specified by:
  `stop` in interface `GridComponent`
Overrides:
  `stop` in class `GridProcessorAdapter`
Parameters:
  `cancel` - If `true`, then all ongoing tasks or jobs for relevant components need to be cancelled.
Throws:
  `IgniteCheckedException` - Thrown in case of any errors.

#### onCacheKernalStart

    public void onCacheKernalStart()
                            throws IgniteCheckedException

Handle cache kernal start. At this point discovery and IO managers are operational, caches are not started yet.

Throws:
  `IgniteCheckedException` - If failed.

#### onCacheReconnect

    public void onCacheReconnect()
                          throws IgniteCheckedException

Handle cache reconnect.

Throws:
  `IgniteCheckedException` - If failed.

#### discoveryDataType

    @Nullable
    public GridComponent.DiscoveryDataExchangeType discoveryDataType()

Gets unique component type to distinguish components providing discovery data. Must return non-null value if component implements any of methods `GridComponent.collectJoiningNodeData(DiscoveryDataBag)` or `GridComponent.collectGridNodeData(DiscoveryDataBag)`.

Specified by:
  `discoveryDataType` in interface `GridComponent`
Overrides:
  `discoveryDataType` in class `GridProcessorAdapter`
Returns:
  Unique component type for discovery data exchange.

#### collectGridNodeData

    public void collectGridNodeData(DiscoveryDataBag dataBag)

Collects discovery data on nodes already in grid on receiving `TcpDiscoveryNodeAddedMessage`.

Specified by:
  `collectGridNodeData` in interface `GridComponent`
Overrides:
  `collectGridNodeData` in class `GridProcessorAdapter`
Parameters:
  `dataBag` - container object to store discovery data in.

#### onGridDataReceived

    public void onGridDataReceived(DiscoveryDataBag.GridDiscoveryData data)

Receives discovery data object from remote nodes (called on new node during discovery process).

Specified by:
  `onGridDataReceived` in interface `GridComponent`
Overrides:
  `onGridDataReceived` in class `GridProcessorAdapter`
Parameters:
  `data` - `DiscoveryDataBag.GridDiscoveryData` interface to retrieve discovery data collected on remote nodes (data common for all nodes in grid and specific for each node).

#### onSchemaPropose

    public void onSchemaPropose(SchemaProposeDiscoveryMessage msg)

Handle schema propose from exchange thread.

Parameters:
  `msg` - Discovery message.

#### moduleEnabled

    public boolean moduleEnabled()

Returns:
  `true` If indexing module is in classpath and successfully initialized.

#### getIndexing

    public GridQueryIndexing getIndexing()
                                  throws IgniteException

Returns:
  Indexing.
Throws:
  `IgniteException` - If module is not enabled.

#### onCacheStart0

    public void onCacheStart0(GridCacheContext<?,?> cctx,
                              QuerySchema schema)
                       throws IgniteCheckedException

Create type descriptors from schema and initialize indexing for given cache.

Use with `busyLock` where appropriate.

Parameters:
  `cctx` - Cache context.
  `schema` - Initial schema.
Throws:
  `IgniteCheckedException` - If failed.

#### onDisconnected

    public void onDisconnected(IgniteFuture<?> reconnectFut)
                        throws IgniteCheckedException

Client disconnected callback.

Specified by:
  `onDisconnected` in interface `GridComponent`
Overrides:
  `onDisconnected` in class `GridProcessorAdapter`
Parameters:
  `reconnectFut` - Reconnect future.
Throws:
  `IgniteCheckedException` - If failed.

#### onCacheStart

    public void onCacheStart(GridCacheContext cctx,
                             QuerySchema schema)
                      throws IgniteCheckedException

Handle cache start. Invoked either from GridCacheProcessor.onKernalStart() method or from exchange worker. When called for the first time, we initialize topology thus understanding whether current node is coordinator or not.

Parameters:
  `cctx` - Cache context.
  `schema` - Index states.
Throws:
  `IgniteCheckedException` - If failed.

#### onCacheStop

    public void onCacheStop(GridCacheContext cctx,
                            boolean removeIdx)

Parameters:
  `cctx` - Cache context.
  `removeIdx` - If `true`, will remove index.

#### skipFieldLookup

    public boolean skipFieldLookup()

Returns:
  Skip field lookup flag.

#### skipFieldLookup

    public void skipFieldLookup(boolean skipFieldLookup)

Parameters:
  `skipFieldLookup` - Skip field lookup flag.

#### onDiscovery

    public void onDiscovery(SchemaAbstractDiscoveryMessage msg)

Handle custom discovery message.

Parameters:
  `msg` - Message.

#### onCoordinatorFinished

    public void onCoordinatorFinished(SchemaAbstractOperation op,
                                      @Nullable
                                      SchemaOperationException err)

Invoked when coordinator finished ensuring that all participants are ready.

Parameters:
  `op` - Operation.
  `err` - Error (if any).

#### onLocalOperationFinished

    public void onLocalOperationFinished(SchemaAbstractOperation op,
                                         @Nullable
                                         QueryTypeDescriptorImpl type)

Apply positive index operation result.

Parameters:
  `op` - Operation.
  `type` - Type descriptor (if available),

#### onNodeLeave

    public void onNodeLeave(ClusterNode node)

Handle node leave.

Parameters:
  `node` - Node.

#### processSchemaOperationLocal

    public void processSchemaOperationLocal(SchemaAbstractOperation op,
                                            QueryTypeDescriptorImpl type,
                                            IgniteUuid depId,
                                            SchemaIndexOperationCancellationToken cancelTok)
                                     throws SchemaOperationException

Process schema operation.

Parameters:
  `op` - Operation.
  `type` - Type descriptor.
  `depId` - Cache deployment ID.
  `cancelTok` - Cancel token.
Throws:
  `SchemaOperationException` - If failed.

#### dynamicTableCreate

    public void dynamicTableCreate(String schemaName,
                                   QueryEntity entity,
                                   String templateName,
                                   String cacheName,
                                   String cacheGroup,
                                   @Nullable
                                   String dataRegion,
                                   String affinityKey,
                                   @Nullable
                                   CacheAtomicityMode atomicityMode,
                                   @Nullable
                                   CacheWriteSynchronizationMode writeSyncMode,
                                   int backups,
                                   boolean ifNotExists)
                            throws IgniteCheckedException

Create cache and table from given query entity.

Parameters:
  `schemaName` - Schema name to create table in.
  `entity` - Entity to create table from.
  `templateName` - Template name.
  `cacheName` - Cache name.
  `cacheGroup` - Cache group name.
  `dataRegion` - Data region name.
  `affinityKey` - Affinity key column name.
  `atomicityMode` - Atomicity mode.
  `writeSyncMode` - Write synchronization mode.
  `backups` - Backups.
  `ifNotExists` - Quietly ignore this command if table already exists.
Throws:
  `IgniteCheckedException` - If failed.

#### dynamicTableDrop

    public void dynamicTableDrop(String cacheName,
                                 String tblName,
                                 boolean ifExists)
                          throws SchemaOperationException

Drop table by destroying its cache if it's an 1:1 per cache table.

Parameters:
  `cacheName` - Cache name.
  `tblName` - Table name.
  `ifExists` - Quietly ignore this command if table does not exist.
Throws:
  `SchemaOperationException` - if `ifExists` is `false` and cache was not found.

#### onCacheStop0

    public void onCacheStop0(GridCacheContext cctx,
                             boolean destroy)

Unregister cache.

Use with `busyLock` where appropriate.

Parameters:
  `cctx` - Cache context.
  `destroy` - Destroy flag.

#### belongsToTable

    public boolean belongsToTable(GridCacheContext cctx,
                                  String expCacheName,
                                  String expTblName,
                                  KeyCacheObject key,
                                  CacheObject val)
                           throws IgniteCheckedException

Check whether provided key and value belongs to expected cache and table.

Parameters:
  `cctx` - Target cache context.
  `expCacheName` - Expected cache name.
  `expTblName` - Expected table name.
  `key` - Key.
  `val` - Value.
Returns:
  `True` if this key-value pair belongs to expected cache/table, `false` otherwise or if cache or table doesn't exist.
Throws:
  `IgniteCheckedException` - If failed.

#### rebuildIndexesFromHash

    public IgniteInternalFuture<?> rebuildIndexesFromHash(Collection<Integer> cacheIds)

Rebuilds indexes for provided caches from corresponding hash indexes.

Parameters:
  `cacheIds` - Cache IDs.
Returns:
  Future that will be completed when rebuilding is finished.

#### store

    public void store(GridCacheContext cctx,
                      CacheDataRow newRow,
                      @Nullable
                      CacheDataRow prevRow,
                      boolean prevRowAvailable)
               throws IgniteCheckedException

Parameters:
  `cctx` - Cache context.
  `newRow` - New row.
  `prevRow` - Previous row.
Throws:
  `IgniteCheckedException` - In case of error.

#### querySqlFields

    public List<FieldsQueryCursor<List<?>>> querySqlFields(SqlFieldsQuery qry,
                                                           boolean keepBinary,
                                                           boolean failOnMultipleStmts)

Query SQL fields.

Parameters:
  `qry` - Query.
  `keepBinary` - Keep binary flag.
Returns:
  Cursor.

#### querySqlFields

    public FieldsQueryCursor<List<?>> querySqlFields(GridCacheContext<?,?> cctx,
                                                     SqlFieldsQuery qry,
                                                     boolean keepBinary)

#### querySqlFields

    public FieldsQueryCursor<List<?>> querySqlFields(SqlFieldsQuery qry,
                                                     boolean keepBinary)

Query SQL fields.

Parameters:
  `qry` - Query.
  `keepBinary` - Keep binary flag.
Returns:
  Cursor.

#### querySqlFields

    public List<FieldsQueryCursor<List<?>>> querySqlFields(@Nullable
                                                           GridCacheContext<?,?> cctx,
                                                           SqlFieldsQuery qry,
                                                           boolean keepBinary,
                                                           boolean failOnMultipleStmts)

Query SQL fields.

Parameters:
  `cctx` - Cache context.
  `qry` - Query.
  `keepBinary` - Keep binary flag.
  `failOnMultipleStmts` - If `true` the method must throws exception when query contains more then one SQL statement.
Returns:
  Cursor.

#### streamUpdateQuery

    public long streamUpdateQuery(@Nullable
                                  String cacheName,
                                  String schemaName,
                                  IgniteDataStreamer<?,?> streamer,
                                  String qry,
                                  Object[] args)

Parameters:
  `cacheName` - Cache name.
  `schemaName` - Schema name.
  `streamer` - Data streamer.
  `qry` - Query.
Returns:
  Iterator.

#### querySql

    public <K,V> QueryCursor<javax.cache.Cache.Entry<K,V>> querySql(GridCacheContext<?,?> cctx,
                                                                    SqlQuery qry,
                                                                    boolean keepBinary)

Execute distributed SQL query.

Parameters:
  `cctx` - Cache context.
  `qry` - Query.
  `keepBinary` - Keep binary flag.
Returns:
  Cursor.

#### runningQueries

    public Collection<GridRunningQueryInfo> runningQueries(long duration)

Collect queries that already running more than specified duration.

Parameters:
  `duration` - Duration to check.
Returns:
  Collection of long running queries.

#### cancelQueries

    public void cancelQueries(Collection<Long> queries)

Cancel specified queries.

Parameters:
  `queries` - Queries ID's to cancel.

#### dynamicIndexCreate

    public IgniteInternalFuture<?> dynamicIndexCreate(String cacheName,
                                                      String schemaName,
                                                      String tblName,
                                                      QueryIndex idx,
                                                      boolean ifNotExists,
                                                      int parallel)

Entry point for index procedure.

Parameters:
  `cacheName` - Cache name.
  `schemaName` - Schema name.
  `tblName` - Table name.
  `idx` - Index.
  `ifNotExists` - When set to `true` operation will fail if index already exists.
  `parallel` - Index creation parallelism level.
Returns:
  Future completed when index is created.

#### dynamicIndexDrop

    public IgniteInternalFuture<?> dynamicIndexDrop(String cacheName,
                                                    String schemaName,
                                                    String idxName,
                                                    boolean ifExists)

Entry point for index drop procedure

Parameters:
  `cacheName` - Cache name.
  `schemaName` - Schema name.
  `idxName` - Index name.
  `ifExists` - When set to `true` operation fill fail if index doesn't exists.
Returns:
  Future completed when index is created.

#### dynamicColumnAdd

    public IgniteInternalFuture<?> dynamicColumnAdd(String cacheName,
                                                    String schemaName,
                                                    String tblName,
                                                    List<QueryField> cols,
                                                    boolean ifTblExists,
                                                    boolean ifNotExists)

Entry point for add column procedure.

Parameters:
  `schemaName` - Schema name.
  `tblName` - Target table name.
  `cols` - Columns to add.
  `ifTblExists` - Ignore operation if target table doesn't exist.
  `ifNotExists` - Ignore operation if column exists.

#### dynamicColumnRemove

    public IgniteInternalFuture<?> dynamicColumnRemove(String cacheName,
                                                       String schemaName,
                                                       String tblName,
                                                       List<String> cols,
                                                       boolean ifTblExists,
                                                       boolean ifExists)

Entry point for drop column procedure.

Parameters:
  `schemaName` - Schema name.
  `tblName` - Target table name.
  `cols` - Columns to drop.
  `ifTblExists` - Ignore operation if target table doesn't exist.
  `ifExists` - Ignore operation if column does not exist.

#### prepareNativeStatement

    public PreparedStatement prepareNativeStatement(String schemaName,
                                                    String sql)
                                             throws SQLException

Parameters:
  `schemaName` - Schema name.
  `sql` - Query.
Returns:
  `PreparedStatement` from underlying engine to supply metadata to Prepared - most likely H2.
Throws:
  `SQLException` - On error.

#### remove

    public void remove(GridCacheContext cctx,
                       CacheDataRow val)
                throws IgniteCheckedException

Parameters:
  `cctx` - Cache context.
  `val` - Row.
Throws:
  `IgniteCheckedException` - Thrown in case of any errors.

#### queryText

    public <K,V> GridCloseableIterator<IgniteBiTuple<K,V>> queryText(String cacheName,
                                                                     String clause,
                                                                     String resType,
                                                                     IndexingQueryFilter filters)
                                                              throws IgniteCheckedException

Type Parameters:
  `K` - Key type.
  `V` - Value type.
Parameters:
  `cacheName` - Cache name.
  `clause` - Clause.
  `resType` - Result type.
  `filters` - Key and value filters.
Returns:
  Key/value rows.
Throws:
  `IgniteCheckedException` - If failed.

#### types

    public Collection<GridQueryTypeDescriptor> types(@Nullable
                                                     String cacheName)

Gets types for cache.

Parameters:
  `cacheName` - Cache name.
Returns:
  Descriptors.

#### executeQuery

    public <R> R executeQuery(GridCacheQueryType qryType,
                              String qry,
                              @Nullable
                              GridCacheContext<?,?> cctx,
                              IgniteOutClosureX<R> clo,
                              boolean complete)
                       throws IgniteCheckedException

Parameters:
  `qryType` - Query type.
  `qry` - Query description.
  `cctx` - Cache context.
  `clo` - Closure.
  `complete` - Complete.
Throws:
  `IgniteCheckedException`

#### sendStatusMessage

    public void sendStatusMessage(UUID destNodeId,
                                  UUID opId,
                                  SchemaOperationException err)

Send status message to coordinator node.

Parameters:
  `destNodeId` - Destination node ID.
  `opId` - Operation ID.
  `err` - Error.

#### objectContext

    public CacheQueryObjectValueContext objectContext()

Returns:
  Value object context.

#### validateKeyAndValue

    public void validateKeyAndValue(CacheObjectContext coctx,
                                    KeyCacheObject key,
                                    CacheObject val)
                             throws IgniteCheckedException

Performs validation of provided key and value against configured constraints. Throws runtime exception if validation fails.

Parameters:
  `coctx` - Cache object context.
  `key` - Key.
  `val` - Value.
Throws:
  `IgniteCheckedException,` - If error happens.
  `IgniteCheckedException`

#### setRequestAffinityTopologyVersion

    public static void setRequestAffinityTopologyVersion(AffinityTopologyVersion ver)

Parameters:
  `ver` - Version.

#### getRequestAffinityTopologyVersion

    public static AffinityTopologyVersion getRequestAffinityTopologyVersion()

Returns:
  Affinity topology version of the current request.

2018 Copyright © Apache Software Foundation

Follow @ApacheIgnite

Ignite Fabric | : ver. 2.4.0
Release Date | : March 5 2018