1 Redis

Class Ax.redis.Redis


Wraps an instance to UnifiedJedis client

Constructor Summary

Method
Description
JSRedis(Ax.text.String code)
Allows getting a Redis client for the provided code.
JSRedis(Ax.text.String host, int port)
Allows getting a Redis client for the specified hostname/port.
JSRedis(Ax.text.String master, String[] sentinels, int timeout, Ax.text.String password)
Allows getting a Redis client for the specified Redis Sentinel service list.

Method Summary

Modifier and Type
Method
Description
Ax.text.String 
addAlias(Ax.text.String index, Ax.text.String aliasName)
Adds an alias for the given index.
Ax.text.String 
bgsave()
Ax.text.String 
clientList(String[] options)
<pre>
long 
dbsize()
Return the number of keys in the currently-selected database.
long 
del(String[] keys)
Deletes the given keys.
long 
delete(Ax.text.String pattern)
Deletes the keys matching the given pattern.
Ax.text.String 
deleteAlias(Ax.text.String aliasName)
Deletes an alias for the given index.
Ax.text.String 
escape(Ax.text.String query)
Adds the necessary escaping characters so the query is interpreted as a single token.
boolean 
exists(Ax.text.String code)
Checks if a particular the Redis code exists.
Ax.text.String 
ftAdd(Ax.text.String indexName,Ax.text.String docId,Map<StringObject> fields)
Quick add with no payload
Ax.text.String 
ftAdd(Ax.text.String indexName, Ax.text.String docId, double score, boolean noSave, boolean replace, Ax.text.String payload, Map<StringObject> fields)
Fully configurable add or replace command
redis.clients.jedis.search.aggr.AggregationResult 
ftAggregate(Ax.text.String indexName,Ax.redis.search.AggregationBuilder builder)
Aggregate
Ax.text.String 
ftCreate(Ax.text.String indexName, Ax.redis.search.IndexOptions indexOptions, Ax.redis.search.Schema schema)
Creates an index in redisearch
long 
ftDel(Ax.text.String indexName,Ax.text.String docId)
Ax.text.String 
ftDropIndex(Ax.text.String indexName)
Drops an index in redisearch
Ax.text.String 
ftDropIndex(Ax.text.String indexName,boolean ignoreError)
Drops an index in redisearch.
Ax.text.String 
ftDropIndexDD(Ax.text.String indexName)
Drops an index in redisearch
Ax.text.String 
ftDropIndexDD(Ax.text.String indexName,boolean ignoreError)
Drops an index in redisearch.
redis.clients.jedis.search.SearchResult 
ftSearch(Ax.text.String index, Ax.text.String text, Consumer<redis.clients.jedis.search.Query> options)
Searches in Redis for the specified index.
List 
ftSugGet(Ax.text.String index,Ax.text.String prefix)
Gets completion suggestions for a prefix.
List 
ftSugGet(Ax.text.String index, Ax.text.String prefix, int max)
Gets completion suggestions for a prefix.
List 
ftSugGet(Ax.text.String index,Ax.text.String prefix,boolean fuzzy)
Gets completion suggestions for a prefix.
List 
ftSugGet(Ax.text.String index, Ax.text.String prefix, boolean fuzzy, int max)
Gets completion suggestions for a prefix.
List 
ftSugGet(Ax.text.String index,Ax.text.String prefix,boolean fuzzy,boolean scores,boolean payload,int max)
Gets completion suggestions for a prefix.
Ax.java.lang.Long 
ftSugLen(Ax.text.String index)
Returns the length of the suggestion list with the given index.
Ax.text.String 
ftSynUpdate(Ax.text.String index,Ax.text.String synonymGroupId,String[] terms)
Updates with new elements the list with the given index.
Returns the clients list as ResultSet
Map 
getIndexInfo(Ax.text.String name)
Map 
Ax.text.String 
getIndexName(Ax.db conn)
Return the standard (convention) index name given a database, a tag and language.
Ax.text.String 
getIndexName(Ax.db conn,String[] tags)
List 
Map 
int 
Gets the maximum number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time.
int 
Gets the number of active connections in the pool.
int 
Gets the number of idle connections in the pool.
int 
Gets the number of waiting clients because no connection is available.
Ax.redis.Redis 
getRediSearch(Ax.text.String indexName)
Gets a RediSearch client for a given index.
boolean 
hasModule(Ax.text.String name)
long 
hdel(Ax.text.String key, String[] fields)
Remove the specified field from an hash stored at key.
boolean 
hexists(Ax.text.String key,Ax.text.String field)
Test for existence of a specified field in a hash.
Ax.text.String 
hget(Ax.text.String key, Ax.text.String field)
If key holds a hash, retrieve the value associated to the specified field.
Map 
hgetAll(Ax.text.String key)
Return all the fields and associated values in a hash.
long 
hincrBy(Ax.text.String key, Ax.text.String field, long value)
Increment the number stored at field in the hash at key by value.
double 
hincrByFloat(Ax.text.String key,Ax.text.String field,double value)
Increment the number stored at field in the hash at key by a double precision floating point value.
Set 
hkeys(Ax.text.String key)
Return all the fields in a hash.
long 
hlen(Ax.text.String key)
Return the number of items in a hash.
List 
hmget(Ax.text.String key, String[] fields)
Retrieve the values associated to the specified fields.
Ax.text.String 
hmset(Ax.text.String key,Map<StringString> hash)
Set the respective fields to the respective values.
Ax.text.String 
hrandfield(Ax.text.String key)
Get one random field from a hash.
List 
hrandfield(Ax.text.String key,long count)
Get multiple random fields from a hash.
Map 
hrandfieldWithValues(Ax.text.String key, long count)
Get one or multiple random fields with values from a hash.
long 
hset(Ax.text.String key,Ax.text.String field,Ax.text.String value)
Set the specified hash field to the specified value.
long 
hset(Ax.text.String key, Map<StringString> hash)
long 
hsetnx(Ax.text.String key,Ax.text.String field,Ax.text.String value)
Set the specified hash field to the specified value if the field not exists.
List 
hvals(Ax.text.String key)
Return all the values in a hash.
Ax.text.String 
info()
boolean 
Checks if the redis server is ready.
Ax.text.String 
lindex(Ax.text.String key,long index)
Return the specified element of the list stored at the specified key.
long 
llen(Ax.text.String key)
Return the length of the list stored at the specified key.
Ax.text.String 
lpop(Ax.text.String key)
Atomically return and remove the first (LPOP) or last (RPOP) element of the list.
List 
lpop(Ax.text.String key, int count)
Ax.java.lang.Long 
lpos(Ax.text.String key,Ax.text.String element)
Ax.java.lang.Long 
lpos(Ax.text.String key, Ax.text.String element, redis.clients.jedis.params.LPosParams params)
List 
lpos(Ax.text.String key,Ax.text.String element,redis.clients.jedis.params.LPosParams params,long count)
long 
lpush(Ax.text.String key, String[] strings)
Add the string value to the head (LPUSH) or tail (RPUSH) of the list stored at key.
List 
lrange(Ax.text.String key,long start,long stop)
Return the specified elements of the list stored at the specified key.
long 
lrem(Ax.text.String key, long count, Ax.text.String value)
Remove the first count occurrences of the value element from the list.
Ax.text.String 
lset(Ax.text.String key,long index,Ax.text.String value)
Set a new value as the element at index position of the List at key.
Ax.text.String 
ltrim(Ax.text.String key, long start, long stop)
Trim an existing list so that it will contain only the specified range of elements specified.
Ax.text.String 
ping()
Uses a ping command to check if redis is running.
Ax.text.String 
ping(Ax.text.String msg)
Uses a ping command to check if redis is running.
Ax.text.String 
rpop(Ax.text.String key)
Atomically return and remove the first (LPOP) or last (RPOP) element of the list.
List 
rpop(Ax.text.String key,int count)
Ax.text.String 
rpoplpush(Ax.text.String srckey, Ax.text.String dstkey)
Atomically return and remove the last (tail) element of the srckey list, and push the element as the first (head) element of the dstkey list.
long 
rpush(Ax.text.String key,String[] strings)
Add the string value to the head (LPUSH) or tail (RPUSH) of the list stored at key.
long 
sadd(Ax.text.String key, String[] members)
Add the specified member to the set value stored at key.
Ax.text.String 
save()
The SAVE commands performs a synchronous save of the dataset producing a point in time snapshot of all the data inside the Redis instance, in the form of an RDB file.
long 
scard(Ax.text.String key)
Return the set cardinality (number of elements).
Set 
sdiff(String[] keys)
Return the difference between the Set stored at key1 and all the Sets key2, .
long 
sdiffstore(Ax.text.String dstkey, String[] keys)
This command works exactly like
Ax.text.String 
select(int db)
Set 
sinter(String[] keys)
Return the members of a set resulting from the intersection of all the sets hold at the specified keys.
long 
sinterstore(Ax.text.String dstkey,String[] keys)
This command works exactly like
boolean 
sismember(Ax.text.String key, Ax.text.String member)
Return true if member is a member of the set stored at key, otherwise false is returned.
List 
long 
List 
smembers(Ax.text.String key)
Return all the members (elements) of the set value stored at key.
List 
smismember(Ax.text.String key, String[] members)
Returns whether each member is a member of the set stored at key.
long 
smove(Ax.text.String srckey,Ax.text.String dstkey,Ax.text.String member)
Move the specified member from the set at srckey to the set at dstkey.
Ax.text.String 
spop(Ax.text.String key)
Remove a random element from a Set returning it as return value.
Set 
spop(Ax.text.String key,int count)
Ax.text.String 
srandmember(Ax.text.String key)
Return a random element from a Set, without removing the element.
List 
srandmember(Ax.text.String key,int count)
Return a random elements from a Set, without removing the elements.
long 
srem(Ax.text.String key)
Remove the specified member from the set value stored at key.
Set 
sunion(String[] keys)
Return the members of a set resulting from the union of all the sets hold at the specified keys.
long 
sunionstore(Ax.text.String dstkey, String[] keys)
This command works exactly like
Ax.text.String 
swapdb(int from,int to)
This command swaps two Redis databases, so that immediately all the clients connected to a given database will see the data of the other database, and the other way around.
Ax.text.String 
Returns JedisClient toString() function.
Ax.text.String 
updateAlias(Ax.text.String index,Ax.text.String aliasName)
Updates an alias for the given index.
Ax.text.String 
updateSynonym(Ax.text.String index, Ax.text.String synonymGroupId, String[] terms)
Updates with new elements the list with the given index.
long 
zadd(Ax.text.String key,Ax.text.String subkey,Ax.text.String member)
Adds one or more members to a sorted set, or updates its score to 0 if it already exists.
long 
zadd(Ax.text.String key, double score, Ax.text.String member)
Adds one or more members to a sorted set, or updates its score if it already exists.
long 
zcount(byte[] key,double min,double max)
long 
zcount(byte[] key, byte[] min, byte[] max)
Set 
zdiff(byte[][] keys)
long 
zdiffStore(byte[] dstkey, byte[][] keys)
Set 
zdiffWithScores(byte[][] keys)
double 
zincrby(Ax.text.String key, double increment, Ax.text.String member)
If member already exists in the sorted set adds the increment to its score and updates the position of the element in the sorted set accordingly.
Set 
zinter(redis.clients.jedis.params.ZParams params,byte[][] keys)
Intersect multiple sorted sets, This command is similar to ZINTERSTORE, but instead of storing the resulting sorted set, it is returned to the connection.
Set 
zinterWithScores(redis.clients.jedis.params.ZParams params, byte[][] keys)
Intersect multiple sorted sets, This command is similar to ZINTERSTORE, but instead of storing the resulting sorted set, it is returned to the connection.
long 
zinterstore(byte[] dstkey,byte[][] sets)
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey.
long 
zinterstore(byte[] dstkey, redis.clients.jedis.params.ZParams params, byte[][] sets)
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey.
long 
zlexcount(byte[] key,byte[] min,byte[] max)
zrange(Ax.text.String key, long start, long stop)
Return a range of members in a sorted set, by score, with scores ordered from low to high.
List 
zrangeByLex(byte[] key,byte[] min,byte[] max)
List 
zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count)
List 
zrangeByScore(byte[] key,double min,double max)
Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
List 
zrangeByScore(byte[] key, byte[] min, byte[] max)
List 
zrangeByScore(byte[] key,double min,double max,int offset,int count)
Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
List 
zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count)
List 
zrangeByScoreWithScores(byte[] key,double min,double max)
Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
List 
zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max)
List 
zrangeByScoreWithScores(byte[] key,double min,double max,int offset,int count)
Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
List 
zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count)
long 
zrem(Ax.text.String key,Ax.text.String member)
Remove the specified member from the sorted set value stored at key.
long 
zremrangeByLex(byte[] key, byte[] min, byte[] max)
long 
zremrangeByRank(byte[] key,long start,long stop)
Remove all elements in the sorted set at key with rank between start and end.
long 
zremrangeByScore(byte[] key, double min, double max)
Remove all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
long 
zremrangeByScore(byte[] key,byte[] min,byte[] max)
List 
zrevrangeByLex(byte[] key, byte[] max, byte[] min)
List 
zrevrangeByLex(byte[] key,byte[] max,byte[] min,int offset,int count)
zrevrangeByScore(Ax.text.String key, double max, double min)
Returns a range of members in a sorted set, by score, with scores ordered from high to low.
zrevrangeByScore(Ax.text.String key,double max,double min,int offset,int count)
Returns a range of members in a sorted set, by score, with scores ordered from high to low.
List 
zrevrangeByScore(byte[] key, double max, double min)
List 
zrevrangeByScore(byte[] key,byte[] max,byte[] min)
List 
zrevrangeByScore(byte[] key, double max, double min, int offset, int count)
List 
zrevrangeByScore(byte[] key,byte[] max,byte[] min,int offset,int count)
List 
zrevrangeByScoreWithScores(byte[] key, double max, double min)
List 
zrevrangeByScoreWithScores(byte[] key,double max,double min,int offset,int count)
List 
zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min)
List 
zrevrangeByScoreWithScores(byte[] key,byte[] max,byte[] min,int offset,int count)
long 
zrevrank(Ax.text.String key, Ax.text.String member)
Determines the index of a member in a sorted set, with scores ordered from high to low.
Set 
zunion(redis.clients.jedis.params.ZParams params,byte[][] keys)
Add multiple sorted sets, This command is similar to ZUNIONSTORE, but instead of storing the resulting sorted set, it is returned to the connection.
Set 
zunionWithScores(redis.clients.jedis.params.ZParams params, byte[][] keys)
Add multiple sorted sets with scores, This command is similar to ZUNIONSTORE, but instead of storing the resulting sorted set, it is returned to the connection.
long 
zunionstore(byte[] dstkey,byte[][] sets)
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey.
long 
zunionstore(byte[] dstkey, redis.clients.jedis.params.ZParams params, byte[][] sets)
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey.
long 
zunionstore(Ax.text.String key,String[] sets)
Computes the union of multiple sets and stores the resulting sorted set in a new key.

