public FullTextExpression(FullTextIndexInfo fullTextIndex, EntityExpression entityExpression, ColumnExpression rankExpression, ParameterExpression parameter)
     : base(ExtendedExpressionType.FullText, typeof(FullTextMatch <>).MakeGenericType(fullTextIndex.PrimaryIndex.ReflectedType.UnderlyingType), parameter, false)
 {
     FullTextIndex    = fullTextIndex;
     RankExpression   = rankExpression;
     EntityExpression = entityExpression;
 }
        /// <inheritdoc/>
        protected override IPathNode VisitFullTextIndexInfo(FullTextIndexInfo fullTextIndex)
        {
            if (!providerInfo.Supports(ProviderFeatures.FullText))
            {
                UpgradeLog.Warning(Strings.LogFullTextIndexesAreNotSupportedByCurrentStorageIgnoringIndexX, fullTextIndex.Name);
                return(null);
            }

            var table        = GetTable(fullTextIndex.PrimaryIndex.ReflectedType);
            var primaryIndex = table.PrimaryIndex;
            var ftIndex      = new StorageFullTextIndexInfo(table, fullTextIndex.Name);

            foreach (var fullTextColumn in fullTextIndex.Columns)
            {
                var    column     = table.Columns[fullTextColumn.Name];
                string typeColumn = null;
                if (providerInfo.Supports(ProviderFeatures.FullTextColumnDataTypeSpecification))
                {
                    if (fullTextColumn.TypeColumn != null)
                    {
                        typeColumn = table.Columns[fullTextColumn.TypeColumn.Name].Name;
                    }
                }
                else
                {
                    UpgradeLog.Warning(Strings.LogSpecificationOfTypeColumnForFulltextColumnIsNotSupportedByCurrentStorageIgnoringTypeColumnSpecificationForColumnX, fullTextColumn.Column.Name);
                }
                new FullTextColumnRef(ftIndex, column, fullTextColumn.Configuration, typeColumn);
            }

            ftIndex.FullTextCatalog =
                fulltextCatalogNameBuilder.Build(fullTextIndex.PrimaryIndex.ReflectedType, table);
            ftIndex.ChangeTrackingMode = configuration.FullTextChangeTrackingMode;
            return(ftIndex);
        }
 public FreeTextProvider(FullTextIndexInfo index, Func <string> searchCriteria, string rankColumnName, Func <int> topN, bool fullFeatured)
     : base(ProviderType.FreeText)
 {
     SearchCriteria = searchCriteria;
     FullFeatured   = fullFeatured;
     TopN           = topN;
     PrimaryIndex   = new IndexInfoRef(index.PrimaryIndex);
     if (FullFeatured)
     {
         var primaryIndexRecordsetHeader = index.PrimaryIndex.ReflectedType.Indexes.PrimaryIndex.GetRecordSetHeader();
         var rankColumn = new MappedColumn(rankColumnName, primaryIndexRecordsetHeader.Length, typeof(double));
         indexHeader = primaryIndexRecordsetHeader.Add(rankColumn);
     }
     else
     {
         var primaryIndexKeyColumns = index.PrimaryIndex.KeyColumns;
         if (primaryIndexKeyColumns.Count != 1)
         {
             throw new InvalidOperationException(Strings.ExOnlySingleColumnKeySupported);
         }
         var fieldTypes = primaryIndexKeyColumns
                          .Select(columnInfo => columnInfo.Key.ValueType)
                          .AddOne(typeof(double))
                          .ToArray(primaryIndexKeyColumns.Count + 1);
         var tupleDescriptor = TupleDescriptor.Create(fieldTypes);
         var columns         = primaryIndexKeyColumns
                               .Select((c, i) => (Column) new MappedColumn("KEY", i, c.Key.ValueType))
                               .AddOne(new MappedColumn("RANK", tupleDescriptor.Count, typeof(double)));
         indexHeader = new RecordSetHeader(tupleDescriptor, columns);
     }
     Initialize();
 }
 public ContainsTableProvider(FullTextIndexInfo index, Func <ParameterContext, string> searchCriteria, string rankColumnName, IList <ColumnInfo> targetColumns, Func <ParameterContext, int> topNByRank, bool fullFeatured)
     : base(ProviderType.ContainsTable)
 {
     SearchCriteria = searchCriteria;
     FullFeatured   = fullFeatured;
     PrimaryIndex   = new IndexInfoRef(index.PrimaryIndex);
     TargetColumns  = new ReadOnlyList <FullTextColumnInfo>(targetColumns.Select(tc => index.Columns.First(c => c.Column == tc)).ToList());
     TopN           = topNByRank;
     if (FullFeatured)
     {
         var primaryIndexRecordsetHeader =
             index.PrimaryIndex.ReflectedType.Indexes.PrimaryIndex.GetRecordSetHeader();
         var rankColumn = new MappedColumn(rankColumnName, primaryIndexRecordsetHeader.Length, WellKnownTypes.Double);
         indexHeader = primaryIndexRecordsetHeader.Add(rankColumn);
     }
     else
     {
         var primaryIndexKeyColumns = index.PrimaryIndex.KeyColumns;
         if (primaryIndexKeyColumns.Count != 1)
         {
             throw new InvalidOperationException(Strings.ExOnlySingleColumnKeySupported);
         }
         var fieldTypes = primaryIndexKeyColumns
                          .Select(columnInfo => columnInfo.Key.ValueType)
                          .Append(WellKnownTypes.Double)
                          .ToArray(primaryIndexKeyColumns.Count + 1);
         var tupleDescriptor = TupleDescriptor.Create(fieldTypes);
         var columns         = primaryIndexKeyColumns
                               .Select((c, i) => (Column) new MappedColumn("KEY", i, c.Key.ValueType))
                               .Append(new MappedColumn("RANK", tupleDescriptor.Count, WellKnownTypes.Double));
         indexHeader = new RecordSetHeader(tupleDescriptor, columns);
     }
     Initialize();
 }
        private void BuildFullTextIndexesSingleTable(TypeInfo root, IEnumerable <FullTextIndexDef> hierarchyIndexes)
        {
            var model        = context.Model;
            var primaryIndex = root.Indexes.Single(i => i.IsPrimary && !i.IsVirtual);
            var name         = context.NameBuilder.BuildFullTextIndexName(root);
            var index        = new FullTextIndexInfo(primaryIndex, name);
            var types        = new HashSet <TypeInfo>();

            foreach (var fullTextIndexDef in hierarchyIndexes)
            {
                var type = model.Types[fullTextIndexDef.Type.UnderlyingType];
                types.Add(type);
                foreach (var descendant in type.GetDescendants(true))
                {
                    types.Add(descendant);
                }
                foreach (var fullTextFieldDef in fullTextIndexDef.Fields)
                {
                    var fullTextColumn = GetFullTextColumn(type, fullTextFieldDef);
                    index.Columns.Add(fullTextColumn);
                }
            }
            foreach (var type in types)
            {
                model.FullTextIndexes.Add(type, index);
            }
        }
        private void BuildFullTextIndexesClassTable(TypeInfo root, IEnumerable <FullTextIndexDef> hierarchyIndexes)
        {
            var model           = context.Model;
            var indexesToDefine = hierarchyIndexes.ToList();

            if (indexesToDefine.Any(fti => fti.Type.UnderlyingType != root.UnderlyingType) || indexesToDefine.Count > 1)
            {
                throw new DomainBuilderException(string.Format(Strings.ExUnableToBuildFulltextIndexesForHierarchyWithInheritanceSchemaClassTable, root.Name));
            }
            var descendants  = root.GetDescendants(true).Append(root);
            var indexDef     = indexesToDefine[0];
            var primaryIndex = root.Indexes.Single(i => i.IsPrimary && !i.IsVirtual);
            var name         = context.NameBuilder.BuildFullTextIndexName(root);
            var index        = new FullTextIndexInfo(primaryIndex, name);

            foreach (var fullTextFieldDef in indexDef.Fields)
            {
                var fullTextColumn = GetFullTextColumn(root, fullTextFieldDef);
                index.Columns.Add(fullTextColumn);
            }
            foreach (var type in descendants)
            {
                model.FullTextIndexes.Add(type, index);
            }
        }
        private void BuildFullTextIndexesConcreteTable(TypeInfo root, IEnumerable <FullTextIndexDef> hierarchyIndexes)
        {
            var model     = context.Model;
            var indexDefs = GatherFullTextIndexDefinitons(root, hierarchyIndexes);

            foreach (var typeIndexDef in indexDefs)
            {
                var type         = typeIndexDef.Key;
                var primaryIndex = type.Indexes.Single(i => i.IsPrimary && !i.IsVirtual);
                var name         = context.NameBuilder.BuildFullTextIndexName(root);
                var index        = new FullTextIndexInfo(primaryIndex, name);
                foreach (var fullTextFieldDef in typeIndexDef.Value.SelectMany(def => def.Fields))
                {
                    var fullTextColumn = GetFullTextColumn(type, fullTextFieldDef);
                    index.Columns.Add(fullTextColumn);
                }
                model.FullTextIndexes.Add(type, index);
            }
        }
 public ContainsTableProvider(FullTextIndexInfo index, Func <ParameterContext, string> searchCriteria, string rankColumnName, IList <ColumnInfo> targetColumns, bool fullFeatured)
     : this(index, searchCriteria, rankColumnName, targetColumns, null, fullFeatured)
 {
 }
 public ContainsTableProvider(FullTextIndexInfo index, Func <string> searchCriteria, string rankColumnName, bool fullFeatured)
     : this(index, searchCriteria, rankColumnName, new List <ColumnInfo>(), null, fullFeatured)
 {
 }
 public FreeTextProvider(FullTextIndexInfo index, Func <string> searchCriteria, string rankColumnName, bool fullFeatured)
     : this(index, searchCriteria, rankColumnName, null, fullFeatured)
 {
 }
