| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| 'use strict'; |
| |
| import {ComplexObjectType, CompositeType, ObjectArrayType} from "./ObjectType"; |
| import BinaryUtils from "./internal/BinaryUtils"; |
| import BinaryCommunicator from "./internal/BinaryCommunicator"; |
| import ArgumentChecker from "./internal/ArgumentChecker"; |
| import { IgniteClientError } from "./Errors"; |
| import MessageBuffer from "./internal/MessageBuffer"; |
| import {PRIMITIVE_TYPE} from "./internal/Constants"; |
| |
| /** |
| * Class representing Cache Key part of Ignite {@link CacheConfiguration}. |
| * |
| * All configuration settings are optional and have defaults which are defined on a server side. |
| * |
| * See Apache Ignite documentation for details of every configuration setting. |
| */ |
| export class CacheKeyConfiguration { |
| |
| private _typeName: string; |
| |
| private _affinityKeyFieldName: string; |
| |
| /** |
| * Public constructor. |
| * |
| * @param {string} [typeName=null] - Type name for which affinity field name is being defined. |
| * @param {string} [affinityKeyFieldName=null] - Affinity key field name. |
| * |
| * @return {CacheKeyConfiguration} - new CacheKeyConfiguration instance. |
| */ |
| constructor(typeName: string = null, affinityKeyFieldName: string = null) { |
| this._typeName = typeName; |
| this._affinityKeyFieldName = affinityKeyFieldName; |
| } |
| |
| /** |
| * Sets type name for which affinity field name is being defined. |
| * |
| * @param {string} typeName - Type name for which affinity field name is being defined. |
| * |
| * @return {CacheKeyConfiguration} - the same instance of the CacheKeyConfiguration. |
| */ |
| setTypeName(typeName) { |
| this._typeName = typeName; |
| return this; |
| } |
| |
| /** |
| * Gets type name for which affinity field name is being defined. |
| * |
| * @return {string} - Type name for which affinity field name is being defined. |
| */ |
| getTypeName() { |
| return this._typeName; |
| } |
| |
| /** |
| * Sets affinity key field name. |
| * |
| * @param {string} affinityKeyFieldName - Affinity key field name. |
| * |
| * @return {CacheKeyConfiguration} - the same instance of the CacheKeyConfiguration. |
| */ |
| setAffinityKeyFieldName(affinityKeyFieldName) { |
| this._affinityKeyFieldName = affinityKeyFieldName; |
| return this; |
| } |
| |
| /** |
| * Gets affinity key field name. |
| * |
| * @return {string} - Affinity key field name. |
| */ |
| getAffinityKeyFieldName() { |
| return this._affinityKeyFieldName; |
| } |
| |
| /** Private methods */ |
| |
| /** |
| * @ignore |
| */ |
| async _write(communicator, buffer) { |
| BinaryCommunicator.writeString(buffer, this._typeName); |
| BinaryCommunicator.writeString(buffer, this._affinityKeyFieldName); |
| } |
| |
| /** |
| * @ignore |
| */ |
| async _read(communicator, buffer) { |
| this._typeName = BinaryCommunicator.readString(buffer); |
| this._affinityKeyFieldName = BinaryCommunicator.readString(buffer); |
| } |
| } |
| |
| /** |
| * Class representing one Query Entity element of Ignite {@link CacheConfiguration}. |
| * |
| * All configuration settings are optional and have defaults which are defined on a server side. |
| * |
| * See Apache Ignite documentation for details of every configuration setting. |
| */ |
| export class QueryEntity { |
| private _keyTypeName: string; |
| private _valueTypeName: string; |
| private _tableName: string; |
| private _keyFieldName: string; |
| private _valueFieldName: string; |
| private _fields: QueryField[]; |
| private _aliases: Map<string, string>; |
| private _indexes: QueryIndex[]; |
| |
| /** |
| * Public constructor. |
| * |
| * @return {QueryEntity} - new QueryEntity instance. |
| */ |
| constructor() { |
| this._keyTypeName = null; |
| this._valueTypeName = null; |
| this._tableName = null; |
| this._keyFieldName = null; |
| this._valueFieldName = null; |
| this._fields = null; |
| this._aliases = null; |
| this._indexes = null; |
| } |
| |
| /** |
| * Sets key type name for this query entity. |
| * |
| * @param {string} keyTypeName - Key type name. |
| * |
| * @return {QueryEntity} - the same instance of the QueryEntity. |
| */ |
| setKeyTypeName(keyTypeName: string) { |
| this._keyTypeName = keyTypeName; |
| return this; |
| } |
| |
| /** |
| * Gets key type name for this query entity. |
| * |
| * @return {string} - Key type name. |
| */ |
| getKeyTypeName() { |
| return this._keyTypeName; |
| } |
| |
| /** |
| * Sets value type name for this query entity. |
| * |
| * @param {string} valueTypeName - Value type name. |
| * |
| * @return {QueryEntity} - the same instance of the QueryEntity. |
| */ |
| setValueTypeName(valueTypeName: string) { |
| this._valueTypeName = valueTypeName; |
| return this; |
| } |
| |
| /** |
| * Gets value type name for this query entity. |
| * |
| * @return {string} - Value type name. |
| */ |
| getValueTypeName() { |
| return this._valueTypeName; |
| } |
| |
| /** |
| * Sets table name for this query entity. |
| * |
| * @param {string} tableName - Table name. |
| * |
| * @return {QueryEntity} - the same instance of the QueryEntity. |
| */ |
| setTableName(tableName: string) { |
| this._tableName = tableName; |
| return this; |
| } |
| |
| /** |
| * Gets table name for this query entity. |
| * |
| * @return {string} - Table name. |
| */ |
| getTableName() { |
| return this._tableName; |
| } |
| |
| /** |
| * Sets key field name. |
| * |
| * @param {string} keyFieldName - Key name. |
| * |
| * @return {QueryEntity} - the same instance of the QueryEntity. |
| */ |
| setKeyFieldName(keyFieldName: string) { |
| this._keyFieldName = keyFieldName; |
| return this; |
| } |
| |
| /** |
| * Gets key field name. |
| * |
| * @return {string} - Key name. |
| */ |
| getKeyFieldName() { |
| return this._keyFieldName; |
| } |
| |
| /** |
| * Sets value field name. |
| * |
| * @param {string} valueFieldName - Value name. |
| * |
| * @return {QueryEntity} - the same instance of the QueryEntity. |
| */ |
| setValueFieldName(valueFieldName: string) { |
| this._valueFieldName = valueFieldName; |
| return this; |
| } |
| |
| /** |
| * Gets value field name. |
| * |
| * @return {string} - Value name. |
| */ |
| getValueFieldName() { |
| return this._valueFieldName; |
| } |
| |
| /** |
| * Sets query fields for this query pair. The order of the fields is important as it |
| * defines the order of columns returned by the 'select *' queries. |
| * |
| * @param {Array<QueryField>} fields - Array of query fields. |
| * |
| * @return {QueryEntity} - the same instance of the QueryEntity. |
| */ |
| setFields(fields: QueryField[]) { |
| this._fields = fields; |
| return this; |
| } |
| |
| /** |
| * Gets query fields for this query pair. The order of the fields is |
| * defines the order of columns returned by the 'select *' queries. |
| * |
| * @return {Array<QueryField>} - Array of query fields. |
| */ |
| getFields() { |
| return this._fields; |
| } |
| |
| /** |
| * Sets mapping from a full property name in dot notation to an alias that will be |
| * used as SQL column name. Example: {"parent.name" -> "parentName"}. |
| * |
| * @param {Map<string, string>} aliases - Aliases map. |
| * |
| * @return {QueryEntity} - the same instance of the QueryEntity. |
| */ |
| setAliases(aliases: Map<string, string>) { |
| this._aliases = aliases; |
| return this; |
| } |
| |
| /** |
| * Gets aliases map. |
| * |
| * @return {Map<string, string>} - Aliases map. |
| */ |
| getAliases() { |
| return this._aliases; |
| } |
| |
| /** |
| * Sets a collection of index entities. |
| * |
| * @param {Array<QueryIndex>} indexes - Collection (array) of index entities. |
| * |
| * @return {QueryEntity} - the same instance of the QueryEntity. |
| */ |
| setIndexes(indexes: QueryIndex[]) { |
| this._indexes = indexes; |
| return this; |
| } |
| |
| /** |
| * Gets a collection of index entities. |
| * |
| * @return {Array<QueryIndex>} - Collection (array) of index entities. |
| */ |
| getIndexes() { |
| return this._indexes; |
| } |
| |
| /** Private methods */ |
| |
| /** |
| * @ignore |
| */ |
| async _write(communicator, buffer) { |
| BinaryCommunicator.writeString(buffer, this._keyTypeName); |
| BinaryCommunicator.writeString(buffer, this._valueTypeName); |
| BinaryCommunicator.writeString(buffer, this._tableName); |
| BinaryCommunicator.writeString(buffer, this._keyFieldName); |
| BinaryCommunicator.writeString(buffer, this._valueFieldName); |
| await this._writeSubEntities(communicator, buffer, this._fields); |
| await this._writeAliases(communicator, buffer); |
| await this._writeSubEntities(communicator, buffer, this._indexes); |
| } |
| |
| /** |
| * @ignore |
| */ |
| async _writeAliases(communicator, buffer) { |
| const length = this._aliases ? this._aliases.size : 0; |
| buffer.writeInteger(length); |
| if (length > 0) { |
| for (let [key, value] of this._aliases.entries()) { |
| BinaryCommunicator.writeString(buffer, key); |
| BinaryCommunicator.writeString(buffer, value); |
| } |
| } |
| } |
| |
| /** |
| * @ignore |
| */ |
| async _writeSubEntities(communicator, buffer, entities) { |
| const length = entities ? entities.length : 0; |
| buffer.writeInteger(length); |
| if (length > 0) { |
| for (let entity of entities) { |
| await entity._write(communicator, buffer); |
| } |
| } |
| } |
| |
| /** |
| * @ignore |
| */ |
| async _read(communicator, buffer) { |
| this._keyTypeName = await communicator.readObject(buffer); |
| this._valueTypeName = await communicator.readObject(buffer); |
| this._tableName = await communicator.readObject(buffer); |
| this._keyFieldName = await communicator.readObject(buffer); |
| this._valueFieldName = await communicator.readObject(buffer); |
| this._fields = await this._readSubEntities(communicator, buffer, QueryField); |
| await this._readAliases(communicator, buffer); |
| this._indexes = await this._readSubEntities(communicator, buffer, QueryIndex); |
| } |
| |
| /** |
| * @ignore |
| */ |
| async _readSubEntities(communicator, buffer, objectConstructor) { |
| const length = buffer.readInteger(buffer); |
| const result = new Array(length); |
| if (length > 0) { |
| let res; |
| for (let i = 0; i < length; i++) { |
| res = new objectConstructor(); |
| await res._read(communicator, buffer); |
| result[i] = res; |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * @ignore |
| */ |
| async _readAliases(communicator, buffer) { |
| const length = buffer.readInteger(buffer); |
| this._aliases = new Map(); |
| if (length > 0) { |
| let res; |
| for (let i = 0; i < length; i++) { |
| this._aliases.set(await communicator.readObject(buffer), await communicator.readObject(buffer)); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Class representing one Query Field element of {@link QueryEntity} of Ignite {@link CacheConfiguration}. |
| * |
| * All configuration settings are optional and have defaults which are defined on a server side. |
| * |
| * See Apache Ignite documentation for details of every configuration setting. |
| */ |
| export class QueryField { |
| private _name: string; |
| private _typeName: string; |
| private _isKeyField: boolean; |
| private _isNotNull: boolean; |
| private _precision: number; |
| private _scale: number; |
| private _communicator: BinaryCommunicator; |
| private _buffer: MessageBuffer; |
| private _defaultValue: object; |
| private _valueType: PRIMITIVE_TYPE | CompositeType; |
| private _index: number; |
| |
| /** |
| * Public constructor. |
| * |
| * @param {string} [name=null] - Query field name. |
| * @param {string} [typeName=null] - Query field type name. |
| * |
| * @return {QueryField} - new QueryField instance. |
| */ |
| constructor(name: string = null, typeName: string = null) { |
| this._name = name; |
| this._typeName = typeName; |
| this._isKeyField = false; |
| this._isNotNull = false; |
| this._defaultValue = undefined; |
| this._precision = -1; |
| this._scale = -1; |
| this._valueType = null; |
| this._communicator = null; |
| this._buffer = null; |
| this._index = null; |
| } |
| |
| /** |
| * Sets query field name. |
| * |
| * @param {string} name - Query field name. |
| * |
| * @return {QueryField} - the same instance of the QueryField. |
| */ |
| setName(name) { |
| this._name = name; |
| return this; |
| } |
| |
| /** |
| * Gets query field name. |
| * |
| * @return {string} - Query field name. |
| */ |
| getName() { |
| return this._name; |
| } |
| |
| /** |
| * Sets query field type name. |
| * |
| * @param {string} typeName - Query field type name. |
| * |
| * @return {QueryField} - the same instance of the QueryField. |
| */ |
| setTypeName(typeName) { |
| this._typeName = typeName; |
| return this; |
| } |
| |
| /** |
| * Gets query field type name. |
| * |
| * @return {string} - Query field type name. |
| */ |
| getTypeName() { |
| return this._typeName; |
| } |
| |
| /** |
| * Sets if it is a key query field or not. |
| * |
| * @param {boolean} isKeyField - True to make this query field a key field. False otherwise. |
| * |
| * @return {QueryField} - the same instance of the QueryField. |
| */ |
| setIsKeyField(isKeyField) { |
| this._isKeyField = isKeyField; |
| return this; |
| } |
| |
| /** |
| * Gets if it is a key query field or not. |
| * |
| * @return {boolean} - True if this query field is a key field. False otherwise. |
| */ |
| getIsKeyField() { |
| return this._isKeyField; |
| } |
| |
| /** |
| * Sets if this query field must be checked for null. |
| * |
| * @param {boolean} isNotNull - True if this query field must be checked for null. False otherwise. |
| * |
| * @return {QueryField} - the same instance of the QueryField. |
| */ |
| setIsNotNull(isNotNull) { |
| this._isNotNull = isNotNull; |
| return this; |
| } |
| |
| /** |
| * Gets if this query field must be checked for null. |
| * |
| * @return {boolean} - True if this query field must be checked for null. False otherwise. |
| */ |
| getIsNotNull() { |
| return this._isNotNull; |
| } |
| |
| /** |
| * Sets query field default value. |
| * |
| * @param {*} defaultValue - Query field default value. |
| * @param {PRIMITIVE_TYPE | CompositeType} [valueType=null] - type of the default value: |
| * - either a type code of primitive (simple) type |
| * - or an instance of class representing non-primitive (composite) type |
| * - or null (or not specified) that means the type is not specified |
| * |
| * @return {QueryField} - the same instance of the QueryField. |
| */ |
| setDefaultValue(defaultValue: object, valueType: PRIMITIVE_TYPE | CompositeType = null) { |
| this._defaultValue = defaultValue; |
| this._valueType = valueType; |
| return this; |
| } |
| |
| /** |
| * Gets query field default value. |
| * |
| * @param {ObjectType.PRIMITIVE_TYPE | CompositeType} [valueType=null] - type of the default value: |
| * - either a type code of primitive (simple) type |
| * - or an instance of class representing non-primitive (composite) type |
| * - or null (or not specified) that means the type is not specified |
| * |
| * @async |
| * |
| * @return {*} - Query field default value. |
| */ |
| async getDefaultValue(valueType = null) { |
| if (this._defaultValue === undefined) { |
| if (this._buffer) { |
| const position = this._buffer.position; |
| this._buffer.position = this._index; |
| const result = await this._communicator.readObject(this._buffer, valueType); |
| this._buffer.position = position; |
| return result; |
| } |
| else { |
| return null; |
| } |
| } |
| else { |
| return this._defaultValue; |
| } |
| } |
| |
| /** |
| * Sets query field precision. |
| * |
| * @param {number} precision - Query field precision. |
| * |
| * @return {QueryField} - the same instance of the QueryField. |
| */ |
| setPrecision(precision) { |
| ArgumentChecker.isInteger(precision, 'precision'); |
| this._precision = precision; |
| return this; |
| } |
| |
| /** |
| * Gets query field precision. |
| * |
| * @return {number} - Query field precision. |
| */ |
| getPrecision() { |
| return this._precision; |
| } |
| |
| /** |
| * Sets query field scale. |
| * |
| * @param {number} scale - Query field scale. |
| * |
| * @return {QueryField} - the same instance of the QueryField. |
| */ |
| setScale(scale) { |
| ArgumentChecker.isInteger(scale, 'scale'); |
| this._scale = scale; |
| return this; |
| } |
| |
| /** |
| * Gets query field scale. |
| * |
| * @return {number} - Query field scale. |
| */ |
| getScale() { |
| return this._scale; |
| } |
| |
| /** Private methods */ |
| |
| /** |
| * @ignore |
| */ |
| async _write(communicator, buffer) { |
| BinaryCommunicator.writeString(buffer, this._name); |
| BinaryCommunicator.writeString(buffer, this._typeName); |
| buffer.writeBoolean(this._isKeyField); |
| buffer.writeBoolean(this._isNotNull); |
| await communicator.writeObject(buffer, this._defaultValue ? this._defaultValue : null, this._valueType); |
| buffer.writeInteger(this._precision); |
| buffer.writeInteger(this._scale); |
| } |
| |
| /** |
| * @ignore |
| */ |
| async _read(communicator, buffer) { |
| this._name = await communicator.readObject(buffer); |
| this._typeName = await communicator.readObject(buffer); |
| this._isKeyField = buffer.readBoolean(); |
| this._isNotNull = buffer.readBoolean(); |
| this._defaultValue = undefined; |
| this._communicator = communicator; |
| this._buffer = buffer; |
| this._index = buffer.position; |
| await communicator.readObject(buffer); |
| this._precision = buffer.readInteger(); |
| this._scale = buffer.readInteger(); |
| } |
| } |
| |
| /** |
| * |
| * @typedef QueryIndex.INDEX_TYPE |
| * @enum |
| * @readonly |
| * @property SORTED 0 |
| * @property FULLTEXT 1 |
| * @property GEOSPATIAL 2 |
| */ |
| export enum INDEX_TYPE { |
| SORTED = 0, |
| FULLTEXT = 1, |
| GEOSPATIAL = 2 |
| } |
| |
| /** |
| * Class representing one Query Index element of {@link QueryEntity} of Ignite {@link CacheConfiguration}. |
| * |
| * All configuration settings are optional and have defaults which are defined on a server side. |
| * |
| * See Apache Ignite documentation for details of every configuration setting. |
| */ |
| export class QueryIndex { |
| |
| private _name: string; |
| |
| private _inlineSize: number; |
| |
| private _type: INDEX_TYPE; |
| |
| private _fields: Map<string, boolean>; |
| |
| /** |
| * Public constructor. |
| * |
| * @param {string} [name=null] - Query index name. |
| * @param {string} type - Query index type name. |
| * |
| * @return {QueryIndex} - new QueryIndex instance. |
| */ |
| constructor(name: string = null, type: INDEX_TYPE = INDEX_TYPE.SORTED) { |
| this._name = name; |
| this.setType(type); |
| this._inlineSize = -1; |
| this._fields = null; |
| } |
| |
| static get INDEX_TYPE() { |
| return INDEX_TYPE; |
| } |
| |
| /** |
| * Sets query index name. Will be automatically set if not provided by a user. |
| * |
| * @param {string} name - Query index name. |
| * |
| * @return {QueryIndex} - the same instance of the QueryIndex. |
| */ |
| setName(name) { |
| this._name = name; |
| return this; |
| } |
| |
| /** |
| * Gets query index name. |
| * |
| * @return {string} - Query index name. |
| */ |
| getName() { |
| return this._name; |
| } |
| |
| /** |
| * Sets query index type. |
| * |
| * @param {INDEX_TYPE} type - Query index type. |
| * |
| * @return {QueryIndex} - the same instance of the QueryIndex. |
| * |
| * @throws {IgniteClientError} if error. |
| */ |
| setType(type: INDEX_TYPE): QueryIndex { |
| ArgumentChecker.hasValueFrom(type, 'type', false, QueryIndex.INDEX_TYPE); |
| this._type = type; |
| return this; |
| } |
| |
| /** |
| * Gets query index type. |
| * |
| * @return {QueryIndex.INDEX_TYPE} - Query index type. |
| */ |
| getType() { |
| return this._type; |
| } |
| |
| /** |
| * Sets index inline size in bytes. When enabled, a part of the indexed value is placed directly |
| * to the index pages, thus minimizing data page accesses and increasing query performance. Allowed values: |
| * - -1 (default) - determine inline size automatically (see below) |
| * - 0 - index inline is disabled (not recommended) |
| * - positive value - fixed index inline |
| * |
| * When set to -1, Ignite will try to detect inline size automatically. It will be no more than |
| * CacheConfiguration.getSqlIndexInlineMaxSize(). Index inline will be enabled for all fixed-length types, |
| * but will not be enabled for String. |
| * |
| * @param {number} inlineSize - Index inline size in bytes. |
| * |
| * @return {QueryIndex} - the same instance of the QueryIndex. |
| */ |
| setInlineSize(inlineSize) { |
| this._inlineSize = inlineSize; |
| return this; |
| } |
| |
| /** |
| * Gets index inline size in bytes. |
| * |
| * @return {number} - Index inline size in bytes. |
| */ |
| getInlineSize() { |
| return this._inlineSize; |
| } |
| |
| /** |
| * Sets fields included in the index. |
| * |
| * @param {Map<string, boolean>} fields - Map of the index fields. |
| * |
| * @return {QueryIndex} - the same instance of the QueryIndex. |
| */ |
| setFields(fields: Map<string, boolean>): QueryIndex { |
| this._fields = fields; |
| return this; |
| } |
| |
| /** |
| * Gets fields included in the index. |
| * |
| * @return {Map<string, boolean>} - Map of the index fields. |
| */ |
| getFields() { |
| return this._fields; |
| } |
| |
| /** Private methods */ |
| |
| /** |
| * @ignore |
| */ |
| async _write(communicator, buffer) { |
| BinaryCommunicator.writeString(buffer, this._name); |
| buffer.writeByte(this._type); |
| buffer.writeInteger(this._inlineSize); |
| // write fields |
| const length = this._fields ? this._fields.size : 0; |
| buffer.writeInteger(length); |
| if (length > 0) { |
| for (let [key, value] of this._fields.entries()) { |
| BinaryCommunicator.writeString(buffer, key); |
| buffer.writeBoolean(value); |
| } |
| } |
| } |
| |
| /** |
| * @ignore |
| */ |
| async _read(communicator, buffer) { |
| this._name = await communicator.readObject(buffer); |
| this._type = buffer.readByte(); |
| this._inlineSize = buffer.readInteger(); |
| // read fields |
| const length = buffer.readInteger(buffer); |
| this._fields = new Map(); |
| if (length > 0) { |
| let res; |
| for (let i = 0; i < length; i++) { |
| this._fields.set(await communicator.readObject(buffer), buffer.readBoolean()); |
| } |
| } |
| } |
| } |
| |
| const PROP_NAME = 0; |
| const PROP_CACHE_MODE = 1; |
| const PROP_ATOMICITY_MODE = 2; |
| const PROP_BACKUPS = 3; |
| const PROP_WRITE_SYNCHRONIZATION_MODE = 4; |
| const PROP_COPY_ON_READ = 5; |
| const PROP_READ_FROM_BACKUP = 6; |
| const PROP_DATA_REGION_NAME = 100; |
| const PROP_IS_ONHEAP_CACHE_ENABLED = 101; |
| const PROP_QUERY_ENTITY = 200; |
| const PROP_QUERY_PARALLELISM = 201; |
| const PROP_QUERY_DETAIL_METRICS_SIZE = 202; |
| const PROP_SQL_SCHEMA = 203; |
| const PROP_SQL_INDEX_INLINE_MAX_SIZE = 204; |
| const PROP_SQL_ESCAPE_ALL = 205; |
| const PROP_MAX_QUERY_ITERATORS = 206; |
| const PROP_REBALANCE_MODE = 300; |
| const PROP_REBALANCE_DELAY = 301; |
| const PROP_REBALANCE_TIMEOUT = 302; |
| const PROP_REBALANCE_BATCH_SIZE = 303; |
| const PROP_REBALANCE_BATCHES_PREFETCH_COUNT = 304; |
| const PROP_REBALANCE_ORDER = 305; |
| const PROP_REBALANCE_THROTTLE = 306; |
| const PROP_GROUP_NAME = 400; |
| const PROP_CACHE_KEY_CONFIGURATION = 401; |
| const PROP_DEFAULT_LOCK_TIMEOUT = 402; |
| const PROP_MAX_CONCURRENT_ASYNC_OPS = 403; |
| const PROP_PARTITION_LOSS_POLICY = 404; |
| const PROP_EAGER_TTL = 405; |
| const PROP_STATISTICS_ENABLED = 406; |
| |
| const PROP_TYPES = Object.freeze({ |
| [PROP_NAME] : BinaryUtils.TYPE_CODE.STRING, |
| [PROP_CACHE_MODE] : BinaryUtils.TYPE_CODE.INTEGER, |
| [PROP_ATOMICITY_MODE] : BinaryUtils.TYPE_CODE.INTEGER, |
| [PROP_BACKUPS] : BinaryUtils.TYPE_CODE.INTEGER, |
| [PROP_WRITE_SYNCHRONIZATION_MODE] : BinaryUtils.TYPE_CODE.INTEGER, |
| [PROP_COPY_ON_READ] : BinaryUtils.TYPE_CODE.BOOLEAN, |
| [PROP_READ_FROM_BACKUP] : BinaryUtils.TYPE_CODE.BOOLEAN, |
| [PROP_DATA_REGION_NAME] : BinaryUtils.TYPE_CODE.STRING, |
| [PROP_IS_ONHEAP_CACHE_ENABLED] : BinaryUtils.TYPE_CODE.BOOLEAN, |
| [PROP_QUERY_ENTITY] : new ObjectArrayType(new ComplexObjectType(new QueryEntity())), |
| [PROP_QUERY_PARALLELISM] : BinaryUtils.TYPE_CODE.INTEGER, |
| [PROP_QUERY_DETAIL_METRICS_SIZE] : BinaryUtils.TYPE_CODE.INTEGER, |
| [PROP_SQL_SCHEMA] : BinaryUtils.TYPE_CODE.STRING, |
| [PROP_SQL_INDEX_INLINE_MAX_SIZE] : BinaryUtils.TYPE_CODE.INTEGER, |
| [PROP_SQL_ESCAPE_ALL] : BinaryUtils.TYPE_CODE.BOOLEAN, |
| [PROP_MAX_QUERY_ITERATORS] : BinaryUtils.TYPE_CODE.INTEGER, |
| [PROP_REBALANCE_MODE] : BinaryUtils.TYPE_CODE.INTEGER, |
| [PROP_REBALANCE_DELAY] : BinaryUtils.TYPE_CODE.LONG, |
| [PROP_REBALANCE_TIMEOUT] : BinaryUtils.TYPE_CODE.LONG, |
| [PROP_REBALANCE_BATCH_SIZE] : BinaryUtils.TYPE_CODE.INTEGER, |
| [PROP_REBALANCE_BATCHES_PREFETCH_COUNT] : BinaryUtils.TYPE_CODE.LONG, |
| [PROP_REBALANCE_ORDER] : BinaryUtils.TYPE_CODE.INTEGER, |
| [PROP_REBALANCE_THROTTLE] : BinaryUtils.TYPE_CODE.LONG, |
| [PROP_GROUP_NAME] : BinaryUtils.TYPE_CODE.STRING, |
| [PROP_CACHE_KEY_CONFIGURATION] : new ObjectArrayType(new ComplexObjectType(new CacheKeyConfiguration())), |
| [PROP_DEFAULT_LOCK_TIMEOUT] : BinaryUtils.TYPE_CODE.LONG, |
| [PROP_MAX_CONCURRENT_ASYNC_OPS] : BinaryUtils.TYPE_CODE.INTEGER, |
| [PROP_PARTITION_LOSS_POLICY] : BinaryUtils.TYPE_CODE.INTEGER, |
| [PROP_EAGER_TTL] : BinaryUtils.TYPE_CODE.BOOLEAN, |
| [PROP_STATISTICS_ENABLED] : BinaryUtils.TYPE_CODE.BOOLEAN |
| }); |
| |
| /** |
| * |
| * @typedef CacheConfiguration.CACHE_ATOMICITY_MODE |
| * @enum |
| * @readonly |
| * @property TRANSACTIONAL 0 |
| * @property ATOMIC 1 |
| */ |
| const CACHE_ATOMICITY_MODE = Object.freeze({ |
| TRANSACTIONAL : 0, |
| ATOMIC : 1 |
| }); |
| |
| /** |
| * |
| * @typedef CacheConfiguration.CACHE_MODE |
| * @enum |
| * @readonly |
| * @property LOCAL 0 |
| * @property REPLICATED 1 |
| * @property PARTITIONED 2 |
| */ |
| const CACHE_MODE = Object.freeze({ |
| LOCAL : 0, |
| REPLICATED : 1, |
| PARTITIONED : 2 |
| }); |
| |
| /** |
| * |
| * @typedef CacheConfiguration.PARTITION_LOSS_POLICY |
| * @enum |
| * @readonly |
| * @property READ_ONLY_SAFE 0 |
| * @property READ_ONLY_ALL 1 |
| * @property READ_WRITE_SAFE 2 |
| * @property READ_WRITE_ALL 3 |
| * @property IGNORE 4 |
| */ |
| const PARTITION_LOSS_POLICY = Object.freeze({ |
| READ_ONLY_SAFE : 0, |
| READ_ONLY_ALL : 1, |
| READ_WRITE_SAFE : 2, |
| READ_WRITE_ALL : 3, |
| IGNORE : 4 |
| }); |
| |
| /** |
| * |
| * @typedef CacheConfiguration.REABALANCE_MODE |
| * @enum |
| * @readonly |
| * @property SYNC 0 |
| * @property ASYNC 1 |
| * @property NONE 2 |
| */ |
| const REABALANCE_MODE = Object.freeze({ |
| SYNC : 0, |
| ASYNC : 1, |
| NONE : 2 |
| }); |
| |
| /** |
| * |
| * @typedef CacheConfiguration.WRITE_SYNCHRONIZATION_MODE |
| * @enum |
| * @readonly |
| * @property FULL_SYNC 0 |
| * @property FULL_ASYNC 1 |
| * @property PRIMARY_SYNC 2 |
| */ |
| const WRITE_SYNCHRONIZATION_MODE = Object.freeze({ |
| FULL_SYNC : 0, |
| FULL_ASYNC : 1, |
| PRIMARY_SYNC : 2 |
| }); |
| |
| /** |
| * Class representing Ignite cache configuration on a server. |
| * |
| * All configuration settings are optional and have defaults which are defined on a server side. |
| * |
| * See Apache Ignite documentation for details of every configuration setting. |
| */ |
| export class CacheConfiguration { |
| private _properties: Map<number, object>; |
| |
| /** |
| * Public constructor. |
| * |
| * @return {CacheConfiguration} - new CacheConfiguration instance. |
| */ |
| constructor() { |
| this._properties = new Map<number, object>(); |
| } |
| |
| static get CACHE_ATOMICITY_MODE() { |
| return CACHE_ATOMICITY_MODE; |
| } |
| |
| static get CACHE_MODE() { |
| return CACHE_MODE; |
| } |
| |
| static get PARTITION_LOSS_POLICY() { |
| return PARTITION_LOSS_POLICY; |
| } |
| |
| static get REABALANCE_MODE() { |
| return REABALANCE_MODE; |
| } |
| |
| static get WRITE_SYNCHRONIZATION_MODE() { |
| return WRITE_SYNCHRONIZATION_MODE; |
| } |
| |
| /** |
| * Sets cache atomicity mode. |
| * |
| * @param {CacheConfiguration.CACHE_ATOMICITY_MODE} atomicityMode - Cache atomicity mode. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| * |
| * @throws {IgniteClientError} if error. |
| */ |
| setAtomicityMode(atomicityMode) { |
| ArgumentChecker.hasValueFrom(atomicityMode, 'atomicityMode', false, CACHE_ATOMICITY_MODE); |
| this._properties.set(PROP_ATOMICITY_MODE, atomicityMode); |
| return this; |
| } |
| |
| /** |
| * Gets cache atomicity mode. |
| * |
| * @return {CacheConfiguration.CACHE_ATOMICITY_MODE} - Cache atomicity mode. |
| */ |
| getAtomicityMode() { |
| return this._properties.get(PROP_ATOMICITY_MODE); |
| } |
| |
| /** |
| * Sets number of nodes used to back up single partition for {@link CacheConfiguration.CACHE_MODE}.PARTITIONED cache. |
| * |
| * @param {number} backups - Number of backup nodes for one partition. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setBackups(backups) { |
| this._properties.set(PROP_BACKUPS, backups); |
| return this; |
| } |
| |
| /** |
| * Gets number of nodes used to back up single partition for {@link CacheConfiguration.CACHE_MODE}.PARTITIONED cache. |
| * |
| * @return {number} - Number of backup nodes for one partition. |
| */ |
| getBackups() { |
| return this._properties.get(PROP_BACKUPS); |
| } |
| |
| /** |
| * Sets caching mode. |
| * |
| * @param {CacheConfiguration.CACHE_MODE} cacheMode - Caching mode. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| * |
| * @throws {IgniteClientError} if error. |
| */ |
| setCacheMode(cacheMode) { |
| ArgumentChecker.hasValueFrom(cacheMode, 'cacheMode', false, CACHE_MODE); |
| this._properties.set(PROP_CACHE_MODE, cacheMode); |
| return this; |
| } |
| |
| /** |
| * Gets caching mode. |
| * |
| * @return {CacheConfiguration.CACHE_MODE} - Caching mode. |
| */ |
| getCacheMode() { |
| return this._properties.get(PROP_CACHE_MODE); |
| } |
| |
| /** |
| * Sets the flag indicating whether a copy of the value stored in the on-heap cache |
| * should be created for a cache operation return the value. Also, if this flag |
| * is set, copies are created for values passed to CacheInterceptor and to CacheEntryProcessor. |
| * If the on-heap cache is disabled then this flag is of no use. |
| * |
| * @param {boolean} copyOnRead - Copy on read flag. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setCopyOnRead(copyOnRead) { |
| this._properties.set(PROP_COPY_ON_READ, copyOnRead); |
| return this; |
| } |
| |
| /** |
| * Gets copy on read flag. |
| * |
| * @return {boolean} - Copy on read flag. |
| */ |
| getCopyOnRead() { |
| return this._properties.get(PROP_COPY_ON_READ); |
| } |
| |
| /** |
| * Sets a name of DataRegionConfiguration for this cache. |
| * |
| * @param {string} dataRegionName - DataRegionConfiguration name. Can be null |
| * (default DataRegionConfiguration will be used) but should not be empty. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setDataRegionName(dataRegionName) { |
| this._properties.set(PROP_DATA_REGION_NAME, dataRegionName); |
| return this; |
| } |
| |
| /** |
| * Gets the name of DataRegionConfiguration for this cache. |
| * |
| * @return {string} - DataRegionConfiguration name. |
| */ |
| getDataRegionName() { |
| return this._properties.get(PROP_DATA_REGION_NAME); |
| } |
| |
| /** |
| * Sets eager ttl flag. If there is at least one cache configured with this flag set to true, |
| * Ignite will create a single thread to clean up expired entries in background. |
| * When flag is set to false, expired entries will be removed on next entry access. |
| * |
| * @param {boolean} eagerTtl - True if Ignite should eagerly remove expired cache entries. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setEagerTtl(eagerTtl) { |
| this._properties.set(PROP_EAGER_TTL, eagerTtl); |
| return this; |
| } |
| |
| /** |
| * Gets eager ttl flag. If there is at least one cache configured with this flag set to true, |
| * Ignite will create a single thread to clean up expired entries in background. |
| * When flag is set to false, expired entries will be removed on next entry access. |
| * |
| * @return {boolean} - Flag indicating whether Ignite will eagerly remove expired entries. |
| */ |
| getEagerTtl() { |
| return this._properties.get(PROP_EAGER_TTL); |
| } |
| |
| /** |
| * Enables or disables statistics for this cache. |
| * |
| * @param {boolean} statisticsEnabled - True to enable, false to disable. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setStatisticsEnabled(statisticsEnabled) { |
| this._properties.set(PROP_STATISTICS_ENABLED, statisticsEnabled); |
| return this; |
| } |
| |
| /** |
| * Gets if statistics are enabled for this cache. |
| * |
| * @return {boolean} - True if enabled, false if disabled. |
| */ |
| getStatisticsEnabled() { |
| return this._properties.get(PROP_STATISTICS_ENABLED); |
| } |
| |
| /** |
| * Sets the cache group name. Caches with the same group name share single underlying 'physical' cache |
| * (partition set), but are logically isolated. Grouping caches reduces overall overhead, since |
| * internal data structures are shared. |
| * |
| * @param {string} groupName - Cache group name. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setGroupName(groupName) { |
| this._properties.set(PROP_GROUP_NAME, groupName); |
| return this; |
| } |
| |
| /** |
| * Gets the cache group name. |
| * |
| * @return {string} - Cache group name. |
| */ |
| getGroupName() { |
| return this._properties.get(PROP_GROUP_NAME); |
| } |
| |
| /** |
| * Sets default lock timeout in milliseconds. |
| * |
| * @param {number} lockTimeout - Default lock timeout. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setDefaultLockTimeout(lockTimeout) { |
| this._properties.set(PROP_DEFAULT_LOCK_TIMEOUT, lockTimeout); |
| return this; |
| } |
| |
| /** |
| * Gets default lock acquisition timeout. |
| * |
| * @return {number} - Default lock timeout. |
| */ |
| getDefaultLockTimeout() { |
| return this._properties.get(PROP_DEFAULT_LOCK_TIMEOUT); |
| } |
| |
| /** |
| * Sets maximum number of allowed concurrent asynchronous operations. 0 - the number of concurrent asynchronous |
| * operations is unlimited. |
| * |
| * @param {number} maxConcurrentAsyncOperations - Maximum number of concurrent asynchronous operations. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setMaxConcurrentAsyncOperations(maxConcurrentAsyncOperations) { |
| this._properties.set(PROP_MAX_CONCURRENT_ASYNC_OPS, maxConcurrentAsyncOperations); |
| return this; |
| } |
| |
| /** |
| * Gets maximum number of allowed concurrent asynchronous operations. |
| * If 0 returned then number of concurrent asynchronous operations is unlimited. |
| * |
| * @return {number} - Maximum number of concurrent asynchronous operations or 0 if unlimited. |
| */ |
| getMaxConcurrentAsyncOperations() { |
| return this._properties.get(PROP_MAX_CONCURRENT_ASYNC_OPS); |
| } |
| |
| /** |
| * Sets maximum number of query iterators that can be stored. Iterators are stored to support query |
| * pagination when each page of data is sent to user's node only on demand. Increase this property |
| * if you are running and processing lots of queries in parallel. |
| * |
| * @param {number} maxQueryIterators - Maximum number of query iterators that can be stored. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setMaxQueryIterators(maxQueryIterators) { |
| this._properties.set(PROP_MAX_QUERY_ITERATORS, maxQueryIterators); |
| return this; |
| } |
| |
| /** |
| * Gets maximum number of query iterators that can be stored. |
| * |
| * @return {number} - Maximum number of query iterators that can be stored. |
| */ |
| getMaxQueryIterators() { |
| return this._properties.get(PROP_MAX_QUERY_ITERATORS); |
| } |
| |
| /** |
| * Enables/disables on-heap cache for the off-heap based page memory. |
| * |
| * @param {boolean} isOnheapCacheEnabled - On-heap cache enabled flag. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setIsOnheapCacheEnabled(isOnheapCacheEnabled) { |
| this._properties.set(PROP_IS_ONHEAP_CACHE_ENABLED, isOnheapCacheEnabled); |
| return this; |
| } |
| |
| /** |
| * Checks if the on-heap cache is enabled for the off-heap based page memory. |
| * |
| * @return {boolean} - On-heap cache enabled flag. |
| */ |
| getIsOnheapCacheEnabled() { |
| return this._properties.get(PROP_IS_ONHEAP_CACHE_ENABLED); |
| } |
| |
| /** |
| * Sets partition loss policy. This policy defines how Ignite will react to a situation when |
| * all nodes for some partition leave the cluster. |
| * |
| * @param {CacheConfiguration.PARTITION_LOSS_POLICY} partitionLossPolicy - Partition loss policy. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| * |
| * @throws {IgniteClientError} if error. |
| */ |
| setPartitionLossPolicy(partitionLossPolicy) { |
| ArgumentChecker.hasValueFrom(partitionLossPolicy, 'partitionLossPolicy', false, PARTITION_LOSS_POLICY); |
| this._properties.set(PROP_PARTITION_LOSS_POLICY, partitionLossPolicy); |
| return this; |
| } |
| |
| /** |
| * Gets partition loss policy. This policy defines how Ignite will react to a situation when |
| * all nodes for some partition leave the cluster. |
| * |
| * @return {CacheConfiguration.PARTITION_LOSS_POLICY} - Partition loss policy. |
| */ |
| getPartitionLossPolicy() { |
| return this._properties.get(PROP_PARTITION_LOSS_POLICY); |
| } |
| |
| /** |
| * Sets size of queries detail metrics that will be stored in memory for monitoring purposes. |
| * If 0, then history will not be collected. Note, larger number may lead to higher memory consumption. |
| * |
| * @param {number} queryDetailMetricsSize - Maximum number of latest queries metrics that will be stored in memory. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setQueryDetailMetricsSize(queryDetailMetricsSize) { |
| this._properties.set(PROP_QUERY_DETAIL_METRICS_SIZE, queryDetailMetricsSize); |
| return this; |
| } |
| |
| /** |
| * Gets size of queries detail metrics that will be stored in memory for monitoring purposes. |
| * If 0, then history will not be collected. Note, larger number may lead to higher memory consumption. |
| * |
| * @return {number} - Maximum number of query metrics that will be stored in memory. |
| */ |
| getQueryDetailMetricsSize() { |
| return this._properties.get(PROP_QUERY_DETAIL_METRICS_SIZE); |
| } |
| |
| /** |
| * Defines a hint to query execution engine on desired degree of parallelism within a single node. |
| * Query executor may or may not use this hint depending on estimated query costs. |
| * Query executor may define certain restrictions on parallelism depending on query type and/or cache type. |
| * |
| * @param {number} queryParallelism - Query parallelism. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setQueryParallelism(queryParallelism) { |
| this._properties.set(PROP_QUERY_PARALLELISM, queryParallelism); |
| return this; |
| } |
| |
| /** |
| * Gets query parallelism parameter which is a hint to query execution engine on desired degree of |
| * parallelism within a single node. |
| * |
| * @return {number} - Query parallelism. |
| */ |
| getQueryParallelism() { |
| return this._properties.get(PROP_QUERY_PARALLELISM); |
| } |
| |
| /** |
| * Sets read from backup flag. |
| * |
| * @param {boolean} readFromBackup - True to allow reads from backups. False - data always |
| * should be read from primary node and never from backup. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setReadFromBackup(readFromBackup) { |
| this._properties.set(PROP_READ_FROM_BACKUP, readFromBackup); |
| return this; |
| } |
| |
| /** |
| * Gets flag indicating whether data can be read from backup. |
| * |
| * @return {boolean} - true if data can be read from backup node or false if data always |
| * should be read from primary node and never from backup. |
| */ |
| getReadFromBackup() { |
| return this._properties.get(PROP_READ_FROM_BACKUP); |
| } |
| |
| /** |
| * Sets rebalance batch size (to be loaded within a single rebalance message). Rebalancing algorithm will split |
| * total data set on every node into multiple batches prior to sending data. |
| * |
| * @param {number} rebalanceBatchSize - Rebalance batch size (size in bytes of a single rebalance message). |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setRebalanceBatchSize(rebalanceBatchSize) { |
| this._properties.set(PROP_REBALANCE_BATCH_SIZE, rebalanceBatchSize); |
| return this; |
| } |
| |
| /** |
| * Gets size (in number bytes) to be loaded within a single rebalance message. |
| * |
| * @return {number} - Size in bytes of a single rebalance message. |
| */ |
| getRebalanceBatchSize() { |
| return this._properties.get(PROP_REBALANCE_BATCH_SIZE); |
| } |
| |
| /** |
| * To gain better rebalancing performance supplier node can provide more than one batch at rebalancing start |
| * and provide one new to each next demand request. Sets number of batches generated by supply node at |
| * rebalancing start. Minimum is 1. |
| * |
| * @param {number} rebalanceBatchesPrefetchCount - Batches count. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setRebalanceBatchesPrefetchCount(rebalanceBatchesPrefetchCount) { |
| this._properties.set(PROP_REBALANCE_BATCHES_PREFETCH_COUNT, rebalanceBatchesPrefetchCount); |
| return this; |
| } |
| |
| /** |
| * To gain better rebalancing performance supplier node can provide more than one batch at rebalancing start |
| * and provide one new to each next demand request. Gets number of batches generated by supply node at |
| * rebalancing start. Minimum is 1. |
| * |
| * @return {number} - Batches count. |
| */ |
| getRebalanceBatchesPrefetchCount() { |
| return this._properties.get(PROP_REBALANCE_BATCHES_PREFETCH_COUNT); |
| } |
| |
| /** |
| * Sets delay in milliseconds upon a node joining or leaving topology (or crash) after which rebalancing should be |
| * started automatically. Rebalancing should be delayed if you plan to restart nodes after they leave topology, |
| * or if you plan to start multiple nodes at once or one after another and don't want to repartition and rebalance |
| * until all nodes are started. |
| * |
| * @param {number} rebalanceDelay - Rebalance delay to set. 0 to start rebalancing immediately, |
| * -1 to start rebalancing manually, or positive value to specify delay in milliseconds after which rebalancing |
| * should start automatically. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setRebalanceDelay(rebalanceDelay) { |
| this._properties.set(PROP_REBALANCE_DELAY, rebalanceDelay); |
| return this; |
| } |
| |
| /** |
| * Gets rebalance delay. |
| * |
| * @return {number} - Rebalance delay. |
| */ |
| getRebalanceDelay() { |
| return this._properties.get(PROP_REBALANCE_DELAY); |
| } |
| |
| /** |
| * Sets rebalance mode for distributed cache. |
| * |
| * @param {CacheConfiguration.REABALANCE_MODE} rebalanceMode - Rebalance mode. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| * |
| * @throws {IgniteClientError} if error. |
| */ |
| setRebalanceMode(rebalanceMode) { |
| ArgumentChecker.hasValueFrom(rebalanceMode, 'rebalanceMode', false, REABALANCE_MODE); |
| this._properties.set(PROP_REBALANCE_MODE, rebalanceMode); |
| return this; |
| } |
| |
| /** |
| * Gets rebalance mode for distributed cache. |
| * |
| * @return {CacheConfiguration.REABALANCE_MODE} - Rebalance mode. |
| */ |
| getRebalanceMode() { |
| return this._properties.get(PROP_REBALANCE_MODE); |
| } |
| |
| /** |
| * Sets cache rebalance order. Rebalance order can be set to non-zero value for caches with SYNC or |
| * ASYNC rebalance modes only. If cache rebalance order is positive, rebalancing for this cache will be started |
| * only when rebalancing for all caches with smaller rebalance order will be completed. |
| * |
| * @param {number} rebalanceOrder - Cache rebalance order. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setRebalanceOrder(rebalanceOrder) { |
| this._properties.set(PROP_REBALANCE_ORDER, rebalanceOrder); |
| return this; |
| } |
| |
| /** |
| * Gets cache rebalance order. |
| * |
| * @return {number} - Cache rebalance order. |
| */ |
| getRebalanceOrder() { |
| return this._properties.get(PROP_REBALANCE_ORDER); |
| } |
| |
| /** |
| * Sets time in milliseconds to wait between rebalance messages to avoid overloading of CPU or network. This parameter |
| * helps tune the amount of time to wait between rebalance messages to make sure that rebalancing process does not |
| * have any negative performance impact. |
| * |
| * @param {number} rebalanceThrottle - Time in millis to wait between rebalance messages, 0 to disable throttling. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setRebalanceThrottle(rebalanceThrottle) { |
| this._properties.set(PROP_REBALANCE_THROTTLE, rebalanceThrottle); |
| return this; |
| } |
| |
| /** |
| * Gets time in milliseconds to wait between rebalance messages to avoid overloading of CPU or network. |
| * |
| * @return {number} - Time in millis to wait between rebalance messages, 0 - throttling disabled. |
| */ |
| getRebalanceThrottle() { |
| return this._properties.get(PROP_REBALANCE_THROTTLE); |
| } |
| |
| /** |
| * Sets rebalance timeout (ms). |
| * |
| * @param {number} rebalanceTimeout - Rebalance timeout (ms). |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setRebalanceTimeout(rebalanceTimeout) { |
| this._properties.set(PROP_REBALANCE_TIMEOUT, rebalanceTimeout); |
| return this; |
| } |
| |
| /** |
| * Gets rebalance timeout (ms). |
| * |
| * @return {number} - Rebalance timeout (ms). |
| */ |
| getRebalanceTimeout() { |
| return this._properties.get(PROP_REBALANCE_TIMEOUT); |
| } |
| |
| /** |
| * Sets sqlEscapeAll flag. If true all the SQL table and field names will be escaped with double quotes like |
| * ("tableName"."fieldsName"). This enforces case sensitivity for field names and also allows having special |
| * characters in table and field names. |
| * |
| * @param {boolean} sqlEscapeAll - Flag value. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setSqlEscapeAll(sqlEscapeAll) { |
| this._properties.set(PROP_SQL_ESCAPE_ALL, sqlEscapeAll); |
| return this; |
| } |
| |
| /** |
| * Gets sqlEscapeAll flag. |
| * |
| * @return {boolean} - Flag value. |
| */ |
| getSqlEscapeAll() { |
| return this._properties.get(PROP_SQL_ESCAPE_ALL); |
| } |
| |
| /** |
| * Sets maximum inline size for sql indexes. |
| * |
| * @param {number} sqlIndexInlineMaxSize - Maximum payload size for offheap indexes. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setSqlIndexInlineMaxSize(sqlIndexInlineMaxSize) { |
| this._properties.set(PROP_SQL_INDEX_INLINE_MAX_SIZE, sqlIndexInlineMaxSize); |
| return this; |
| } |
| |
| /** |
| * Gets maximum inline size for sql indexes. |
| * |
| * @return {number} - Maximum payload size for offheap indexes. |
| */ |
| getSqlIndexInlineMaxSize() { |
| return this._properties.get(PROP_SQL_INDEX_INLINE_MAX_SIZE); |
| } |
| |
| /** |
| * Sets sql schema to be used for current cache. This name will correspond to SQL ANSI-99 standard. Nonquoted |
| * identifiers are not case sensitive. Quoted identifiers are case sensitive. Be aware of using the same string |
| * in case sensitive and case insensitive manner simultaneously, since behaviour for such case is not specified. |
| * When sqlSchema is not specified, quoted cacheName is used instead. sqlSchema could not be an empty string. |
| * Has to be "\"\"" (quoted empty string) instead. |
| * |
| * @param {string} sqlSchema - Schema name for current cache according to SQL ANSI-99. Should not be null. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| */ |
| setSqlSchema(sqlSchema) { |
| this._properties.set(PROP_SQL_SCHEMA, sqlSchema); |
| return this; |
| } |
| |
| /** |
| * Gets custom name of the sql schema. If custom sql schema is not set then undefined will be returned and quoted |
| * case sensitive name will be used as sql schema. |
| * |
| * @return {string} - Schema name for current cache according to SQL ANSI-99. Could be undefined. |
| */ |
| getSqlSchema() { |
| return this._properties.get(PROP_SQL_SCHEMA); |
| } |
| |
| /** |
| * Sets write synchronization mode. Default synchronization mode is |
| * {@link CacheConfiguration.WRITE_SYNCHRONIZATION_MODE}.PRIMARY_SYNC. |
| * |
| * @param {CacheConfiguration.WRITE_SYNCHRONIZATION_MODE} writeSynchronizationMode - Write synchronization mode |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| * |
| * @throws {IgniteClientError} if error. |
| */ |
| setWriteSynchronizationMode(writeSynchronizationMode) { |
| ArgumentChecker.hasValueFrom(writeSynchronizationMode, 'writeSynchronizationMode', false, WRITE_SYNCHRONIZATION_MODE); |
| this._properties.set(PROP_WRITE_SYNCHRONIZATION_MODE, writeSynchronizationMode); |
| return this; |
| } |
| |
| /** |
| * Gets write synchronization mode. This mode controls whether the main caller should wait for update on |
| * other nodes to complete or not. |
| * |
| * @return {CacheConfiguration.WRITE_SYNCHRONIZATION_MODE} - Write synchronization mode. |
| */ |
| getWriteSynchronizationMode() { |
| return this._properties.get(PROP_WRITE_SYNCHRONIZATION_MODE); |
| } |
| |
| /** |
| * Sets cache key configurations. |
| * |
| * @param {...CacheKeyConfiguration} keyConfigurations - Cache key configurations. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| * |
| * @throws {IgniteClientError} if error. |
| */ |
| setKeyConfigurations(...keyConfigurations) { |
| ArgumentChecker.hasType(keyConfigurations, 'keyConfigurations', true, CacheKeyConfiguration); |
| this._properties.set(PROP_CACHE_KEY_CONFIGURATION, keyConfigurations); |
| return this; |
| } |
| |
| /** |
| * Gets cache key configurations. |
| * |
| * @return {Array<CacheKeyConfiguration>} - Array of cache key configurations. |
| */ |
| getKeyConfigurations() { |
| return this._properties.get(PROP_CACHE_KEY_CONFIGURATION); |
| } |
| |
| /** |
| * Sets query entities configuration. |
| * |
| * @param {...QueryEntity} queryEntities - Query entities configuration. |
| * |
| * @return {CacheConfiguration} - the same instance of the CacheConfiguration. |
| * |
| * @throws {IgniteClientError} if error. |
| */ |
| setQueryEntities(...queryEntities: QueryEntity[]) { |
| ArgumentChecker.hasType(queryEntities, 'queryEntities', true, QueryEntity); |
| this._properties.set(PROP_QUERY_ENTITY, queryEntities); |
| return this; |
| } |
| |
| /** |
| * Gets a collection (array) of configured query entities. |
| * |
| * @return {Array<QueryEntity>} - Array of query entities configurations. |
| */ |
| getQueryEntities() { |
| return this._properties.get(PROP_QUERY_ENTITY); |
| } |
| |
| /** Private methods */ |
| |
| /** |
| * @ignore |
| */ |
| async _write(communicator, buffer, name) { |
| this._properties.set(PROP_NAME, name); |
| |
| const startPos = buffer.position; |
| buffer.position = buffer.position + |
| BinaryUtils.getSize(BinaryUtils.TYPE_CODE.INTEGER) + |
| BinaryUtils.getSize(BinaryUtils.TYPE_CODE.SHORT); |
| |
| for (let [propertyCode, property] of this._properties) { |
| await this._writeProperty(communicator, buffer, propertyCode, property); |
| } |
| |
| const length = buffer.position - startPos; |
| buffer.position = startPos; |
| |
| buffer.writeInteger(length); |
| buffer.writeShort(this._properties.size); |
| } |
| |
| /** |
| * @ignore |
| */ |
| async _writeProperty(communicator, buffer, propertyCode, property) { |
| buffer.writeShort(propertyCode); |
| const propertyType = PROP_TYPES[propertyCode]; |
| switch (BinaryUtils.getTypeCode(propertyType)) { |
| case BinaryUtils.TYPE_CODE.INTEGER: |
| case BinaryUtils.TYPE_CODE.LONG: |
| case BinaryUtils.TYPE_CODE.BOOLEAN: |
| await communicator.writeObject(buffer, property, propertyType, false); |
| return; |
| case BinaryUtils.TYPE_CODE.STRING: |
| await communicator.writeObject(buffer, property, propertyType); |
| return; |
| case BinaryUtils.TYPE_CODE.OBJECT_ARRAY: |
| const length = property ? property.length : 0; |
| buffer.writeInteger(length); |
| for (let prop of property) { |
| await prop._write(communicator, buffer); |
| } |
| return; |
| default: |
| throw IgniteClientError.internalError(); |
| } |
| } |
| |
| /** |
| * @ignore |
| */ |
| async _read(communicator, buffer) { |
| // length |
| buffer.readInteger(); |
| await this._readProperty(communicator, buffer, PROP_ATOMICITY_MODE); |
| await this._readProperty(communicator, buffer, PROP_BACKUPS); |
| await this._readProperty(communicator, buffer, PROP_CACHE_MODE); |
| await this._readProperty(communicator, buffer, PROP_COPY_ON_READ); |
| await this._readProperty(communicator, buffer, PROP_DATA_REGION_NAME); |
| await this._readProperty(communicator, buffer, PROP_EAGER_TTL); |
| await this._readProperty(communicator, buffer, PROP_STATISTICS_ENABLED); |
| await this._readProperty(communicator, buffer, PROP_GROUP_NAME); |
| await this._readProperty(communicator, buffer, PROP_DEFAULT_LOCK_TIMEOUT); |
| await this._readProperty(communicator, buffer, PROP_MAX_CONCURRENT_ASYNC_OPS); |
| await this._readProperty(communicator, buffer, PROP_MAX_QUERY_ITERATORS); |
| await this._readProperty(communicator, buffer, PROP_NAME); |
| await this._readProperty(communicator, buffer, PROP_IS_ONHEAP_CACHE_ENABLED); |
| await this._readProperty(communicator, buffer, PROP_PARTITION_LOSS_POLICY); |
| await this._readProperty(communicator, buffer, PROP_QUERY_DETAIL_METRICS_SIZE); |
| await this._readProperty(communicator, buffer, PROP_QUERY_PARALLELISM); |
| await this._readProperty(communicator, buffer, PROP_READ_FROM_BACKUP); |
| await this._readProperty(communicator, buffer, PROP_REBALANCE_BATCH_SIZE); |
| await this._readProperty(communicator, buffer, PROP_REBALANCE_BATCHES_PREFETCH_COUNT); |
| await this._readProperty(communicator, buffer, PROP_REBALANCE_DELAY); |
| await this._readProperty(communicator, buffer, PROP_REBALANCE_MODE); |
| await this._readProperty(communicator, buffer, PROP_REBALANCE_ORDER); |
| await this._readProperty(communicator, buffer, PROP_REBALANCE_THROTTLE); |
| await this._readProperty(communicator, buffer, PROP_REBALANCE_TIMEOUT); |
| await this._readProperty(communicator, buffer, PROP_SQL_ESCAPE_ALL); |
| await this._readProperty(communicator, buffer, PROP_SQL_INDEX_INLINE_MAX_SIZE); |
| await this._readProperty(communicator, buffer, PROP_SQL_SCHEMA); |
| await this._readProperty(communicator, buffer, PROP_WRITE_SYNCHRONIZATION_MODE); |
| await this._readProperty(communicator, buffer, PROP_CACHE_KEY_CONFIGURATION); |
| await this._readProperty(communicator, buffer, PROP_QUERY_ENTITY); |
| } |
| |
| /** |
| * @ignore |
| */ |
| async _readProperty(communicator, buffer, propertyCode) { |
| const propertyType = PROP_TYPES[propertyCode]; |
| switch (BinaryUtils.getTypeCode(propertyType)) { |
| case BinaryUtils.TYPE_CODE.INTEGER: |
| case BinaryUtils.TYPE_CODE.LONG: |
| case BinaryUtils.TYPE_CODE.BOOLEAN: |
| this._properties.set(propertyCode, await communicator._readTypedObject(buffer, propertyType)); |
| return; |
| case BinaryUtils.TYPE_CODE.STRING: |
| this._properties.set(propertyCode, await communicator.readObject(buffer, propertyType)); |
| return; |
| case BinaryUtils.TYPE_CODE.OBJECT_ARRAY: |
| const length = buffer.readInteger(); |
| if (length > 0) { |
| const properties = new Array(length); |
| for (let i = 0; i < length; i++) { |
| const property = new propertyType._elementType._objectConstructor(); |
| await property._read(communicator, buffer); |
| properties[i] = property; |
| } |
| this._properties.set(propertyCode, properties); |
| } |
| return; |
| default: |
| throw IgniteClientError.internalError(); |
| } |
| } |
| } |
