public SelectManyQuery(IDocumentSchema schema, IQueryableDocument mapping, QueryModel query, int index)
{
Index = index;
_schema = schema;
_query = query;
_from = query.BodyClauses[index - 1].As <AdditionalFromClause>();
var members = FindMembers.Determine(_from.FromExpression);
_field = mapping.FieldFor(members);
IsDistinct = query.HasOperator <DistinctResultOperator>();
var next = query.BodyClauses.Skip(index + 1).FirstOrDefault(x => x is AdditionalFromClause);
if (next != null)
{
throw new NotSupportedException("Not yet supporting SelectMany().SelectMany()");
}
else
{
_take = _query.BodyClauses.Count - index;
}
_tableAlias = "sub" + Index;
_documentType = _field.MemberType.GetElementType();
_document = _schema.StoreOptions.GetChildDocument(_tableAlias + ".x", _documentType);
}
public SelectManyQuery(DocumentStore store, IQueryableDocument mapping, QueryModel query, int index)
{
Index = index;
_store = store;
_query = query;
_from = query.BodyClauses[index - 1].As <AdditionalFromClause>();
_field = mapping.FieldFor(_from.FromExpression);
IsDistinct = query.HasOperator <DistinctResultOperator>();
var next = query.BodyClauses.Skip(index + 1).FirstOrDefault(x => x is AdditionalFromClause);
if (next != null)
{
throw new NotSupportedException("Not yet supporting SelectMany().SelectMany()");
}
_take = _query.BodyClauses.Count - index;
_tableAlias = "sub" + Index;
_documentType = _field.FieldType.DeriveElementType();
_document = _store.Options.GetChildDocument(_tableAlias + ".x", _documentType);
}
private string toOrderClause(ChildDocument document, Ordering clause)
{
var locator = document.JsonLocator(clause.Expression);
return(clause.OrderingDirection == OrderingDirection.Asc
? locator
: locator + " desc");
}
private string determineOrderClause(ChildDocument document)
{
var orders = bodyClauses().OfType <OrderByClause>().SelectMany(x => x.Orderings).ToArray();
if (!orders.Any())
{
return(string.Empty);
}
return(" order by " + orders.Select(x => toOrderClause(document, x)).Join(", "));
}
private IWhereFragment buildWhereFragment(ChildDocument document)
{
var wheres = findOperators <WhereClause>().ToArray();
if (!wheres.Any())
{
return(null);
}
return(wheres.Length == 1
? _schema.Parser.ParseWhereFragment(document, wheres.Single().Predicate)
: new CompoundWhereFragment(_schema.Parser, document, "and", wheres));
}
public void Repository_Supports_Inheritance()
{
MyDocument newDoc1 = new MyDocument()
{
MyProperty = "Test!"
};
MyDocument newDoc2 = new ChildDocument()
{
MyProperty = "Child", ChildProperty = "some extra string"
};
_repository.Insert(newDoc1);
_repository.Insert(newDoc2);
MyDocument[] fromDatabase = _repository.OrderBy(x => x.MyProperty).ToArray();
AssertState(newDoc2, fromDatabase[0]);
AssertState(newDoc1, fromDatabase[1]);
}
/// <summary>
/// Solid archive item requests a stream to write extracted item's data.
/// </summary>
/// <param name="index">The zero-offset archive child item index.</param>
/// <param name="stream">The stream to be provided for extracted data.</param>
private void ItemGetStreamCallback(int index, out Stream stream)
{
// This delegate requests a stream to which to extract the archive item. It can be a MemoryStream or FileStream depending
// on your needs, however, pay attention to the extracted size of the item (ChildDocument.Size) to determine if you want to
// or even can extract to a MemoryStream:
ChildDocument childDoc = null;
try
{
stream = null;
childDoc = _archiveContent.ChildDocuments[index];
if (string.IsNullOrWhiteSpace(childDoc.Name))
{
// Give the item a name based on index if it does not have one:
childDoc.Name = string.Format("item_{0}", childDoc.Index);
}
var filePath = Path.Combine(_rootOutputFolder, childDoc.ContainerRelativePath, childDoc.Name);
//
// Check for duplicate file paths and if found rename filename with like Windows does for duplicate files, e.g., "filename (2).ext"
// Some archive types can have duplicate named files in same directory, so this is a check for that:
//
FileSystemHelper.CheckForAndCorrectDuplicateItemFilePaths(_itemFilenameByCountDict, childDoc, ref filePath);
// Return an open file stream:
stream = new FileStream(filePath, FileMode.CreateNew, FileAccess.ReadWrite);
}
catch
{
stream = null;
if (childDoc != null)
{
childDoc.FormatId = DocumentIdentifier.ContainerUnextractableResult;
}
}
}
/// <summary>
/// Checks for potential duplicate container item names in extracted path. Ideally, we would want to check for
/// illegal characters in the filename/file path and also long file paths. That will be left up to the user to
/// implement for production level code.
/// </summary>
/// <remarks>
/// Some archive formats allow duplicate named files in same archive path - how this happens is by adding the same
/// named file at a later date/time as an update. This method is an attempt to rename duplicate files like Windows
/// does ("filename (##).ext", where (##) = 2,3,...,Number-of-duplicates).
/// </remarks>
/// <param name="itemFilenameByCountDict">A dictionary that stores item path as key and the count of total times this item path was used as value.</param>
/// <param name="childDoc">The <see cref="ChildDocument"/> whose item name will be used as part of full item path.</param>
/// <param name="itemFullPath">The folder path that this item will be eventually saved to.</param>
public static void CheckForAndCorrectDuplicateItemFilePaths(Dictionary <string, int> itemFilenameByCountDict, ChildDocument childDoc, ref string itemFullPath)
{
if (itemFilenameByCountDict.TryGetValue(itemFullPath, out var count))
{
var folder = Path.GetDirectoryName(itemFullPath);
var extension = Path.GetExtension(childDoc.Name);
var nameWithNoExt = Path.GetFileNameWithoutExtension(childDoc.Name);
itemFullPath = Path.Combine(folder, string.Format("{0} ({1}){2}", nameWithNoExt, count, extension));
itemFilenameByCountDict[itemFullPath] = ++count;
}
else
{
itemFilenameByCountDict[itemFullPath] = 1;
}
}