Constructor Detail

Ax.redis.Redis.JSRedis

Ax.redis.Redis.JSRedis(
	string code
						)
Info:
Allows getting a Redis client for the provided code.
Parameters:
code - 

Example
Copy
var client = new Ax.redis.Redis("REDIS1");
   console.log(client.isReady());

Ax.redis.Redis.JSRedis

Ax.redis.Redis.JSRedis(
	string host,
	smallint port
						)
Info:
Allows getting a Redis client for the specified hostname/port.
Parameters:
host - 
port - 

Example
Copy
var client = new Ax.redis.Redis("192.168.105.173", 6379);
   console.log(client.isReady());

Ax.redis.Redis.JSRedis

Ax.redis.Redis.JSRedis(
	string master,
	string[] sentinels,
	smallint timeout,
	string password
						)
Info:
Allows getting a Redis client for the specified Redis Sentinel service list. Will be used when an AX JavaScript program wants to use a specific sentinel services list (not the ones configured in Studio, for example).
Parameters:
master - 
sentinels - 
timeout - 
password - 

Example
Copy
var client = new Ax.redis.Redis("master1", ["192.168.105.174:8001", "192.168.105.174:8002", "192.168.105.174:8003"], 60, null);
 	 console.log('client is ready? ' + client.isReady())
 	 client.ping();
 	 client.sadd("key_4", ["val_44"]);

Method Detail

Ax.redis.Redis.addAlias

string Ax.redis.Redis.addAlias(
	string index,
	string aliasName
)
Info:
Adds an alias for the given index.
Parameters:
index - the index
aliasName - the new alias
Returns:
string

Ax.redis.Redis.bgsave

string Ax.redis.Redis.bgsave()
Returns:
string

Ax.redis.Redis.clientList

string Ax.redis.Redis.clientList(
	string[] options
)
Info:
<pre>
Parameters:
options - 
Returns:
string

Example
Copy
id=49  addr=127.0.0.1:59590 laddr=127.0.0.1:6379 fd=8 name= age=4010 idle=218 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=0 argv-mem=0 obl=0 oll=0 omem=0 tot-mem=17440 events=r cmd=client user=default redir=-1
  id=124 addr=127.0.0.1:60003 laddr=127.0.0.1:6379 fd=9 name= age=0 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=65504 argv-mem=10 obl=0 oll=0 omem=0 tot-mem=82970 events=r cmd=client user=default redir=-1

