public IObservable <IDataKey> GetKeys(IDatabaseAsync database, IIndexKey indexes, long start = 0, long stop = -1)
{
log.LogTrace("GetKeys");
var keys = GetIds(database, indexes, start, stop);
return(keys.Select(item => GetKey(item, indexes)));
}
public virtual void AddIndex(IIndexKey key)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
indexes[key.Key] = key;
}
public Task RemoveIndex(IDatabaseAsync database, IDataKey key, IIndexKey indexes)
{
if (key?.RecordId == null)
{
throw new ArgumentNullException(nameof(key));
}
return(RemoveRawIndex(database, indexes, key.RecordId));
}
public Task AddRawIndex(IDatabaseAsync database, string rawKey, IIndexKey indexes)
{
if (string.IsNullOrEmpty(rawKey))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(rawKey));
}
return(AddRawIndex(database, indexes, rawKey));
}
public Task AddIndex(IDatabaseAsync database, IDataKey key, IIndexKey indexes)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(AddRawIndex(database, key.RecordId, indexes));
}
public override void AddIndex(IIndexKey key)
{
if (key?.RepositoryKey == null)
{
throw new ArgumentNullException(nameof(key));
}
base.AddIndex(key);
}
private IDataKey GetKey(string key, IIndexKey indexes)
{
var repository = indexes.RepositoryKey;
if (!string.IsNullOrEmpty(repository))
{
return(SimpleKey.GenerateKey(repository, key));
}
return(new ObjectKey(key));
}
public static RedisKey GetIndexKey(this IRedisLink link, IIndexKey index)
{
if (link == null)
{
throw new ArgumentNullException(nameof(link));
}
if (index == null)
{
throw new ArgumentNullException(nameof(index));
}
return(string.IsNullOrEmpty(index.RepositoryKey) ? link.GetKey(index.Key) : link.GetKey($"{index.RepositoryKey}:{index.Key}"));
}
public IObservable <T> GetRecords <T>(IIndexKey index, long start = 0, long end = -1)
{
logger.LogDebug($"GetRecords {start}-{end}");
var indexManager = mainIndexManager.GetManager(index);
int batch = BatchSize;
return(ObserverHelpers.Batch(
indexManager.Count(GetDatabase(), index),
(fromIndex, toIndex) => indexManager.GetKeys(GetDatabase(), index, fromIndex, toIndex),
GetRecords <T>,
batch,
start,
end));
}
public Task <long> Count(IIndexKey index)
{
if (index == null)
{
throw new ArgumentNullException(nameof(index));
}
var indexManager = mainIndexManager.GetManager(index);
if (indexManager == null)
{
return(Task.FromResult(0L));
}
return(link.Resilience
.AsyncRetryPolicy
.ExecuteAsync(async() => await indexManager.Count(GetDatabase(), index).ConfigureAwait(false)));
}
public IIndexManager Create(IIndexKey index)
{
if (index == null)
{
throw new ArgumentNullException(nameof(index));
}
switch (index)
{
case IndexKey indexKey:
return(indexKey.IsSet ? table[setName] : table[listName]);
case HashIndexKey indexKey:
return(table[hashName]);
}
throw new NotSupportedException("Indexing type is not supported: " + index);
}
protected override Task RemoveRawIndex(IDatabaseAsync database, IIndexKey index, string rawKey)
{
var hashIndex = (HashIndexKey)index;
return(database.HashDeleteAsync(Link.GetIndexKey(index), hashIndex.HashKey));
}
public abstract Task <long> Count(IDatabaseAsync database, IIndexKey index);
protected override Task AddRawIndex(IDatabaseAsync database, IIndexKey index, string rawKey)
{
return(database.SortedSetAddAsync(Link.GetIndexKey(index), rawKey, DateTime.UtcNow.ToUnixTime()));
}
protected override IObservable <RedisValue> GetIdsSingle(IDatabaseAsync database, IIndexKey index, long start = 0, long stop = -1)
{
return(Observable.Create <RedisValue>(
async observer =>
{
var keys = await Link.Resilience.AsyncRetryPolicy
.ExecuteAsync(async() => await database.SortedSetRangeByRankAsync(Link.GetIndexKey(index), start, stop, Order.Descending).ConfigureAwait(false))
.ConfigureAwait(false);
foreach (var key in keys)
{
observer.OnNext(key);
}
observer.OnCompleted();
}));
}
public override Task <long> Count(IDatabaseAsync database, IIndexKey index)
{
return(database.SortedSetLengthAsync(Link.GetIndexKey(index)));
}
protected override Task RemoveRawIndex(IDatabaseAsync database, IIndexKey index, string rawKey)
{
return(database.SortedSetRemoveAsync(Link.GetIndexKey(index), rawKey));
}
protected override Task RemoveRawIndex(IDatabaseAsync database, IIndexKey index, string rawKey)
{
// not supported
return(Task.CompletedTask);
}
protected override Task AddRawIndex(IDatabaseAsync database, IIndexKey index, string rawKey)
{
return(database.ListLeftPushAsync(Link.GetIndexKey(index), rawKey));
}
protected override IObservable <RedisValue> GetIdsSingle(IDatabaseAsync database, IIndexKey index, long start = 0, long stop = -1)
{
var hashKey = ((HashIndexKey)index).HashKey;
return(Observable.Create <RedisValue>(
async observer =>
{
var result = await Link.Resilience.AsyncRetryPolicy
.ExecuteAsync(async() => await database.HashGetAsync(Link.GetIndexKey(index), hashKey).ConfigureAwait(false))
.ConfigureAwait(false);
observer.OnNext(result);
observer.OnCompleted();
}));
}
public IIndexManager GetManager(IIndexKey index)
{
return(factory.Create(index));
}
protected override Task AddRawIndex(IDatabaseAsync database, IIndexKey index, string rawKey)
{
var hashIndex = (HashIndexKey)index;
return(database.HashSetAsync(Link.GetIndexKey(index), new[] { new HashEntry(hashIndex.HashKey, rawKey) }));
}
public IObservable <RedisValue> GetIds(IDatabaseAsync database, IIndexKey indexes, long start = 0, long stop = -1)
{
return(GetIdsSingle(database, indexes, start, stop));
}
public Task Reset(IDatabaseAsync database, IIndexKey indexes)
{
log.LogDebug("Reset");
return(database.KeyDeleteAsync(Link.GetIndexKey(indexes)));
}
protected abstract Task AddRawIndex(IDatabaseAsync database, IIndexKey index, string rawKey);
protected abstract IObservable <RedisValue> GetIdsSingle(IDatabaseAsync database, IIndexKey key, long start = 0, long stop = -1);
