private void BuildAddIndexNode(IIndexDefinition index, IAstNode parent) { IAddIndexNode addIndexNode = new AddIndexNode(parent, index.Name); parent.ChildNodes.Add(addIndexNode); SemanticModelUtil.Copy(index, addIndexNode); }
public virtual string GetIndexName(IIndexDefinition index) { string columnNames = Algorithms.Join("", index.Columns, delegate(IIndexColumnDefinition icd) { return icd.Name; }); return GetIndexNameForColumns(index, columnNames); }
public void create_index() { _index = new InMemoryProductIndex(); var manager = new IndexManager(); manager.RegisterIndex(_index); manager.CreateIndexes(); }
public ServiceIndexDefinition(IIndexDefinition myIndexDefinition) { this.Edition = myIndexDefinition.Edition; this.ID = myIndexDefinition.ID; this.IndexTypeName = myIndexDefinition.IndexTypeName; this.IsRange = myIndexDefinition.IsRange; this.IsUserdefined = myIndexDefinition.IsUserdefined; this.IsVersioned = myIndexDefinition.IsVersioned; this.Name = myIndexDefinition.Name; this.IndexedProperties = myIndexDefinition.IndexedProperties.Select(x => x.Name).ToList(); }
public override void addSource(MergeOperationContext operationContext, IIndexDefinition sourceDefinition) { if (sourceDefinition.Aliases != null) { references.CollectMust(sourceDefinition.Aliases.MustAliases); references.CollectMay(sourceDefinition.Aliases.MayAliases); } else { hasAliasesAlways = false; } }
public void Test_MS_CreateClusteredIndex() { Initialize(_msContext); _commands.ExecuteNonQuery(string.Format("create table {0} (id int, id2 int, id3 int)", _testTable)); IIndexDefinition index = _msContext.PowerPlant.CreateIndexDefinition("i1_" + _testTable, _testTable, "", true, 0, true); index.Columns = new List <IIndexColumn> { IndexColumnFactory.CreateInstance("id") }; _dbSchema.CreateIndex(index); CheckIndexIsClustered(); }
/// <summary> /// Indexes a single entity with the provided definition /// </summary> /// <typeparam name="TEntity">The type of entity to index</typeparam> /// <param name="entity">The entity to index</param> /// <param name="definition">The index definition</param> /// <returns>An index result with the outcome of the indexing operation</returns> public IndexResult IndexEntity <TEntity>(TEntity entity, IIndexDefinition <TEntity> definition) where TEntity : class { var result = new IndexResult(); result.ExecutionTime = Time(() => { this.GetWriter().UpdateDocument(definition.GetIndex(entity), definition.Convert(entity)); result.Count++; result.Success = true; }); return(result); }
public ServiceIndexDefinition(IIndexDefinition myIndexDefinition) { this.Name = myIndexDefinition.Name; this.ID = myIndexDefinition.ID; this.IndexTypeName = myIndexDefinition.IndexTypeName; this.Edition = myIndexDefinition.Edition; this.IsUserdefined = myIndexDefinition.IsUserdefined; this.IndexedProperties = myIndexDefinition.IndexedProperties.Select(x => x.Name).ToList(); this.VertexType = new ServiceVertexType(myIndexDefinition.VertexType); this.SourceIndex = (myIndexDefinition.SourceIndex == null) ? null : new ServiceIndexDefinition(myIndexDefinition.SourceIndex); this.IsRange = myIndexDefinition.IsRange; this.IsVersioned = myIndexDefinition.IsVersioned; }
private IQueryResult GenerateResult(IRequestStatistics myStats, IIndexDefinition myIndexDefinition) { return(QueryResult.Success(Query, SonesGQLConstants.GQL, new List <IVertexView> { new VertexView(new Dictionary <String, object> { { "CreatedIndex", myIndexDefinition }, { "CreatedIndexTypeName", myIndexDefinition.IndexTypeName } }, new Dictionary <String, IEdgeView>()) }, Convert.ToUInt64(myStats.ExecutionTime.TotalMilliseconds))); }
/// <inheritdoc /> public override void NewIndex(MemoryIndex index) { // TODO: allocation-abstraction hack // see SnapshotBase.CreateObject if (indexDefinitions.ContainsKey(index)) { return; } IIndexDefinition data = Factories.StructuralContainersFactories.IndexDefinitionFactory.CreateIndexDefinition(this); indexDefinitions.Add(index, data); changeTracker.InsertedIndex(index); }
public LuceneSearchEngine(IIndexDefinition <TEntity> indexDefinition) { IndexDefinition = indexDefinition; if (IndexDefinition == null) { IndexDefinition = new EntityIndexDefinition <TEntity>(); } MapDirectory = new MMapDirectory(IndexDefinition.IndexDirectory); Analyzer = new StandardAnalyzer(Core.LuceneVersion); Parser = new MultiFieldQueryParser(Core.LuceneVersion, IndexDefinition.GetSearchableFields().ToArray(), Analyzer); _writerConfiguration = new IndexWriterConfig(Core.LuceneVersion, Analyzer); }
public void create_index() { _index = new InMemoryProductIndex(); var manager = new IndexManager(); manager.RegisterIndex(_index); manager.CreateIndexes(); var files = Directory.GetFiles(@"C:\temp\", "*.facet"); foreach (var file in files) { File.Delete(file); } }
public override void ProcessOperation() { IIndexDefinition definition = Worker.Structure.GetIndexDefinition(TargetIndex); if (Node.ScalarValues != null) { CollectionMemoryUtils.AddAll(Values, Node.ScalarValues); } processArrays(definition.Array); processAliases(definition.Aliases); processObjects(); processIndexModifications(); setValues(); }
private bool compareIndexDefinitions(IIndexDefinition newDefinition, IIndexDefinition oldDefinition) { if (newDefinition == oldDefinition) { return(true); } if (newDefinition == null || oldDefinition == null) { return(false); } if (newDefinition.Array != oldDefinition.Array) { if (newDefinition.Array == null || oldDefinition.Array == null) { return(false); } } if (newDefinition.Aliases != oldDefinition.Aliases) { if (newDefinition.Aliases != null && oldDefinition.Aliases != null) { if (!compareSets(newDefinition.Aliases.MayAliases, oldDefinition.Aliases.MayAliases) || !compareSets(newDefinition.Aliases.MustAliases, oldDefinition.Aliases.MustAliases) ) { return(false); } } else { return(false); } } if (newDefinition.Objects != oldDefinition.Objects) { if (!compareSets(newDefinition.Objects, oldDefinition.Objects)) { return(false); } } return(true); }
private void ReadIndexInfo(ITableDefinition tableDefinition, XmlNode index) { Debug.Assert(index != null, "index != null"); string indexName = index["IndexName"].InnerText; string location = index["Location"].InnerText; bool isUnique = Convert.ToBoolean(index["IsUnique"].InnerText); string db = index["DbSpecific"].InnerText; IIndexDefinition indexDefinition = _dbContext.PowerPlant.CreateIndexDefinition(indexName, tableDefinition.Name, location, isUnique); indexDefinition.DbSpecific = TableDefinition.ConvertStringToDbType(db); indexDefinition.Columns = new List <IIndexColumn>(); foreach (XmlNode indexCol in index["IndexColumns"].ChildNodes) { indexDefinition.Columns.Add(IndexColumnFactory.CreateInstance(indexCol.Name, indexCol.InnerText)); } tableDefinition.Indexes.Add(indexDefinition); }
public override void addSource(MergeOperationContext operationContext, IIndexDefinition sourceDefinition) { MemoryEntry entry; if (operationContext.SnapshotContext.SourceData.TryGetMemoryEntry(operationContext.Index, out entry)) { foreach (Value value in entry.PossibleValues) { if (!(value is AssociativeArray)) { values.Add(value); } } } else { values.Add(targetSnapshot.UndefinedValue); } }
/// <summary> /// Processes the merge operation. /// </summary> /// <param name="operation">The operation.</param> private void processMergeOperation(MergeOperation operation) { MemoryIndex targetIndex = operation.TargetIndex; var targetIndexDatasources = targetSnapshot.MergeInfo.GetOrCreateDatasourcesContaier(targetIndex); // Iterate sources foreach (MergeOperationContext operationContext in operation.Indexes) { // Retreive source context and definition MemoryIndex sourceIndex = operationContext.Index; SnapshotContext context = operationContext.SnapshotContext; IIndexDefinition sourceDefinition = context.SourceStructure.GetIndexDefinition(sourceIndex); // Collect array and aliases data arrayWorker.collectSourceArray(targetIndex, operation, operationContext, sourceDefinition.Array); aliasWorker.collectSourceAliases(sourceDefinition.Aliases); objectWorker.collectSourceObjects(sourceDefinition.Objects); // Store datasource for data and info merging targetIndexDatasources.SetDatasource(context.SourceSnapshot, sourceIndex); } IIndexDefinition targetDefinition; if (targetStructure.TryGetIndexDefinition(targetIndex, out targetDefinition)) { // Index is set in target snapshot if (targetDefinition.Array != null) { arrayWorker.SetTargetArray(targetDefinition.Array); } } else { // Index is not set in target snapshot - create it writeableTargetStructure.NewIndex(targetIndex); } aliasWorker.MergeAliasesAndClear(targetIndex, operation); arrayWorker.MergeArraysAndClear(targetSnapshot, targetIndex, operation); objectWorker.MergeObjectsAndClear(targetIndex); }
/// <summary> /// Compares the structure and simplifies the data. /// </summary> /// <param name="widen">if set to <c>true</c> then widening operation is performed.</param> /// <returns>true if memory state is different; otherwise false</returns> public bool CompareStructureAndSimplify(bool widen) { HashSet <MemoryIndex> usedIndexes = new HashSet <MemoryIndex>(); CollectionMemoryUtils.AddAll(usedIndexes, newStructure.Readonly.Indexes); CollectionMemoryUtils.AddAll(usedIndexes, oldStructure.Readonly.Indexes); IIndexDefinition emptyDefinition = Factories.StructuralContainersFactories.IndexDefinitionFactory.CreateIndexDefinition(newStructure.Writeable); bool areEqual = true; foreach (MemoryIndex index in usedIndexes) { if (index is TemporaryIndex) { continue; } IIndexDefinition newDefinition = getIndexDefinitionOrUndefined(index, newStructure, emptyDefinition); IIndexDefinition oldDefinition = getIndexDefinitionOrUndefined(index, oldStructure, emptyDefinition); if (widen) { if (!compareData(index)) { widenData(index); } } if (!compareIndexDefinitions(newDefinition, oldDefinition)) { areEqual = false; } if (!compareData(index)) { areEqual = false; } } return(!areEqual); }
public override void ProcessOperation() { IIndexDefinition definition = Worker.Structure.GetIndexDefinition(TargetIndex); if (Node.ScalarValues != null) { CollectionMemoryUtils.AddAll(Values, Node.ScalarValues); } MemoryEntry oldEntry = SnapshotDataUtils.GetMemoryEntry(Worker.Snapshot, Worker.Data, TargetIndex); CollectionMemoryUtils.AddAll(Values, oldEntry.PossibleValues); processArrays(definition.Array); processAliases(definition.Aliases); processObjects(definition.Objects); processIndexModifications(TargetIndex); setValues(); }
/// <summary> /// Continues the unknown index collector node. /// </summary> /// <param name="node">The node.</param> protected void continueUnknownIndexCollectorNode(UnknownIndexCollectorNode node) { Structure.NewIndex(node.TargetIndex); PathModifications.GetOrCreateModification(node.TargetIndex).AddDatasource(node.SourceIndex, Snapshot); IIndexDefinition definition = Structure.GetIndexDefinition(node.SourceIndex); HashSet <Value> values = new HashSet <Value>(); processSourceAliases(node, definition.Aliases); processSourceArray(node, definition.Array, values); processSourceObjects(node, definition.Objects); testAndCreateImplicitObject(node, values); testAndCreateUndefinedChildren(node); MemoryEntry entry = SnapshotDataUtils.GetMemoryEntry(Snapshot, Data, node.SourceIndex); copyEntryValues(entry, values, node.IsMust, true); Data.SetMemoryEntry(node.TargetIndex, Snapshot.CreateMemoryEntry(values)); enqueueLocationChildNodes(node); }
/// <summary> /// Assigns the may memory index. /// </summary> /// <param name="mayIndex">Index of the may.</param> /// <param name="composedValues">The composed values.</param> private void assignMay(MemoryIndex mayIndex, CollectComposedValuesVisitor composedValues) { IIndexDefinition data = snapshot.Structure.Readonly.GetIndexDefinition(mayIndex); HashSet <Value> values = new HashSet <Value>(composedValues.Values); if (composedValues.Objects.Count > 0) { HashSet <ObjectValue> objectsSet = new HashSet <ObjectValue>(data.Objects); CollectionMemoryUtils.AddAll(objectsSet, composedValues.Objects); IObjectValueContainer objects = Factories.StructuralContainersFactories.ObjectValueContainerFactory.CreateObjectValueContainer(snapshot.Structure.Writeable, composedValues.Objects); snapshot.Structure.Writeable.SetObjects(mayIndex, objects); //if (data.Objects != null) CollectionMemoryUtils.AddAll(values, data.Objects); } MemoryEntry entry = SnapshotDataUtils.GetMemoryEntry(snapshot, snapshot.CurrentData.Readonly, mayIndex); CollectionMemoryUtils.AddAll(values, entry.PossibleValues); snapshot.CurrentData.Writeable.SetMemoryEntry(mayIndex, snapshot.CreateMemoryEntry(values)); }
private void createObjectMapping() { foreach (var item in snapshot.Structure.Readonly.IndexDefinitions) { IIndexDefinition definition = item.Value; MemoryIndex index = item.Key; if (definition.Objects != null && definition.Objects.Count > 0) { foreach (ObjectValue objectValue in definition.Objects) { List <MemoryIndex> indexes; if (!objects.TryGetValue(objectValue, out indexes)) { indexes = new List <MemoryIndex>(); objects.Add(objectValue, indexes); } indexes.Add(index); } } } }
private void clearStructureTracker() { var previousTracker = newStructure.Readonly.ReadonlyChangeTracker.PreviousTracker; if (previousTracker != null) { List <MemoryIndex> indexes = new List <MemoryIndex>(); CollectionMemoryUtils.AddAll(indexes, newStructure.Readonly.ReadonlyChangeTracker.IndexChanges); IReadOnlySnapshotStructure previousStructure = previousTracker.Container; foreach (MemoryIndex index in indexes) { IIndexDefinition newDefinition = getIndexDefinitionOrUndefined(index, newStructure.Readonly); IIndexDefinition previousDefinition = getIndexDefinitionOrUndefined(index, previousStructure); if (compareIndexDefinitions(newDefinition, previousDefinition)) { newStructure.Writeable.WriteableChangeTracker.RemoveIndexChange(index); } } } }
public EntityUpdateTask(TEntity entity, IIndexDefinition <TEntity> definition, IIndexLocation indexLocation) { if (entity == null) { throw new ArgumentNullException("entity"); } if (definition == null) { throw new ArgumentNullException("definition"); } if (indexLocation == null) { throw new ArgumentNullException("indexLocation"); } this.entity = entity; this.definition = definition; this.IndexOptions = new IndexOptions { IndexLocation = indexLocation }; }
public override void provideCustomDeleteOperation(MemoryIndex targetIndex, IIndexDefinition targetDefinition) { throw new Exception("Error merging structure in readonly mode - adding new index into collection: " + targetIndex); }
private bool IndexNameMatch(IIndexDefinition value) { return(value.IndexName.Equals(_CurrentIndexName)); }
// Convert dtSearch SearchResults to a DataSet, so the DataSet can be bound // to a DataGrid control private DataSet ResultsToDataSet() { DataSet dataSet = new DataSet(); DataTable dataTable = new DataTable("SearchResults"); dataTable.Columns.Add(new DataColumn("Score")); //0 dataTable.Columns.Add(new DataColumn("HitCount")); //1 dataTable.Columns.Add(new DataColumn("DisplayName")); //2 dataTable.Columns.Add(new DataColumn("HighlightLink")); //3 dataTable.Columns.Add(new DataColumn("DirectLink")); //4 dataTable.Columns.Add(new DataColumn("Date")); //5 dataTable.Columns.Add(new DataColumn("Size")); //6 dataTable.Columns.Add(new DataColumn("Synopsis")); //7 dataTable.Columns.Add(new DataColumn("Source")); //8 dataTable.Columns.Add(new DataColumn("RelationName1")); //9 dataTable.Columns.Add(new DataColumn("RelationLink1")); //10 dataTable.Columns.Add(new DataColumn("RelationName2")); //11 dataTable.Columns.Add(new DataColumn("RelationLink2")); //12 dataTable.Columns.Add(new DataColumn("RelationName3")); //13 dataTable.Columns.Add(new DataColumn("RelationLink3")); //14 dataTable.Columns.Add(new DataColumn("RelationName4")); //15 dataTable.Columns.Add(new DataColumn("RelationLink4")); //16 dataTable.Columns.Add(new DataColumn("FullDoc")); //17 dataTable.Columns.Add(new DataColumn("AllowPreview")); //18 dataTable.Columns.Add(new DataColumn("DisplayReturnResult")); //19 foreach (SpeedSearchResultItem item in Results.Items) { DataRow row = dataTable.NewRow(); int start = item.IndexRetrievedFrom.LastIndexOf("\\") + 1; _CurrentIndexName = item.IndexRetrievedFrom.Substring(start, item.IndexRetrievedFrom.Length - start); IIndexDefinition currentIdx = _Indexes.Find(IndexNameMatch); row[0] = item.ScorePercent; row[1] = item.HitCount; if (currentIdx.Type == 0) { row[2] = item.DisplayName; row[3] = item.FileName; row[18] = "true"; } else { string tempName = item.DisplayName; int idx = tempName.Length - 12; string key = tempName.Substring(idx); string tableName = tempName.Substring(0, tempName.IndexOf(" ")); row[2] = GetEntityDisplay(GetEntityFromTable(tableName), key, item.DisplayName); row[18] = "false"; if (_DisplayLink) { row[18] = "true"; string path = Page.ResolveUrl(string.Format("{0}.aspx", tableName)); path = Page.MapPath(path); bool pageexists = File.Exists(path); if (pageexists) { row[3] = string.Format("javascript:Link.entityDetail('{1}', '{0}')", key, tableName); } } else if (m_SLXUserService is WebPortalUserService) { row[18] = "true"; } } row[5] = item.ModifiedDate; row[6] = item.Size / 1024; string tempval = item.Synopsis; //<a NAME=TheBody></a> if (tempval.IndexOf("<a NAME=TheBody></a>") > 0) { tempval = tempval.Remove(tempval.IndexOf("<a NAME=TheBody></a>"), 32); } row[7] = tempval; // look up value in App_GlobalResources\SpeedSearch.resx. If not found, use whatever value came back from SS service. string sourceValue = _CurrentIndexName; object globalResource = GetGlobalResourceObject("SpeedSearch", string.Format("INDEX_{0}", _CurrentIndexName.Replace(" ", "_").ToUpperInvariant())); if (globalResource != null) { sourceValue = globalResource.ToString(); } row[8] = sourceValue; if (item.Fields.ContainsKey("accountid")) { row[9] = GetEntityDisplay(GetEntityFromTable("ACCOUNT"), item.Fields["accountid"]); if (_DisplayLink) { row[10] = string.Format("../../{1}.aspx?entityId={0}", item.Fields["accountid"], "ACCOUNT"); } } if (item.Fields.ContainsKey("contactid")) { row[11] = GetEntityDisplay(GetEntityFromTable("CONTACT"), item.Fields["contactid"]); if (_DisplayLink) { row[12] = string.Format("../../{1}.aspx?entityId={0}", item.Fields["contactid"], "CONTACT"); } } if (item.Fields.ContainsKey("opportunityid")) { row[13] = GetEntityDisplay(GetEntityFromTable("OPPORTUNITY"), item.Fields["opportunityid"]); if (_DisplayLink) { row[14] = string.Format("../../{1}.aspx?entityId={0}", item.Fields["opportunityid"], "OPPORTUNITY"); } } if (item.Fields.ContainsKey("ticketid")) { row[15] = GetEntityDisplay(GetEntityFromTable("TICKET"), item.Fields["ticketid"]); if (_DisplayLink) { row[16] = string.Format("../../{1}.aspx?entityId={0}", item.Fields["ticketid"], "TICKET"); } } row[17] = item.HighlightedDoc; row[19] = "none"; if ((!string.IsNullOrEmpty(_ResultProperty)) && (row[18].ToString() == "true")) { row[19] = "block"; } dataTable.Rows.Add(row); } dataSet.Tables.Add(dataTable); return(dataSet); }
public void create_index() { //Clean any existing facets before running the tests to make sure //we are using new and correct data var facetsDirectory = @"C:\temp\facets"; if (Directory.Exists(facetsDirectory)) { var files = Directory.GetFiles(facetsDirectory, "*.facet"); foreach (var file in files) { File.Delete(file); } } _index = new DiskProductIndex(); _manager = new IndexManager(); _manager.RegisterIndex(_index); _manager.CreateIndexes(); }
private static void BindIndexProperties(IAddIndexNode addIndexNode, IIndexDefinition indexDefinition) { if(addIndexNode.Properties[MdlSyntax.Unique] != null) addIndexNode.Unique = indexDefinition.Unique = Convert.ToBoolean(((IStringAstNodePropertyValue)addIndexNode.Properties[MdlSyntax.Unique].Value).Value); if(addIndexNode.Properties[MdlSyntax.Clustered] != null) addIndexNode.Clustered = indexDefinition.Clustered = Convert.ToBoolean(((IStringAstNodePropertyValue)addIndexNode.Properties[MdlSyntax.Clustered].Value).Value); if(addIndexNode.Properties["where"] != null) addIndexNode.Where = indexDefinition.Where = AstNodePropertyUtil.AsString(addIndexNode.Properties["where"].Value); }
private string IndexDefinitionToResourceKey(IIndexDefinition definition) { return String.Format("INDEX_{0}", StripSpecialChars(definition.IndexName)).ToUpper(); }
public static IIndexDefinition ConverteOnlyIndexDefinition(IRequestStatistics myRequestStatistics, IIndexDefinition myIndexDefinition) { return(myIndexDefinition); }
private IIndexDefinition getIndexDefinitionOrUndefined(MemoryIndex index, ISnapshotStructureProxy snapshotStructure, IIndexDefinition emptyDefinition) { IIndexDefinition definition = null; if (!snapshotStructure.Readonly.TryGetIndexDefinition(index, out definition)) { definition = emptyDefinition; } return(definition); }
protected virtual string GetIndexNameForColumns(IIndexDefinition index, string columnNames) { return index.Unique ?? false ? string.Format("UQ_{0}", columnNames) : string.Format("IX_{0}", columnNames); }
protected abstract List <IIndexColumn> GetIndexColumnsForIndex(IIndexDefinition index);
public static IIndexDefinition ConverteOnlyIndexDefinition(IRequestStatistics myRequestStatistics, IIndexDefinition myIndexDefinition) { return myIndexDefinition; }
private QueryResult GenerateResult(IRequestStatistics myStats, IIndexDefinition myIndexDefinition) { return new QueryResult(Query, "sones.gql", Convert.ToUInt64(myStats.ExecutionTime.TotalMilliseconds), ResultType.Successful, new List<IVertexView> { new VertexView(new Dictionary<String, object> { {"CreatedIndex", myIndexDefinition} } , new Dictionary<String, IEdgeView>()) }); }
/// <inheritdoc /> public override bool TryGetIndexDefinition(MemoryIndex index, out IIndexDefinition data) { return(indexDefinitions.TryGetValue(index, out data)); }
/// <summary> /// Indexes a collection of entities using the provided index definition /// </summary> /// <typeparam name="TEntity">The type of entity to index</typeparam> /// <param name="entities">A list of entities</param> /// <param name="definition">The index definition</param> /// <returns>An index result with the outcome of the indexing operation</returns> public IndexResult IndexEntities <TEntity>(IEnumerable <TEntity> entities, IIndexDefinition <TEntity> definition) where TEntity : class { return(IndexEntities(entities, definition.Convert)); }
private IQueryResult GenerateResult(IRequestStatistics myStats, IIndexDefinition myIndexDefinition) { return QueryResult.Success(Query, SonesGQLConstants.GQL, new List<IVertexView> { new VertexView(new Dictionary<String, object> { {"CreatedIndex", myIndexDefinition}, {"CreatedIndexTypeName", myIndexDefinition.IndexTypeName } }, new Dictionary<String, IEdgeView>()) }, Convert.ToUInt64(myStats.ExecutionTime.TotalMilliseconds)); }
public override void provideCustomDeleteOperation(MemoryIndex targetIndex, IIndexDefinition targetDefinition) { if (targetDefinition.Array != null) { writeableTargetStructure.RemoveArray(targetIndex, targetDefinition.Array); } if (targetDefinition.Aliases != null) { foreach (MemoryIndex aliasIndex in targetDefinition.Aliases.MustAliases) { MemoryAliasInfo aliasInfo = mergeWorker.getAliasInfo(aliasIndex); aliasInfo.AddRemovedAlias(targetIndex); } foreach (MemoryIndex aliasIndex in targetDefinition.Aliases.MayAliases) { MemoryAliasInfo aliasInfo = mergeWorker.getAliasInfo(aliasIndex); aliasInfo.AddRemovedAlias(targetIndex); } } writeableTargetStructure.RemoveIndex(targetIndex); }
private static SingleEdgeUpdateDefinition IndexDefinitionToSingleEdgeUpdate(VertexInformation mySourceVertex, IIndexDefinition myDefinition) { return new SingleEdgeUpdateDefinition(mySourceVertex, new VertexInformation((long)BaseTypes.Index, myDefinition.ID), (long)BaseTypes.Edge); }
private bool IndexNameMatch(IIndexDefinition value) { return value.IndexName.Equals(_CurrentIndexName); }
private string IndexDefinitionToResourceKey(IIndexDefinition definition) { return(String.Format("INDEX_{0}", StripSpecialChars(definition.IndexName)).ToUpper()); }
private bool IsIndexForThisDb(IIndexDefinition index) { return(index.DbSpecific == DbTypeName.Any || index.DbSpecific == DbContext.DbType); }
private IUniqueDefinition ConvertIIndexDefinitionToIUniqueDefinition(IIndexDefinition myIndexDefinition) { return new UniqueDefinition { DefiningVertexType = this, UniquePropertyDefinitions = myIndexDefinition.IndexedProperties, CorrespondingIndex = myIndexDefinition, }; }
private void RemoveVertexPropertyFromIndex(IVertex aVertex, IIndexDefinition aIndexDefinition, IEnumerable<IIndex<IComparable, long>> myIndices, SecurityToken mySecurityToken, TransactionToken myTransactionToken) { var entry = CreateIndexEntry(aIndexDefinition.IndexedProperties, aVertex.GetAllProperties().ToDictionary(key => key.Item1, value => value.Item2)); foreach (var iIndex in myIndices) { if (iIndex is IMultipleValueIndex<IComparable, long>) { lock (iIndex) { if (iIndex.ContainsKey(entry)) { var toBeUpdatedIndex = (IMultipleValueIndex<IComparable, long>)iIndex; var payLoad = toBeUpdatedIndex[entry]; payLoad.Remove(aVertex.VertexID); toBeUpdatedIndex.Add(entry, payLoad, IndexAddStrategy.REPLACE); } } } else { iIndex.Remove(entry); } } }
private static void CopyProperties(IIndexDefinition index, IAddIndexNode addIndexNode) { if(!string.IsNullOrEmpty(index.Table)) AddProperty(addIndexNode, MdlSyntax.Table, index.Table); if(index.Clustered.GetValueOrDefault(false)) AddProperty(addIndexNode, MdlSyntax.Clustered, "true"); if(index.Unique.GetValueOrDefault(false)) AddProperty(addIndexNode, MdlSyntax.Unique, "true"); if(index.Columns.Count == 1) { IAstNodePropertyValue value = GetIndexColumnPropertyValue(index.Columns[0]); AddProperty(addIndexNode, MdlSyntax.Column, value); } // if else AddListProperty(addIndexNode, MdlSyntax.Columns, new List<IIndexColumnDefinition>(index.Columns).ConvertAll<IAstNodePropertyValue>( delegate(IIndexColumnDefinition icd) { return GetIndexColumnPropertyValue(icd); })); }