Ax.redis.Redis.dbsize

long Ax.redis.Redis.dbsize()
Info:
Return the number of keys in the currently-selected database.
Returns:
long

Ax.redis.Redis.del

long Ax.redis.Redis.del(
	string[] keys
)
Info:
Deletes the given keys. Returns the number of keys that were removed.
Parameters:
keys - the keys to delete
Returns:
long

Ax.redis.Redis.delete

long Ax.redis.Redis.delete(
	string pattern
)
Info:
Deletes the keys matching the given pattern.
Parameters:
pattern - the pattern to match
Returns:
long

Ax.redis.Redis.deleteAlias

string Ax.redis.Redis.deleteAlias(
	string aliasName
)
Info:
Deletes an alias for the given index.
Parameters:
aliasName - the alias to remove
Returns:
string

Ax.redis.Redis.escape

string Ax.redis.Redis.escape(
	string query
)
Info:
Adds the necessary escaping characters so the query is interpreted as a single token. All punctuation marks and whitespaces (besides underscores) separate the document and queries into tokens. e.g. any character of ,.
Parameters:
query - the query to escape
Returns:
string

Ax.redis.Redis.exists

boolean Ax.redis.Redis.exists(
	string code
)
Info:
Checks if a particular the Redis code exists.
Parameters:
code - 
Returns:
boolean

Example
Copy
let code = 'myRedis1';
   if (Ax.redis.Redis.exists(code)) {
      console.log('exists Redis with code ' + code);
   }

Ax.redis.Redis.ftAdd

string Ax.redis.Redis.ftAdd(
	string indexName,
	string docId,
	object fields
)
Info:
Quick add with no payload
Parameters:
indexName - 
docId - 
fields - 
Returns:
string

Ax.redis.Redis.ftAdd

string Ax.redis.Redis.ftAdd(
	string indexName,
	string docId,
	double score,
	boolean noSave,
	boolean replace,
	string payload,
	object fields
)
Info:
Fully configurable add or replace command
Parameters:
indexName - The Fulltext index name. The index must be first created with FT.CREATE
docId - The document's id that will be returned from searches. Note that the same docId cannot be added twice to the same index
score - The document's rank based on the user's ranking. This must be between 0.0 and 1.0. If you don't have a score just set it to 1
noSave - If set to true, we will not save the actual document in the index and only index it.
replace - If set, we will do an UPSERT style insertion - and delete an older version of the document if it exists.
payload - Optionally set a binary safe payload string to the document, that can be evaluated at query time by a custom scoring function, or retrieved to the client.
fields - Following the FIELDS specifier, we are looking for pairs of {field} {value} to be indexed.
Returns:
string

Example
Copy
FT.ADD {index} {docId} {score}
	  [NOSAVE]
	  [REPLACE]
	  [LANGUAGE {language}]
	  [PAYLOAD {payload}]
	  FIELDS {field} {value} [{field} {value}...]

Ax.redis.Redis.ftAggregate

object Ax.redis.Redis.ftAggregate(
	string indexName,
	object builder
)
Info:
Aggregate
Parameters:
indexName - 
builder - 
Returns:
object

Ax.redis.Redis.ftCreate

string Ax.redis.Redis.ftCreate(
	string indexName,
	object indexOptions,
	object schema
)
Info:
Creates an index in redisearch
Parameters:
indexName - 
indexOptions - 
schema - 
Returns:
string

Ax.redis.Redis.ftDel

long Ax.redis.Redis.ftDel(
	string indexName,
	string docId
)
Parameters:
indexName - indexName The Fulltext index name. The index must be first created with FT.CREATE
docId - The document's id that will be returned from searches. Note that the same docId cannot be added twice to the same index
Returns:
long

Ax.redis.Redis.ftDropIndex

string Ax.redis.Redis.ftDropIndex(
	string indexName
)
Info:
Drops an index in redisearch
Parameters:
indexName - 
Returns:
string

Ax.redis.Redis.ftDropIndex

string Ax.redis.Redis.ftDropIndex(
	string indexName,
	boolean ignoreError
)
Info:
Drops an index in redisearch. An error is ignored.
Parameters:
indexName - 
ignoreError - 
Returns:
string

Ax.redis.Redis.ftDropIndexDD

string Ax.redis.Redis.ftDropIndexDD(
	string indexName
)
Info:
Drops an index in redisearch
Parameters:
indexName - 
Returns:
string

Ax.redis.Redis.ftDropIndexDD

string Ax.redis.Redis.ftDropIndexDD(
	string indexName,
	boolean ignoreError
)
Info:
Drops an index in redisearch. An error is ignored.
Parameters:
indexName - 
ignoreError - 
Returns:
string

Ax.redis.Redis.ftSearch

object Ax.redis.Redis.ftSearch(
	string index,
	string text,
	object options
)
Info:
Searches in Redis for the specified index. The result is an Iterable
Parameters:
index - index name
text - 
options - search options function
Returns:
object

Example
Copy
SearchResult object.

 
 
 Ax.redis.get().ftSearch("indxname", "q..", options => {
   	options.limit();
   	options.setNoContent();
   	options.setVerbatim();
   	options.setNoStopwords();
   	options.setWithScores();
   	options.setWithPayload();
   	options.setSortBy();
 })

Ax.redis.Redis.ftSugGet

array Ax.redis.Redis.ftSugGet(
	string index,
	string prefix
)
Info:
Gets completion suggestions for a prefix.
Parameters:
index - the suggestion list index
prefix - the prefix to complete
Returns:
array

Example
Copy
Ax.ext.db.getRedisClient().sugget("sug_test", "pilota");

Ax.redis.Redis.ftSugGet

array Ax.redis.Redis.ftSugGet(
	string index,
	string prefix,
	smallint max
)
Info:
Gets completion suggestions for a prefix.
Parameters:
index - the suggestion list index
prefix - the prefix to complete
max - the maximum amount of suggestions
Returns:
array

Example
Copy
Ax.ext.db.getRedisClient().sugget("sug_test", "pilota", 10);

Ax.redis.Redis.ftSugGet

array Ax.redis.Redis.ftSugGet(
	string index,
	string prefix,
	boolean fuzzy
)
Info:
Gets completion suggestions for a prefix.
Parameters:
index - the suggestion list index
prefix - the prefix to complete
fuzzy - whether to do a fuzzy search
Returns:
array

Example
Copy
Ax.ext.db.getRedisClient().sugget("sug_test", "pilota", true);

Ax.redis.Redis.ftSugGet

array Ax.redis.Redis.ftSugGet(
	string index,
	string prefix,
	boolean fuzzy,
	smallint max
)
Info:
Gets completion suggestions for a prefix.
Parameters:
index - the suggestion list index
prefix - the prefix to complete
fuzzy - whether to do a fuzzy search
max - the maximum amount of suggestions
Returns:
array

Example
Copy
Ax.ext.db.getRedisClient().sugget("sug_test", "pilota", true, 10);

Ax.redis.Redis.ftSugGet

array Ax.redis.Redis.ftSugGet(
	string index,
	string prefix,
	boolean fuzzy,
	boolean scores,
	boolean payload,
	smallint max
)
Info:
Gets completion suggestions for a prefix.
Parameters:
index - the suggestion list index
prefix - the prefix to complete
fuzzy - whether to do a fuzzy search
scores - whether to return the suggestion scores
payload - whether to return the suggestion payload
max - the maximum amount of suggestions
Returns:
array

Example
Copy
Ax.ext.db.getRedisClient().sugget("sug_test", "pilota", true, false, true, 10);

Ax.redis.Redis.ftSugLen

object Ax.redis.Redis.ftSugLen(
	string index
)
Info:
Returns the length of the suggestion list with the given index.
Parameters:
index - the suggestion list index
Returns:
object

Ax.redis.Redis.ftSynUpdate

string Ax.redis.Redis.ftSynUpdate(
	string index,
	string synonymGroupId,
	string[] terms
)
Info:
Updates with new elements the list with the given index.
Parameters:
index - the list index
synonymGroupId - 
terms - the list of elements
Returns:
string

Ax.redis.Redis.getClientList

resultset Ax.redis.Redis.getClientList(
	string[] options
)
Info:
Returns the clients list as ResultSet
Parameters:
options - 
Returns:
resultset

Ax.redis.Redis.getIndexInfo

object Ax.redis.Redis.getIndexInfo(
	string name
)
Parameters:
name - 
Returns:
object

Ax.redis.Redis.getIndexInfo

object Ax.redis.Redis.getIndexInfo()
Returns:
object

Ax.redis.Redis.getIndexInfoList

