/// <summary> /// Appends a <see cref="JsonPath"/> by specifying an expression which evaluates to the index to include. /// </summary> /// <param name="expression">The expression.</param> /// <returns>The new <see cref="JsonPath"/>.</returns> public static JsonPath Array(Expression <Func <JsonPathArray, int> > expression) { var path = new JsonPath(); path.Operators.Add(new ArrayOperator(new IndexExpressionQuery(ExpressionTranslator.Translate(expression)))); return(path); }
/// <summary> /// Appends a <see cref="JsonPath"/> by specifying a predicate expression which filters the values. /// </summary> /// <param name="expression">The predicate expression</param> /// <returns>The new <see cref="JsonPath"/>.</returns> public static JsonPath Array(Expression <Func <JsonPathValue, bool> > expression) { var path = new JsonPath(); path.Operators.Add(new ArrayOperator(new FilterExpressionQuery(ExpressionTranslator.Translate(expression)))); return(path); }
public string GetSelectString <T>(string collectionName, Expression <Func <T, Boolean> > filter, string orderBy, bool onlyOne = false) { ExpressionTranslator expressionTranslator = new ExpressionTranslator(); DbCollection collection = _collections[collectionName]; StringBuilder str = new StringBuilder(); str.Append(" select "); if (onlyOne) { str.Append(" Top 1 "); } str.Append(collection.GetFields()); str.Append(" from ["); str.Append(collectionName); str.Append("] "); string sqlWhere = filter == null ? "" : expressionTranslator.Translate <T>(filter); str.Append(string.IsNullOrEmpty(sqlWhere) ? " " : " where " + sqlWhere); if (!string.IsNullOrEmpty(orderBy)) { str.Append(orderBy); } return(str.ToString()); }
public async Task <int> UpdateAsync <T>(T obj, Expression <Func <T, bool> > predicate) where T : class, new() { var tableName = typeof(T).TableNameValidate(); var fields = typeof(T).GetProperties(); var primaryKey = fields.PrimaryKeyValidate(); var pkValue = primaryKey.GetValue(obj); var parameters = Shared.Data.CRUDDataMapping(obj, Enumerables.SqlType.Update); parameters.Remove(primaryKey.Name); var translator = new ExpressionTranslator(); var translatorResult = translator.Translate(predicate); var query = $@"UPDATE {tableName} SET {string.Join(",", parameters.Select(x => $"{x.Key} = @{x.Key}"))} WHERE " + translatorResult; var parametersArray = parameters.Select(x => new TParameterType() { ParameterName = $"@{x.Key}", Value = x.Value }).ToList(); parametersArray.Add(new TParameterType() { ParameterName = $"@{primaryKey.Name}", Value = primaryKey.GetValue(obj) }); var value = await ExecuteNonQueryAsync(query, parametersArray); return(value); }
public static XElement Translate(string xamlFile) { string translatedWorkflowString = null; using (XamlReader xamlReader = new XamlXmlReader(xamlFile)) { TranslationResults result = ExpressionTranslator.Translate(xamlReader); if (result.Errors.Count == 0) { StringBuilder sb = new StringBuilder(); using (XmlWriter xmlWriter = XmlWriter.Create(sb, new XmlWriterSettings { Indent = true, OmitXmlDeclaration = true })) { using (XamlXmlWriter writer = new XamlXmlWriter(xmlWriter, result.Output.SchemaContext)) { XamlServices.Transform(result.Output, writer); } } translatedWorkflowString = sb.ToString(); } else { throw new InvalidOperationException("Translation errors"); } } return(XElement.Parse(translatedWorkflowString)); }
public void Translate(Expression e, string expected) { ExpressionTranslator expressionTransator = new ExpressionTranslator(); string actual = expressionTransator.Translate(e); //Assert.AreEqual(expected, actual); Assert.Pass(expected); }
public async Task <int> DeleteAsync <T>(Expression <Func <T, bool> > predicate) where T : class, new() { var tableName = typeof(T).TableNameValidate(); var baseStatement = $@"DELETE FROM {tableName} WHERE "; var translator = new ExpressionTranslator(); var translatorResult = translator.Translate(predicate); var result = await ExecuteNonQueryAsync(baseStatement + translatorResult); return(result); }
public async Task <IEnumerable <T> > SelectAsync <T>(Expression <Func <T, bool> > predicate) where T : class, new() { var tableName = typeof(T).TableNameValidate(); var translator = new ExpressionTranslator(); var translatorResult = translator.Translate(predicate); var query = $@"SELECT * FROM {tableName} WHERE {translatorResult}"; var result = await ExecuteReaderAsync <T>(query); return(result); }
public IEnumerable <T> Select <T>(Expression <Func <T, bool> > predicate) where T : class, new() { var tableName = typeof(T).TableNameValidate(); var baseStatement = $@"SELECT * FROM {tableName} "; var translator = new ExpressionTranslator(); var tranlatorResult = translator.Translate(predicate); var result = ExecuteReader <T>(baseStatement + tranlatorResult); return(result); }
public int Delete <T>(Expression <Func <T, bool> > predicate) where T : class, new() { var tableName = typeof(T).TableNameValidate(); var translator = new ExpressionTranslator(); var translatorResult = translator.Translate(predicate); var query = $@"DELETE FROM {tableName} WHERE {translatorResult}"; var result = ExecuteNonQuery(query); return(result); }
public void TestContains() { var translator = new ExpressionTranslator(); Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression = query => query.Where(e => e.Workstation.Contains("IZHW006")); string translated = translator.Translate(expression); Assert.AreEqual("Workstation:(*IZHW006*)", translated); }
public void GivenQuery_WhenTwoPropertiesComparing_ThenNotSupportedExceptionRaised() { // Arrange var translator = new ExpressionTranslator(); Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression = query => query.Where(e => e.Workstation == e.Manager); Assert.ThrowsException <NotSupportedException>( () => translator.Translate(expression), "Predicate should contain parameter and constant expression."); }
public void GivenQuery_WhenIntTypeProvided_ThenNotSupportedExceptionRaised() { // Arrange var translator = new ExpressionTranslator(); Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression = query => query.Where(e => e.NonBillable < 100); Assert.ThrowsException <NotSupportedException>( () => translator.Translate(expression), "Not supported expression type 'LessThan'."); }
public void GivenQuery_WhenNotUnaryExpressionProvided_ThenNotSupportedExceptionRaised() { // Arrange var translator = new ExpressionTranslator(); Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression = query => query.Where(e => false); Assert.ThrowsException <NotSupportedException>( () => translator.Translate(expression), $"'Constant' expression is not supported."); }
public void GivenStringQuery_WhenNotSupportedMethodCalled_ThenNotSupportedExceptionRaised() { // Arrange var translator = new ExpressionTranslator(); Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression = query => query.Where(e => e.NativeName.IsNormalized(NormalizationForm.FormC)); Assert.ThrowsException <NotSupportedException>( () => translator.Translate(expression), $"Method 'IsNormalized' is not supported for type '{typeof(string)}'"); }
public void GivenQuery_WhenIntMethodCalled_ThenNotSupportedExceptionRaised() { // Arrange var translator = new ExpressionTranslator(); Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression = query => query.Where(e => e.NonBillable.Equals(100)); Assert.ThrowsException <NotSupportedException>( () => translator.Translate(expression), $"Not supported parameter type '{typeof(double)}'."); }
public void GivenQuery_WhenSelectProvided_ThenNotSupportedExceptionRaised() { // Arrange var translator = new ExpressionTranslator(); Expression <Func <IQueryable <EmployeeEntity>, IQueryable <string> > > expression = query => query.Select(e => e.Workstation); Assert.ThrowsException <NotSupportedException>( () => translator.Translate(expression), "Method 'Select' is not supported."); }
public void Translate_GivenText_CallsTemplateBuilder() { var sut = new ExpressionTranslator(); string input = "Model.Property"; Span span = SpanHelper.BuildSpan(input); sut.Translate(span, this._templateBuilder.Object); this._templateBuilder.Verify(t => t.Write(input)); }
public void Translate(MethodCallExpression method, ITranslationResult result) { if (method.Method.Name != MethodName) { throw new ArgumentOutOfRangeException(nameof(method), $"Method '{nameof(method)}' is not supported"); } var expressionTranslator = new ExpressionTranslator(_nameChanges); expressionTranslator.Translate(result, method); }
public void Translate(MethodCallExpression method, ITranslationResult result) { if (method.Method.Name != MethodName) { var message = string.Format(Resources.TranslatorMemberNotSupported, method.NodeType); throw new ArgumentOutOfRangeException(nameof(method), message); } var expressionTranslator = new ExpressionTranslator(_nameChanges); expressionTranslator.Translate(result, method); }
public void TestMethodEquals() { // Arrange var translator = new ExpressionTranslator(); Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression = query => query.Where(e => e.Workstation.Equals("EPRUIZHW006")); // Act var result = translator.Translate(expression); // Assert Assert.AreEqual("Workstation:(EPRUIZHW006)", result); }
/// <summary> /// Returns rows count on specific condition from specified table. /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> public static int Count <T>(this IDatabaseConnector connector, Expression <Func <T, bool> > predicate) where T : class { var con = connector as DatabaseConnectorBase; if (con == null) { throw new InvalidCastException($"{connector.GetType().FullName} cannot be use with this extension (expected to get instance of {typeof(DatabaseConnectorBase).FullName}"); } var tableName = AttributeExtension.TableNameAttributeValidate(typeof(T)); var exprTranslator = new ExpressionTranslator <T>(con.CompatibleFunctionName); var translateResult = exprTranslator.Translate(predicate); var query = $"SELECT COUNT(*) FROM {tableName} WHERE {translateResult.Expression}"; var count = con.ExecuteScalar(query, translateResult.Parameters); var countAsString = count.ToString(); return(int.Parse(countAsString)); }
public static string TranslateWorkflow(string originalWorkflow) { using (var inputWorkflowReader = new StringReader(originalWorkflow)) using (var xamlReader = new XamlXmlReader(inputWorkflowReader)) { var result = ExpressionTranslator.Translate(xamlReader); if (result.Errors.Count > 0) { var message = CreateErrorMessage(result); throw new ApplicationException(message); } else { return(CreateXamlString(result.Output)); } } }
/// <summary> /// Returns rows count on specific condition from specified table. /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> public static int Count <T>(this DbConnection connector, Expression <Func <T, bool> > predicate) where T : class { if (connector == null) { throw new InvalidCastException($"{connector.GetType().FullName} cannot be use with this extension (expected to get instance of {typeof(DbConnection).FullName}"); } var constraint = RDapter.Global.GetSchemaConstraint <T>(); var tableName = constraint.TableName; var exprTranslator = new ExpressionTranslator <T>(); var translateResult = exprTranslator.Translate(predicate); var query = $"SELECT COUNT(*) FROM {tableName} WHERE {translateResult.Expression}"; var ec = new ExecutionCommand(query, translateResult.Parameters, System.Data.CommandType.Text, null); var count = connector.ExecuteScalar(ec); var countAsString = count.ToString(); return(int.Parse(countAsString)); }
public void TestAndQueryable() { // Arrange var translator = new ExpressionTranslator(); Expression <Func <IQueryable <EmployeeEntity>, IQueryable <EmployeeEntity> > > expression = query => query.Where(e => e.Workstation == "EPRUIZHW006" && e.Manager.StartsWith("John")); // Act var result = translator.Translate(expression); var lines = result.Split(Environment.NewLine); // Assert Assert.AreEqual(2, lines.Length); Assert.AreEqual("Workstation:(EPRUIZHW006)", lines[0]); Assert.AreEqual("Manager:(John*)", lines[1]); }
public virtual void Translate(MethodCallExpression method, ITranslationResult result) { if (method.Method.Name != _methodName) { throw new ArgumentOutOfRangeException($"Method '{nameof(method)}' is not supported"); } var expressionTranslator = new ExpressionTranslator(_nameChanges); MethodCallExpression targetMethod = method; if (method.Arguments.Count == 1 && method.Arguments[0].NodeType == ExpressionType.Call) { targetMethod = (MethodCallExpression)method.Arguments[0]; } expressionTranslator.Translate(result, targetMethod); expressionTranslator.AddPostProcessing(method); }
public string GetExistsString <T>(string collectionName, Expression <Func <T, Boolean> > filter) { ExpressionTranslator expressionTranslator = new ExpressionTranslator(); DbCollection collection = _collections[collectionName]; StringBuilder str = new StringBuilder(); str.Append(" select count(*) from ["); str.Append(collectionName); str.Append("] "); string sqlWhere = filter == null ? "" : expressionTranslator.Translate <T>(filter); str.Append(string.IsNullOrEmpty(sqlWhere) ? " " : " where " + sqlWhere); return(str.ToString()); }
public virtual void Translate(MethodCallExpression method, ITranslationResult result) { if (method.Method.Name != _methodName) { string message = string.Format(Resources.TranslatorMethodNotSupported, method.Method.Name); throw new ArgumentOutOfRangeException(nameof(method), message); } var expressionTranslator = new ExpressionTranslator(_nameChanges); MethodCallExpression targetMethod = method; if (method.Arguments.Count == 1 && method.Arguments[0].NodeType == ExpressionType.Call) { targetMethod = (MethodCallExpression)method.Arguments[0]; } expressionTranslator.Translate(result, targetMethod); expressionTranslator.AddPostProcessing(method); }
public string GetUpdateString <T>(string collectionName, Expression <Func <T, Boolean> > filter, T entity) { ExpressionTranslator expressionTranslator = new ExpressionTranslator(); DbCollection collection = _collections[collectionName]; StringBuilder str = new StringBuilder(); str.Append(" update ["); str.Append(collectionName); str.Append("] "); str.Append(" set "); str.Append(collection.GetFieldValuesForUpdate(entity)); string sqlWhere = filter == null ? "" : expressionTranslator.Translate <T>(filter); str.Append(string.IsNullOrEmpty(sqlWhere) ? " " : " where " + sqlWhere); return(str.ToString()); }
public static XElement TranslateString(string xamlFile) { string translatedWorkflowString = null; using (XamlReader xamlReader = new XamlXmlReader( new StringReader(xamlFile))) { TranslationResults result = ExpressionTranslator.Translate(xamlReader); if (result.Errors.Count == 0) { StringBuilder sb = new StringBuilder(); using (XmlWriter xmlWriter = XmlWriter.Create(sb, new XmlWriterSettings { Indent = true, OmitXmlDeclaration = true })) { using (XamlXmlWriter writer = new XamlXmlWriter(xmlWriter, result.Output.SchemaContext)) { XamlServices.Transform(result.Output, writer); } } translatedWorkflowString = sb.ToString(); } else { string error = "Translation errors"; for (int i = 0; i < result.Errors.Count; i++) { error = error + " :::: [A:" + result.Errors[i].ActivityId + ", Line" + result.Errors[i].StartLine + "] \"" + result.Errors[i].ExpressionText + "\" (" + result.Errors[i].Message + ")"; } throw new InvalidOperationException(error); } } return(XElement.Parse(translatedWorkflowString)); }