public void TestMultipleMIALikeFilter()
{
MultipleTestMIA mia1 = TestBackendUtils.CreateMultipleMIA("Meta1", Cardinality.Inline, true, true);
IFilter filter = new LikeFilter(mia1.ATTR_STRING, "%", null);
ICollection <MediaItemAspectMetadata> requiredMIATypes = new List <MediaItemAspectMetadata>();
requiredMIATypes.Add(mia1.Metadata);
IList <object> parts = new List <object>();
IList <BindVar> bindVars = new List <BindVar>();
MockCompiledFilter compiledFilter = new MockCompiledFilter();
compiledFilter.test(MockCore.Management, filter, null, requiredMIATypes, "test", null, parts, bindVars);
//Console.WriteLine("Parts [{0}]", string.Join(",", parts));
//Console.WriteLine("Part 7 " + parts[7].GetType());
//Console.WriteLine("Bind vars [{0}]", string.Join(",", bindVars));
Assert.AreEqual(new List <object> {
"test", " IN(",
"SELECT ", "MEDIA_ITEM_ID", " FROM ", "M_META1", " WHERE ", "ATTR_STRING", " LIKE ", "@V0", ")"
}, parts, "Parts");
Assert.AreEqual(new List <BindVar> {
new BindVar("V0", "%", typeof(string))
}, bindVars, "Bind vars");
}
public void TestToString()
{
var propertyName = "S";
var filter = new LikeFilter <LinqFilterTestClass>(propertyName, "hello");
Assert.IsNotNull(filter.ToString());
}
public int GetSeriesCount()
{
Guid[] types = new Guid[] { SeriesAspect.ASPECT_ID };
IFilter filter = new LikeFilter(SeriesAspect.ATTR_SERIES_NAME, "%", null, false);
return(GetContentDirectory().CountMediaItemsAsync(types, filter, true, true).Result);
}
public int GetVideoCount()
{
Guid[] types = new Guid[] { VideoStreamAspect.ASPECT_ID };
IFilter filter = new LikeFilter(MediaAspect.ATTR_TITLE, "%", null, false);
return(GetContentDirectory().CountMediaItemsAsync(types, filter, true, true).Result);
}
public void TestSingleMIALikeFilter()
{
SingleTestMIA mia1 = TestCommonUtils.CreateSingleMIA("Meta1", Cardinality.Inline, true, true);
IFilter filter = new LikeFilter(mia1.ATTR_STRING, "%", null);
ICollection <MediaItemAspectMetadata> requiredMIATypes = new List <MediaItemAspectMetadata>();
requiredMIATypes.Add(mia1.Metadata);
IList <object> parts = new List <object>();
IList <BindVar> bindVars = new List <BindVar>();
MockCompiledFilter compiledFilter = new MockCompiledFilter();
compiledFilter.test(MockCore.Management, filter, null, requiredMIATypes, "test", null, parts, bindVars);
//Console.WriteLine("Parts [{0}]", string.Join(",", parts));
//Console.WriteLine("Bind vars [{0}]", string.Join(",", bindVars));
Assert.AreEqual(new List <object> {
new QueryAttribute(mia1.ATTR_STRING), " LIKE ", "@V0"
}, parts, "Parts");
Assert.AreEqual(new List <BindVar> {
new BindVar("V0", "%", typeof(string))
}, bindVars, "Bind vars");
}
public void TestUPnPSongArtistContains()
{
string text = "(upnp:class derivedfrom \"object.item.audioItem\" and (dc:creator contains \"four\" or upnp:artist contains \"five \\\" six\"))";
SearchExp exp = SearchParser.Parse(text);
IList <Guid> types = new List <Guid>();
IFilter filter = SearchParser.Convert(exp, types);
Console.WriteLine(text + " -> filter=" + filter + " types=[" + string.Join(",", types) + "]");
Assert.Contains(AudioAspect.ASPECT_ID, (ICollection)types, "Types");
Assert.IsTrue(filter is BooleanCombinationFilter, "Top level");
BooleanCombinationFilter topFilter = filter as BooleanCombinationFilter;
Assert.AreEqual(BooleanOperator.Or, topFilter.Operator, "Top level operator");
Assert.IsTrue(topFilter.Operands is IList <IFilter>, "Top level");
IList <IFilter> operands = (IList <IFilter>)topFilter.Operands;
Assert.IsTrue(operands[0] is LikeFilter, "First operand");
LikeFilter filter1 = (LikeFilter)operands[0];
Assert.AreEqual(AudioAspect.ATTR_ARTISTS, filter1.AttributeType, "Attribute");
Assert.AreEqual("%four%", filter1.Expression, "Expression");
Assert.IsTrue(operands[0] is LikeFilter, "Second operand");
LikeFilter filter2 = (LikeFilter)operands[1];
Assert.AreEqual(AudioAspect.ATTR_ARTISTS, filter2.AttributeType, "Attribute");
Assert.AreEqual("%five \" six%", filter2.Expression, "Expression");
}
public void Constructor_WithValues_PropertiesAreSet()
{
var filter = new LikeFilter("test_dimension", "foo*");
Assert.That(filter.Dimension, Is.EqualTo("test_dimension"));
Assert.That(filter.Pattern, Is.EqualTo("foo*"));
Assert.That(filter.Escape, Is.Null);
}
internal static async Task <MediaItem> GetMediaItemByFileNameAsync(Guid?userId, string path)
{
string fileName = Path.GetFileName(path);
IFilter searchFilter = new LikeFilter(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH, "%" + SqlUtils.LikeEscape(fileName, '\\'), '\\', false);
IList <MediaItem> items = await GetMediaItemsAsync(userId, searchFilter, 1);
return(items.FirstOrDefault());
}
/// <summary>
/// Generates the text for a LikeFilter builder.
/// </summary>
/// <param name="item">The LikeFilter builder to generate the text for.</param>
protected internal override void VisitLikeFilter(LikeFilter item)
{
StringBuilder operationBuilder = new StringBuilder();
if (item.Not)
{
operationBuilder.Append("NOT ");
}
operationBuilder.Append("LIKE");
visitOrderedFilter(item, operationBuilder.ToString());
}
public IList <MediaItem> SearchSeries(string text)
{
Guid[] types = new Guid[] { MediaAspect.ASPECT_ID, VideoStreamAspect.ASPECT_ID };
IFilter titleFilter = new LikeFilter(MediaAspect.ATTR_TITLE, string.Format("%{0}%", text), null, false);
IFilter actorsFilter = new LikeFilter(VideoAspect.ATTR_ACTORS, string.Format("%{0}%", text), null, false);
IFilter directorsFilter = new LikeFilter(VideoAspect.ATTR_DIRECTORS, string.Format("%{0}%", text), null, false);
IFilter writersFilter = new LikeFilter(VideoAspect.ATTR_WRITERS, string.Format("%{0}%", text), null, false);
IFilter episodeFilter = new LikeFilter(EpisodeAspect.ATTR_EPISODE_NAME, string.Format("%{0}%", text), null, false);
IFilter seriesFilter = new LikeFilter(EpisodeAspect.ATTR_SERIES_NAME, string.Format("%{0}%", text), null, false);
IFilter filter = new BooleanCombinationFilter(BooleanOperator.Or, new IFilter[] { titleFilter, actorsFilter, directorsFilter, writersFilter, episodeFilter, seriesFilter });
return(GetContentDirectory().SearchAsync(new MediaItemQuery(types, new Guid[] { SeriesAspect.ASPECT_ID }, filter), true, null, true).Result);
}
public void TestConfigPofContextException()
{
LikeFilter filter = new LikeFilter("field", "goran", '\\', false);
SimplePofContext ctx = new SimplePofContext();
BinaryPofSerializer serializer = new BinaryPofSerializer(1);
ctx.RegisterUserType(1, filter.GetType(), serializer);
Stream stream = new MemoryStream();
ctx.Serialize(new DataWriter(stream), filter);
}
public void TestRemove()
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlDocument config = XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-local-cache-config.xml");
ccf.Config = config;
INamedCache cache = CacheFactory.GetCache("local-default");
cache.Clear();
Hashtable ht = new Hashtable();
ht.Add("conditionalPutAllKey1", 435);
ht.Add("conditionalPutAllKey2", 253);
ht.Add("conditionalPutAllKey3", 200);
ht.Add("conditionalPutAllKey4", 333);
cache.InsertAll(ht);
IFilter greaterThen300 = new GreaterFilter(IdentityExtractor.Instance, 300);
IFilter lessThen300 = new LessFilter(IdentityExtractor.Instance, 300);
IFilter key3 = new LikeFilter(new KeyExtractor(IdentityExtractor.Instance), "%Key3", '\\', false);
Assert.IsTrue(cache.Count == 4);
// remove key1 with greaterThen300 filter applied
ConditionalRemove processor = new ConditionalRemove(greaterThen300, false);
cache.Invoke("conditionalPutAllKey1", processor);
Assert.IsTrue(cache.Count == 3);
// remove all entries that satisfy filter criteria
processor = new ConditionalRemove(greaterThen300, false);
cache.InvokeAll(ht.Keys, processor);
Assert.IsTrue(cache.Count == 2);
Assert.IsNotNull(cache["conditionalPutAllKey2"]);
Assert.IsNotNull(cache["conditionalPutAllKey3"]);
processor = new ConditionalRemove(lessThen300, false);
cache.InvokeAll(new GreaterFilter(IdentityExtractor.Instance, 200), processor);
Assert.IsTrue(cache.Count == 1);
Assert.IsNotNull(cache["conditionalPutAllKey3"]);
processor = new ConditionalRemove(key3, false);
cache.InvokeAll(new GreaterFilter(IdentityExtractor.Instance, 100), processor);
Assert.IsTrue(cache.Count == 0);
CacheFactory.Shutdown();
}
public void TestUPnPTitle()
{
string text = "(dc:title contains \"two\")";
SearchExp exp = SearchParser.Parse(text);
IList <Guid> types = new List <Guid>();
IFilter filter = SearchParser.Convert(exp, types);
Console.WriteLine(text + " -> filter=" + filter + " types=[" + string.Join(",", types) + "]");
Assert.IsTrue(filter is LikeFilter, "Filter");
LikeFilter filter1 = filter as LikeFilter;
Assert.AreEqual(MediaAspect.ATTR_TITLE, filter1.AttributeType, "Attribute");
Assert.AreEqual("%two%", filter1.Expression, "Expression");
}
internal static Task <IList <MediaItem> > GetTracksByTrackSearchAsync(Guid?userId, string trackSearch, uint?limit = null, uint?offset = null)
{
IFilter searchFilter = null;
if (!string.IsNullOrEmpty(trackSearch))
{
searchFilter = new LikeFilter(AudioAspect.ATTR_TRACKNAME, SqlUtils.LikeEscape(trackSearch, '\\') + "%", '\\', false);
}
List <ISortInformation> sort = new List <ISortInformation>();
sort.Add(new AttributeSortInformation(AudioAspect.ATTR_TRACKNAME, SortDirection.Ascending));
return(GetAlbumsAsync(userId, searchFilter, limit, offset, sort));
}
internal static Task <IList <MediaItem> > GetImagesByImageSearchAsync(Guid?userId, string imageSearch, uint?limit = null, uint?offset = null)
{
IFilter searchFilter = null;
if (!string.IsNullOrEmpty(imageSearch))
{
searchFilter = new LikeFilter(MediaAspect.ATTR_TITLE, SqlUtils.LikeEscape(imageSearch, '\\') + "%", '\\', false);
}
List <ISortInformation> sort = new List <ISortInformation>();
sort.Add(new AttributeSortInformation(MediaAspect.ATTR_TITLE, SortDirection.Ascending));
return(GetImagesAsync(userId, searchFilter, limit, offset, sort));
}
public void TestToWhereExpression_PropertyHasValue_SearchTermIsDifferent()
{
var list = new List <LikeFilterTestClass>();
var instance = new LikeFilterTestClass();
instance.S = "abc";
list.Add(instance);
var filter = new LikeFilter <LikeFilterTestClass>("S", "Hello");
var whereExpression = filter.ToWhereExpression();
var whereFunc = whereExpression.Compile();
var results = list.Where(whereFunc).ToList();
Assert.AreEqual(0, results.Count);
}
public void TestWhereExtension_IEnumerable_SingleLinqFilter()
{
var list = new List <LinqFilterTestClass>();
list.Add(new LinqFilterTestClass
{
Id = 1,
NullableId = 1,
S = "hello"
});
var filter = new LikeFilter <LinqFilterTestClass>("S", "hello");
var results = list.Where(filter).ToList();
Assert.AreEqual(1, results.Count);
}
public void TestUPnPAlbumContains()
{
string text = "(upnp:class = \"object.container.album.musicAlbum\" and dc:title contains \"three\")";
SearchExp exp = SearchParser.Parse(text);
IList <Guid> types = new List <Guid>();
IFilter filter = SearchParser.Convert(exp, types);
Console.WriteLine(text + " -> filter=" + filter + " types=[" + string.Join(",", types) + "]");
Assert.Contains(AudioAspect.ASPECT_ID, (ICollection)types, "Types");
Assert.IsTrue(filter is LikeFilter, "Filter");
LikeFilter filter1 = filter as LikeFilter;
Assert.AreEqual(AudioAspect.ATTR_ALBUM, filter1.AttributeType, "Attribute");
Assert.AreEqual("%three%", filter1.Expression, "Expression");
}
public void TestUPnPTrackContains()
{
string text = "(upnp:class derivedfrom \"object.item.audioItem\" and dc:title contains \"nine\")";
SearchExp exp = SearchParser.Parse(text);
IList <Guid> types = new List <Guid>();
IFilter filter = SearchParser.Convert(exp, types);
Console.WriteLine(text + " -> filter=" + filter + " types=[" + string.Join(",", types) + "]");
Assert.Contains(AudioAspect.ASPECT_ID, (ICollection)types, "Types");
Assert.IsTrue(filter is LikeFilter, "Filter");
LikeFilter filter1 = filter as LikeFilter;
Assert.AreEqual(MediaAspect.ATTR_TITLE, filter1.AttributeType, "Attribute");
Assert.AreEqual("%nine%", filter1.Expression, "Expression");
}
public void TestToWhereExpression_PropertyHasValue_CaseInsentive()
{
var list = new List <LikeFilterTestClass>();
var instance = new LikeFilterTestClass();
instance.S = "hello".ToUpper();
list.Add(instance);
var filter = new LikeFilter <LikeFilterTestClass>("S", instance.S.ToLower());
var whereExpression = filter.ToWhereExpression();
var whereFunc = whereExpression.Compile();
var results = list.Where(whereFunc).ToList();
Assert.AreEqual(1, results.Count);
Assert.AreEqual(instance.S, results.First().S);
}
public void GetGroup(object elementValue,
out object groupKey, out IFilter additionalFilter)
{
string elementName = elementValue == null ? string.Empty : elementValue.ToString().Trim();
char firstChar;
if (elementName != string.Empty && IsLetterOrDigit(firstChar = elementName[0]))
{
string fcs = firstChar.ToString().ToUpperInvariant();
groupKey = fcs + "*";
additionalFilter = new LikeFilter(_attributeType, fcs + "%", null, false);
}
else
{
groupKey = _emptyOrMiscCharacterGroupName;
additionalFilter = GetEmptyOrMiscGroupFilter();
}
}
public void TestWhereExtension_IEnumerable_MultipleLinqFilters()
{
var list = new List <LinqFilterTestClass>();
list.Add(new LinqFilterTestClass
{
Id = 1,
NullableId = 1,
S = "hello"
});
var filter1 = new LikeFilter <LinqFilterTestClass>("S", "h");
var filter2 = new LikeFilter <LinqFilterTestClass>("S", "o");
var results = list.Where(new List <LinqFilter <LinqFilterTestClass> > {
filter1, filter2
}).ToList();
Assert.AreEqual(1, results.Count);
}
protected virtual Command Filter(LikeFilter filter)
{
//Validating if there are filters defined
if (filter == null)
{
return(null);
}
Command command = new Command();
CommandParameter param = new CommandParameter(filter.Pattern, null, filter.Column.DbType);
command.Parameters.Add(param);
command.Script =
EqualityComparison(
ColumnFullName(filter),
param.Name,
CompareOperator.Like);
return(command);
}
public void TestSingleAndMultipleMIAQueryBuilder()
{
SingleTestMIA mia1 = TestBackendUtils.CreateSingleMIA("single1", Cardinality.Inline, true, false);
MultipleTestMIA mia2 = TestBackendUtils.CreateMultipleMIA("multi1", Cardinality.Inline, true, false);
IFilter filter1 = new LikeFilter(mia1.ATTR_STRING, "%", null);
IFilter filter2 = new LikeFilter(mia2.ATTR_STRING, "%", null);
IFilter filter = new BooleanCombinationFilter(BooleanOperator.And, new[] { filter1, filter2 });
ICollection <MediaItemAspectMetadata> requiredMIATypes = new List <MediaItemAspectMetadata>();
requiredMIATypes.Add(mia1.Metadata);
requiredMIATypes.Add(mia2.Metadata);
MIAQueryBuilder builder = new MIAQueryBuilder(MockCore.Management, new List <QueryAttribute>(), null, requiredMIATypes, new List <MediaItemAspectMetadata>(), filter, null, null);
string mediaItemIdAlias = null;
IDictionary <MediaItemAspectMetadata, string> miamAliases = null;
IDictionary <QueryAttribute, string> attributeAliases = null;
string statementStr = null;
IList <BindVar> bindVars = null;
builder.GenerateSqlStatement(out mediaItemIdAlias, out miamAliases, out attributeAliases, out statementStr, out bindVars);
Console.WriteLine("mediaItemIdAlias: {0}", mediaItemIdAlias);
Console.WriteLine("miamAliases: [{0}]", string.Join(",", miamAliases));
Console.WriteLine("attributeAliases: [{0}]", string.Join(",", attributeAliases));
Console.WriteLine("statementStr: {0}", statementStr);
Console.WriteLine("bindVars: [{0}]", string.Join(",", bindVars));
Assert.AreEqual("A0", mediaItemIdAlias, "Media item ID alias");
Assert.AreEqual(CreateMIAMAliases(mia1.Metadata, "A1", mia2.Metadata, "A2"), miamAliases, "MIAM aliases");
Assert.AreEqual(new Dictionary <QueryAttribute, string>(), attributeAliases, "Attribute aliases");
Assert.AreEqual("SELECT T0.MEDIA_ITEM_ID A0, T0.MEDIA_ITEM_ID A1, T1.MEDIA_ITEM_ID A2 FROM M_SINGLE1 T0 INNER JOIN M_MULTI1 T1 ON T1.MEDIA_ITEM_ID = T0.MEDIA_ITEM_ID " +
"WHERE T0.MEDIA_ITEM_ID IN(SELECT MEDIA_ITEM_ID FROM M_MULTI1 WHERE ATTR_STRING LIKE @V0) AND T0.ATTR_STRING LIKE @V1", statementStr, "Statement");
Assert.AreEqual(new List <BindVar>
{
new BindVar("V0", "%", typeof(string)),
new BindVar("V1", "%", typeof(string))
}, bindVars, "Bind vars");
}
public void TestMediaItemLoader_SingleMIAs_LikeFilter()
{
MockDBUtils.Reset();
SingleTestMIA mia1 = TestBackendUtils.CreateSingleMIA("SINGLE1", Cardinality.Inline, true, false);
SingleTestMIA mia2 = TestBackendUtils.CreateSingleMIA("SINGLE2", Cardinality.Inline, false, true);
SingleTestMIA mia3 = TestBackendUtils.CreateSingleMIA("SINGLE3", Cardinality.Inline, true, true);
Guid itemId = new Guid("aaaaaaaa-1111-1111-1111-aaaaaaaaaaaa");
IFilter filter = new LikeFilter(mia1.ATTR_STRING, "%", null);
MockReader reader = MockDBUtils.AddReader(
"SELECT T0.MEDIA_ITEM_ID A4, T0.MEDIA_ITEM_ID A5, T1.MEDIA_ITEM_ID A6, T2.MEDIA_ITEM_ID A7, T0.ATTR_STRING A0, T1.ATTR_INTEGER A1, T2.ATTR_STRING A2, T2.ATTR_INTEGER A3 " +
"FROM M_SINGLE1 T0 INNER JOIN M_SINGLE2 T1 ON T1.MEDIA_ITEM_ID = T0.MEDIA_ITEM_ID LEFT OUTER JOIN M_SINGLE3 T2 ON T2.MEDIA_ITEM_ID = T0.MEDIA_ITEM_ID " +
" WHERE T0.ATTR_STRING LIKE @V0", "A4", "A5", "A6", "A7", "A0", "A1", "A2", "A3");
reader.AddResult(itemId, itemId, itemId, itemId, "zerozero", 11, "twotwo", 33);
Guid[] requiredAspects = new Guid[] { mia1.ASPECT_ID, mia2.ASPECT_ID };
Guid[] optionalAspects = new Guid[] { mia3.ASPECT_ID };
MediaItemQuery query = new MediaItemQuery(requiredAspects, optionalAspects, filter);
CompiledMediaItemQuery compiledQuery = CompiledMediaItemQuery.Compile(MockCore.Management, query);
MediaItem result = compiledQuery.QueryMediaItem();
//Console.WriteLine("Query result " + result.MediaItemId + ": " + string.Join(",", result.Aspects) + ": " + result);
Assert.AreEqual(itemId, result.MediaItemId, "MediaItem ID");
SingleMediaItemAspect value = null;
Assert.IsTrue(MediaItemAspect.TryGetAspect(result.Aspects, mia1.Metadata, out value), "MIA1");
Assert.AreEqual("zerozero", value.GetAttributeValue(mia1.ATTR_STRING), "MIA1 string attibute");
Assert.IsTrue(MediaItemAspect.TryGetAspect(result.Aspects, mia2.Metadata, out value), "MIA2");
Assert.AreEqual(11, value.GetAttributeValue(mia2.ATTR_INTEGER), "MIA2 integer attibute");
Assert.IsTrue(MediaItemAspect.TryGetAspect(result.Aspects, mia3.Metadata, out value), "MIA3");
Assert.AreEqual("twotwo", value.GetAttributeValue(mia3.ATTR_STRING), "MIA3 string attibute");
Assert.AreEqual(33, value.GetAttributeValue(mia3.ATTR_INTEGER), "MIA3 integer attibute");
}
public void TestConstructor_ValueNotAString()
{
var filer = new LikeFilter <LikeFilterTestClass>("S", 1);
}
protected virtual IFilter BuildTextSearchFilter()
{
var filter = new LikeFilter(MediaAspect.ATTR_TITLE, GetSearchTerm(), null);
return(filter);
}
public void Constructor_TypeIsCorrect()
{
var filter = new LikeFilter("test_dimension", "foo*");
Assert.That(filter.Type, Is.EqualTo("like"));
}
public void Constructor_WithSpecificEscapeCharacter_EscapeIsSet()
{
var filter = new LikeFilter("test_dimension", "foo*", "o");
Assert.That(filter.Escape, Is.EqualTo("o"));
}
/// <summary>
/// Builds the actual filter SQL expression <c>[Attribute-Operand] [Operator] [Comparison-Value]</c> for the given
/// attribute <paramref name="filter"/>.
/// </summary>
/// <param name="filter">Attribute filter instance to create the SQL expression for.</param>
/// <param name="attributeOperand">Comparison attribute to be used. Depending on the cardinality of the
/// to-be-filtered attribute, this will be the inline attribute alias or the attribute alias of the collection
/// attribute table.</param>
/// <param name="bvNamespace">Namespace used to build bind var names.</param>
/// <param name="resultParts">Statement parts for the attribute filter.</param>
/// <param name="resultBindVars">Bind variables for the attribute filter.</param>
public static void BuildAttributeFilterExpression(IAttributeFilter filter, object attributeOperand, BindVarNamespace bvNamespace,
IList <object> resultParts, IList <BindVar> resultBindVars)
{
Type attributeType = filter.AttributeType.AttributeType;
RelationalFilter relationalFilter = filter as RelationalFilter;
if (relationalFilter != null)
{
resultParts.Add(attributeOperand);
switch (relationalFilter.Operator)
{
case RelationalOperator.EQ:
resultParts.Add(" = ");
break;
case RelationalOperator.NEQ:
resultParts.Add(" <> ");
break;
case RelationalOperator.LT:
resultParts.Add(" < ");
break;
case RelationalOperator.LE:
resultParts.Add(" <= ");
break;
case RelationalOperator.GT:
resultParts.Add(" > ");
break;
case RelationalOperator.GE:
resultParts.Add(" >= ");
break;
default:
throw new NotImplementedException(string.Format(
"Relational filter operator '{0}' isn't supported by the media library", relationalFilter.Operator));
}
BindVar bindVar = new BindVar(bvNamespace.CreateNewBindVarName("V"), relationalFilter.FilterValue, attributeType);
resultParts.Add("@" + bindVar.Name);
resultBindVars.Add(bindVar);
return;
}
LikeFilter likeFilter = filter as LikeFilter;
if (likeFilter != null)
{
if (!likeFilter.CaseSensitive)
{
resultParts.Add("UPPER(");
}
resultParts.Add(attributeOperand);
if (!likeFilter.CaseSensitive)
{
resultParts.Add(")");
}
resultParts.Add(" LIKE ");
BindVar bindVar = new BindVar(bvNamespace.CreateNewBindVarName("V"), likeFilter.Expression, attributeType);
if (likeFilter.CaseSensitive)
{
resultParts.Add("@" + bindVar.Name);
}
else
{
resultParts.Add("UPPER(@" + bindVar.Name + ")");
}
resultBindVars.Add(bindVar);
if (likeFilter.EscapeChar.HasValue)
{
bindVar = new BindVar(bvNamespace.CreateNewBindVarName("E"), likeFilter.EscapeChar.ToString(), typeof(Char));
resultParts.Add(" ESCAPE @" + bindVar.Name);
resultBindVars.Add(bindVar);
}
return;
}
BetweenFilter betweenFilter = filter as BetweenFilter;
if (betweenFilter != null)
{
resultParts.Add(attributeOperand);
resultParts.Add(" BETWEEN ");
BindVar bindVar = new BindVar(bvNamespace.CreateNewBindVarName("V"), betweenFilter.Value1, attributeType);
resultParts.Add("@" + bindVar.Name);
resultBindVars.Add(bindVar);
resultParts.Add(" AND ");
bindVar = new BindVar(bvNamespace.CreateNewBindVarName("V"), betweenFilter.Value2, attributeType);
resultParts.Add("@" + bindVar.Name);
resultBindVars.Add(bindVar);
return;
}
InFilter inFilter = filter as InFilter;
if (inFilter != null)
{
if (inFilter.Values.Count == 0)
{
resultParts.Add("1 = 2"); // No comparison values means filter is always false
return;
}
int clusterCount = 0;
foreach (IList <object> valuesCluster in CollectionUtils.Cluster(inFilter.Values, MAX_IN_VALUES_SIZE))
{
if (clusterCount > 0)
{
resultParts.Add(" OR ");
}
resultParts.Add(attributeOperand);
IList <string> bindVarRefs = new List <string>(MAX_IN_VALUES_SIZE);
foreach (object value in valuesCluster)
{
BindVar bindVar = new BindVar(bvNamespace.CreateNewBindVarName("V"), value, attributeType);
bindVarRefs.Add("@" + bindVar.Name);
resultBindVars.Add(bindVar);
}
resultParts.Add(" IN (" + StringUtils.Join(", ", bindVarRefs) + ")");
clusterCount++;
}
return;
}
throw new InvalidDataException("Filter type '{0}' isn't supported by the media library", filter.GetType().Name);
}