resultset Ax.redis.Redis.getIndexInfoList()
Returns:
resultset

Example
Copy
FT.INFO demo_pos_v2_prod_sp_B
	1) index_name
	2) demo_pos_v2_prod_sp_B
	3) index_options
	4)
	5) index_definition
	6)      1) key_type
	        2) HASH
	        3) prefixes
	        4)              1) demo_pos_v2_prod_sp_B:

	        5) default_score
	        6) 1
	        7) payload_field
	        8) __payload

	7) attributes
	 8) 1) 1) identifier
	       2) title
	       3) attribute
	       4) title
	       5) type
	       6) TEXT
	       7) WEIGHT
	       8) "1"
	    2) 1) identifier
	       2) release_year
	       3) attribute
	       4) release_year
	       5) type
	       6) NUMERIC
	       7) SORTABLE


	9) num_docs
	10) 196
	11) max_doc_id
	12) 394
	13) num_terms
	14) 3899
	15) num_records
	16) 12311
	17) inverted_sz_mb
	18) 0.068743705749511719
	19) total_inverted_index_blocks
	20) 15455349
	21) offset_vectors_sz_mb
	22) 0.0176239013671875
	23) doc_table_size_mb
	24) 0.25942230224609375
	25) sortable_values_size_mb
	26) 0.042790412902832031
	27) key_table_size_mb
	28) 0.0050230026245117188
	29) records_per_doc_avg
	30) 62.811225891113281
	31) bytes_per_record_avg
	32) 5.8551702499389648
	33) offsets_per_term_avg
	34) 1.5010966062545776
	35) offset_bits_per_record_avg
	36) 8
	37) hash_indexing_failures
	38) 0
	39) indexing
	40) 0
	41) percent_indexed
 	42) 1
 	43) gc_stats
 	44)     1) bytes_collected
 	        2) 31626
 	        3) total_ms_run
 	        4) 229
 	        5) total_cycles
 	        6) 1
 	        7) average_cycle_time_ms
 	        8) 229
 	        9) last_run_time_ms
 	        10) 229
 	        11) gc_numeric_trees_missed
 	        12) 0
 	        13) gc_blocks_denied
 	        14) 0

 	45) cursor_stats
 	46)     1) global_idle
 	        2) 0
 	        3) global_total
 	        4) 0
 	        5) index_capacity
 	        6) 128
 	        7) index_total
 	        8) 0

 	47) stopwords_list

Ax.redis.Redis.getIndexName

string Ax.redis.Redis.getIndexName(
	object conn
)
Info:
Return the standard (convention) index name given a database, a tag and language. for example: demo_sports:products:es demo_sports:products:en Redis keys Redis keys are binary safe, this means that you can use any binary sequence as a key, from a string like "foo" to the content of a JPEG file. The empty string is also a valid key. A few other rules about keys: Very long keys are not a good idea. For instance a key of 1024 bytes is a bad idea not only memory-wise, but also because the lookup of the key in the dataset may require several costly key-comparisons. Even when the task at hand is to match the existence of a large value, hashing it (for example with SHA1) is a better idea, especially from the perspective of memory and bandwidth. Very short keys are often not a good idea. There is little point in writing "u1000flw" as a key if you can instead write "user:1000:followers". The latter is more readable and the added space is minor compared to the space used by the key object itself and the value object. While short keys will obviously consume a bit less memory, your job is to find the right balance. Try to stick with a schema. For instance "object-type:id" is a good idea, as in "user:1000". Dots or dashes are often used for multi-word fields, as in "comment:1234:reply.to" or "comment:1234:reply-to". The maximum allowed key size is 512 MB.
Parameters:
conn - 
Returns:
string

Ax.redis.Redis.getIndexName

string Ax.redis.Redis.getIndexName(
	object conn,
	string[] tags
)
Parameters:
conn - 
tags - 
Returns:
string

Ax.redis.Redis.getIndexNames

array Ax.redis.Redis.getIndexNames()
Returns:
array

Ax.redis.Redis.getInfo

object Ax.redis.Redis.getInfo()
Returns:
object

Ax.redis.Redis.getMaxTotal

smallint Ax.redis.Redis.getMaxTotal()
Info:
Gets the maximum number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. When negative, there is no limit to the number of objects that can be managed by the pool at one time.
Returns:
smallint

Ax.redis.Redis.getNumActive

smallint Ax.redis.Redis.getNumActive()
Info:
Gets the number of active connections in the pool.
Returns:
smallint

Ax.redis.Redis.getNumIdle

smallint Ax.redis.Redis.getNumIdle()
Info:
Gets the number of idle connections in the pool.
Returns:
smallint

Ax.redis.Redis.getNumWaiters

smallint Ax.redis.Redis.getNumWaiters()
Info:
Gets the number of waiting clients because no connection is available.
Returns:
smallint

Ax.redis.Redis.getRediSearch

object Ax.redis.Redis.getRediSearch(
	string indexName
)
Info:
Gets a RediSearch client for a given index.
Parameters:
indexName - the index name
Returns:
object

Ax.redis.Redis.hasModule

boolean Ax.redis.Redis.hasModule(
	string name
)
Parameters:
name - 
Returns:
boolean

Example
Copy
# Modules
	module:name=search,ver=999999,api=1,filters=0,usedby=[],using=[],options=[]

Ax.redis.Redis.hdel

long Ax.redis.Redis.hdel(
	string key,
	string[] fields
)
Info:
Remove the specified field from an hash stored at key.
Parameters:
key - 
fields - 
Returns:
long

Example
Copy
Time complexity:

Ax.redis.Redis.hexists

boolean Ax.redis.Redis.hexists(
	string key,
	string field
)
Info:
Test for existence of a specified field in a hash.
Parameters:
key - 
field - 
Returns:
boolean

Example
Copy
Time complexity:

Ax.redis.Redis.hget

string Ax.redis.Redis.hget(
	string key,
	string field
)
Info:
If key holds a hash, retrieve the value associated to the specified field.
Parameters:
key - 
field - 
Returns:
string

Example
Copy
If the field is not found or the key does not exist, a special 'nil' value is returned.
 
 Time complexity:

Ax.redis.Redis.hgetAll

object Ax.redis.Redis.hgetAll(
	string key
)
Info:
Return all the fields and associated values in a hash.
Parameters:
key - 
Returns:
object

Example
Copy
Time complexity:

Ax.redis.Redis.hincrBy

long Ax.redis.Redis.hincrBy(
	string key,
	string field,
	long value
)
Info:
Increment the number stored at field in the hash at key by value. If key does not exist, a new key holding a hash is created. If field does not exist or holds a string, the value is set to 0 before applying the operation. Since the value argument is signed you can use this command to perform both increments and decrements.
Parameters:
key - 
field - 
value - 
Returns:
long

Example
Copy
The range of values supported by HINCRBY is limited to 64 bit signed integers.
 
 Time complexity:

Ax.redis.Redis.hincrByFloat

double Ax.redis.Redis.hincrByFloat(
	string key,
	string field,
	double value
)
Info:
Increment the number stored at field in the hash at key by a double precision floating point value. If key does not exist, a new key holding a hash is created. If field does not exist or holds a string, the value is set to 0 before applying the operation. Since the value argument is signed you can use this command to perform both increments and decrements.
Parameters:
key - 
field - 
value - 
Returns:
double

Example
Copy
The range of values supported by HINCRBYFLOAT is limited to double precision floating point values.
 
 Time complexity:

Ax.redis.Redis.hkeys

object Ax.redis.Redis.hkeys(
	string key
)
Info:
Return all the fields in a hash.
Parameters:
key - 
Returns:
object

Example
Copy
Time complexity:

Ax.redis.Redis.hlen

long Ax.redis.Redis.hlen(
	string key
)
Info:
Return the number of items in a hash.
Parameters:
key - 
Returns:
long

Example
Copy
Time complexity:

Ax.redis.Redis.hmget

array Ax.redis.Redis.hmget(
	string key,
	string[] fields
)
Info:
Retrieve the values associated to the specified fields.
Parameters:
key - 
fields - 
Returns:
array

Example
Copy
If some of the specified fields do not exist, nil values are returned. Non existing keys are considered like empty
 hashes.
 
 Time complexity:

Ax.redis.Redis.hmset

string Ax.redis.Redis.hmset(
	string key,
	object hash
)
Info:
Set the respective fields to the respective values. HMSET replaces old values with new values.
Parameters:
key - 
hash - 
Returns:
string

Example
Copy
If key does not exist, a new key holding a hash is created.
 
 Time complexity:

Ax.redis.Redis.hrandfield

string Ax.redis.Redis.hrandfield(
	string key
)
Info:
Get one random field from a hash.
Parameters:
key - 
Returns:
string

Example
Copy
Time complexity:

