/// <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); }