1 Redis
Class Ax.redis.Redis
Constructor Summary
Method Summary
Constructor Detail
Ax.redis.Redis.JSRedis
-
Ax.redis.Redis.JSRedis( string code )
- Info:
-
Allows getting a Redis client for the provided code. - Parameters:
- code -
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 -
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 -
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
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
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
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
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
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
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
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
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
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
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
# 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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:
key1 = [x, a, b, c] key2 = [c] key3 = [a, d] SDIFF key1,key2,key3 = [x, b]
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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.