public static Task <IGetResult> GetAsync(this ICouchbaseCollection collection, string id) { return(collection.GetAsync(id, new GetOptions())); }
/// <summary> /// Executes a query and ingests the results as documents into Couchbase server for further analytics. /// <para> /// NOTE: This is an experimental API and may change in the future. /// </para> /// </summary> /// <typeparam name="T"></typeparam> /// <param name="cluster"></param> /// <param name="collection"></param> /// <param name="statement"></param> /// <param name="ingestOptions"></param> /// <returns></returns> public static async Task <IEnumerable <IMutationResult> > IngestAsync <T>(this ICluster cluster, string statement, ICouchbaseCollection collection, IngestOptions ingestOptions = null) { //use defaults if not options not explicitly passed ingestOptions ??= new IngestOptions(); if (ingestOptions.TokenValue.IsCancellationRequested) { ingestOptions.TokenValue.ThrowIfCancellationRequested(); } //execute the analytics query var result = await cluster.AnalyticsQueryAsync <T>( statement, options => options.CancellationToken(ingestOptions.TokenValue) ).ConfigureAwait(false); // ingest result into collection var results = new ConcurrentBag <Task <IMutationResult> >(); await foreach (var row in result.WithCancellation(ingestOptions.TokenValue).ConfigureAwait(false)) { Task <IMutationResult> op; switch (ingestOptions.IngestMethodValue) { case IngestMethod.Insert: op = collection.InsertAsync( ingestOptions.IdGeneratorValue(row), row, options => { options.Expiry(ingestOptions.ExpiryValue); options.Timeout(ingestOptions.TimeoutValue); }); break; case IngestMethod.Upsert: op = collection.UpsertAsync( ingestOptions.IdGeneratorValue(row), row, options => { options.Expiry(ingestOptions.ExpiryValue); options.Timeout(ingestOptions.TimeoutValue); }); break; case IngestMethod.Replace: op = collection.ReplaceAsync( ingestOptions.IdGeneratorValue(row), row, options => { options.Expiry(ingestOptions.ExpiryValue); options.Timeout(ingestOptions.TimeoutValue); }); break; default: throw new ArgumentOutOfRangeException(); } results.Add(op); } return(await Task.WhenAll(results).ConfigureAwait(false)); }
public static IAsyncDisposable RemoveDocument(ICouchbaseCollection collection, string docId, ITestOutputHelper outputHelper) { return(new DisposeCleanerAsync(() => collection.RemoveAsync(docId), outputHelper)); }
public async Task UnstageRemove(ICouchbaseCollection collection, string docId, ulong cas = 0) => _ = await LookupDocumentAsync(collection, docId);
internal PersistentQueue(ICouchbaseCollection collection, string key, ILogger?logger, IRedactor?redactor) : base(collection, key, logger, redactor, new object(), false) { }
public async Task <(ulong updatedCas, MutationToken mutationToken)> MutateStagedInsert(ICouchbaseCollection collection, string docId, object content, IAtrRepository atr, ulong?cas = null) { List <MutateInSpec> specs = CreateMutationSpecs(atr, "insert", content); var opts = GetMutateInOptions(StoreSemantics.Insert) .AccessDeleted(true) .CreateAsDeleted(true); if (cas.HasValue) { opts.Cas(cas.Value).StoreSemantics(StoreSemantics.Replace); } else { opts.Cas(0); } var mutateResult = await collection.MutateInAsync(docId, specs, opts).CAF(); return(mutateResult.Cas, mutateResult.MutationToken); }
public Task <(ulong updatedCas, MutationToken mutationToken)> MutateStagedInsert(ICouchbaseCollection collection, string docId, object content, IAtrRepository atr, ulong?cas = null) { var mockLookupInResult = new Mock <ILookupInResult>(MockBehavior.Strict); mockLookupInResult.SetupGet(l => l.IsDeleted).Returns(false); mockLookupInResult.SetupGet(l => l.Cas).Returns(5); Add(collection, docId, new DocumentLookupResult(docId, null, new JObjectContentWrapper(content), mockLookupInResult.Object, new Components.DocumentMetadata(), collection)); Interlocked.Increment(ref _rollingCas); return(Task.FromResult(((ulong)_rollingCas, new MutationToken("fake", 1, 2, _rollingCas)))); }
public static Task <IGetReplicaResult> GetAnyReplicaAsync(this ICouchbaseCollection collection, string id) { return(collection.GetAnyReplicaAsync(id, GetAnyReplicaOptions.Default)); }
public static Task <IMutateInResult> MutateInAsync(this ICouchbaseCollection collection, string id, IEnumerable <MutateInSpec> specs) { return(collection.MutateInAsync(id, specs, new MutateInOptions())); }
public static Task <IGetResult> GetAndLockAsync(this ICouchbaseCollection collection, string id, TimeSpan expiry) { return(collection.GetAndLockAsync(id, expiry, new GetAndLockOptions())); }
public static Task <ILookupInResult> LookupInAsync(this ICouchbaseCollection collection, string id, IEnumerable <LookupInSpec> specs) { return(collection.LookupInAsync(id, specs, new LookupInOptions())); }
public static Task TouchAsync(this ICouchbaseCollection collection, string id, TimeSpan expiry) { return(collection.TouchAsync(id, expiry, new TouchOptions())); }
public static Task UnlockAsync <T>(this ICouchbaseCollection collection, string id, ulong cas) { return(collection.UnlockAsync <T>(id, cas, new UnlockOptions())); }
public static Task RemoveAsync(this ICouchbaseCollection collection, string id) { return(collection.RemoveAsync(id, new RemoveOptions())); }
public async Task UnstageRemove(ICouchbaseCollection collection, string docId, ulong cas = 0) { var opts = new RemoveOptions().Defaults(_durability, _keyValueTimeout).Cas(cas); await collection.RemoveAsync(docId, opts).CAF(); }
public static IPersistentQueue <T> Queue <T>(this ICouchbaseCollection collection, string docId) { return(new PersistentQueue <T>(collection, docId, (collection as CouchbaseCollection)?.Logger, (collection as CouchbaseCollection)?.Redactor)); }
public async Task <DocumentLookupResult> LookupDocumentAsync(ICouchbaseCollection collection, string docId, bool fullDocument = true) => await LookupDocumentAsync(collection, docId, _keyValueTimeout, fullDocument).CAF();
public static IPersistentDictionary <TValue> Dictionary <TValue>(this ICouchbaseCollection collection, string docId) { return(new PersistentDictionary <TValue>(collection, docId, (collection as CouchbaseCollection)?.Logger, (collection as CouchbaseCollection)?.Redactor)); }
public void Add(ICouchbaseCollection collection, string docId, DocumentLookupResult doc) => Docs.Add(collection.GetKey(docId), doc);
public static IEnumerable <Task <IGetReplicaResult> > GetAllReplicasAsync(this ICouchbaseCollection collection, string id) { return(collection.GetAllReplicasAsync(id, GetAllReplicasOptions.Default)); }
public async Task <(ulong updatedCas, MutationToken mutationToken)> UnstageInsertOrReplace(ICouchbaseCollection collection, string docId, ulong cas, object finalDoc, bool insertMode) { _ = await LookupDocumentAsync(collection, docId); Interlocked.Increment(ref _rollingCas); return((ulong)_rollingCas, new MutationToken("fake", 1, 2, _rollingCas)); }
public static Task <IExistsResult> ExistsAsync(this ICouchbaseCollection collection, string id) { return(collection.ExistsAsync(id, new ExistsOptions())); }
/// <summary> /// Set <see cref="ICouchbaseCollection"/> to use for Active Transaction Record metadata. /// </summary> /// <param name="metadataCollection">The collection to use.</param> /// <returns>The builder.</returns> /// <remarks>If this is not set, then the metadata collection will be chosen based on the VBucket of the first document modification in the transaction.</remarks> public TransactionConfigBuilder MetadataCollection(ICouchbaseCollection metadataCollection) { _config.MetadataCollection = metadataCollection; return(this); }
public static Task <IMutationResult> UpsertAsync <T>(this ICouchbaseCollection collection, string id, T content) { return(collection.UpsertAsync(id, content, new UpsertOptions())); }
/// <summary> /// Executes a query and ingests the results as documents into Couchbase server for further analytics. /// <para> /// NOTE: This is an experimental API and may change in the future. /// </para> /// </summary> /// <typeparam name="T"></typeparam> /// <param name="cluster"></param> /// <param name="collection"></param> /// <param name="statement"></param> /// <param name="configureOptions"></param> /// <returns></returns> public static Task <IEnumerable <IMutationResult> > IngestAsync <T>(this ICluster cluster, string statement, ICouchbaseCollection collection, Action <IngestOptions> configureOptions) { var options = new IngestOptions(); configureOptions(options); return(IngestAsync <T>( cluster, statement, collection, options )); }
static async Task Main(string[] args) { // SETUP: connect to Couchbase _cluster = await Cluster.ConnectAsync( "couchbase://localhost", "Administrator", "password"); _bucket = await _cluster.BucketAsync("matt"); _scope = await _bucket.ScopeAsync("myScope"); _coll = await _scope.CollectionAsync("myCollection"); // SETUP: create a 'conference' document and a 'conference activities' document await SetupInitialDocuments(); // STEP 1: create transactions object var transactions = Transactions.Create(_cluster, TransactionConfigBuilder.Create() .DurabilityLevel(DurabilityLevel.MajorityAndPersistToActive) // since I have 1 node, replication must be 0, or this will throw exception .Build()); Console.WriteLine("Press ENTER to continue"); Console.ReadLine(); // STEP 2: transaction operations await transactions.RunAsync(async (ctx) => { var now = DateTime.Now; // FIRST: get the two document I want to change var confDoc = await ctx.GetAsync(_coll, "dataLove2021"); var actsDoc = await ctx.GetAsync(_coll, "dataLove2021::activities"); var conf = confDoc.ContentAs <Conference>(); var acts = actsDoc.ContentAs <ConferenceActivities>(); // SECOND: add an event to the "activities" document acts.Events.Add(new ConferenceEvent { Type = "CFP", DtActivity = now, Desc = "Submitted to the CFP" }); // acts.Events.Add(new ConferenceEvent // { // Type = "PRESENTATION", // DtActivity = now, // Desc = "Delivered ACID presentation" // }); // acts.Events.Add(new ConferenceEvent // { // Type = "SPATIAL", // DtActivity = now, // Desc = "Answered questions in Spatial Chat" // }); // THIRD: change the "conference" document conf.Followups = (conf.Followups ?? 0) + 1; conf.LastActivity = now; // FOURTH: write the changes await ctx.ReplaceAsync(confDoc, conf); // OPTIONAL STEP: fail right in the middle of the transaction making two writes // var fail = true; // if(fail) throw new Exception("Something went wrong!"); await ctx.ReplaceAsync(actsDoc, acts); // FIFTH: commit (implied) }); await _cluster.DisposeAsync(); }
private static Task Upsert(ICouchbaseCollection collection, KeyValuePair <string, object> document) { return(collection.UpsertAsync(document.Key, document.Value)); }
public async Task <(ulong updatedCas, MutationToken?mutationToken)> UnstageInsertOrReplace(ICouchbaseCollection collection, string docId, ulong cas, object finalDoc, bool insertMode) { if (insertMode) { var opts = new InsertOptions().Defaults(_durability, _keyValueTimeout); var mutateResult = await collection.InsertAsync(docId, finalDoc, opts).CAF(); return(mutateResult.Cas, mutateResult?.MutationToken); } else { var opts = GetMutateInOptions(StoreSemantics.Replace).Cas(cas); var mutateResult = await collection.MutateInAsync(docId, specs => specs.Upsert(TransactionFields.TransactionInterfacePrefixOnly, string.Empty, isXattr : true, createPath : true) .Remove(TransactionFields.TransactionInterfacePrefixOnly, isXattr : true) .SetDoc(finalDoc), opts).CAF(); return(mutateResult.Cas, mutateResult?.MutationToken); } }
/// <summary> /// Request a distributed Couchbase Mutex that expires after <paramref name="expiration"/>. /// </summary> /// <remarks> /// Uses the default holder from <see cref="LockHolder"/>. /// /// The <see cref="ICouchbaseMutex"/> should be disposed once the lock is no longer needed. /// </remarks> /// <param name="collection">Couchbase collection.</param> /// <param name="name">Name of the lock.</param> /// <param name="expiration">Time until mutex expires, if not renewed.</param> /// <param name="cancellationToken">Cancellation token.</param> /// <returns>The <see cref="ICouchbaseMutex"/>.</returns> /// <exception cref="CouchbaseLockUnavailableException">Thrown if the lock could not be acquired.</exception> /// <exception cref="CouchbaseException">Thrown on general Couchbase communication errors.</exception> /// <exception cref="ArgumentNullException">Thrown if bucket is null.</exception> /// <exception cref="ArgumentException">Thrown for invalid name.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown for non-positive expiration.</exception> public static Task <ICouchbaseMutex> RequestMutexAsync(this ICouchbaseCollection collection, string name, TimeSpan expiration, CancellationToken cancellationToken = default) { return(collection.RequestMutexAsync(name, LockHolder.Default, expiration, cancellationToken)); }
public static Task <IMutationResult> ReplaceAsync <T>(this ICouchbaseCollection collection, string id, T content) { return(collection.ReplaceAsync(id, content, new ReplaceOptions())); }