Ax.redis.Redis.hrandfield

array Ax.redis.Redis.hrandfield(
	string key,
	long count
)
Info:
Get multiple random fields from a hash.
Parameters:
key - 
count - 
Returns:
array

Example
Copy
Time complexity:

Ax.redis.Redis.hrandfieldWithValues

object Ax.redis.Redis.hrandfieldWithValues(
	string key,
	long count
)
Info:
Get one or multiple random fields with values from a hash.
Parameters:
key - 
count - 
Returns:
object

Example
Copy
Time complexity:

Ax.redis.Redis.hset

long Ax.redis.Redis.hset(
	string key,
	string field,
	string value
)
Info:
Set the specified hash field to the specified value.
Parameters:
key - 
field - 
value - 
Returns:
long

Example
Copy
If key does not exist, a new key holding a hash is created.
 
 Time complexity:

Ax.redis.Redis.hset

long Ax.redis.Redis.hset(
	string key,
	object hash
)
Parameters:
key - 
hash - 
Returns:
long

Ax.redis.Redis.hsetnx

long Ax.redis.Redis.hsetnx(
	string key,
	string field,
	string value
)
Info:
Set the specified hash field to the specified value if the field not exists.
Parameters:
key - 
field - 
value - 
Returns:
long

Example
Copy
Time complexity:

Ax.redis.Redis.hvals

array Ax.redis.Redis.hvals(
	string key
)
Info:
Return all the values in a hash.
Parameters:
key - 
Returns:
array

Example
Copy
Time complexity:

Ax.redis.Redis.info

string Ax.redis.Redis.info()
Returns:
string

Ax.redis.Redis.isReady

boolean Ax.redis.Redis.isReady()
Info:
Checks if the redis server is ready.
Returns:
boolean

Ax.redis.Redis.lindex

string Ax.redis.Redis.lindex(
	string key,
	long index
)
Info:
Return the specified element of the list stored at the specified key. 0 is the first element, 1 the second and so on. Negative indexes are supported, for example -1 is the last element, -2 the penultimate and so on.
Parameters:
key - 
index - 
Returns:
string

Ax.redis.Redis.llen

long Ax.redis.Redis.llen(
	string key
)
Info:
Return the length of the list stored at the specified key. If the key does not exist zero is returned (the same behaviour as for empty lists). If the value stored at key is not a list an error is returned.
Parameters:
key - 
Returns:
long

Ax.redis.Redis.lpop

string Ax.redis.Redis.lpop(
	string key
)
Info:
Atomically return and remove the first (LPOP) or last (RPOP) element of the list. For example if the list contains the elements "a","b","c" LPOP will return "a" and the list will become "b","c".
Parameters:
key - 
Returns:
string

Ax.redis.Redis.lpop

array Ax.redis.Redis.lpop(
	string key,
	smallint count
)
Parameters:
key - 
count - 
Returns:
array

Ax.redis.Redis.lpos

object Ax.redis.Redis.lpos(
	string key,
	string element
)
Parameters:
key - 
element - 
Returns:
object

Ax.redis.Redis.lpos

object Ax.redis.Redis.lpos(
	string key,
	string element,
	object params
)
Parameters:
key - 
element - 
params - 
Returns:
object

Ax.redis.Redis.lpos

array Ax.redis.Redis.lpos(
	string key,
	string element,
	object params,
	long count
)
Parameters:
key - 
element - 
params - 
count - 
Returns:
array

Ax.redis.Redis.lpush

long Ax.redis.Redis.lpush(
	string key,
	string[] strings
)
Info:
Add the string value to the head (LPUSH) or tail (RPUSH) of the list stored at key. If the key does not exist an empty list is created just before the append operation. If the key exists but is not a List an error is returned.
Parameters:
key - 
strings - 
Returns:
long

Ax.redis.Redis.lrange

array Ax.redis.Redis.lrange(
	string key,
	long start,
	long stop
)
Info:
Return the specified elements of the list stored at the specified key. Start and end are zero-based indexes. 0 is the first element of the list (the list head), 1 the next element and so on.
Parameters:
key - 
start - 
stop - 
Returns:
array

Example
Copy
For example LRANGE foobar 0 2 will return the first three elements of the list.
 
 start and end can also be negative numbers indicating offsets from the end of the list. For example -1 is the last
 element of the list, -2 the penultimate element and so on.
 
 Consistency with range functions in various programming languages
Example
Copy
Note that if you have a list of numbers from 0 to 100, LRANGE 0 10 will return 11 elements, that is, rightmost item is
 included. This may or may not be consistent with behavior of range-related functions in your programming language of
 choice (think Ruby's Range.new, Array#slice or Python's range() function).
 
 LRANGE behavior is consistent with one of Tcl.
 
 Out-of-range indexes

Ax.redis.Redis.lrem

long Ax.redis.Redis.lrem(
	string key,
	long count,
	string value
)
Info:
Remove the first count occurrences of the value element from the list. If count is zero all the elements are removed. If count is negative elements are removed from tail to head, instead to go from head to tail that is the normal behaviour. So for example LREM with count -2 and hello as value to remove against the list (a,b,c,hello,x,hello,hello) will leave the list (a,b,c,hello,x). The number of removed elements is returned as an integer, see below for more information about the returned value. Note that non existing keys are considered like empty lists by LREM, so LREM against non existing keys will always return 0.
Parameters:
key - 
count - 
value - 
Returns:
long

Ax.redis.Redis.lset

string Ax.redis.Redis.lset(
	string key,
	long index,
	string value
)
Info:
Set a new value as the element at index position of the List at key.
Parameters:
key - 
index - 
value - 
Returns:
string

Example
Copy
Out of range indexes will generate an error.
 
 Similarly to other list commands accepting indexes, the index can be negative to access elements starting from the end of
 the list. So -1 is the last element, -2 is the penultimate, and so forth.
 
 Time complexity:

Ax.redis.Redis.ltrim

string Ax.redis.Redis.ltrim(
	string key,
	long start,
	long stop
)
Info:
Trim an existing list so that it will contain only the specified range of elements specified. Start and end are zero-based indexes. 0 is the first element of the list (the list head), 1 the next element and so on.
Parameters:
key - 
start - 
stop - 
Returns:
string

Ax.redis.Redis.ping

string Ax.redis.Redis.ping()
Info:
Uses a ping command to check if redis is running.
Returns:
string

Ax.redis.Redis.ping

string Ax.redis.Redis.ping(
	string msg
)
Info:
Uses a ping command to check if redis is running. Returns msg.
Parameters:
msg - the message to return in case of successful ping
Returns:
string

Ax.redis.Redis.pipelined

object Ax.redis.Redis.pipelined()
Returns:
object

Ax.redis.Redis.rpop

string Ax.redis.Redis.rpop(
	string key
)
Info:
Atomically return and remove the first (LPOP) or last (RPOP) element of the list. For example if the list contains the elements "a","b","c" RPOP will return "c" and the list will become "a","b".
Parameters:
key - 
Returns:
string

Ax.redis.Redis.rpop

array Ax.redis.Redis.rpop(
	string key,
	smallint count
)
Parameters:
key - 
count - 
Returns:
array

Ax.redis.Redis.rpoplpush

string Ax.redis.Redis.rpoplpush(
	string srckey,
	string dstkey
)
Info:
Atomically return and remove the last (tail) element of the srckey list, and push the element as the first (head) element of the dstkey list. For example if the source list contains the elements "a","b","c" and the destination list contains the elements "foo","bar" after an RPOPLPUSH command the content of the two lists will be "a","b" and "c","foo","bar".
Parameters:
srckey - 
dstkey - 
Returns:
string

Ax.redis.Redis.rpush

long Ax.redis.Redis.rpush(
	string key,
	string[] strings
)
Info:
Add the string value to the head (LPUSH) or tail (RPUSH) of the list stored at key. If the key does not exist an empty list is created just before the append operation. If the key exists but is not a List an error is returned.
Parameters:
key - 
strings - 
Returns:
long

Ax.redis.Redis.sadd

long Ax.redis.Redis.sadd(
	string key,
	string[] members
)
Info:
Add the specified member to the set value stored at key. If member is already a member of the set no operation is performed. If key does not exist a new set with the specified member as sole member is created. If the key exists but does not hold a set value an error is returned.
Parameters:
key - 
members - 
Returns:
long

Ax.redis.Redis.save

string Ax.redis.Redis.save()
Info:
The SAVE commands performs a synchronous save of the dataset producing a point in time snapshot of all the data inside the Redis instance, in the form of an RDB file. You almost never want to call SAVE in production environments where it will block all the other clients. Instead usually BGSAVE is used. However in case of issues preventing Redis to create the background saving child (for instance errors in the fork(2) system call), the SAVE command can be a good last resort to perform the dump of the latest dataset.
Returns:
string

