//--------------------------------------------------------------------------
// we return a list of location pairs - each pair contains the first and
// last word in the phrase with their location details
public List <Tuple <LocationDetail, LocationDetail> > Query(Phrase phrase)
{
// first, get a list of Contains which build potential phrases
List <Contains> potentialPhrases = ContainsDao.Query(phrase);
// break the list into sublists (by unique doc,sentence)
Dictionary <Tuple <long, long>, List <Contains> > phraseContainsMap =
new Dictionary <Tuple <long, long>, List <Contains> >();
foreach (Contains item in potentialPhrases)
{
Tuple <long, long> currentKey =
new Tuple <long, long>(item.DocumentId, item.Sentence);
if (!phraseContainsMap.ContainsKey(currentKey))
{
phraseContainsMap[currentKey] = new List <Contains>();
}
phraseContainsMap[currentKey].Add(item);
}
List <Tuple <LocationDetail, LocationDetail> > result =
new List <Tuple <LocationDetail, LocationDetail> >();
// now check which phrase contains all our words
foreach (var containsPhrase in phraseContainsMap.Values)
{
int startIndex = 0;
int foundIndex = 0;
// we have a while to support sentences that have our phrase more than
// once in them
while (ContainsPhraseEqualsPhrase(containsPhrase,
startIndex,
phrase,
out foundIndex))
{
Tuple <LocationDetail, LocationDetail> pair =
new Tuple <LocationDetail, LocationDetail>(
new LocationDetail()
{
Document = DocumentsService.Instance.GetById(
containsPhrase[0].DocumentId),
Location = containsPhrase[foundIndex]
},
new LocationDetail()
{
Document = DocumentsService.Instance.GetById(
containsPhrase[0].DocumentId),
Location = containsPhrase[foundIndex + phrase.Words.Count - 1]
});
result.Add(pair);
startIndex = foundIndex + phrase.Words.Count;
}
}
return(result);
}
//-------------------------------------------------------------------------
public List <WordLocationDetails> Query(
List <Document> documents,
List <WordLocationProperty> wordLocationProperties)
{
if (wordLocationProperties.Count <= 0)
{
throw new Exception("You must use, at least, ONE word location filter");
}
// query the DB
List <Contains> contains = ContainsDao.Query(documents,
wordLocationProperties);
// we want to return a grouped result (as-in grouped by words)
// so we use a dictionary to collect all location details per word and
// then we can build a grouped result of List<WordLocationDetails>
Dictionary <long, List <LocationDetail> > wordLocationDetailsMap =
new Dictionary <long, List <LocationDetail> >();
foreach (Contains containsItem in contains)
{
if (!wordLocationDetailsMap.ContainsKey(containsItem.WordId))
{
wordLocationDetailsMap[containsItem.WordId] =
new List <LocationDetail>();
}
wordLocationDetailsMap[containsItem.WordId].Add(new LocationDetail()
{
Document = DocumentsService.Instance.GetById(containsItem.DocumentId),
Location = containsItem
});
}
// now we can convert to List<WordLocationDetails>
List <WordLocationDetails> result = new List <WordLocationDetails>();
foreach (var item in wordLocationDetailsMap.Keys)
{
result.Add(new WordLocationDetails()
{
Word = WordsService.Instance.GetWordById(item),
LocationDetails = wordLocationDetailsMap[item]
});
}
return(result);
}
//-------------------------------------------------------------------------
public WordLocationDetails Query(List <Document> documents, Word word)
{
// query the DB
List <Contains> contains = ContainsDao.Query(documents, word);
WordLocationDetails locationDetails = new WordLocationDetails();
locationDetails.Word = word;
locationDetails.LocationDetails = new List <LocationDetail>();
foreach (Contains item in contains)
{
locationDetails.LocationDetails.Add(new LocationDetail()
{
Document = DocumentsService.Instance.GetById(item.DocumentId),
Location = item
});
}
return(locationDetails);
}
//-------------------------------------------------------------------------
public List <WordLocationDetails> Query(Group group)
{
// query the DB
List <Contains> contains = ContainsDao.Query(group);
// we want to return a grouped result (as-in grouped by words)
// so we use a dictionary to collect all location details per word and
// then we can build a grouped result of List<WordLocationDetails>
Dictionary <long, List <LocationDetail> > wordLocationDetailsMap =
new Dictionary <long, List <LocationDetail> >();
foreach (Contains containsItem in contains)
{
if (!wordLocationDetailsMap.ContainsKey(containsItem.WordId))
{
wordLocationDetailsMap[containsItem.WordId] =
new List <LocationDetail>();
}
wordLocationDetailsMap[containsItem.WordId].Add(new LocationDetail()
{
Document = DocumentsService.Instance.GetById(containsItem.DocumentId),
Location = containsItem
});
}
// now we can convert to List<WordLocationDetails>
List <WordLocationDetails> result = new List <WordLocationDetails>();
foreach (var item in wordLocationDetailsMap.Keys)
{
result.Add(new WordLocationDetails()
{
Word = WordsService.Instance.GetWordById(item),
LocationDetails = wordLocationDetailsMap[item]
});
}
return(result);
}
