private void SkipNode (JSNode node, string name, Indices indices, int depth) { indices.GetNodeIndex(); if (node is JSStatement) indices.GetStatementIndex(); foreach (var e in VisitChildren(node, indices, depth)) { foreach (var c in e) ; } }
private IEnumerable<State> VisitNode (JSNode node, string name = null, Indices indices = null, int depth = 0) { int? statementIndex = null; if (indices == null) indices = new Indices(); int nodeIndex = indices.GetNodeIndex(); if (node is JSStatement) statementIndex = indices.GetStatementIndex(); yield return new State( node, name, depth, nodeIndex, statementIndex ); foreach (var e in VisitChildren(node, indices, depth)) { foreach (var c in e) yield return c; } }
/// <inheritdoc/> public Task<IExistsResponse> TypeExistsAsync(Indices indices, Types types, Func<TypeExistsDescriptor, ITypeExistsRequest> selector = null) => this.TypeExistsAsync(selector.InvokeOrDefault(new TypeExistsDescriptor(indices, types)));
public IUpgradeResponse Upgrade(Indices indices, Func<UpgradeDescriptor, IUpgradeRequest> selector = null) => this.Upgrade(selector.InvokeOrDefault(new UpgradeDescriptor().Index(indices)));
/// <inheritdoc/> public ISegmentsResponse Segments(Indices indices, Func<SegmentsDescriptor, ISegmentsRequest> selector = null) => this.Segments(selector.InvokeOrDefault(new SegmentsDescriptor().Index(indices)));
/// <inheritdoc/> public IForceMergeResponse ForceMerge(Indices indices, Func<ForceMergeDescriptor, IForceMergeRequest> selector = null) => this.ForceMerge(selector.InvokeOrDefault(new ForceMergeDescriptor().Index(indices)));
/// <inheritdoc/> public Task<IClearCacheResponse> ClearCacheAsync( Indices indices, Func<ClearCacheDescriptor, IClearCacheRequest> selector = null, CancellationToken cancellationToken = default(CancellationToken) ) => this.ClearCacheAsync(selector.InvokeOrDefault(new ClearCacheDescriptor().Index(indices)), cancellationToken);
/// <summary> /// <c>GET</c> request to the <c>ccr.follow_info</c> API, read more about this API online: /// <para></para> /// <a href = "https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-follow-info.html">https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-follow-info.html</a> /// </summary> public FollowInfoResponse FollowInfo(Indices index, Func <FollowInfoDescriptor, IFollowInfoRequest> selector = null) => FollowInfo(selector.InvokeOrDefault(new FollowInfoDescriptor(index: index)));
public void Test_Indices_Count() { var input = new Indices(0, 1); Assert.True(input.Count == 2); }
/// <inheritdoc/> public Task<IIndicesOperationResponse> CloseIndexAsync(Indices indices, Func<CloseIndexDescriptor, ICloseIndexRequest> selector = null) => this.CloseIndexAsync(selector.InvokeOrDefault(new CloseIndexDescriptor(indices)));
private bool IndexExists(string index) { return(_elasticClient.IndexExists(Indices.Index(index)).Exists); }
private void CleanIndex() { elasticClient.DeleteIndex(Indices.Index("sdresults")); }
private void CreateAliasForLastNIndices(int amount) { var responseCatIndices = _elasticClient.CatIndices(new CatIndicesRequest(Indices.Parse($"{_alias}-*"))); var records = responseCatIndices.Records.ToList(); List <string> indicesToAddToAlias = new List <string>(); for (int i = amount; i > 0; i--) { if (_options.Value.IndexPerMonth) { var indexName = $"{_alias}-{DateTime.UtcNow.AddMonths(-i + 1).ToString("yyyy-MM")}"; if (records.Exists(t => t.Index == indexName)) { indicesToAddToAlias.Add(indexName); } } else { var indexName = $"{_alias}-{DateTime.UtcNow.AddDays(-i + 1).ToString("yyyy-MM-dd")}"; if (records.Exists(t => t.Index == indexName)) { indicesToAddToAlias.Add(indexName); } } } var response = _elasticClient.AliasExists(new AliasExistsRequest(new Names(new List <string> { _alias }))); if (!response.IsValid) { throw response.OriginalException; } if (response.Exists) { _elasticClient.DeleteAlias(new DeleteAliasRequest(Indices.Parse($"{_alias}-*"), _alias)); } Indices multipleIndicesFromStringArray = indicesToAddToAlias.ToArray(); var responseCreateIndex = _elasticClient.PutAlias(new PutAliasRequest(multipleIndicesFromStringArray, _alias)); if (!responseCreateIndex.IsValid) { throw responseCreateIndex.OriginalException; } }
public CodeIndexerExpression(CodeExpression targetObject, params CodeExpression[] indices) { TargetObject = targetObject; Indices.AddRange(indices); }
public void AddIndex(int index) { Indices.Add(index); }
public static void Main(string[] args) { Storage db = StorageFactory.Instance.CreateStorage(); db.Open("test1.dbs", pagePoolSize); Indices root = (Indices) db.GetRoot(); if (root == null) { root = new Indices(); root.strIndex = db.CreateIndex(typeof(string), true); root.intIndex = db.CreateFieldIndex(typeof(Record), "intKey", true); root.compoundIndex = db.CreateFieldIndex(typeof(Record), new string[]{"strKey", "intKey"}, true); db.SetRoot(root); } FieldIndex intIndex = root.intIndex; FieldIndex compoundIndex = root.compoundIndex; Index strIndex = root.strIndex; long start = (DateTime.Now.Ticks - 621355968000000000) / 10000; long key = 1999; int i; for (i = 0; i < nRecords; i++) { Record rec = new Record(); key = (3141592621L * key + 2718281829L) % 1000000007L; rec.intKey = key; rec.strKey = Convert.ToString(key); rec.realKey = (double) key; intIndex.Put(rec); strIndex.Put(new Key(rec.strKey), rec); compoundIndex.Put(rec); } db.Commit(); Console.Out.WriteLine("Elapsed time for inserting " + nRecords + " records: " + ((DateTime.Now.Ticks - 621355968000000000) / 10000 - start) + " milliseconds"); start = (DateTime.Now.Ticks - 621355968000000000) / 10000; System.IO.StreamWriter writer = new System.IO.StreamWriter("test.xml", false, System.Text.Encoding.Default); db.ExportXML(writer); writer.Close(); System.Console.Out.WriteLine("Elapsed time for XML export " + ((DateTime.Now.Ticks - 621355968000000000) / 10000 - start) + " milliseconds"); db.Close(); db.Open("test2.dbs", pagePoolSize); start = (DateTime.Now.Ticks - 621355968000000000) / 10000; System.IO.StreamReader reader = new System.IO.StreamReader("test.xml", System.Text.Encoding.Default); db.ImportXML(reader); reader.Close(); Console.Out.WriteLine("Elapsed time for XML import " + ((DateTime.Now.Ticks - 621355968000000000) / 10000 - start) + " milliseconds"); root = (Indices) db.GetRoot(); intIndex = root.intIndex; strIndex = root.strIndex; compoundIndex = root.compoundIndex; start = (DateTime.Now.Ticks - 621355968000000000) / 10000; key = 1999; for (i = 0; i < nRecords; i++) { key = (3141592621L * key + 2718281829L) % 1000000007L; System.String strKey = Convert.ToString(key); Record rec1 = (Record) intIndex.Get(new Key(key)); Record rec2 = (Record) strIndex.Get(new Key(strKey)); Record rec3 = (Record) compoundIndex.Get(new Key(strKey, (long) key)); Assert.That(rec1 != null); Assert.That(rec1 == rec2); Assert.That(rec1 == rec3); Assert.That(rec1.intKey == key); Assert.That(rec1.realKey == (double) key); Assert.That(strKey.Equals(rec1.strKey)); } Console.Out.WriteLine("Elapsed time for performing " + nRecords * 2 + " index searches: " + ((DateTime.Now.Ticks - 621355968000000000) / 10000 - start) + " milliseconds"); db.Close(); }
public bool Test_Indices_Increment(int[] upperLimits) { var input = new Indices(upperLimits); return(input.Increment()); }
/// <inheritdoc/> public Task<IClearCacheResponse> ClearCacheAsync(Indices indices, Func<ClearCacheDescriptor, IClearCacheRequest> selector = null) => this.Dispatcher.DispatchAsync<IClearCacheRequest, ClearCacheRequestParameters, ClearCacheResponse, IClearCacheResponse>( selector.InvokeOrDefault(new ClearCacheDescriptor().Index(indices)), (p, d) => this.LowLevelDispatch.IndicesClearCacheDispatchAsync<ClearCacheResponse>(p) );
/// <inheritdoc/> public IUpdateIndexSettingsResponse UpdateIndexSettings(Indices indices, Func<UpdateIndexSettingsDescriptor, IUpdateIndexSettingsRequest> selector) => this.UpdateIndexSettings(selector.InvokeOrDefault(new UpdateIndexSettingsDescriptor().Index(indices)));
public void Add(int index) { Indices.Add(index); Cost += Results[Indices.Count - 1].GetCost(index); }
/// <inheritdoc/> public Task<IPutAliasResponse> PutAliasAsync( Indices indices, Name alias, Func<PutAliasDescriptor, IPutAliasRequest> selector = null, CancellationToken cancellationToken = default(CancellationToken) ) => this.PutAliasAsync(selector.InvokeOrDefault(new PutAliasDescriptor(indices, alias)), cancellationToken);
/// <inheritdoc/> public Task<IExistsResponse> IndexExistsAsync(Indices indices, Func<IndexExistsDescriptor, IIndexExistsRequest> selector = null) => this.IndexExistsAsync(selector.InvokeOrDefault(new IndexExistsDescriptor(indices)));
/// <summary> /// <c>GET</c> request to the <c>ccr.follow_stats</c> API, read more about this API online: /// <para></para> /// <a href = "https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-follow-stats.html">https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-follow-stats.html</a> /// </summary> public Task <FollowIndexStatsResponse> FollowIndexStatsAsync(Indices index, Func <FollowIndexStatsDescriptor, IFollowIndexStatsRequest> selector = null, CancellationToken ct = default) => FollowIndexStatsAsync(selector.InvokeOrDefault(new FollowIndexStatsDescriptor(index: index)), ct);
/// <inheritdoc/> public Task<IUpdateIndexSettingsResponse> UpdateIndexSettingsAsync( Indices indices, Func<UpdateIndexSettingsDescriptor, IUpdateIndexSettingsRequest> selector, CancellationToken cancellationToken = default(CancellationToken) ) => this.UpdateIndexSettingsAsync(selector.InvokeOrDefault(new UpdateIndexSettingsDescriptor().Index(indices)), cancellationToken);
/// <inheritdoc/> public Task<IShardsOperationResponse> RefreshAsync(Indices indices, Func<RefreshDescriptor, IRefreshRequest> selector = null) => this.RefreshAsync(selector.InvokeOrDefault(new RefreshDescriptor().Index(indices)));
/// <inheritdoc/> public Task<IDeleteWarmerResponse> DeleteWarmerAsync(Indices indices, Names names, Func<DeleteWarmerDescriptor, IDeleteWarmerRequest> selector = null) => this.DeleteWarmerAsync(selector.InvokeOrDefault(new DeleteWarmerDescriptor(indices, names)));
/// <inheritdoc/> public Task<IFlushResponse> FlushAsync(Indices indices, Func<FlushDescriptor, IFlushRequest> selector = null) => this.FlushAsync(selector.InvokeOrDefault(new FlushDescriptor().Index(indices)));
/// <inheritdoc/> public Task<ISegmentsResponse> SegmentsAsync( Indices indices, Func<SegmentsDescriptor, ISegmentsRequest> selector = null, CancellationToken cancellationToken = default(CancellationToken) ) => this.SegmentsAsync(selector.InvokeOrDefault(new SegmentsDescriptor().Index(indices)), cancellationToken);
private IEnumerable<IEnumerable<State>> VisitChildren(JSNode node, Indices indices, int depth) { if (node == null) throw new ArgumentNullException("node"); JSNode nextSibling = null; string nextSiblingName = null; int nextDepth = depth + 1; using (var e = node.Children.EnumeratorTemplate) while (e.MoveNext()) { var toVisit = nextSibling; var toVisitName = nextSiblingName; nextSibling = e.Current; nextSiblingName = e.CurrentName; if (toVisit != null) { if (toVisitName == null || !NamesToSkip.Contains(toVisitName)) { yield return VisitNode(toVisit, toVisitName, indices, nextDepth); } else { SkipNode(toVisit, toVisitName, indices, nextDepth); } } } if (nextSibling != null) { if (nextSiblingName == null || !NamesToSkip.Contains(nextSiblingName)) { yield return VisitNode(nextSibling, nextSiblingName, indices, nextDepth); } else { SkipNode(nextSibling, nextSiblingName, indices, nextDepth); } } }
/// <inheritdoc/> public Task<IForceMergeResponse> ForceMergeAsync(Indices indices, Func<ForceMergeDescriptor, IForceMergeRequest> selector = null, CancellationToken cancellationToken = default(CancellationToken)) => this.ForceMergeAsync(selector.InvokeOrDefault(new ForceMergeDescriptor().Index(indices)), cancellationToken);
/// <inheritdoc/> public ISyncedFlushResponse SyncedFlush(Indices indices, Func<SyncedFlushDescriptor, ISyncedFlushRequest> selector = null) => this.SyncedFlush(selector.InvokeOrDefault(new SyncedFlushDescriptor().Index(indices)));
/// <inheritdoc/> public Task<IRefreshResponse> RefreshAsync(Indices indices, Func<RefreshDescriptor, IRefreshRequest> selector = null, CancellationToken cancellationToken = default(CancellationToken)) => this.RefreshAsync(selector.InvokeOrDefault(new RefreshDescriptor().Index(indices)), cancellationToken);
/// <summary> /// Returns a collection of aliases that point to the specified index, simplified version of GetAlias. /// </summary> /// <param name="client">The client</param> /// <param name="indices">The index name(s) we want to know aliases of</param> public static IEnumerable<AliasDefinition> GetAliasesPointingToIndex(this IElasticClient client, Indices indices) { var aliasesResponse = client.GetAlias(a => a.Index(indices)); return AliasesPointingToIndex(client.ConnectionSettings, indices, aliasesResponse); }
public Task<IUpgradeResponse> UpgradeAsync(Indices indices, Func<UpgradeDescriptor, IUpgradeRequest> selector = null, CancellationToken cancellationToken = default(CancellationToken)) => this.UpgradeAsync(selector.InvokeOrDefault(new UpgradeDescriptor().Index(indices)), cancellationToken);
/// <summary> /// Returns a collection of aliases that point to the specified index, simplified version of GetAlias. /// </summary> /// <param name="client">The client</param> /// <param name="indices">The index name(s) we want to know aliases of</param> public static async Task<IEnumerable<AliasDefinition>> GetAliasesPointingToIndexAsync(this IElasticClient client, Indices indices) { var response = await client.GetAliasAsync(a => a.Index(indices)).ConfigureAwait(false); return AliasesPointingToIndex(client.ConnectionSettings, indices, response); }
/// <inheritdoc/> public IRefreshResponse Refresh(Indices indices, Func<RefreshDescriptor, IRefreshRequest> selector = null) => this.Refresh(selector.InvokeOrDefault(new RefreshDescriptor().Index(indices)));
/// <inheritdoc/> public Task<IShardsOperationResponse> SyncedFlushAsync(Indices indices, Func<SyncedFlushDescriptor, ISyncedFlushRequest> selector = null) => this.SyncedFlushAsync(selector.InvokeOrDefault(new SyncedFlushDescriptor().Index(indices)));
/// <inheritdoc/> public Task<IRecoveryStatusResponse> RecoveryStatusAsync(Indices indices, Func<RecoveryStatusDescriptor, IRecoveryStatusRequest> selector = null) => this.RecoveryStatusAsync(selector.InvokeOrDefault(new RecoveryStatusDescriptor().Index(indices)));
public static void Main(String[] args) { Storage db = StorageFactory.Instance.CreateStorage(); bool serializableTransaction = false; for (int i = 0; i < args.Length; i++) { if ("inmemory".Equals(args[i])) pagePoolSize = StorageConstants.INFINITE_PAGE_POOL; else if ("altbtree".Equals(args[i])) { db.SetProperty("perst.alternative.btree", true); //db.SetProperty("perst.object.cache.kind", "weak"); db.SetProperty("perst.object.cache.init.size", 1013); } else if ("serializable".Equals(args[i])) { db.SetProperty("perst.alternative.btree", true); serializableTransaction = true; } else Console.Error.WriteLine("Unrecognized option: " + args[i]); } db.Open("testidx.dbs", pagePoolSize); if (serializableTransaction) db.BeginThreadTransaction(StorageConstants.SERIALIZABLE_TRANSACTION); Indices root = (Indices) db.GetRoot(); if (root == null) { root = new Indices(); root.strIndex = db.CreateIndex(typeof(string), true); root.intIndex = db.CreateIndex(typeof(long), true); db.SetRoot(root); } Index intIndex = root.intIndex; Index strIndex = root.strIndex; long start = (DateTime.Now.Ticks - 621355968000000000) / 10000; long key = 1999; int i2; for (i2 = 0; i2 < nRecords; i2++) { Record rec = new Record(); key = (3141592621L * key + 2718281829L) % 1000000007L; rec.intKey = key; rec.strKey = Convert.ToString(key); intIndex.Put(new Key(rec.intKey), rec); strIndex.Put(new Key(rec.strKey), rec); /* if (i % 100000 == 0) { System.out.print("Insert " + i + " records\r"); db.Commit(); } */ } if (serializableTransaction) { db.EndThreadTransaction(); db.BeginThreadTransaction(StorageConstants.SERIALIZABLE_TRANSACTION); } else { db.Commit(); } //db.Gc(); Console.Out.WriteLine("Elapsed time for inserting " + nRecords + " records: " + ((DateTime.Now.Ticks - 621355968000000000) / 10000 - start) + " milliseconds"); start = (DateTime.Now.Ticks - 621355968000000000) / 10000; key = 1999; for (i2 = 0; i2 < nRecords; i2++) { key = (3141592621L * key + 2718281829L) % 1000000007L; Record rec1 = (Record) intIndex.Get(new Key(key)); Record rec2 = (Record) strIndex.Get(new Key(Convert.ToString(key))); Assert.That(rec1 != null && rec1 == rec2); } Console.Out.WriteLine("Elapsed time for performing " + nRecords * 2 + " index searches: " + ((DateTime.Now.Ticks - 621355968000000000) / 10000 - start) + " milliseconds"); start = (DateTime.Now.Ticks - 621355968000000000) / 10000; key = System.Int64.MinValue; i2 = 0; foreach (Record rec in intIndex) { Assert.That(rec.intKey >= key); key = rec.intKey; ++i2; } Assert.That(i2 == nRecords); string strKey = ""; i2 = 0; foreach (Record rec in strIndex) { Assert.That(String.CompareOrdinal(rec.strKey, strKey) >= 0); strKey = rec.strKey; i2++; } Assert.That(i2 == nRecords); Console.Out.WriteLine("Elapsed time for iterating through " + (nRecords * 2) + " records: " + ((DateTime.Now.Ticks - 621355968000000000) / 10000 - start) + " milliseconds"); //UPGRADE_TODO: Class 'java.util.HashMap' was converted to 'System.Collections.Hashtable' which has a different behavior. Hashtable map = db.GetMemoryDump(); Console.Out.WriteLine("Memory usage"); start = (DateTime.Now.Ticks - 621355968000000000) / 10000; foreach (MemoryUsage usage in map.Values) { Console.Out.WriteLine(" " + usage.cls.FullName + ": instances=" + usage.nInstances + ", total size=" + usage.totalSize + ", allocated size=" + usage.allocatedSize); } Console.Out.WriteLine("Elapsed time for memory dump: " + ((DateTime.Now.Ticks - 621355968000000000) / 10000 - start) + " milliseconds"); start = (DateTime.Now.Ticks - 621355968000000000) / 10000; key = 1999; for (i2 = 0; i2 < nRecords; i2++) { key = (3141592621L * key + 2718281829L) % 1000000007L; Record rec = (Record) intIndex.Get(new Key(key)); Record removed = (Record) intIndex.Remove(new Key(key)); Assert.That(removed == rec); //strIndex.Remove(new Key(Long.toString(key)), rec); strIndex.Remove(new Key(Convert.ToString(key))); rec.Deallocate(); } Assert.That(!intIndex.GetEnumerator().MoveNext()); Assert.That(!strIndex.GetEnumerator().MoveNext()); Assert.That(!intIndex.GetEnumerator(null, null, IndexSortOrder.Descent).MoveNext()); Assert.That(!strIndex.GetEnumerator(null, null, IndexSortOrder.Descent).MoveNext()); Assert.That(!intIndex.GetEnumerator(null, null, IndexSortOrder.Ascent).MoveNext()); Assert.That(!strIndex.GetEnumerator(null, null, IndexSortOrder.Ascent).MoveNext()); Console.Out.WriteLine("Elapsed time for deleting " + nRecords + " records: " + ((DateTime.Now.Ticks - 621355968000000000) / 10000 - start) + " milliseconds"); db.Close(); }
/// <inheritdoc/> public Task<IPutAliasResponse> PutAliasAsync(Indices indices, Name alias, Func<PutAliasDescriptor, IPutAliasRequest> selector = null) => this.PutAliasAsync(selector.InvokeOrDefault(new PutAliasDescriptor(indices, alias)));
/// <summary> /// Asynchronously gets the resources that match the given params /// </summary> /// <param name="query">Query parameters (optional)</param> /// <param name="size">Number of results to return (optional)</param> /// <param name="from">Beginning index for results (optional)</param> /// <param name="includeFields">Fields to include (optional)</param> /// <returns>Resource query result</returns> public async Task <ResourceQueryResult> QueryResourcesAsync( ResourceQuery query, int size = 20, int from = 0, string[] includeFields = null ) { ResourceQueryResult queryResults = new ResourceQueryResult(); // Set up the SearchRequest to send to the API. Indices index = Indices.Index(new string[] { this._apiOptions.AliasName }); Types types = Types.Type(new string[] { "resource" }); SearchRequest request = new SearchRequest(index, types) { Size = size, From = from, Sort = new List <ISort> { new SortField { Field = "title._sort", Order = SortOrder.Ascending } }, //TODO: Source = new SourceFilter { Includes = includeFields } }; //Add in the query var searchQuery = this.GetFullQuery(query.Keyword, query.Filters); if (searchQuery != null) { request.Query = searchQuery; } ISearchResponse <Resource> response = null; try { // Fetch the resources that match the given query and parameters from the API. response = await _elasticClient.SearchAsync <Resource>(request); } catch (Exception ex) { //TODO: Update error logger to include query _logger.LogError("Could not fetch resources for query.", ex); throw new APIErrorException(500, "Could not fetch resources for query."); } // If the API's response isn't valid, throw an error and return 500 status code. if (!response.IsValid) { _logger.LogError("Bad request."); throw new APIErrorException(500, "Errors occurred."); } // If the API finds resources matching the params, build the ResourceQueryResult to return. if (response.Total > 0) { // Build the array of resources for the returned restult. List <Resource> resourceResults = new List <Resource>(); foreach (Resource res in response.Documents) { resourceResults.Add(res); } queryResults.Results = resourceResults.ToArray(); queryResults.TotalResults = Convert.ToInt32(response.Total); queryResults.From = from; } return(queryResults); }