Ax.redis.Redis.scard

long Ax.redis.Redis.scard(
	string key
)
Info:
Return the set cardinality (number of elements). If the key does not exist 0 is returned, like for empty sets.
Parameters:
key - 
Returns:
long

Ax.redis.Redis.sdiff

object Ax.redis.Redis.sdiff(
	string[] keys
)
Info:
Return the difference between the Set stored at key1 and all the Sets key2, ..., keyN
Parameters:
keys - 
Returns:
object

Example
Copy
Example:
Example
Copy
key1 = [x, a, b, c]
 key2 = [c]
 key3 = [a, d]
 SDIFF key1,key2,key3 = [x, b]
Example
Copy
Time complexity:

Ax.redis.Redis.sdiffstore

long Ax.redis.Redis.sdiffstore(
	string dstkey,
	string[] keys
)
Info:
This command works exactly like
Parameters:
dstkey - 
keys - 
Returns:
long

Ax.redis.Redis.select

string Ax.redis.Redis.select(
	smallint db
)
Parameters:
db - 
Returns:
string

Ax.redis.Redis.sinter

object Ax.redis.Redis.sinter(
	string[] keys
)
Info:
Return the members of a set resulting from the intersection of all the sets hold at the specified keys. Like in
Parameters:
keys - 
Returns:
object

Ax.redis.Redis.sinterstore

long Ax.redis.Redis.sinterstore(
	string dstkey,
	string[] keys
)
Info:
This command works exactly like
Parameters:
dstkey - 
keys - 
Returns:
long

Ax.redis.Redis.sismember

boolean Ax.redis.Redis.sismember(
	string key,
	string member
)
Info:
Return true if member is a member of the set stored at key, otherwise false is returned.
Parameters:
key - 
member - 
Returns:
boolean

Ax.redis.Redis.slowlogGet

array Ax.redis.Redis.slowlogGet()
Returns:
array

Ax.redis.Redis.slowlogLen

long Ax.redis.Redis.slowlogLen()
Returns:
long

Ax.redis.Redis.smembers

array Ax.redis.Redis.smembers(
	string key
)
Info:
Return all the members (elements) of the set value stored at key. This is just syntax glue for
Parameters:
key - 
Returns:
array

Ax.redis.Redis.smismember

array Ax.redis.Redis.smismember(
	string key,
	string[] members
)
Info:
Returns whether each member is a member of the set stored at key.
Parameters:
key - 
members - 
Returns:
array

Ax.redis.Redis.smove

long Ax.redis.Redis.smove(
	string srckey,
	string dstkey,
	string member
)
Info:
Move the specified member from the set at srckey to the set at dstkey. This operation is atomic, in every given moment the element will appear to be in the source or destination set for accessing clients.
Parameters:
srckey - 
dstkey - 
member - 
Returns:
long

Ax.redis.Redis.spop

string Ax.redis.Redis.spop(
	string key
)
Info:
Remove a random element from a Set returning it as return value. If the Set is empty or the key does not exist, a nil object is returned.
Parameters:
key - 
Returns:
string

Ax.redis.Redis.spop

object Ax.redis.Redis.spop(
	string key,
	smallint count
)
Parameters:
key - 
count - 
Returns:
object

Ax.redis.Redis.srandmember

string Ax.redis.Redis.srandmember(
	string key
)
Info:
Return a random element from a Set, without removing the element. If the Set is empty or the key does not exist, a nil object is returned.
Parameters:
key - 
Returns:
string

Ax.redis.Redis.srandmember

array Ax.redis.Redis.srandmember(
	string key,
	smallint count
)
Info:
Return a random elements from a Set, without removing the elements. If the Set is empty or the key does not exist, an empty list is returned.
Parameters:
key - 
count - if positive, return an array of distinct elements. If negative the behavior changes and the command is allowed to return the same element multiple times
Returns:
array

Ax.redis.Redis.srem

long Ax.redis.Redis.srem(
	string key
)
Info:
Remove the specified member from the set value stored at key. If member was not a member of the set no operation is performed. If key does not hold a set value an error is returned.
Parameters:
key - 
Returns:
long

Ax.redis.Redis.sunion

object Ax.redis.Redis.sunion(
	string[] keys
)
Info:
Return the members of a set resulting from the union of all the sets hold at the specified keys. Like in
Parameters:
keys - 
Returns:
object

Ax.redis.Redis.sunionstore

long Ax.redis.Redis.sunionstore(
	string dstkey,
	string[] keys
)
Info:
This command works exactly like
Parameters:
dstkey - 
keys - 
Returns:
long

Ax.redis.Redis.swapdb

string Ax.redis.Redis.swapdb(
	smallint from,
	smallint to
)
Info:
This command swaps two Redis databases, so that immediately all the clients connected to a given database will see the data of the other database, and the other way around. Example:
Parameters:
from - 
to - 
Returns:
string

Example
Copy
SWAPDB 0 1

Ax.redis.Redis.toString

string Ax.redis.Redis.toString()
Info:
Returns JedisClient toString() function.
Returns:
string

Ax.redis.Redis.updateAlias

string Ax.redis.Redis.updateAlias(
	string index,
	string aliasName
)
Info:
Updates an alias for the given index.
Parameters:
index - the index
aliasName - the new alias
Returns:
string

Ax.redis.Redis.updateSynonym

string Ax.redis.Redis.updateSynonym(
	string index,
	string synonymGroupId,
	string[] terms
)
Info:
Updates with new elements the list with the given index.
Parameters:
index - the list index
synonymGroupId - 
terms - the list of elements
Returns:
string

Ax.redis.Redis.zadd

long Ax.redis.Redis.zadd(
	string key,
	string subkey,
	string member
)
Info:
Adds one or more members to a sorted set, or updates its score to 0 if it already exists. Creates the set if not exists. Returns the number of elements added to the sorted set, not including elements already existing for which the score was updated.
Parameters:
key - the first part of the set key (before :)
subkey - second part of the set key (after :)
member - the member to add/update
Returns:
long

Ax.redis.Redis.zadd

long Ax.redis.Redis.zadd(
	string key,
	double score,
	string member
)
Info:
Adds one or more members to a sorted set, or updates its score if it already exists. Creates the set if not exists. Returns the number of elements added to the sorted set, not including elements already existing for which the score was updated.
Parameters:
key - the set key
score - score to add/update
member - the member to add/update
Returns:
long

Ax.redis.Redis.zcount

long Ax.redis.Redis.zcount(
	byte[] key,
	double min,
	double max
)
Parameters:
key - 
min - 
max - 
Returns:
long

Ax.redis.Redis.zcount

long Ax.redis.Redis.zcount(
	byte[] key,
	byte[] min,
	byte[] max
)
Parameters:
key - 
min - 
max - 
Returns:
long

Ax.redis.Redis.zdiff

object Ax.redis.Redis.zdiff(
	object keys
)
Parameters:
keys - 
Returns:
object

Ax.redis.Redis.zdiffStore

long Ax.redis.Redis.zdiffStore(
	byte[] dstkey,
	object keys
)
Parameters:
dstkey - 
keys - 
Returns:
long

Ax.redis.Redis.zdiffWithScores

object Ax.redis.Redis.zdiffWithScores(
	object keys
)
Parameters:
keys - 
Returns:
object

Ax.redis.Redis.zincrby

double Ax.redis.Redis.zincrby(
	string key,
	double increment,
	string member
)
Info:
If member already exists in the sorted set adds the increment to its score and updates the position of the element in the sorted set accordingly. If member does not already exist in the sorted set it is added with increment as score (that is, like if the previous score was virtually zero). If key does not exist a new sorted set with the specified member as sole member is created. If the key exists but does not hold a sorted set value an error is returned.
Parameters:
key - 
increment - 
member - 
Returns:
double

Ax.redis.Redis.zinter

object Ax.redis.Redis.zinter(
	object params,
	object keys
)
Info:
Intersect multiple sorted sets, This command is similar to ZINTERSTORE, but instead of storing the resulting sorted set, it is returned to the connection.
Parameters:
params - 
keys - 
Returns:
object

Ax.redis.Redis.zinterWithScores

object Ax.redis.Redis.zinterWithScores(
	object params,
	object keys
)
Info:
Intersect multiple sorted sets, This command is similar to ZINTERSTORE, but instead of storing the resulting sorted set, it is returned to the connection.
Parameters:
params - 
keys - 
Returns:
object

Ax.redis.Redis.zinterstore

long Ax.redis.Redis.zinterstore(
	byte[] dstkey,
	object sets
)
Info:
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey. It is mandatory to provide the number of input keys N, before passing the input keys and the other (optional) arguments.
Parameters:
dstkey - 
sets - 
Returns:
long

