public DatastoreResults <T> Query(DatastoreQuery <T> q)
{
var results = new BlockingCollection <DatastoreResult <T> >();
Task.Factory.StartNew(() =>
{
foreach (var item in new DirectoryInfo(_path).EnumerateFiles("*" + ObjectKeySuffix, SearchOption.AllDirectories)
.Select(f =>
{
var path = f.FullName;
if (path.StartsWith(_path))
{
path = path.Substring(_path.Length);
}
if (Path.IsPathRooted(path))
{
path = path.TrimStart(Path.DirectorySeparatorChar);
}
var key = new DatastoreKey(path.Substring(0, path.IndexOf(ObjectKeySuffix)));
var entry = new DatastoreEntry <T>(key, default(T));
return(new DatastoreResult <T>(entry));
}))
{
if (!results.TryAdd(item, Timeout.Infinite))
{
break;
}
}
})
.ContinueWith(_ => results.CompleteAdding());
return(DatastoreResults <T> .WithCollection(q, results).NaiveQueryApply());
}
public virtual DatastoreResults <T> Query(DatastoreQuery <T> q)
{
if (q.QueryFilters.Length > 0 ||
q.QueryOrders.Length > 0 ||
q.Limit > 0 ||
q.Offset > 0)
{
throw new Exception("mount only supports listing all prefixed keys in random order");
}
var key = new DatastoreKey(q.Prefix);
IDatastore <T> ds;
DatastoreKey mp, k;
if (!Lookup(key, out ds, out mp, out k))
{
throw new Exception("Mount only supports listing a mount point");
}
var q2 = new DatastoreQuery <T>(prefix: k);
var wrapDS = new KeyTransformDatastore <T>(ds, new KeyTransformPair(null, x => mp.Child(x)));
var r = wrapDS.Query(q2);
return(DatastoreResults <T> .ReplaceQuery(r, q));
}
private static void TestResults <T>(DatastoreResults <T> datastoreResults, DatastoreKey[] expected)
{
var actual = datastoreResults
.Rest()
.Select(e => e.DatastoreKey)
.ToArray();
Assert.That(actual, Is.EqualTo(expected));
}
private static void TestKeyFilter <T>(QueryFilter <T> queryFilter, DatastoreKey[] datastoreKeys, DatastoreKey[] expected)
{
var e = datastoreKeys.Select(key => new DatastoreEntry <T>(key, default(T))).ToArray();
var res = DatastoreResults <T> .WithEntries(new DatastoreQuery <T>(), e).NaiveFilter(queryFilter);
var actualE = res.Rest();
var actual = actualE.Select(x => x.DatastoreKey).ToArray();
Assert.That(actual, Is.EqualTo(expected));
}
public DatastoreResults <T> Query(DatastoreQuery <T> q)
{
var re = _values
.Select(kv => new DatastoreEntry <T>(kv.Key, kv.Value))
.ToArray();
return(DatastoreResults <T>
.WithEntries(q, re)
.NaiveQueryApply());
}
private static void TestKeyOffset <T>(int offset, DatastoreKey[] datastoreKeys, DatastoreKey[] expected)
{
var entries = datastoreKeys
.Select(e => new DatastoreEntry <T>(e, default(T)))
.ToArray();
var res = DatastoreResults <T> .WithEntries(new DatastoreQuery <T>(), entries)
.NaiveOffset(offset);
TestResults(res, expected);
}
public DatastoreResults <byte[]> Query(DatastoreQuery <byte[]> q)
{
if ((!string.IsNullOrEmpty(q.Prefix) && q.Prefix != "/") ||
q.QueryFilters.Length > 0 ||
q.QueryOrders.Length > 0 ||
q.Limit > 0 ||
q.Offset > 0 ||
!q.KeysOnly)
{
throw new Exception("flatfs only supports listing all keys in random order");
}
var reschan = new BlockingCollection <DatastoreResult <byte[]> >(DatastoreQuery <byte[]> .KeysOnlyBufferSize);
Task.Run(() => WalkTopLevel(_path, reschan))
.ContinueWith(_ => reschan.CompleteAdding());
return(DatastoreResults <byte[]> .WithCollection(q, reschan));
}
public DatastoreResults <byte[]> Query(DatastoreQuery <byte[]> q)
{
var qrb = new DatastoreResults <byte[]> .ResultBuilder(q);
Task.Run(() => RunQuery(qrb))
.ContinueWith(_ => qrb.Output.CompleteAdding());
var qr = qrb.Results();
foreach (var filter in q.QueryFilters)
{
qr = qr.NaiveFilter(filter);
}
foreach (var order in q.QueryOrders)
{
qr = qr.NaiveOrder(order);
}
return(qr);
}
public DatastoreResults <T> Query(DatastoreQuery <T> q) => DatastoreResults <T> .WithEntries(q, Array.Empty <DatastoreEntry <T> >());
private static void ExpectMatches <T>(DatastoreKey[] expected, DatastoreResults <T> results)
{
var actual = results.Rest().Select(r => r.DatastoreKey).ToArray();
Assert.That(actual, Is.EqualTo(expected));
}
private void RunQuery(DatastoreResults <byte[]> .ResultBuilder qrb)
{
byte[] range = null;
if (!string.IsNullOrEmpty(qrb.DatastoreQuery.Prefix))
{
range = Encoding.UTF8.GetBytes(qrb.DatastoreQuery.Prefix);
}
using (var i = _db.NewIterator(ReadOptions.Default))
{
i.SeekToFirst();
if (qrb.DatastoreQuery.Offset > 0)
{
var offset = 0;
while (offset < qrb.DatastoreQuery.Offset)
{
if (range != null)
{
if (i.Key().ToArray().HasPrefix(range))
{
offset++;
}
}
else
{
offset++;
}
i.Next();
}
}
for (var sent = 0; i.Valid(); sent++)
{
if (qrb.DatastoreQuery.Limit > 0 && sent >= qrb.DatastoreQuery.Limit)
{
break;
}
if (qrb.Cancellation.IsCancellationRequested)
{
break;
}
if (range != null && i.Key().ToArray().HasPrefix(range))
{
var k = new DatastoreKey(i.Key().ToString());
var v = qrb.DatastoreQuery.KeysOnly ? null : i.Value().ToArray();
var e = new DatastoreEntry <byte[]>(k, v);
if (!qrb.Output.TryAdd(new DatastoreResult <byte[]>(e), Timeout.Infinite, qrb.Cancellation.Token))
{
break;
}
}
i.Next();
}
}
}
