/// <summary />
public DatastoreSliceable(DatastoreProvider provider, Expression expression, DatastoreService service)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
if (service == null)
{
throw new ArgumentNullException(nameof(service));
}
if (!typeof(IDatastoreSliceable <TSourceType>).IsAssignableFrom(expression.Type))
{
throw new InvalidOperationException("Expression is not of type IDatastoreSliceable");
}
Provider = provider;
Expression = expression;
dsService = service;
}
/// <summary />
public static RepositorySchema LoadSchemaTemplate(Type datastoreType)
{
var schema = DatastoreService.LoadSchemaForType(datastoreType);
schema.ID = schema.ID; //RepositoryId;
schema.Name = string.Format("{0}-{1}", schema.Name[0], schema.ID); //RepositoryId
schema.CreatedDate = DateTime.Now;
return(schema);
}
/// <summary />
internal static List <FieldDefinition> GetFields(Type datastoreType)
{
var schema = DatastoreService.LoadSchemaForType(datastoreType, true);
if (schema != null)
{
return(schema.FieldList);
}
return(null);
}
/// <summary />
internal DatastoreResultsAsync(DatastoreService dsService, DataQuery query)
{
try
{
_dsService = dsService;
_query = query;
_hookId = _dsService.QueryAsync(query);
_schema = _dsService.Schema;
}
catch
{
this.IsComplete = true;
throw;
}
}
private static object ExecuteResults(MethodCallExpression methodExpression, Type returnType, DatastoreService dsService)
{
if (methodExpression.Arguments.Count < 1)
{
throw new InvalidOperationException("Missing arguments for the Results expression.");
}
var parser = new DatastoreExpressionParser();
parser.Visit(methodExpression.Arguments[0]);
var dataQuery = BuildDataQueryFromParser(parser);
var results = dsService.Query(dataQuery);
var sourceType = GetGenericArgument(returnType, 0);
#region Create the dimensions
var dimensions = new List <DimensionItem>();
foreach (var d in results.DimensionList)
{
dimensions.Add((DimensionItem)((ICloneable)d).Clone());
}
var dimensionStore = Activator.CreateInstance(
typeof(DimensionStore <>).MakeGenericType(sourceType),
new object[] { dimensions, results.Query.NonParsedFieldList });
#endregion
#region Create the ALL dimensions
var allDimensions = new List <DimensionItem>();
foreach (var d in results.AllDimensionList)
{
allDimensions.Add((DimensionItem)((ICloneable)d).Clone());
}
var allDimensionStore = Activator.CreateInstance(
typeof(DimensionStore <>).MakeGenericType(sourceType),
new object[] { allDimensions, results.Query.NonParsedFieldList });
#endregion
#region Create the APPLIED dimensions
var appliedDimensions = new List <DimensionItem>();
foreach (var d in results.AppliedDimensionList)
{
appliedDimensions.Add((DimensionItem)((ICloneable)d).Clone());
}
var appliedDimensionstore = Activator.CreateInstance(
typeof(DimensionStore <>).MakeGenericType(sourceType),
new object[] { appliedDimensions, results.Query.NonParsedFieldList });
#endregion
var dsResults = Activator.CreateInstance(typeof(DatastoreResults <>).MakeGenericType(sourceType));
SetProperty(dsResults, "DimensionStore", dimensionStore);
SetProperty(dsResults, "AppliedDimensionList", appliedDimensionstore);
SetProperty(dsResults, "AppliedFieldFilterList", results.Query.FieldFilters ?? new List <IFieldFilter>());
SetProperty(dsResults, "AllDimensions", allDimensionStore);
SetProperty(dsResults, "DerivedFieldList", results.DerivedFieldList?.ToList());
SetResultItems(dsResults, sourceType, dataQuery, results, parser.SelectExpression);
var diag = new ResultDiagnostics
{
CacheHit = results.CacheHit,
ComputeTime = results.ComputeTime,
LockTime = results.LockTime,
DataVersion = results.DataVersion,
VersionHash = results.VersionHash,
RepositoryId = dsService.RepositoryId,
};
SetProperty(dsResults, "Diagnostics", diag);
SetProperty(dsResults, "Query", ((ICloneable)results.Query).Clone());
return(dsResults);
}
/// <summary />
public DatastoreProvider(DatastoreService service)
{
_dsService = service;
}
private static object ExecuteToSlice(MethodCallExpression methodExpression, Type returnType, DatastoreService dsService)
{
if (methodExpression.Arguments.Count < 1)
{
throw new InvalidOperationException("Missing arguments for the Results expression.");
}
var parser = new DatastoreExpressionParser();
parser.Visit(methodExpression.Arguments[0]);
var dataQuery = BuildDataSliceQueryFromParser(parser);
return(dsService.CalculateSlice(dataQuery));
}
private static string ExecuteToUrl(MethodCallExpression methodExpression, Type returnType, DatastoreService dsService)
{
var dataQuery = ExecuteToQuery(methodExpression, returnType, dsService);
return(dataQuery.ToString());
}
private static object GetDataVersion(MethodCallExpression methodExpression, Type returnType, DatastoreService dsService)
{
return(dsService.GetDataVersion());
}
/// <summary />
internal DatastoreDeletable(DatastoreService service)
{
dsService = service;
Provider = new DatastoreProvider(dsService);
Expression = Expression.Constant(this);
}
private static ActionDiagnostics ExecuteUpdate(MethodCallExpression methodExpression, Type returnType, DatastoreService dsService)
{
if (methodExpression.Arguments.Count < 1)
{
throw new InvalidOperationException("Invalid argument count for the Update expression.");
}
var parser = new DatastoreExpressionParser();
parser.Visit(methodExpression.Arguments[0]);
var dataQuery = BuildDataQueryFromParser(parser);
if (parser.FieldUpdates == null || parser.FieldUpdates.Count == 0)
{
return new ActionDiagnostics {
IsSuccess = false
}
}
; //throw new InvalidOperationException("No field updates specified");
return(dsService.UpdateDataWhere(dataQuery, parser.FieldUpdates));
}
private static object ExecuteAggregateSum(MethodCallExpression methodExpression, Type returnType, DatastoreService dsService)
{
if (methodExpression.Arguments.Count < 1)
{
throw new InvalidOperationException("Missing arguments for the Aggregate expression.");
}
var dataQuery = GetAggregateParser(methodExpression);
var results = dsService.Query(dataQuery);
return(BuildItemFromDerivedFields2(results, returnType));
}
private static object ExecuteItems2(MethodCallExpression methodExpression, Type returnType, DatastoreService dsService)
{
if (methodExpression.Arguments.Count < 1)
{
throw new InvalidOperationException("Missing arguments for the Items expression.");
}
var parser = new DatastoreExpressionParser();
parser.Visit(methodExpression.Arguments[0]);
var dataQuery = BuildDataQueryFromParser(parser);
dataQuery.IncludeDimensions = false;
dataQuery.IncludeAllDimensions = false;
dataQuery.IncludeRecords = true;
var itemType = GetGenericArgument(returnType, 0);
var dsItems = Activator.CreateInstance(typeof(DatastoreItems <>).MakeGenericType(itemType));
var results = dsService.Query(dataQuery);
SetResultItems(dsItems, itemType, dataQuery, results, parser.SelectExpression);
return(dsItems);
}
/// <summary />
public DatastoreSliceable(DatastoreService service)
{
dsService = service;
Provider = new DatastoreProvider(dsService);
Expression = Expression.Constant(this);
}
private static object ExecuteResultsAsync(MethodCallExpression methodExpression, Type returnType, DatastoreService dsService)
{
if (methodExpression.Arguments.Count < 1)
{
throw new InvalidOperationException("Missing arguments for the Results expression.");
}
var parser = new DatastoreExpressionParser();
parser.Visit(methodExpression.Arguments[0]);
var dataQuery = BuildDataQueryFromParser(parser);
var flags = System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance;
var retval = Activator.CreateInstance(type: returnType, bindingAttr: flags, binder: null, args: new object[] { dsService, dataQuery }, culture: CultureInfo.CurrentCulture);
return(retval);
//return new DatastoreResultsAsync<object>(dsService, dataQuery);
}
private static ActionDiagnostics ExecuteCommit(MethodCallExpression methodExpression, Type returnType, DatastoreService dsService)
{
if (methodExpression.Arguments.Count < 1)
{
throw new InvalidOperationException("Invalid argument count for the Commit expression.");
}
if (typeof(IDatastoreUpdatable).IsAssignableFrom(methodExpression.Arguments[0].Type))
{
return(ExecuteUpdate(methodExpression, returnType, dsService));
}
else if (typeof(IDatastoreDeletable).IsAssignableFrom(methodExpression.Arguments[0].Type))
{
return(ExecuteDelete(methodExpression, returnType, dsService));
}
throw new InvalidOperationException("Commit not available");
}
private static object ExecuteCount(MethodCallExpression methodExpression, Type returnType, DatastoreService dsService)
{
if (methodExpression.Arguments.Count < 1)
{
throw new InvalidOperationException("Missing arguments for the Count expression.");
}
var parser = new DatastoreExpressionParser();
parser.Visit(methodExpression.Arguments[0]);
var dataQuery = BuildDataQueryFromParser(parser);
dataQuery.IncludeDimensions = false;
dataQuery.IncludeAllDimensions = false;
dataQuery.IncludeRecords = false;
dataQuery.ExcludeCount = false;
var result = dsService.Query(dataQuery);
return(result.TotalRecordCount);
}
private static ActionDiagnostics ExecuteDelete(MethodCallExpression methodExpression, Type returnType, DatastoreService dsService)
{
if (methodExpression.Arguments.Count < 1)
{
throw new InvalidOperationException("Invalid argument count for the Delete expression.");
}
var parser = new DatastoreExpressionParser();
parser.Visit(methodExpression.Arguments[0]);
var dataQuery = BuildDataQueryFromParser(parser);
return(dsService.DeleteData(dataQuery));
}
private static object ExecuteAllDimensions(MethodCallExpression methodExpression, Type returnType, DatastoreService dsService)
{
if (methodExpression.Arguments.Count < 1)
{
throw new InvalidOperationException("Missing arguments for the AllDimensions expression.");
}
// This comes from IDatastoreQueryable<TSourceType, TResultType>
var sourceType = GetGenericArgument(returnType, 0);
var parser = new DatastoreExpressionParser();
parser.Visit(methodExpression.Arguments[0]);
var dataQuery = BuildDataQueryFromParser(parser);
dataQuery.IncludeDimensions = true;
dataQuery.IncludeAllDimensions = false;
dataQuery.IncludeRecords = false;
dataQuery.ExcludeCount = true;
var results = dsService.Query(dataQuery);
var allDimensions = new List <DimensionItem>();
foreach (var d in results.DimensionList)
{
allDimensions.Add((DimensionItem)((ICloneable)d).Clone());
}
var dimensionStore = Activator.CreateInstance(
typeof(DimensionStore <>).MakeGenericType(sourceType),
new object[] { allDimensions, results.Query.NonParsedFieldList });
return(dimensionStore);
}