Example
Copy
As the terms imply, the ZINTERSTORE command requires an element to be present
 in each of the given inputs to be inserted in the result. The ZUNIONSTORE
 command inserts all elements across all inputs.
 
 Using the WEIGHTS option, it is possible to add weight to each input sorted set. This means that the score of each
 element in the sorted set is first multiplied by this weight before being passed to the aggregation. When this option is
 not given, all weights default to 1.
 
 With the AGGREGATE option, it is possible to specify how the results of the union or intersection are aggregated. This
 option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is
 set to be either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs
 where it exists.
 
 Time complexity:

Ax.redis.Redis.zinterstore

long Ax.redis.Redis.zinterstore(
	byte[] dstkey,
	object params,
	object sets
)
Info:
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey. It is mandatory to provide the number of input keys N, before passing the input keys and the other (optional) arguments.
Parameters:
dstkey - 
params - 
sets - 
Returns:
long

Example
Copy
As the terms imply, the ZINTERSTORE command requires an element to be present
 in each of the given inputs to be inserted in the result. The ZUNIONSTORE
 command inserts all elements across all inputs.
 
 Using the WEIGHTS option, it is possible to add weight to each input sorted set. This means that the score of each
 element in the sorted set is first multiplied by this weight before being passed to the aggregation. When this option is
 not given, all weights default to 1.
 
 With the AGGREGATE option, it is possible to specify how the results of the union or intersection are aggregated. This
 option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is
 set to be either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs
 where it exists.
 
 Time complexity:

Ax.redis.Redis.zlexcount

long Ax.redis.Redis.zlexcount(
	byte[] key,
	byte[] min,
	byte[] max
)
Parameters:
key - 
min - 
max - 
Returns:
long

Ax.redis.Redis.zrange

string[] Ax.redis.Redis.zrange(
	string key,
	long start,
	long stop
)
Info:
Return a range of members in a sorted set, by score, with scores ordered from low to high. Returns list of elements in the specified range.
Parameters:
key - the set key
start - the minimum score
stop - the maximum score
Returns:
string[]

Ax.redis.Redis.zrangeByLex

array Ax.redis.Redis.zrangeByLex(
	byte[] key,
	byte[] min,
	byte[] max
)
Parameters:
key - 
min - 
max - 
Returns:
array

Ax.redis.Redis.zrangeByLex

array Ax.redis.Redis.zrangeByLex(
	byte[] key,
	byte[] min,
	byte[] max,
	smallint offset,
	smallint count
)
Parameters:
key - 
min - 
max - 
offset - 
count - 
Returns:
array

Ax.redis.Redis.zrangeByScore

array Ax.redis.Redis.zrangeByScore(
	byte[] key,
	double min,
	double max
)
Info:
Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
Parameters:
key - 
min - 
max - 
Returns:
array

Example
Copy
The elements having the same score are returned sorted lexicographically as ASCII strings (this follows from a property
 of Redis sorted sets and does not involve further computation).
 
 Using the optional LIMIT it is possible to get only a range
 of the matching elements in an SQL-alike way. Note that if the offset is large the commands needs to traverse the list
 for offset elements and this adds up to the O(M) figure.
 
 The ZCOUNT command is similar to
 ZRANGEBYSCORE but instead of returning the actual elements in the
 specified interval, it just returns the number of matching elements.
 
 Exclusive intervals and infinity
