/// <summary>
/// Throws if collation value is not null and collations are not supported.
/// </summary>
/// <param name="serverVersion">The server version.</param>
/// <param name="value">The value.</param>
public void ThrowIfNotSupported(SemanticVersion serverVersion, Collation value)
{
if (value != null && !base.IsSupported(serverVersion))
{
throw new NotSupportedException($"Server version {serverVersion} does not support collations.");
}
}
public void Collation_get_and_set_should_work()
{
var subject = new AggregateExplainOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
var value = new Collation("en_US");
subject.Collation = value;
var result = subject.Collation;
result.Should().BeSameAs(value);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnCollation_Click(object sender, EventArgs e)
{
var frm = new frmCreateCollation();
UIAssistant.OpenModalForm(frm, false, true);
if (frm.mCollation != null)
{
mCollation = frm.mCollation;
UiHelper.FillDataToTreeView("Collation", trvCollation, mCollation.ToBsonDocument());
}
}
private void cmdOK_Click(object sender, System.EventArgs e)
{
if (string.IsNullOrEmpty(txtLocale.Text))
{
MessageBox.Show("Please Input Locale!");
return;
}
mCollation = new Collation(locale: txtLocale.Text,
caseLevel: chkCaseLevel.Checked,
numericOrdering: chkNumbericOrdering.Checked,
backwards: chkBackwards.Checked,
strength: ((CollationStrength)cmbStrength.SelectedIndex + 1),
maxVariable: (CollationMaxVariable)cmbMaxVariable.SelectedIndex,
alternate: (CollationAlternate)cmbAlternate.SelectedIndex,
caseFirst: (CollationCaseFirst)cmbCaseFirst.SelectedIndex);
Close();
}
ICollationPolicy.Collate(
Collation sender,
Bam.Core.ExecutionContext context)
{
var meta = new MakeFileBuilder.MakeFileMeta(sender);
var rule = meta.AddRule();
rule.AddTarget(Bam.Core.TokenizedString.CreateVerbatim("publish"), isPhony: true);
foreach (var required in sender.Requirements)
{
var requiredMeta = required.MetaData as MakeFileBuilder.MakeFileMeta;
if (null == requiredMeta)
{
continue;
}
foreach (var rules in requiredMeta.Rules)
{
// TODO: only the first?
rule.AddPrerequisite(rules.Targets[0]);
}
}
}
protected override bool TrySetArgument(string name, BsonValue value)
{
switch (name)
{
case "filter":
_filter = (BsonDocument)value;
return(true);
case "replacement":
_replacement = (BsonDocument)value;
return(true);
case "projection":
_options.Projection = (BsonDocument)value;
return(true);
case "sort":
_options.Sort = (BsonDocument)value;
return(true);
case "upsert":
_options.IsUpsert = value.ToBoolean();
return(true);
case "returnDocument":
_options.ReturnDocument = (ReturnDocument)Enum.Parse(typeof(ReturnDocument), value.ToString());
return(true);
case "collation":
_options.Collation = Collation.FromBsonDocument(value.AsBsonDocument);
return(true);
case "hint":
_options.Hint = value;
return(true);
}
return(false);
}
public void CreateCommand_should_return_expected_result_when_Collation_is_set(
[Values("en_US", "fr_CA")]
string locale)
{
var collation = new Collation(locale);
var subject = new AggregateExplainOperation(_collectionNamespace, __pipeline, _messageEncoderSettings)
{
Collation = collation
};
var result = subject.CreateCommand();
var expectedResult = new BsonDocument
{
{ "aggregate", _collectionNamespace.CollectionName },
{ "explain", true },
{ "pipeline", new BsonArray(__pipeline) },
{ "collation", collation.ToBsonDocument() }
};
result.Should().Be(expectedResult);
}
private void DrawCollation(Dims parentDimensions, Collation collation, double height)
{
var x = collation.PosX;
for (var kdx = 0; kdx < collation.CountX; ++kdx)
{
var y = collation.PosY;
for (var ldx = 0; ldx < collation.CountY; ++ldx)
{
var shape = new Shape3D(FormType.Box)
{
Length = parentDimensions.Width,
Breadth = parentDimensions.Depth,
Height = parentDimensions.Height,
X = x,
Y = y,
Z = height
};
this.drawing.Shapes.Add(shape);
}
}
}
private void ParseDeleteArguments(BsonDocument value, out FilterDefinition <BsonDocument> filter, out Collation collation)
{
filter = null;
collation = null;
foreach (BsonElement argument in value["arguments"].AsBsonDocument)
{
switch (argument.Name)
{
case "collation":
collation = Collation.FromBsonDocument(argument.Value.AsBsonDocument);
break;
case "filter":
filter = ParseFilter(argument.Value.AsBsonDocument);
break;
default:
throw new FormatException($"Unexpected argument: {argument.Name}.");
}
}
}
public void Execute_should_work_when_Collation_has_value(
[Values("en_US", "fr_CA")]
string locale,
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.Collation);
DropCollection();
var collation = new Collation(locale);
var requests = new[] { new CreateIndexRequest(new BsonDocument("x", 1))
{
Collation = collation
} };
var subject = new CreateIndexesUsingCommandOperation(_collectionNamespace, requests, _messageEncoderSettings);
ExecuteOperation(subject, async);
var indexes = ListIndexes();
var index = indexes.Single(i => i["name"].AsString == "x_1");
index["collation"]["locale"].AsString.Should().Be(locale);
}
public void Execute_should_return_expected_results_when_Collation_is_set(
[Values(false, true)]
bool caseSensitive,
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.Collation);
EnsureTestData();
var collation = new Collation("en_US", caseLevel: caseSensitive, strength: CollationStrength.Primary);
var filter = BsonDocument.Parse("{ y : 'a' }");
var subject = new MapReduceOperation <BsonDocument>(_collectionNamespace, _mapFunction, _reduceFunction, _resultSerializer, _messageEncoderSettings)
{
Collation = collation,
Filter = filter
};
var cursor = ExecuteOperation(subject, async);
var results = ReadCursorToEnd(cursor, async);
BsonDocument[] expectedResults;
if (caseSensitive)
{
expectedResults = new[]
{
BsonDocument.Parse("{ _id : 1, value : 1 }"),
BsonDocument.Parse("{ _id : 2, value : 4 }")
};
}
else
{
expectedResults = new[]
{
BsonDocument.Parse("{ _id : 1, value : 3 }"),
BsonDocument.Parse("{ _id : 2, value : 4 }")
};
}
results.Should().Equal(expectedResults);
}
protected override bool TrySetArgument(string name, BsonValue value)
{
switch (name)
{
case "filter":
_filter = (BsonDocument)value;
return(true);
case "skip":
_options.Skip = value.ToInt64();
return(true);
case "limit":
_options.Limit = value.ToInt64();
return(true);
case "collation":
_options.Collation = Collation.FromBsonDocument(value.AsBsonDocument);
return(true);
}
return(false);
}
protected override bool TrySetArgument(string name, BsonValue value)
{
switch (name)
{
case "filter":
_filter = (BsonDocument)value;
return(true);
case "projection":
_options.Projection = (BsonDocument)value;
return(true);
case "sort":
_options.Sort = (BsonDocument)value;
return(true);
case "collation":
_options.Collation = Collation.FromBsonDocument(value.AsBsonDocument);
return(true);
}
return(false);
}
ICollationPolicy.Collate(
Collation sender,
Bam.Core.ExecutionContext context)
{
var meta = new MakeFileBuilder.MakeFileMeta(sender);
var rule = meta.AddRule();
rule.AddTarget(Bam.Core.TokenizedString.CreateVerbatim("publish"), isPhony: true);
foreach (var required in sender.Requirements)
{
var requiredMeta = required.MetaData as MakeFileBuilder.MakeFileMeta;
if (null == requiredMeta)
{
continue;
}
foreach (var rules in requiredMeta.Rules)
{
// TODO: only the first?
rule.AddPrerequisite(rules.Targets[0]);
}
}
}
protected override bool TrySetArgument(string name, BsonValue value)
{
switch (name)
{
case "pipeline":
_stages = ((BsonArray)value).Cast <BsonDocument>().ToList();
return(true);
case "allowDiskUse":
_options.AllowDiskUse = value.ToBoolean();
return(true);
case "batchSize":
_options.BatchSize = (int)value;
return(true);
case "collation":
_options.Collation = Collation.FromBsonDocument(value.AsBsonDocument);
return(true);
}
return(false);
}
protected override bool TrySetArgument(string name, BsonValue value)
{
switch (name)
{
case "filter":
_filter = (BsonDocument)value;
return(true);
case "update":
_update = (BsonDocument)value;
return(true);
case "upsert":
_options.IsUpsert = value.ToBoolean();
return(true);
case "collation":
_options.Collation = Collation.FromBsonDocument(value.AsBsonDocument);
return(true);
}
return(false);
}
private void ParseReplaceArguments(
BsonDocument value,
out FilterDefinition <BsonDocument> filter,
out BsonDocument replacement,
out Collation collation,
out bool isUpsert)
{
filter = null;
replacement = null;
collation = null;
isUpsert = false;
foreach (BsonElement argument in value["arguments"].AsBsonDocument)
{
switch (argument.Name)
{
case "collation":
collation = Collation.FromBsonDocument(argument.Value.AsBsonDocument);
break;
case "filter":
filter = ParseFilter(argument.Value.AsBsonDocument);
break;
case "replacement":
replacement = argument.Value.AsBsonDocument;
break;
case "upsert":
isUpsert = argument.Value.ToBoolean();
break;
default:
throw new FormatException($"Unexpected argument: {argument.Name}.");
}
}
}
protected override bool TrySetArgument(string name, BsonValue value)
{
switch (name)
{
case "filter":
_filter = (BsonDocument)value;
return(true);
case "update":
_update = value;
return(true);
case "upsert":
_options.IsUpsert = value.ToBoolean();
return(true);
case "collation":
_options.Collation = Collation.FromBsonDocument(value.AsBsonDocument);
return(true);
case "arrayFilters":
var arrayFilters = new List <ArrayFilterDefinition>();
foreach (BsonDocument arrayFilterDocument in value.AsBsonArray)
{
var arrayFilter = new BsonDocumentArrayFilterDefinition <BsonDocument>(arrayFilterDocument);
arrayFilters.Add(arrayFilter);
}
_options.ArrayFilters = arrayFilters;
return(true);
case "hint":
_options.Hint = value;
return(true);
}
return(false);
}
public void Execute_should_return_expected_results_when_Collation_is_set(
[Values(false, true)]
bool caseSensitive,
[Values(false, true)]
bool async)
{
RequireServer.Check().ClusterTypes(ClusterType.Standalone, ClusterType.ReplicaSet).Supports(Feature.Collation);
EnsureTestData();
var collation = new Collation("en_US", caseLevel: caseSensitive, strength: CollationStrength.Primary);
var filter = BsonDocument.Parse("{ y : 'a' }");
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings)
{
Collation = collation,
Filter = filter
};
ExecuteOperation(subject, async);
BsonDocument[] expectedResults;
if (caseSensitive)
{
expectedResults = new[]
{
BsonDocument.Parse("{ _id : 1, value : 1 }"),
BsonDocument.Parse("{ _id : 2, value : 4 }")
};
}
else
{
expectedResults = new[]
{
BsonDocument.Parse("{ _id : 1, value : 3 }"),
BsonDocument.Parse("{ _id : 2, value : 4 }")
};
}
ReadAllFromCollection(_outputCollectionNamespace).Should().Equal(expectedResults);
}
public void Execute_should_return_expected_result_when_Collation_is_set(
[Values(false, true)]
bool caseSensitive,
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.Collation);
EnsureTestData();
var collation = new Collation("en_US", caseLevel: caseSensitive, strength: CollationStrength.Primary);
var filter = BsonDocument.Parse("{ y : 'a' }");
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, filter, _messageEncoderSettings)
{
Collation = collation
};
var result = ExecuteOperation(subject, async);
BsonDocument[] expectedResult;
if (caseSensitive)
{
expectedResult = new[]
{
BsonDocument.Parse("{ x : 1, count : 2 }"),
BsonDocument.Parse("{ x : 3, count : 2 }")
};
}
else
{
expectedResult = new[]
{
BsonDocument.Parse("{ x : 1, count : 2 }"),
BsonDocument.Parse("{ x : 2, count : 1 }"),
BsonDocument.Parse("{ x : 3, count : 3 }")
};
}
result.Should().Equal(expectedResult);
}
// methods
internal override BsonDocument CreateCommand(ICoreSessionHandle session, ConnectionDescription connectionDescription, long?transactionNumber)
{
var serverVersion = connectionDescription.ServerVersion;
Feature.Collation.ThrowIfNotSupported(serverVersion, Collation);
var writeConcern = WriteConcernHelper.GetWriteConcernForCommand(session, WriteConcern, serverVersion, Feature.FindAndModifyWriteConcern);
return(new BsonDocument
{
{ "findAndModify", CollectionNamespace.CollectionName },
{ "query", _filter },
{ "update", _replacement },
{ "new", true, _returnDocument == ReturnDocument.After },
{ "sort", _sort, _sort != null },
{ "fields", _projection, _projection != null },
{ "upsert", true, _isUpsert },
{ "maxTimeMS", () => MaxTimeHelper.ToMaxTimeMS(_maxTime.Value), _maxTime.HasValue },
{ "writeConcern", writeConcern, writeConcern != null },
{ "bypassDocumentValidation", () => _bypassDocumentValidation.Value, _bypassDocumentValidation.HasValue&& Feature.BypassDocumentValidation.IsSupported(serverVersion) },
{ "collation", () => Collation.ToBsonDocument(), Collation != null },
{ "txnNumber", () => transactionNumber, transactionNumber.HasValue }
});
}
public void Equals_should_compare_normalization_fields(
[Values(null, false, true)]
bool? lhsNormalization,
[Values(null, false, true)]
bool? rhsNormalization)
{
var lhs = new Collation("en_US", normalization: lhsNormalization);
var rhs = new Collation("en_US", normalization: rhsNormalization);
Equals_Act_and_Assert(lhs, rhs, lhsNormalization == rhsNormalization);
}
public void With_should_return_expected_result(
[Values("en_US", "fr_CA")]
string locale)
{
var subject = new Collation(locale);
var result = subject.With();
result.Should().Be(subject);
}
internal SqlDropCollation(Collation collation) : base(SqlNodeType.Drop)
{
this.collation = collation;
}
public void With_should_return_expected_result_when_backwards_is_set(
[Values(null, false, true)]
bool? originalBackwards,
[Values(null, false, true)]
bool? backwards)
{
var subject = new Collation("en_US", backwards: originalBackwards);
var result = subject.With(backwards: backwards);
result.Backwards.Should().Be(backwards);
result.With(backwards: originalBackwards).Should().Be(subject);
}
/// <summary>
/// Deletes matching entities with an expression
/// <para>HINT: If the expression matches more than 100,000 entities, they will be deleted in batches of 100k.</para>
/// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
/// </summary>
/// <typeparam name="T">Any class that implements IEntity</typeparam>
/// <param name="expression">A lambda expression for matching entities to delete.</param>
/// <param name = "session" >An optional session if using within a transaction</param>
/// <param name="cancellation">An optional cancellation token</param>
/// <param name="collation">An optional collation object</param>
public static Task <DeleteResult> DeleteAsync <T>(Expression <Func <T, bool> > expression, IClientSessionHandle session = null, CancellationToken cancellation = default, Collation collation = null) where T : IEntity
{
return(DeleteAsync(Builders <T> .Filter.Where(expression), session, cancellation, collation));
}
/// <summary>
/// Deletes matching entities with a filter definition
/// <para>HINT: If the expression matches more than 100,000 entities, they will be deleted in batches of 100k.</para>
/// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
/// </summary>
/// <typeparam name="T">Any class that implements IEntity</typeparam>
/// <param name="filter">A filter definition for matching entities to delete.</param>
/// <param name = "session" >An optional session if using within a transaction</param>
/// <param name="cancellation">An optional cancellation token</param>
/// <param name="collation">An optional collation object</param>
public static async Task <DeleteResult> DeleteAsync <T>(FilterDefinition <T> filter, IClientSessionHandle session = null, CancellationToken cancellation = default, Collation collation = null) where T : IEntity
{
ThrowIfCancellationNotSupported(session, cancellation);
var cursor = await new Find <T, string>(session, null)
.Match(_ => filter)
.Project(e => e.ID)
.Option(o => o.BatchSize = deleteBatchSize)
.Option(o => o.Collation = collation)
.ExecuteCursorAsync(cancellation)
.ConfigureAwait(false);
long deletedCount = 0;
DeleteResult res = null;
using (cursor)
{
while (await cursor.MoveNextAsync(cancellation).ConfigureAwait(false))
{
if (cursor.Current.Any())
{
res = await DeleteCascadingAsync <T>(cursor.Current, session, cancellation).ConfigureAwait(false);
deletedCount += res.DeletedCount;
}
}
}
if (res?.IsAcknowledged == false)
{
return(DeleteResult.Unacknowledged.Instance);
}
return(new DeleteResult.Acknowledged(deletedCount));
}
public void ToBsonDocument_should_return_expected_result_when_caseFirst_is_set(
[Values("en_US", "fr_CA")]
string locale,
[Values(null, CollationCaseFirst.Lower, CollationCaseFirst.Upper)]
CollationCaseFirst? caseFirst)
{
var subject = new Collation(locale, caseFirst: caseFirst);
var result = subject.ToBsonDocument();
var json = subject.ToString();
var expectedResult = new BsonDocument
{
{ "locale", locale },
{ "caseFirst", () => Collation.ToString(caseFirst.Value), caseFirst.HasValue }
};
result.Should().Be(expectedResult);
json.Should().Be(expectedResult.ToJson());
}
/// <inheritdoc/>
/// <exception cref="NotSupportedException">Method is not supported.</exception>
protected override IPathNode VisitCollation(Collation collation)
{
throw new NotSupportedException();
}
public void With_should_return_expected_result_when_maxVariable_is_set(
[Values(null, CollationMaxVariable.Punctuation, CollationMaxVariable.Space)]
CollationMaxVariable? originalMaxVariable,
[Values(null, CollationMaxVariable.Punctuation, CollationMaxVariable.Space)]
CollationMaxVariable? maxVariable)
{
var subject = new Collation("en_US", maxVariable: originalMaxVariable);
var result = subject.With(maxVariable: maxVariable);
result.MaxVariable.Should().Be(maxVariable);
result.With(maxVariable: originalMaxVariable).Should().Be(subject);
}
public void ToBsonDocument_should_return_expected_result_when_caseLevel_is_set(
[Values("en_US", "fr_CA")]
string locale,
[Values(null, false, true)]
bool? caseLevel)
{
var subject = new Collation(locale, caseLevel: caseLevel);
var result = subject.ToBsonDocument();
var json = subject.ToString();
var expectedResult = new BsonDocument
{
{ "locale", locale },
{ "caseLevel", () => caseLevel.Value, caseLevel.HasValue }
};
result.Should().Be(expectedResult);
json.Should().Be(expectedResult.ToJson());
}
public void With_should_return_expected_result_when_locale_is_set(
[Values("en_US", "fr_CA")]
string originalLocale,
[Values("en_US", "fr_CA")]
string locale)
{
var subject = new Collation(originalLocale);
var result = subject.With(locale: locale);
result.Locale.Should().Be(locale);
result.With(locale: originalLocale).Should().Be(subject);
}
public void With_should_return_expected_result_when_caseLevel_is_set(
[Values(null, false, true)]
bool? originalCaseLevel,
[Values(null, false, true)]
bool? caseLevel)
{
var subject = new Collation("en_US", caseLevel: originalCaseLevel);
var result = subject.With(caseLevel: caseLevel);
result.CaseLevel.Should().Be(caseLevel);
result.With(caseLevel: originalCaseLevel).Should().Be(subject);
}
public void With_should_return_expected_result_when_caseFirst_is_set(
[Values(null, CollationCaseFirst.Lower, CollationCaseFirst.Upper)]
CollationCaseFirst? originalCaseFirst,
[Values(null, CollationCaseFirst.Lower, CollationCaseFirst.Upper)]
CollationCaseFirst? caseFirst)
{
var subject = new Collation("en_US", caseFirst: originalCaseFirst);
var result = subject.With(caseFirst: caseFirst);
result.CaseFirst.Should().Be(caseFirst);
result.With(caseFirst: originalCaseFirst).Should().Be(subject);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnClearCollation_Click(object sender, EventArgs e)
{
mCollation = null;
trvCollation.Clear();
}
/// <summary>
/// Create a new TypeSpecification object.
/// </summary>
/// <param name="typeName">Initial value of TypeName.</param>
/// <param name="collation">Initial value of Collation.</param>
/// <param name="characterSet">Initial value of CharacterSet.</param>
/// <param name="isMultiSet">Initial value of IsMultiSet.</param>
public static TypeSpecification CreateTypeSpecification(string typeName, Collation collation, CharacterSet characterSet, bool isMultiSet)
{
TypeSpecification typeSpecification = new TypeSpecification();
typeSpecification.TypeName = typeName;
typeSpecification.Collation = global::System.Data.Objects.DataClasses.StructuralObject.VerifyComplexObjectIsNotNull(collation, "Collation");
typeSpecification.CharacterSet = global::System.Data.Objects.DataClasses.StructuralObject.VerifyComplexObjectIsNotNull(characterSet, "CharacterSet");
typeSpecification.IsMultiSet = isMultiSet;
return typeSpecification;
}
public void ToBsonDocument_should_return_expected_result_when_numericOrdering_is_set(
[Values("en_US", "fr_CA")]
string locale,
[Values(null, false, true)]
bool? numericOrdering)
{
var subject = new Collation(locale, numericOrdering: numericOrdering);
var result = subject.ToBsonDocument();
var json = subject.ToString();
var expectedResult = new BsonDocument
{
{ "locale", locale },
{ "numericOrdering", () => numericOrdering.Value, numericOrdering.HasValue }
};
result.Should().Be(expectedResult);
json.Should().Be(expectedResult.ToJson());
}
public void ToBsonDocument_should_return_expected_result_when_backwards_is_set(
[Values("en_US", "fr_CA")]
string locale,
[Values(null, false, true)]
bool? backwards)
{
var subject = new Collation(locale, backwards: backwards);
var result = subject.ToBsonDocument();
var json = subject.ToString();
var expectedResult = new BsonDocument
{
{ "locale", locale },
{ "backwards", () => backwards.Value, backwards.HasValue }
};
result.Should().Be(expectedResult);
json.Should().Be(expectedResult.ToJson());
}
public void Equals_should_compare_strenght_fields(
[Values(null, CollationStrength.Primary, CollationStrength.Identical)]
CollationStrength? lhsStrength,
[Values(null, CollationStrength.Primary, CollationStrength.Identical)]
CollationStrength? rhsStrength)
{
var lhs = new Collation("en_US", strength: lhsStrength);
var rhs = new Collation("en_US", strength: rhsStrength);
Equals_Act_and_Assert(lhs, rhs, lhsStrength == rhsStrength);
}
public void Execute_should_return_expected_result_when_Collation_is_set(
[Values(false, true)]
bool caseSensitive,
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.Aggregate, Feature.Collation);
EnsureTestData();
var collation = new Collation("en_US", caseLevel: caseSensitive, strength: CollationStrength.Primary);
var subject = new AggregateOperation<BsonDocument>(_collectionNamespace, __pipeline, __resultSerializer, _messageEncoderSettings)
{
Collation = collation
};
var cursor = ExecuteOperation(subject, async);
var result = ReadCursorToEnd(cursor, async);
result.Should().NotBeNull();
result.Should().HaveCount(caseSensitive ? 1 : 2);
}
/// <summary>
/// Deletes matching entities with a filter expression
/// <para>HINT: If the expression matches more than 100,000 entities, they will be deleted in batches of 100k.</para>
/// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
/// </summary>
/// <typeparam name="T">Any class that implements IEntity</typeparam>
/// <param name="filter">f => f.Eq(x => x.Prop, Value) & f.Gt(x => x.Prop, Value)</param>
/// <param name = "session" >An optional session if using within a transaction</param>
/// <param name="cancellation">An optional cancellation token</param>
/// <param name="collation">An optional collation object</param>
public static Task <DeleteResult> DeleteAsync <T>(Func <FilterDefinitionBuilder <T>, FilterDefinition <T> > filter, IClientSessionHandle session = null, CancellationToken cancellation = default, Collation collation = null) where T : IEntity
{
return(DeleteAsync(filter(Builders <T> .Filter), session, cancellation, collation));
}
/// <summary>
/// Deletes matching entities from MongoDB
/// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
/// <para>TIP: Try to keep the number of entities to delete under 100 in a single call</para>
/// </summary>
/// <typeparam name="T">The type of entity</typeparam>
/// <param name="expression">A lambda expression for matching entities to delete.</param>
/// <param name="cancellation">An optional cancellation token</param>
/// <param name="collation">An optional collation object</param>
/// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
public Task <DeleteResult> DeleteAsync <T>(Expression <Func <T, bool> > expression, CancellationToken cancellation = default, Collation collation = null, bool ignoreGlobalFilters = false) where T : IEntity
{
return(DB.DeleteAsync(
Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, Builders <T> .Filter.Where(expression)),
Session,
cancellation,
collation));
}
/// <summary>
/// 构造方法会自动建立所需要的索引
/// </summary>
/// <param name="settings"></param>
/// <param name="colname">mongodb里article集合的名称</param>
/// <param name="mapper"></param>
/// <param name="logService">用来获取点赞、收藏信息的LogService</param>
/// <param name="esClient">如果不用es，手动传入null</param>
/// <param name="userService"></param>
/// <param name="imageService">imageservice只有word上传用到了，不准备使用word上传功能的话可以设为null</param>
/// <param name="readlogService">用来获得用户阅读信息的logservice，可以和之前的logservice相同</param>
/// <param name="getSearchFromArticle">把article映射到articlesearch的函数</param>
/// <param name="mapArticleToBrief">把article映射成brief的函数</param>
public IntergratedArticleService(IBaseDbSettings settings, string colname, IMapper mapper,
ILogService <TUserBrief> logService, IElasticClient esClient, IUserService <TUser> userService
, IImageService imageService, ILogService <TUserBrief> readlogService
, Func <TArticle, TArticleSearch> getSearchFromArticle, Expression <Func <TArticle, TArticleFeed> > mapArticleToBrief)
: base(settings.ConnectionString, settings.DatabaseName, colname)
{
this.getSearchFromArticle = getSearchFromArticle;
this.mapArticleToBrief = mapArticleToBrief;
this.readlogService = readlogService;
enableEs = esClient != null;
client = esClient;
allowedTags = HtmlSanitizer.DefaultAllowedTags.ToList();
allowedTags.Add("audio");
allowedTags.Add("svg");
allowedTags.Add("source");
allowedTags.Add("style");
allowedTags.Add("path");
allowedTags.Add("iframe");
allowedTags.Add("img");
allowedTags.Add("blockquote");
allowedTags.Add("span");
allowedTags.Add("center");
this.userService = userService;
this.logService = logService;
pipeline = new MarkdownPipelineBuilder()
.UseAdvancedExtensions()
.UseDiagrams()
.UseEmphasisExtras()
.UseEmojiAndSmiley()
.UseGridTables()
.UsePipeTables()
//.UseMathematics()
.UseMediaLinks()
.UseAutoLinks()
.UseFigures()
.UseFooters()
.UseFootnotes()
.Build();
Collation _caseInsensitiveCollation = new Collation("en", strength: CollationStrength.Primary);
this.imageService = imageService;
this.mapper = mapper;
createIndex:
try
{
collection.Indexes.CreateOne(new CreateIndexModel <TArticle>(Builders <TArticle> .IndexKeys.Ascending(l => l.Stars)));
collection.Indexes.CreateOne(new CreateIndexModel <TArticle>(Builders <TArticle> .IndexKeys.Ascending(l => l.Awesomes)));
collection.Indexes.CreateOne(new CreateIndexModel <TArticle>(Builders <TArticle> .IndexKeys.Ascending(l => l.IsDraft)));
collection.Indexes.CreateOne(new CreateIndexModel <TArticle>(Builders <TArticle> .IndexKeys.Ascending(l => l.AuthorBrief.Id)));
collection.Indexes.CreateOne(new CreateIndexModel <TArticle>(Builders <TArticle> .IndexKeys.Ascending(l => l.Visibility)));
collection.Indexes.CreateOne(new CreateIndexModel <TArticle>(Builders <TArticle> .IndexKeys.Ascending(l => l.KeyWords),
new CreateIndexOptions()
{
Collation = _caseInsensitiveCollation
}));
collection.Indexes.CreateOne(new CreateIndexModel <TArticle>(Builders <TArticle> .IndexKeys.Ascending(l => l.ProjectId)));
collection.Indexes.CreateOne(new CreateIndexModel <TArticle>(Builders <TArticle> .IndexKeys.Ascending(l => l.Saved)));
collection.Indexes.CreateOne(new CreateIndexModel <TArticle>(Builders <TArticle> .IndexKeys.Ascending(l => l.ArticleId)));
collection.Indexes.CreateOne(new CreateIndexModel <TArticle>(Builders <TArticle> .IndexKeys.Ascending(l => l.Score)));
collection.Indexes.CreateOne(new CreateIndexModel <TArticle>(Builders <TArticle> .IndexKeys.Ascending(l => l.Examined)));
collection.Indexes.CreateOne(new CreateIndexModel <TArticle>(Builders <TArticle> .IndexKeys.Ascending(l => l.Tokens),
new CreateIndexOptions()
{
Collation = _caseInsensitiveCollation
}));
collection.Indexes.CreateOne(new CreateIndexModel <TArticle>(Builders <TArticle> .IndexKeys.Ascending(l => l.ManagedId)));
}
catch (Exception)
{
collection.Indexes.DropAll();
goto createIndex;
}
Config config = new Config();
// 设置上传区域
config.Zone = Zone.ZONE_CN_East;
// 设置 http 或者 https 上传
config.UseHttps = true;
config.UseCdnDomains = true;
config.ChunkSize = ChunkUnit.U512K;
target = new ResumableUploader(config);
var attrs = new[]
{
"style",
"class",
"href",
"alt",
"src",
"controls",
"id",
"preserveAspectRatio",
"d",
"viewBox",
"width",
"height",
"title",
"data-formula",
"aria-hidden",
};
foreach (var item in attrs)
{
HtmlSanitizer.DefaultAllowedAttributes.Add(item);
}
sanitizer = new HtmlSanitizer(allowedTags, allowedAttributes: HtmlSanitizer.DefaultAllowedAttributes);
//StartReportService();
//StartElastic();
}
public void Equals_should_compare_numericOrdering_fields(
[Values(null, false, true)]
bool? lhsNumericOrdering,
[Values(null, false, true)]
bool? rhsNumericOrdering)
{
var lhs = new Collation("en_US", numericOrdering: lhsNumericOrdering);
var rhs = new Collation("en_US", numericOrdering: rhsNumericOrdering);
Equals_Act_and_Assert(lhs, rhs, lhsNumericOrdering == rhsNumericOrdering);
}
public void Execute_should_throw_when_Collation_is_set_but_not_supported(
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.Aggregate).DoesNotSupport(Feature.Collation);
var collation = new Collation("en_US");
var subject = new AggregateOperation<BsonDocument>(_collectionNamespace, __pipeline, __resultSerializer, _messageEncoderSettings)
{
Collation = collation
};
var exception = Record.Exception(() => ExecuteOperation(subject, async));
exception.Should().BeOfType<NotSupportedException>();
}
public void With_should_return_expected_result_when_alternate_is_set(
[Values(null, CollationAlternate.NonIgnorable, CollationAlternate.Shifted)]
CollationAlternate? originalAlternate,
[Values(null, CollationAlternate.NonIgnorable, CollationAlternate.Shifted)]
CollationAlternate? alternate)
{
var subject = new Collation("en_US", alternate: originalAlternate);
var result = subject.With(alternate: alternate);
result.Alternate.Should().Be(alternate);
result.With(alternate: originalAlternate).Should().Be(subject);
}
/// <summary>
/// Deletes matching entities with a filter definition
/// <para>HINT: If the expression matches more than 100,000 entities, they will be deleted in batches of 100k.</para>
/// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
/// </summary>
/// <typeparam name="T">Any class that implements IEntity</typeparam>
/// <param name="filter">A filter definition for matching entities to delete.</param>
/// <param name="cancellation">An optional cancellation token</param>
/// <param name="collation">An optional collation object</param>
/// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
public Task <DeleteResult> DeleteAsync <T>(FilterDefinition <T> filter, CancellationToken cancellation = default, Collation collation = null, bool ignoreGlobalFilters = false) where T : IEntity
{
return(DB.DeleteAsync(
Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, filter),
Session,
cancellation,
collation));
}
public void ToBsonDocument_should_return_expected_result_when_alternate_is_set(
[Values("en_US", "fr_CA")]
string locale,
[Values(null, CollationAlternate.NonIgnorable, CollationAlternate.Shifted)]
CollationAlternate? alternate)
{
var subject = new Collation(locale, alternate: alternate);
var result = subject.ToBsonDocument();
var json = subject.ToString();
var expectedResult = new BsonDocument
{
{ "locale", locale },
{ "alternate", () => Collation.ToString(alternate.Value), alternate.HasValue }
};
result.Should().Be(expectedResult);
json.Should().Be(expectedResult.ToJson());
}
public QueryOptimization(Snapshot snapshot, Query query, IEnumerable<BsonDocument> source, Collation collation)
{
if (query.Select == null) throw new ArgumentNullException(nameof(query.Select));
_snapshot = snapshot;
_query = query;
_collation = collation;
_queryPlan = new QueryPlan(snapshot.CollectionName)
{
// define index only if source are external collection
Index = source != null ? new IndexVirtual(source) : null,
Select = new Select(_query.Select, _query.Select.UseSource),
ForUpdate = query.ForUpdate,
Limit = query.Limit,
Offset = query.Offset
};
}
public SortContainer(Collation collation, int size)
{
_collation = collation;
_size = size;
}
public void ToBsonDocument_should_return_expected_result(
[Values("en_US", "fr_CA")]
string locale)
{
var subject = new Collation(locale);
var result = subject.ToBsonDocument();
var json = subject.ToString();
var expectedResult = new BsonDocument("locale", locale);
result.Should().Be(expectedResult);
json.Should().Be(expectedResult.ToJson());
}
public void ToBsonDocument_should_return_expected_result_when_strength_is_set(
[Values("en_US", "fr_CA")]
string locale,
[Values(null, CollationStrength.Primary, CollationStrength.Identical)]
CollationStrength? strength)
{
var subject = new Collation(locale, strength: strength);
var result = subject.ToBsonDocument();
var json = subject.ToString();
var expectedResult = new BsonDocument
{
{ "locale", locale },
{ "strength", () => Collation.ToInt32(strength.Value), strength.HasValue }
};
result.Should().Be(expectedResult);
json.Should().Be(expectedResult.ToJson());
}
/// <inheritdoc/>
public override string Translate(Collation collation)
{
return(collation.DbName);
}
/// <summary>
/// Sets the collation.
/// </summary>
/// <param name="value">The collation.</param>
/// <returns>The builder (so method calls can be chained).</returns>
public CollectionOptionsBuilder SetCollation(Collation value)
{
_document["collation"] = value.ToBsonDocument();
return(this);
}
public void Culture_Ordinal_Sort()
{
// 1046 = pt-BR
var collation = new Collation(1046, CompareOptions.IgnoreCase);
var s = new EngineSettings
{
DataStream = new MemoryStream()
};
var names = new string[] { "Ze", "Ana", "Ána", "Ánã", "Ana Paula", "ana lucia" };
var sortByLinq = names.OrderBy(x => x, collation).ToArray();
var findByLinq = names.Where(x => collation.Compare(x, "ANA") == 0).ToArray();
using (var e = new LiteEngine(s))
{
//e.Rebuild(new RebuildOptions { Collation = collation });
e.Insert("col1", names.Select(x => new BsonDocument {
["name"] = x
}), BsonAutoId.Int32);
// sort by merge sort
var sortByOrderByName = e.Query("col1", new Query {
OrderBy = "name"
})
.ToEnumerable()
.Select(x => x["name"].AsString)
.ToArray();
var query = new Query();
query.Where.Add("name = 'ANA'");
// find by expression
var findByExpr = e.Query("col1", query)
.ToEnumerable()
.Select(x => x["name"].AsString)
.ToArray();
sortByOrderByName.Should().BeEquivalentTo(sortByLinq);
findByExpr.Should().BeEquivalentTo(findByLinq);
// index test
e.EnsureIndex("col1", "idx_name", "name", false);
// sort by index
var sortByIndexName = e.Query("col1", new Query {
OrderBy = "name"
})
.ToEnumerable()
.Select(x => x["name"].AsString)
.ToArray();
// find by index
var findByIndex = e.Query("col1", query)
.ToEnumerable()
.Select(x => x["name"].AsString)
.ToArray();
sortByIndexName.Should().BeEquivalentTo(sortByLinq);
findByIndex.Should().BeEquivalentTo(findByLinq);
}
}
/// <summary>
/// Sets the collation.
/// </summary>
/// <param name="value">The collation.</param>
/// <returns>The builder (so method calls can be chained).</returns>
public static CollectionOptionsBuilder SetCollation(Collation value)
{
return(new CollectionOptionsBuilder().SetCollation(value));
}
public void CreateCollation(string name, Collation collation)
{
name = name.ToUpperInvariant();
var nativeCollation = new CollationNative((applicationData, firstLength, firstString, secondLength, secondString) =>
{
var first = this.platformMarshal.MarshalStringNativeUTF8ToManaged(firstString);
var second = this.platformMarshal.MarshalStringNativeUTF8ToManaged(secondString);
try
{
return collation.Invoke(first, second);
}
catch
{
return 0;
}
});
var collationDelegate = this.platformMarshal.ApplyNativeCallingConventionToCollation(nativeCollation);
this.collationDelegates[name] = collationDelegate;
var collPtr = this.platformMarshal.MarshalDelegateToNativeFunctionPointer(collationDelegate);
int nameLength;
var namePtr = this.platformMarshal.MarshalStringManagedToNativeUTF8(name, out nameLength);
try
{
this.sqlite3Provider.Sqlite3CreateCollation(this.db, namePtr, collPtr);
}
finally
{
if (namePtr != IntPtr.Zero)
{
this.platformMarshal.CleanUpStringNativeUTF8(namePtr);
}
}
}
public void ToBsonDocument_should_return_expected_result_when_maxVariable_is_set(
[Values("en_US", "fr_CA")]
string locale,
[Values(null, CollationMaxVariable.Punctuation, CollationMaxVariable.Space)]
CollationMaxVariable? maxVariable)
{
var subject = new Collation(locale, maxVariable: maxVariable);
var result = subject.ToBsonDocument();
var json = subject.ToString();
var expectedResult = new BsonDocument
{
{ "locale", locale },
{ "maxVariable", () => Collation.ToString(maxVariable.Value), maxVariable.HasValue }
};
result.Should().Be(expectedResult);
json.Should().Be(expectedResult.ToJson());
}
partial void OnCollationChanging(Collation value);
public void Collation_get_and_set_should_work()
{
var subject = new AggregateOperation<BsonDocument>(_collectionNamespace, __pipeline, __resultSerializer, _messageEncoderSettings);
var collation = new Collation("en_US");
subject.Collation = collation;
var result = subject.Collation;
result.Should().BeSameAs(collation);
}
