public static async Task <FdbSystemStatus> GetStatusAsync([NotNull] IFdbReadOnlyTransaction trans) { Contract.NotNull(trans, nameof(trans)); Slice data = await trans.GetAsync(StatusJsonKey).ConfigureAwait(false); if (data.IsNullOrEmpty) { return(null); } string jsonText = data.ToUnicode(); var doc = TinyJsonParser.ParseObject(jsonText); if (doc == null) { return(null); } long rv = 0; if (doc.ContainsKey("cluster")) { rv = await trans.GetReadVersionAsync(); } return(new FdbSystemStatus(doc, rv, jsonText)); }
public static async Task <FdbSystemStatus?> GetStatusAsync(IFdbReadOnlyTransaction trans) { Contract.NotNull(trans); var data = await trans.GetAsync(StatusJsonKey).ConfigureAwait(false); if (data.IsNullOrEmpty) { return(null); } var doc = TinyJsonParser.ParseObject(data); if (doc == null) { return(null); } long rv = 0; if (doc.ContainsKey("cluster")) { rv = await trans.GetReadVersionAsync(); } return(new FdbSystemStatus(doc, rv, data)); }
/// <summary>Checks if a (key, value) pair exists</summary> public async Task<bool> ContainsAsync([NotNull] IFdbReadOnlyTransaction trans, TKey key, TValue value) { if (trans == null) throw new ArgumentNullException(nameof(trans)); var v = await trans.GetAsync(this.Subspace.Keys[key, value]).ConfigureAwait(false); return this.AllowNegativeValues ? v.IsPresent : v.ToInt64() > 0; }
/// <summary>Return the count for the value of a specific key</summary> /// <param name="trans"></param> /// <param name="key"></param> /// <param name="value"></param> /// <returns>Value for this value, or null if the index does not contains that particular value</returns> /// <remarks>The count can be zero or negative if AllowNegativeValues is enable.</remarks> public async Task<long?> GetCountAsync([NotNull] IFdbReadOnlyTransaction trans, TKey key, TValue value) { if (trans == null) throw new ArgumentNullException(nameof(trans)); Slice v = await trans.GetAsync(this.Subspace.Keys[key, value]).ConfigureAwait(false); if (v.IsNullOrEmpty) return null; long c = v.ToInt64(); return this.AllowNegativeValues || c > 0 ? c : default(long?); }
/// <summary>Checks if a (key, value) pair exists</summary> public async Task <bool> ContainsAsync([NotNull] IFdbReadOnlyTransaction trans, TKey key, TValue value) { if (trans == null) { throw new ArgumentNullException("trans"); } var v = await trans.GetAsync(this.Location.Keys.Encode(key, value)).ConfigureAwait(false); return(this.AllowNegativeValues ? v.IsPresent : v.ToInt64() > 0); }
public async Task <bool> ContainsAsync(IFdbReadOnlyTransaction trans, Slice key) { if (trans == null) { throw new ArgumentNullException(nameof(trans)); } if (key.IsNull) { throw new ArgumentException("Empty key not allowed in set", nameof(key)); } return((await trans.GetAsync(this.Subspace.Encode(0, key)).ConfigureAwait(false)).HasValue); }
private async Task <string> LookupSlowAsync(IFdbReadOnlyTransaction trans, Slice uid) { var valueBytes = await trans.GetAsync(UidKey(uid)).ConfigureAwait(false); if (valueBytes.IsNull) { throw new KeyNotFoundException("String intern indentifier not found"); } string value = valueBytes.ToUnicode(); //BUGBUG: if the uid has just been Interned in the current transaction, and if the transaction fails to commit (conflict, ...) we will insert a bad value in the cache! AddToCache(value, uid); return(value); }
/// <summary>Read the value of a counter</summary> /// <param name="transaction">Transaction to use for the operation</param> /// <param name="counterKey">Key of the counter, relative to the list's subspace</param> /// <returns></returns> public async Task <long?> ReadAsync(IFdbReadOnlyTransaction transaction, TKey counterKey) { if (transaction == null) { throw new ArgumentNullException(nameof(transaction)); } if (counterKey == null) { throw new ArgumentNullException(nameof(counterKey)); } var data = await transaction.GetAsync(this.Location[counterKey]).ConfigureAwait(false); if (data.IsNullOrEmpty) { return(default);
/// <summary>Return the count for the value of a specific key</summary> /// <param name="trans"></param> /// <param name="key"></param> /// <param name="value"></param> /// <returns>Value for this value, or null if the index does not contains that particular value</returns> /// <remarks>The count can be zero or negative if AllowNegativeValues is enable.</remarks> public async Task <long?> GetCountAsync([NotNull] IFdbReadOnlyTransaction trans, TKey key, TValue value) { if (trans == null) { throw new ArgumentNullException("trans"); } Slice v = await trans.GetAsync(this.Location.Keys.Encode(key, value)).ConfigureAwait(false); if (v.IsNullOrEmpty) { return(null); } long c = v.ToInt64(); return(this.AllowNegativeValues || c > 0 ? c : default(long?)); }
/// <summary>Return the value of a specific field of an hashset</summary> /// <param name="trans">Transaction that will be used for this request</param> /// <param name="id">Unique identifier of the hashset</param> /// <param name="field">Name of the field to read</param> /// <returns>Value of the corresponding field, or <see cref="Slice.Nil"/> if it the hashset does not exist, or doesn't have a field with this name</returns> public Task <Slice> GetValueAsync(IFdbReadOnlyTransaction trans, IVarTuple id, string field) { if (trans == null) { throw new ArgumentNullException(nameof(trans)); } if (id == null) { throw new ArgumentNullException(nameof(id)); } if (string.IsNullOrEmpty(field)) { throw new ArgumentNullException(nameof(field)); } return(trans.GetAsync(GetFieldKey(id, field))); }
/// <summary>Return the value of a specific field of an hashset</summary> /// <param name="trans">Transaction that will be used for this request</param> /// <param name="id">Unique identifier of the hashset</param> /// <param name="field">Name of the field to read</param> /// <returns>Value of the corresponding field, or Slice.Nil if it the hashset does not exist, or doesn't have a field with this name</returns> public Task <Slice> GetValueAsync([NotNull] IFdbReadOnlyTransaction trans, [NotNull] IFdbTuple id, string field) { if (trans == null) { throw new ArgumentNullException("trans"); } if (id == null) { throw new ArgumentNullException("id"); } if (string.IsNullOrEmpty(field)) { throw new ArgumentNullException("field"); } return(trans.GetAsync(GetFieldKey(id, field))); }
private async Task <long?> GetSizeInternalAsync(IFdbReadOnlyTransaction trans) { Slice value = await trans.GetAsync(SizeKey()).ConfigureAwait(false); if (value.IsNullOrEmpty) { return(default(long?)); } //note: python code stores the size as a string long size = Int64.Parse(value.ToString()); if (size < 0) { throw new InvalidOperationException("The internal blob size cannot be negative"); } return(size); }
/// <summary>Returns the value of an existing entry in the map</summary> /// <param name="trans">Transaction used for the operation</param> /// <param name="id">Key of the entry to read from the map</param> /// <returns>Value of the entry if it exists; otherwise, throws an exception</returns> /// <exception cref="System.ArgumentNullException">If either <paramref name="trans"/> or <paramref name="id"/> is null.</exception> /// <exception cref="System.Collections.Generic.KeyNotFoundException">If the map does not contain an entry with this key.</exception> public async Task <TValue> GetAsync([NotNull] IFdbReadOnlyTransaction trans, TKey id) { if (trans == null) { throw new ArgumentNullException("trans"); } if (id == null) { throw new ArgumentNullException("id"); } var data = await trans.GetAsync(this.Location.Keys.Encode(id)).ConfigureAwait(false); if (data.IsNull) { throw new KeyNotFoundException("The given id was not present in the map."); } return(this.ValueEncoder.DecodeValue(data)); }
/// <summary>Returns the value of an entry in the map if it exists.</summary> /// <param name="trans">Transaction used for the operation</param> /// <param name="id">Key of the entry to read from the map</param> /// <returns>Optional with the value of the entry it it exists, or an empty result if it is not present in the map.</returns> public async Task <(TValue Value, bool HasValue)> TryGetAsync([NotNull] IFdbReadOnlyTransaction trans, TKey id) { if (trans == null) { throw new ArgumentNullException(nameof(trans)); } if (id == null) { throw new ArgumentNullException(nameof(id)); } var data = await trans.GetAsync(this.Subspace.Keys[id]).ConfigureAwait(false); if (data.IsNull) { return(default(TValue), false); } return(this.ValueEncoder.DecodeValue(data), true); }
/// <summary>Returns the value of an entry in the map if it exists.</summary> /// <param name="trans">Transaction used for the operation</param> /// <param name="id">Key of the entry to read from the map</param> /// <returns>Optional with the value of the entry it it exists, or an empty result if it is not present in the map.</returns> public async Task <Optional <TValue> > TryGetAsync([NotNull] IFdbReadOnlyTransaction trans, TKey id) { if (trans == null) { throw new ArgumentNullException("trans"); } if (id == null) { throw new ArgumentNullException("id"); } var data = await trans.GetAsync(this.Location.Keys.Encode(id)).ConfigureAwait(false); if (data.IsNull) { return(default(Optional <TValue>)); } return(this.ValueEncoder.DecodeValue(data)); }
/// <summary>Read the value of a counter</summary> /// <param name="transaction">Transaction to use for the operation</param> /// <param name="counterKey">Key of the counter, relative to the list's subspace</param> /// <returns></returns> public async Task <long?> ReadAsync([NotNull] IFdbReadOnlyTransaction transaction, [NotNull] TKey counterKey) { if (transaction == null) { throw new ArgumentNullException("transaction"); } if (counterKey == null) { throw new ArgumentNullException("counterKey"); } var data = await transaction.GetAsync(this.Location.Keys.Encode(counterKey)).ConfigureAwait(false); if (data.IsNullOrEmpty) { return(default(long?)); } return(data.ToInt64()); }
/// <summary>Returns the value of an existing entry in the map</summary> /// <param name="trans">Transaction used for the operation</param> /// <param name="id">Key of the entry to read from the map</param> /// <returns>Value of the entry if it exists; otherwise, throws an exception</returns> /// <exception cref="System.ArgumentNullException">If either <paramref name="trans"/> or <paramref name="id"/> is null.</exception> /// <exception cref="System.Collections.Generic.KeyNotFoundException">If the map does not contain an entry with this key.</exception> public async Task <TValue> GetAsync(IFdbReadOnlyTransaction trans, TKey id) { if (trans == null) { throw new ArgumentNullException(nameof(trans)); } if (id == null) { throw new ArgumentNullException(nameof(id)); } var data = await trans.GetAsync(this.Subspace[id]).ConfigureAwait(false); if (data.IsNull) { throw new KeyNotFoundException("The given id was not present in the map."); } return(this.ValueEncoder.DecodeValue(data) !); }
/// <summary>Returns a list of ids matching a specific value</summary> /// <param name="trans"></param> /// <param name="value">Value to lookup</param> /// <param name="reverse"></param> /// <returns>List of document ids matching this value for this particular index (can be empty if no document matches)</returns> public async Task <IEnumerable <long> > LookupAsync([NotNull] IFdbReadOnlyTransaction trans, TValue value, bool reverse = false) { var key = this.Location.Keys.Encode(value); var data = await trans.GetAsync(key).ConfigureAwait(false); if (data.IsNull) { return(null); } if (data.IsEmpty) { return(Enumerable.Empty <long>()); } var bitmap = new CompressedBitmap(data); if (reverse) { throw new NotImplementedException(); //TODO: GetView(reverse:true) ! } return(bitmap.GetView().Select(x => (long)x /*BUGBUG 64 bits*/)); }
/// <summary> /// Get the size (in bytes) of the blob. /// </summary> /// <returns>Return null if the blob does not exists, 0 if is empty, or the size in bytes</returns> public async Task <long?> GetSizeAsync([NotNull] IFdbReadOnlyTransaction trans) { if (trans == null) { throw new ArgumentNullException("trans"); } Slice value = await trans.GetAsync(SizeKey()).ConfigureAwait(false); if (value.IsNullOrEmpty) { return(default(long?)); } //note: python code stores the size as a string long size = Int64.Parse(value.ToAscii()); if (size < 0) { throw new InvalidOperationException("The internal blob size cannot be negative"); } return(size); }
private async Task CheckReadVersionAsync(IFdbReadOnlyTransaction trans) { var value = await trans.GetAsync(this.RootNode.Pack(VersionKey)).ConfigureAwait(false); if (!value.IsNullOrEmpty) { CheckVersion(value, false); } }
/// <summary>Read a key inside a subspace</summary> /// <example> /// Both lines are equivalent: /// tr.GetAsync(new FdbSubspace("Hello"), FdbTuple.Create("World")); /// tr.GetAsync(FdbTuple.Create("Hello", "World")); /// </example> public static Task <Slice> GetAsync(this IFdbReadOnlyTransaction trans, [NotNull] FdbSubspace subspace, IFdbTuple key) { Contract.Requires(trans != null && subspace != null); return(trans.GetAsync(subspace.Pack(key))); }
public virtual Task <Slice> GetAsync(Slice key) { return(m_transaction.GetAsync(key)); }
public Task <Slice> GetAsync([NotNull] IFdbReadOnlyTransaction trans, T key) { return(trans.GetAsync(EncodeKey(key))); }
/// <summary> /// Get the size (in bytes) of the blob. /// </summary> /// <returns>Return null if the blob does not exists, 0 if is empty, or the size in bytes</returns> public async Task<long?> GetSizeAsync(IFdbReadOnlyTransaction trans) { if (trans == null) throw new ArgumentNullException("trans"); Slice value = await trans.GetAsync(SizeKey()).ConfigureAwait(false); if (value.IsNullOrEmpty) return default(long?); //note: python code stores the size as a string long size = Int64.Parse(value.ToAscii()); if (size < 0) throw new InvalidOperationException("The internal blob size cannot be negative"); return size; }
public Task <Slice> GetAsync([NotNull] IFdbReadOnlyTransaction trans, T1 key1, T2 key2, T3 key3) { return(trans.GetAsync(EncodeKey(key1, key2, key3))); }
/// <inheritdoc /> public virtual Task <Slice> GetAsync(ReadOnlySpan <byte> key) { return(m_transaction.GetAsync(key)); }
/// <summary>Finds a node subspace, given its path, by walking the tree from the root.</summary> /// <returns>Node if it was found, or null</returns> private async Task<Node> FindAsync(IFdbReadOnlyTransaction tr, IFdbTuple path) { Contract.Requires(tr != null && path != null); // look for the node by traversing from the root down. Stop when crossing a partition... var n = this.RootNode; int i = 0; Slice layer = Slice.Nil; while (i < path.Count) { if (FdbDirectoryLayer.AnnotateTransactions) tr.Annotate("Looking for child {0} under node {1}...", path.Get<string>(i), n.Key); n = NodeWithPrefix(await tr.GetAsync(GetSubDirKey(n, path.Get<string>(i))).ConfigureAwait(false)); if (n == null) { return new Node(null, path.Substring(0, i + 1), path, Slice.Empty); } if (FdbDirectoryLayer.AnnotateTransactions) tr.Annotate("Reading Layer value for subfolder {0} found at {1}", path, n.Key); layer = await tr.GetAsync(n.Pack(LayerSuffix)).ConfigureAwait(false); if (layer == FdbDirectoryPartition.LayerId) { // stop when reaching a partition return new Node(n, path.Substring(0, i + 1), path, FdbDirectoryPartition.LayerId); } ++i; } return new Node(n, path, path, layer); }
/// <summary>Return the value of a specific field of an hashset</summary> /// <param name="trans">Transaction that will be used for this request</param> /// <param name="id">Unique identifier of the hashset</param> /// <param name="field">Name of the field to read</param> /// <returns>Value of the corresponding field, or Slice.Nil if it the hashset does not exist, or doesn't have a field with this name</returns> public Task<Slice> GetValueAsync(IFdbReadOnlyTransaction trans, IFdbTuple id, string field) { if (trans == null) throw new ArgumentNullException("trans"); if (id == null) throw new ArgumentNullException("id"); if (string.IsNullOrEmpty(field)) throw new ArgumentNullException("field"); return trans.GetAsync(GetFieldKey(id, field)); }