public virtual XElement SerializeUpdateCommand(SolrSchema schema) { var existingFieldType = schema.SolrFieldTypes.Find(f => f.Name == Name); var fieldType = new XElement(existingFieldType == null ? "add-field-type" : "replace-field-type"); fieldType.Add(new XElement("name", Name)); foreach (var pair in Properties) { fieldType.Add(new XElement(pair.Key, pair.Value)); } // There can be an index + query analyzer, one common untyped analyzer or none at all. var indexAnalyzer = _analyzers.SingleOrDefault(a => a.Attributes["type"]?.Value == "index"); var queryAnalyzer = _analyzers.SingleOrDefault(a => a.Attributes["type"]?.Value == "query"); var genericAnalyzer = _analyzers.SingleOrDefault(a => !a.HasAttribute("type")); if (indexAnalyzer != null && queryAnalyzer != null) { fieldType.Add(SerializeAnalyzer(indexAnalyzer)); fieldType.Add(SerializeAnalyzer(queryAnalyzer)); } else if (genericAnalyzer != null) { fieldType.Add(SerializeAnalyzer(genericAnalyzer)); } return(fieldType); }
public void SolrFieldParsing() { var schemaParser = new SolrSchemaParser(); var xml = EmbeddedResource.GetEmbeddedXml(GetType(), "Resources.solrSchemaBasic.xml"); SolrSchema schemaDoc = schemaParser.Parse(xml); Assert.Equal(4, schemaDoc.SolrFields.Count); Assert.Equal("id", schemaDoc.SolrFields[0].Name); Assert.True(schemaDoc.SolrFields[0].IsRequired); Assert.False(schemaDoc.SolrFields[2].IsRequired); Assert.True(schemaDoc.SolrFields[3].IsMultiValued); Assert.False(schemaDoc.SolrFields[0].IsMultiValued); Assert.True(schemaDoc.SolrFields[2].IsIndexed); Assert.False(schemaDoc.SolrFields[3].IsIndexed); Assert.True(schemaDoc.SolrFields[0].IsStored); Assert.False(schemaDoc.SolrFields[3].IsStored); Assert.False(schemaDoc.SolrFields[1].IsDocValues); Assert.False(schemaDoc.SolrFields[2].IsDocValues); Assert.True(schemaDoc.SolrFields[3].IsDocValues); Assert.Equal("string", schemaDoc.SolrFields[0].Type.Name); }
public ISchemaPopulateHelper GetPopulateHelper(SolrSchema solrSchema) { // Sitecore default implementation returns SchemaPopulateHelper // Optionally, DefaultWithDebugPopulateHelper can be returned using // Sitecore's default implementation but adds logging. return(new ConfigurationDrivenPopulateHelper(solrSchema)); }
/// <summary> /// Validates that all SolrFields in the SolrSchema which are required are /// either present in the mapping or as a CopyField. /// </summary> /// <param name="documentType">Document type</param> /// <param name="solrSchema">The solr schema.</param> /// <param name="mappingManager">The mapping manager.</param> /// <returns> /// A collection of <see cref="ValidationResult"/> objects with any issues found during validation. /// </returns> public IEnumerable <ValidationResult> Validate(Type documentType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager) { foreach (SolrField solrField in solrSchema.SolrFields) { if (solrField.IsRequired) { bool fieldFoundInMappingOrCopyFields = mappingManager.GetFields(documentType).ContainsKey(solrField.Name); if (!fieldFoundInMappingOrCopyFields) { foreach (SolrCopyField copyField in solrSchema.SolrCopyFields) { if (copyField.Destination.Equals(solrField.Name)) { fieldFoundInMappingOrCopyFields = true; break; } } } if (!fieldFoundInMappingOrCopyFields) { yield return(new ValidationError(String.Format("Required field '{0}' in the Solr schema is not mapped in type '{1}'.", solrField.Name, documentType.FullName))); } } } }
public void UniqueKeyNotPresent() { var schemaParser = new SolrSchemaParser(); var xml = EmbeddedResource.GetEmbeddedXml(GetType(), "Resources.solrSchemaNoUniqueKey.xml"); SolrSchema schemaDoc = schemaParser.Parse(xml); Assert.IsNull(schemaDoc.UniqueKey); }
public void UniqueKeyEmptyManagedSchema() { var schemaParser = new SolrSchemaParser(); var xml = EmbeddedResource.GetEmbeddedXml(GetType(), "Resources.solrManagedSchemaEmptyUniqueKey.xml"); SolrSchema schemaDoc = schemaParser.Parse(xml); Assert.Null(schemaDoc.UniqueKey); }
public void UniqueKeyPresent() { var schemaParser = new SolrSchemaParser(); var xml = EmbeddedResource.GetEmbeddedXml(GetType(), "Resources.solrSchemaBasic.xml"); SolrSchema schemaDoc = schemaParser.Parse(xml); Assert.AreEqual("id", schemaDoc.UniqueKey); }
public void SolrDynamicFieldParsing() { var schemaParser = new SolrSchemaParser(); var xml = EmbeddedResource.GetEmbeddedXml(GetType(), "Resources.solrSchemaBasic.xml"); SolrSchema schemaDoc = schemaParser.Parse(xml); Assert.AreEqual(1, schemaDoc.SolrDynamicFields.Count); Assert.AreEqual("*_s", schemaDoc.SolrDynamicFields[0].Name); }
public SynthesisSolrFieldNameTranslator(SolrFieldMap solrFieldMap, SolrIndexSchema solrIndexSchema, ISettings settings, ISolrFieldConfigurationResolver fieldConfigurationResolver, IExtensionStripHelper extensionStripHelper, TemplateFieldTypeResolverFactory typeResolverFactory, ICultureContextGuard cultureContextGuard) : base(solrFieldMap, solrIndexSchema, settings, fieldConfigurationResolver, extensionStripHelper, typeResolverFactory, cultureContextGuard) { _schema = solrIndexSchema.SolrSchema; }
public void SolrDynamicFieldParsingManagedSchema() { var schemaParser = new SolrSchemaParser(); var xml = EmbeddedResource.GetEmbeddedXml(GetType(), "Resources.solrManagedSchemaBasic.xml"); SolrSchema schemaDoc = schemaParser.Parse(xml); Assert.Single(schemaDoc.SolrDynamicFields); Assert.Equal("*_s", schemaDoc.SolrDynamicFields[0].Name); }
public void SchemaNull_MappingNull_no_errors() { var rule = new UniqueKeyMatchesMappingRule(); var schema = new SolrSchema(); var validations = rule.Validate(typeof(SchemaMappingTestDocument), schema, new MappingManager()).ToList(); Assert.IsNotNull(validations); Assert.AreEqual(0, validations.Count); }
public void SolrFieldTypeParsing() { var schemaParser = new SolrSchemaParser(); var xml = EmbeddedResource.GetEmbeddedXml(GetType(), "Resources.solrSchemaBasic.xml"); SolrSchema schemaDoc = schemaParser.Parse(xml); Assert.AreEqual(2, schemaDoc.SolrFieldTypes.Count); Assert.AreEqual("string", schemaDoc.SolrFieldTypes[0].Name); Assert.AreEqual("solr.StrField", schemaDoc.SolrFieldTypes[0].Type); }
public void SolrCopyFieldParsing() { var schemaParser = new SolrSchemaParser(); var xml = EmbeddedResource.GetEmbeddedXml(GetType(), "Resources.solrSchemaBasic.xml"); SolrSchema schemaDoc = schemaParser.Parse(xml); Assert.AreEqual(1, schemaDoc.SolrCopyFields.Count); Assert.AreEqual("name", schemaDoc.SolrCopyFields[0].Source); Assert.AreEqual("nameSort", schemaDoc.SolrCopyFields[0].Destination); }
public SynthesisSolrFieldNameTranslator(IProviderSearchContext context, AbstractFieldNameTranslator translator) : base(translator) { //sitecore hides the solr schema behind a private field, we need it to find dynamic fields. var fieldInfo = context.Index.Schema.GetType().GetField("schema", BindingFlags.NonPublic | BindingFlags.Instance); if (fieldInfo != null) { _schema = (SolrSchema)fieldInfo.GetValue(context.Index.Schema); } }
public virtual XElement SerializeDeleteCommand(SolrSchema schema) { if (schema.SolrFields.Find(f => f.Name == Name) == null) { return(null); } XElement deleteField = new XElement("delete-field"); deleteField.Add(new XElement("name", Name)); return(deleteField); }
public XElement SerializeDeleteCommand(SolrSchema schema) { if (schema.SolrCopyFields.Find(f => f.Source == Source && f.Destination == Destination) == null) { return(null); } XElement deleteField = new XElement("delete-copy-field"); deleteField.Add(new XElement("source", Source)); deleteField.Add(new XElement("dest", Destination)); return(deleteField); }
public virtual XElement SerializeUpdateCommand(SolrSchema schema) { XElement field = new XElement(GetOperation(schema)); field.Add(new XElement("name", Name)); foreach (var pair in Properties) { field.Add(new XElement(pair.Key, pair.Value)); } return(field); }
public ConfigurationDrivenPopulateHelper([NotNull] SolrSchema solrSchema) { _solrSchema = solrSchema; var xmlNode = Sitecore.Configuration.Factory.GetConfigNode("contentSearch/indexConfigurations/solrManagedSchema"); _solrSolrSchemaConfiguration = Sitecore.Configuration.Factory.CreateObject <ISolrSchemaConfiguration>(xmlNode); if (!_solrSolrSchemaConfiguration.IsValid()) { Log.Error("Solr Schema configuration errors found. Schema population may fail.", nameof(ConfigurationDrivenPopulateHelper)); } }
public virtual XElement SerializeUpdateCommand(SolrSchema schema) { var copyField = new XElement("add-copy-field"); copyField.Add(new XElement("source", Source)); copyField.Add(new XElement("dest", Destination)); if (MaxChars > 0) { copyField.Add(new XElement("maxChars", MaxChars)); } return(copyField); }
public override XElement SerializeDeleteCommand(SolrSchema schema) { var existingField = schema.SolrDynamicFields.Find(f => f.Name == Name); if (existingField == null) { return(null); } XElement deleteField = new XElement("delete-dynamic-field"); deleteField.Add(new XElement("name", Name)); return(deleteField); }
public void DictionaryFields_are_ignored() { var rule = new MappedPropertiesIsInSolrSchemaRule(); var mapper = new MappingManager(); mapper.Add(typeof(SchemaMappingTestDocument).GetProperty("DynamicMapped"), "ma_*"); var schema = new SolrSchema(); var fieldType = new SolrFieldType("string", "solr.StrField"); schema.SolrFields.Add(new SolrField("ma_uaua", fieldType)); var results = rule.Validate(typeof(SchemaMappingTestDocument), new SolrSchema(), mapper).ToList(); Assert.Empty(results); }
public void SchemaNotNull_MappingNull_generates_warning() { var rule = new UniqueKeyMatchesMappingRule(); var schema = new SolrSchema { UniqueKey = "id" }; var validations = rule.Validate(typeof(SchemaMappingTestDocument), schema, new MappingManager()).ToList(); Assert.NotNull(validations); Assert.Single(validations); foreach (var v in validations) { testOutputHelper.WriteLine("{0}: {1}", v.GetType(), v.Message); } Assert.IsType <ValidationWarning>(validations[0]); }
public void SchemaNotNull_MappingNull_generates_warning() { var rule = new UniqueKeyMatchesMappingRule(); var schema = new SolrSchema { UniqueKey = "id" }; var validations = rule.Validate(typeof(SchemaMappingTestDocument), schema, new MappingManager()).ToList(); Assert.IsNotNull(validations); Assert.AreEqual(1, validations.Count); foreach (var v in validations) { Console.WriteLine("{0}: {1}", v.GetType(), v.Message); } Assert.IsInstanceOf <ValidationWarning>(validations[0]); }
/// <summary> /// Validates that all properties in the mapping are present in the Solr schema /// as either a SolrField or a DynamicField /// </summary> /// <param name="documentType">Document type</param> /// <param name="solrSchema">The solr schema.</param> /// <param name="mappingManager">The mapping manager.</param> /// <returns> /// A collection of <see cref="ValidationResult"/> objects with any issues found during validation. /// </returns> public IEnumerable <ValidationResult> Validate(Type documentType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager) { foreach (var mappedField in mappingManager.GetFields(documentType).Values) { var field = mappedField; if (IgnoredFieldNames != null && IgnoredFieldNames.Any(f => f == field.FieldName)) { continue; } if (field.FieldName.Contains("*")) // ignore multi-mapped fields (wildcards or dictionary mappings) { continue; } var fieldFoundInSolrSchema = false; foreach (var solrField in solrSchema.SolrFields) { if (solrField.Name.Equals(field.FieldName)) { fieldFoundInSolrSchema = true; break; } } if (!fieldFoundInSolrSchema) { foreach (var dynamicField in solrSchema.SolrDynamicFields) { if (IsGlobMatch(dynamicField.Name, field.FieldName)) { fieldFoundInSolrSchema = true; break; } } } if (!fieldFoundInSolrSchema) { // If field couldn't be matched to any of the solrfield, dynamicfields throw an exception. yield return(new ValidationError(String.Format("No matching SolrField or DynamicField '{0}' found in the Solr schema for document property '{1}' in type '{2}'.", field.FieldName, field.Property.Name, documentType.FullName))); } } }
/// <summary> /// Validates that the uniqueKey mapped in the type is the same as in the Solr schema. /// </summary> /// <param name="documentType">Document type</param> /// <param name="solrSchema">The solr schema.</param> /// <param name="mappingManager">The mapping manager.</param> /// <returns> /// A collection of <see cref="ValidationResult"/> objects with any issues found during validation. /// </returns> public IEnumerable <ValidationResult> Validate(Type documentType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager) { var mappedKey = mappingManager.GetUniqueKey(documentType); if (mappedKey == null && solrSchema.UniqueKey == null) { yield break; } if (mappedKey == null && solrSchema.UniqueKey != null) { yield return(new ValidationWarning(string.Format("Solr schema has unique key field '{0}' but mapped type '{1}' doesn't have a declared unique key", solrSchema.UniqueKey, documentType))); } else if (mappedKey != null && solrSchema.UniqueKey == null) { yield return(new ValidationError(string.Format("Type '{0}' has a declared unique key '{1}' but Solr schema doesn't have a unique key", documentType, mappedKey.FieldName))); } else if (!mappedKey.FieldName.Equals(solrSchema.UniqueKey)) { yield return(new ValidationError(String.Format("Solr schema unique key '{0}' does not match document unique key '{1}' in type '{2}'.", solrSchema.UniqueKey, mappedKey, documentType))); } }
/// <summary> /// Validates the specified the mapped document against the solr schema. /// </summary> /// <param name="documentType">Document type</param> /// <param name="solrSchema">The solr schema.</param> /// <param name="mappingManager">The mapping manager.</param> /// <returns> /// A collection of <see cref="ValidationResult"/> objects with any issues found during validation. /// </returns> public IEnumerable <ValidationResult> Validate(Type documentType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager) { var collectionFieldParser = new CollectionFieldParser(null); // Used to check if the type is a collection type. foreach (var prop in mappingManager.GetFields(documentType)) { var solrField = solrSchema.FindSolrFieldByName(prop.Key); if (solrField == null) { continue; } var isCollection = collectionFieldParser.CanHandleType(prop.Value.Property.PropertyType); if (solrField.IsMultiValued && !isCollection) { yield return(new ValidationError(String.Format("SolrField '{0}' is multivalued while property '{1}.{2}' is not mapped as a collection.", solrField.Name, prop.Value.Property.DeclaringType, prop.Value.Property.Name))); } else if (!solrField.IsMultiValued && isCollection) { yield return(new ValidationError(String.Format("SolrField '{0}' is not multivalued while property '{1}.{2}' is mapped as a collection.", solrField.Name, prop.Value.Property.DeclaringType, prop.Value.Property.Name))); } } }
public IEnumerable <ValidationResult> Validate(Type documentType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager) { foreach (var x in mappingManager.GetFields(documentType)) { var solrField = solrSchema.FindSolrFieldByName(x.Key); if (solrField == null) { continue; } foreach (var checker in fieldTypeCheckers) { if (!checker.CanHandleType(x.Value.Property.PropertyType)) { continue; } var i = checker.Validate(solrField.Type, x.Value.Property.Name, x.Value.Property.PropertyType); if (i != null) { yield return(i); } } } }
public IEnumerable <ValidationResult> Validate(Type propertyType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager) { return(new ValidationResult[] { new ValidationError("Dummy warning validation rule") }); }
public IEnumerable <ValidationResult> EnumerateValidationResults(Type documentType, SolrSchema schema) { return(enumerate.Invoke(documentType, schema)); }
protected override string GetOperation(SolrSchema schema) { return(schema.SolrDynamicFields.Find(f => f.Name == Name) != null ? "replace-dynamic-field" : "add-dynamic-field"); }