Пример #11
0
        private static StorageInfo CreateSimpleStorageModel()
        {
            var storage = new StorageInfo("Storage");

            // Types table
            var t   = new TableInfo(storage, "Types");
            var tId = new ColumnInfo(t, "Id")
            {
                Type = new TypeInfo(typeof(int), false)
            };
            var tValue = new ColumnInfo(t, "Value")
            {
                Type = new TypeInfo(typeof(string), 1024)
            };
            var tData = new ColumnInfo(t, "Data")
            {
                Type = new TypeInfo(typeof(byte[]), 1024 * 1024)
            };

            var tiPk = new PrimaryIndexInfo(t, "PK_Types");

            new KeyColumnRef(tiPk, tId);
            tiPk.PopulateValueColumns();

            var tiValue = new SecondaryIndexInfo(t, "IX_Value");

            new KeyColumnRef(tiValue, tValue);
            tiValue.PopulatePrimaryKeyColumns();

            var tiFt = new FullTextIndexInfo(t, "FT_Index");

            new FullTextColumnRef(tiFt, tValue);

            // Objects table
            var o   = new TableInfo(storage, "Objects");
            var oId = new ColumnInfo(o, "Id")
            {
                Type = new TypeInfo(typeof(long), false)
            };
            var oTypeId = new ColumnInfo(o, "TypeId")
            {
                Type = new TypeInfo(typeof(int), false)
            };
            var oValue = new ColumnInfo(o, "Value")
            {
                Type = new TypeInfo(typeof(string), 1024)
            };

            var oiPk = new PrimaryIndexInfo(o, "PK_Objects");

            new KeyColumnRef(oiPk, oId);
            oiPk.PopulateValueColumns();

            var oiTypeId = new SecondaryIndexInfo(o, "IX_TypeId");

            new KeyColumnRef(oiTypeId, oTypeId);
            oiTypeId.PopulatePrimaryKeyColumns();

            var oiValue = new SecondaryIndexInfo(o, "IX_Value");

            new KeyColumnRef(oiValue, oValue);
            new IncludedColumnRef(oiValue, oTypeId);
            oiValue.PopulatePrimaryKeyColumns();

            var ofkTypeId = new ForeignKeyInfo(o, "FK_TypeId")
            {
                PrimaryKey = tiPk,
            };

            ofkTypeId.ForeignKeyColumns.Set(oiTypeId);

            storage.Validate();
            return(storage);
        }