Example
Copy
min and max can be -inf and +inf, so that you are not required to know what's the greatest or smallest element in order
 to take, for instance, elements "up to a given value".
 
 Also while the interval is for default closed (inclusive) it is possible to specify open intervals prefixing the score
 with a "(" character, so for instance:
 
 ZRANGEBYSCORE zset (1.3 5
 
 Will return all the values with score  1.3 and = 5, while for instance:
 
 ZRANGEBYSCORE zset (5 (10
 
 Will return all the values with score  5 and  10 (5 and 10 excluded).
 
 Time complexity:

Ax.redis.Redis.zrangeByScore

array Ax.redis.Redis.zrangeByScore(
	byte[] key,
	byte[] min,
	byte[] max
)
Parameters:
key - 
min - 
max - 
Returns:
array

Ax.redis.Redis.zrangeByScore

array Ax.redis.Redis.zrangeByScore(
	byte[] key,
	double min,
	double max,
	smallint offset,
	smallint count
)
Info:
Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
Parameters:
key - 
min - 
max - 
offset - 
count - 
Returns:
array

Example
Copy
The elements having the same score are returned sorted lexicographically as ASCII strings (this follows from a property
 of Redis sorted sets and does not involve further computation).
 
 Using the optional LIMIT it is possible to get only a range
 of the matching elements in an SQL-alike way. Note that if offset is large the commands needs to traverse the list for
 offset elements and this adds up to the O(M) figure.
 
 The ZCOUNT command is similar to
 ZRANGEBYSCORE but instead of returning the actual elements in the
 specified interval, it just returns the number of matching elements.
 
 Exclusive intervals and infinity
Example
Copy
min and max can be -inf and +inf, so that you are not required to know what's the greatest or smallest element in order
 to take, for instance, elements "up to a given value".
 
 Also while the interval is for default closed (inclusive) it is possible to specify open intervals prefixing the score
 with a "(" character, so for instance:
 
 ZRANGEBYSCORE zset (1.3 5
 
 Will return all the values with score  1.3 and = 5, while for instance:
 
 ZRANGEBYSCORE zset (5 (10
 
 Will return all the values with score  5 and  10 (5 and 10 excluded).
 
 Time complexity:

Ax.redis.Redis.zrangeByScore

array Ax.redis.Redis.zrangeByScore(
	byte[] key,
	byte[] min,
	byte[] max,
	smallint offset,
	smallint count
)
Parameters:
key - 
min - 
max - 
offset - 
count - 
Returns:
array

Ax.redis.Redis.zrangeByScoreWithScores

array Ax.redis.Redis.zrangeByScoreWithScores(
	byte[] key,
	double min,
	double max
)
Info:
Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
Parameters:
key - 
min - 
max - 
Returns:
array

Example
Copy
The elements having the same score are returned sorted lexicographically as ASCII strings (this follows from a property
 of Redis sorted sets and does not involve further computation).
 
 Using the optional LIMIT it is possible to get only a range
 of the matching elements in an SQL-alike way. Note that if offset is large the commands needs to traverse the list for
 offset elements and this adds up to the O(M) figure.
 
 The ZCOUNT command is similar to
 ZRANGEBYSCORE but instead of returning the actual elements in the
 specified interval, it just returns the number of matching elements.
 
 Exclusive intervals and infinity
Example
Copy
min and max can be -inf and +inf, so that you are not required to know what's the greatest or smallest element in order
 to take, for instance, elements "up to a given value".
 
 Also while the interval is for default closed (inclusive) it is possible to specify open intervals prefixing the score
 with a "(" character, so for instance:
 
 ZRANGEBYSCORE zset (1.3 5
 
 Will return all the values with score  1.3 and = 5, while for instance:
 
 ZRANGEBYSCORE zset (5 (10
 
 Will return all the values with score  5 and  10 (5 and 10 excluded).
 
 Time complexity:

Ax.redis.Redis.zrangeByScoreWithScores

array Ax.redis.Redis.zrangeByScoreWithScores(
	byte[] key,
	byte[] min,
	byte[] max
)
Parameters:
key - 
min - 
max - 
Returns:
array

Ax.redis.Redis.zrangeByScoreWithScores

array Ax.redis.Redis.zrangeByScoreWithScores(
	byte[] key,
	double min,
	double max,
	smallint offset,
	smallint count
)
Info:
Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
Parameters:
key - 
min - 
max - 
offset - 
count - 
Returns:
array

Example
Copy
The elements having the same score are returned sorted lexicographically as ASCII strings (this follows from a property
 of Redis sorted sets and does not involve further computation).
 
 Using the optional LIMIT it is possible to get only a range
 of the matching elements in an SQL-alike way. Note that if offset is large the commands needs to traverse the list for
 offset elements and this adds up to the O(M) figure.
 
 The ZCOUNT command is similar to
 ZRANGEBYSCORE but instead of returning the actual elements in the
 specified interval, it just returns the number of matching elements.
 
 Exclusive intervals and infinity
Example
Copy
min and max can be -inf and +inf, so that you are not required to know what's the greatest or smallest element in order
 to take, for instance, elements "up to a given value".
 
 Also while the interval is for default closed (inclusive) it is possible to specify open intervals prefixing the score
 with a "(" character, so for instance:
 
 ZRANGEBYSCORE zset (1.3 5
 
 Will return all the values with score  1.3 and = 5, while for instance:
 
 ZRANGEBYSCORE zset (5 (10
 
 Will return all the values with score  5 and  10 (5 and 10 excluded).
 
 Time complexity:

Ax.redis.Redis.zrangeByScoreWithScores

array Ax.redis.Redis.zrangeByScoreWithScores(
	byte[] key,
	byte[] min,
	byte[] max,
	smallint offset,
	smallint count
)
Parameters:
key - 
min - 
max - 
offset - 
count - 
Returns:
array

Ax.redis.Redis.zrem

long Ax.redis.Redis.zrem(
	string key,
	string member
)
Info:
Remove the specified member from the sorted set value stored at key. If member was not a member of the set no operation is performed. If key does not not hold a set value an error is returned.
Parameters:
key - 
member - 
Returns:
long

Ax.redis.Redis.zremrangeByLex

long Ax.redis.Redis.zremrangeByLex(
	byte[] key,
	byte[] min,
	byte[] max
)
Parameters:
key - 
min - 
max - 
Returns:
long

Ax.redis.Redis.zremrangeByRank

long Ax.redis.Redis.zremrangeByRank(
	byte[] key,
	long start,
	long stop
)
Info:
Remove all elements in the sorted set at key with rank between start and end. Start and end are 0-based with rank 0 being the element with the lowest score. Both start and end can be negative numbers, where they indicate offsets starting at the element with the highest rank. For example: -1 is the element with the highest score, -2 the element with the second highest score and so forth.
Parameters:
key - 
start - 
stop - 
Returns:
long

Example
Copy
Time complexity:

Ax.redis.Redis.zremrangeByScore

long Ax.redis.Redis.zremrangeByScore(
	byte[] key,
	double min,
	double max
)
Info:
Remove all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
Parameters:
key - 
min - 
max - 
Returns:
long

Example
Copy
Time complexity:

Ax.redis.Redis.zremrangeByScore

long Ax.redis.Redis.zremrangeByScore(
	byte[] key,
	byte[] min,
	byte[] max
)
Parameters:
key - 
min - 
max - 
Returns:
long

Ax.redis.Redis.zrevrangeByLex

array Ax.redis.Redis.zrevrangeByLex(
	byte[] key,
	byte[] max,
	byte[] min
)
Parameters:
key - 
max - 
min - 
Returns:
array

Ax.redis.Redis.zrevrangeByLex

array Ax.redis.Redis.zrevrangeByLex(
	byte[] key,
	byte[] max,
	byte[] min,
	smallint offset,
	smallint count
)
Parameters:
key - 
max - 
min - 
offset - 
count - 
Returns:
array

Ax.redis.Redis.zrevrangeByScore

string[] Ax.redis.Redis.zrevrangeByScore(
	string key,
	double max,
	double min
)
Info:
Returns a range of members in a sorted set, by score, with scores ordered from high to low. Returns the list of elements in the specified score range.
Parameters:
key - the set key
max - the maximum score
min - the minimum score
Returns:
string[]

Ax.redis.Redis.zrevrangeByScore

string[] Ax.redis.Redis.zrevrangeByScore(
	string key,
	double max,
	double min,
	smallint offset,
	smallint count
)
Info:
Returns a range of members in a sorted set, by score, with scores ordered from high to low. Returns the list of elements in the specified score range.
Parameters:
key - the set key
max - the maximum score
min - the minimum score
offset - 
count - 
Returns:
string[]

Ax.redis.Redis.zrevrangeByScore

array Ax.redis.Redis.zrevrangeByScore(
	byte[] key,
	double max,
	double min
)
Parameters:
key - 
max - 
min - 
Returns:
array

Ax.redis.Redis.zrevrangeByScore

array Ax.redis.Redis.zrevrangeByScore(
	byte[] key,
	byte[] max,
	byte[] min
)
Parameters:
key - 
max - 
min - 
Returns:
array

Ax.redis.Redis.zrevrangeByScore

array Ax.redis.Redis.zrevrangeByScore(
	byte[] key,
	double max,
	double min,
	smallint offset,
	smallint count
)
Parameters:
key - 
max - 
min - 
offset - 
count - 
Returns:
array

Ax.redis.Redis.zrevrangeByScore

array Ax.redis.Redis.zrevrangeByScore(
	byte[] key,
	byte[] max,
	byte[] min,
	smallint offset,
	smallint count
)
Parameters:
key - 
max - 
min - 
offset - 
count - 
Returns:
array

Ax.redis.Redis.zrevrangeByScoreWithScores

array Ax.redis.Redis.zrevrangeByScoreWithScores(
	byte[] key,
	double max,
	double min
)
Parameters:
key - 
max - 
min - 
Returns:
array

Ax.redis.Redis.zrevrangeByScoreWithScores

array Ax.redis.Redis.zrevrangeByScoreWithScores(
	byte[] key,
	double max,
	double min,
	smallint offset,
	smallint count
)
Parameters:
key - 
max - 
min - 
offset - 
count - 
Returns:
array

Ax.redis.Redis.zrevrangeByScoreWithScores

array Ax.redis.Redis.zrevrangeByScoreWithScores(
	byte[] key,
	byte[] max,
	byte[] min
)
Parameters:
key - 
max - 
min - 
Returns:
array

Ax.redis.Redis.zrevrangeByScoreWithScores

array Ax.redis.Redis.zrevrangeByScoreWithScores(
	byte[] key,
	byte[] max,
	byte[] min,
	smallint offset,
	smallint count
)
Parameters:
key - 
max - 
min - 
offset - 
count - 
Returns:
array

Ax.redis.Redis.zrevrank

long Ax.redis.Redis.zrevrank(
	string key,
	string member
)
Info:
Determines the index of a member in a sorted set, with scores ordered from high to low. Returns: the rank of the member, if the member exists in the sorted set; null, if the member does not exist in the sorted set or key does not exist.
Parameters:
key - the key
member - the member to get its index
Returns:
long

Ax.redis.Redis.zunion

object Ax.redis.Redis.zunion(
	object params,
	object keys
)
Info:
Add multiple sorted sets, This command is similar to ZUNIONSTORE, but instead of storing the resulting sorted set, it is returned to the connection.
Parameters:
params - 
keys - 
Returns:
object

Ax.redis.Redis.zunionWithScores

object Ax.redis.Redis.zunionWithScores(
	object params,
	object keys
)
Info:
Add multiple sorted sets with scores, This command is similar to ZUNIONSTORE, but instead of storing the resulting sorted set, it is returned to the connection.
Parameters:
params - 
keys - 
Returns:
object

Ax.redis.Redis.zunionstore

long Ax.redis.Redis.zunionstore(
	byte[] dstkey,
	object sets
)
Info:
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey. It is mandatory to provide the number of input keys N, before passing the input keys and the other (optional) arguments.
Parameters:
dstkey - 
sets - 
Returns:
long

Example
Copy
As the terms imply, the  ZINTERSTORE} command requires an element to be
 present in each of the given inputs to be inserted in the result. The  command
 inserts all elements across all inputs.
 
 Using the WEIGHTS option, it is possible to add weight to each input sorted set. This means that the score of each
 element in the sorted set is first multiplied by this weight before being passed to the aggregation. When this option is
 not given, all weights default to 1.
 
 With the AGGREGATE option, it is possible to specify how the results of the union or intersection are aggregated. This
 option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is
 set to be either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs
 where it exists.
 
 Time complexity:

Ax.redis.Redis.zunionstore

long Ax.redis.Redis.zunionstore(
	byte[] dstkey,
	object params,
	object sets
)
Info:
Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey. It is mandatory to provide the number of input keys N, before passing the input keys and the other (optional) arguments.
Parameters:
dstkey - 
params - 
sets - 
Returns:
long

Example
Copy
As the terms imply, the ZINTERSTORE command requires an element to be present
 in each of the given inputs to be inserted in the result. The ZUNIONSTORE
 command inserts all elements across all inputs.
 
 Using the WEIGHTS option, it is possible to add weight to each input sorted set. This means that the score of each
 element in the sorted set is first multiplied by this weight before being passed to the aggregation. When this option is
 not given, all weights default to 1.
 
 With the AGGREGATE option, it is possible to specify how the results of the union or intersection are aggregated. This
 option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is
 set to be either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs
 where it exists.
 
 Time complexity:

Ax.redis.Redis.zunionstore

long Ax.redis.Redis.zunionstore(
	string key,
	string[] sets
)
Info:
Computes the union of multiple sets and stores the resulting sorted set in a new key. Returns the number of elements in the resulting sorted set at destination.
Parameters:
key - the resulting set key
sets - the kes of the sorted sets to unite
Returns:
long

2 Redisearch

2.1 AggregationBuilder

AggregationBuilder documentation page.

2.2 SortedField

SortedField documentation page.

2.3 Reducers

Reducers documentation page.