Пример #1
0
        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();
 }
Пример #5
0
 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;
     }
 }
Пример #6
0
        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();
        }
Пример #7
0
        /// <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);
        }
Пример #8
0
 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;
 }
Пример #9
0
 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)));
 }
Пример #10
0
 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;
 }
Пример #11
0
        /// <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);
        }
Пример #12
0
        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);
        }
Пример #13
0
        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);
            }
        }
Пример #14
0
        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();
        }
Пример #15
0
        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);
        }
Пример #16
0
        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);
        }
Пример #17
0
            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);
                }
            }
Пример #18
0
        /// <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);
        }
Пример #19
0
        /// <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);
        }
Пример #20
0
        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();
        }
Пример #21
0
        /// <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);
        }
Пример #22
0
        /// <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));
        }
Пример #23
0
        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);
                    }
                }
            }
        }
Пример #24
0
        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);
                    }
                }
            }
        }
Пример #25
0
        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
            };
        }
Пример #26
0
 public override void provideCustomDeleteOperation(MemoryIndex targetIndex, IIndexDefinition targetDefinition)
 {
     throw new Exception("Error merging structure in readonly mode - adding new index into collection: " + targetIndex);
 }
Пример #27
0
 private bool IndexNameMatch(IIndexDefinition value)
 {
     return(value.IndexName.Equals(_CurrentIndexName));
 }
Пример #28
0
    // 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; //&lt;a NAME=TheBody&gt;&lt;/a&gt;
            if (tempval.IndexOf("&lt;a NAME=TheBody&gt;&lt;/a&gt;") > 0)
            {
                tempval = tempval.Remove(tempval.IndexOf("&lt;a NAME=TheBody&gt;&lt;/a&gt;"), 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();
 }
Пример #32
0
 public static IIndexDefinition ConverteOnlyIndexDefinition(IRequestStatistics myRequestStatistics, IIndexDefinition myIndexDefinition)
 {
     return(myIndexDefinition);
 }
Пример #33
0
        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);
 }
Пример #35
0
 protected abstract List <IIndexColumn> GetIndexColumnsForIndex(IIndexDefinition index);
Пример #36
0
 public static IIndexDefinition ConverteOnlyIndexDefinition(IRequestStatistics myRequestStatistics, IIndexDefinition myIndexDefinition)
 {
     return myIndexDefinition;
 }
Пример #37
0
 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>()) });
 }
Пример #38
0
 /// <inheritdoc />
 public override bool TryGetIndexDefinition(MemoryIndex index, out IIndexDefinition data)
 {
     return(indexDefinitions.TryGetValue(index, out data));
 }
Пример #39
0
 /// <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));
 }
Пример #40
0
 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));
 }
Пример #41
0
            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);
            }
Пример #42
0
 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);
 }
Пример #44
0
 private string IndexDefinitionToResourceKey(IIndexDefinition definition)
 {
     return(String.Format("INDEX_{0}", StripSpecialChars(definition.IndexName)).ToUpper());
 }
Пример #45
0
 private bool IsIndexForThisDb(IIndexDefinition index)
 {
     return(index.DbSpecific == DbTypeName.Any || index.DbSpecific == DbContext.DbType);
 }
Пример #46
0
 private IUniqueDefinition ConvertIIndexDefinitionToIUniqueDefinition(IIndexDefinition myIndexDefinition)
 {
     return new UniqueDefinition
     {
         DefiningVertexType = this,
         UniquePropertyDefinitions = myIndexDefinition.IndexedProperties,
         CorrespondingIndex = myIndexDefinition,
     };
 }
Пример #47
0
        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);
                }

            }
        }
Пример #48
0
        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); }));
        }