public FunctionMappings() : base() { FunctionMapping mapping = new FunctionMapping(typeof(Functions), "Like", 2, "{0} LIKE {1}"); this.Add(mapping); }
public override DynamicMetaObject BindInvokeMember( InvokeMemberBinder binder, DynamicMetaObject[] args) { var expressionFunctionConstructor = typeof(ExpressionFunction).GetConstructor(new[] { typeof(string), typeof(IEnumerable<object>) }); if (FunctionMapping.ContainsFunction(binder.Name, args.Length)) { var expression = Expression.New(CtorWithExpressionAndExpressionFunction, Expression.Convert(Expression, LimitType), Expression.New(expressionFunctionConstructor, Expression.Constant(binder.Name), Expression.NewArrayInit(typeof(object), args.Select(x => Expression.Convert(x.Expression, typeof(object)))))); return new DynamicMetaObject( expression, BindingRestrictions.GetTypeRestriction(Expression, LimitType)); } if (string.Equals(binder.Name, ODataLiteral.Any, StringComparison.OrdinalIgnoreCase) || string.Equals(binder.Name, ODataLiteral.All, StringComparison.OrdinalIgnoreCase)) { var expression = Expression.New(CtorWithExpressionAndExpressionFunction, Expression.Convert(Expression, LimitType), Expression.New(expressionFunctionConstructor, Expression.Constant(binder.Name), Expression.NewArrayInit(typeof(object), args.Select(x => Expression.Convert(x.Expression, typeof(object)))))); return new DynamicMetaObject( expression, BindingRestrictions.GetTypeRestriction(Expression, LimitType)); } if (string.Equals(binder.Name, ODataLiteral.IsOf, StringComparison.OrdinalIgnoreCase) || string.Equals(binder.Name, ODataLiteral.Is, StringComparison.OrdinalIgnoreCase) || string.Equals(binder.Name, ODataLiteral.Cast, StringComparison.OrdinalIgnoreCase) || string.Equals(binder.Name, ODataLiteral.As, StringComparison.OrdinalIgnoreCase)) { var functionName = string.Equals(binder.Name, ODataLiteral.Is, StringComparison.OrdinalIgnoreCase) ? ODataLiteral.IsOf : string.Equals(binder.Name, ODataLiteral.As, StringComparison.OrdinalIgnoreCase) ? ODataLiteral.Cast : binder.Name; var isNullProperty = typeof(DynamicODataExpression).GetProperty(nameof(IsNull)); var expressionFunctionArguments = Expression.Condition(Expression.MakeMemberAccess(Expression.Convert(Expression, LimitType), isNullProperty), Expression.Convert(Expression, typeof(object)), Expression.Convert(args.First().Expression, typeof(object))); var expression = Expression.New(CtorWithExpressionAndExpressionFunction, Expression.Convert(Expression, LimitType), Expression.New(expressionFunctionConstructor, Expression.Constant(functionName), Expression.NewArrayInit(typeof(object), expressionFunctionArguments))); return new DynamicMetaObject( expression, BindingRestrictions.GetTypeRestriction(Expression, LimitType)); } return base.BindInvokeMember(binder, args); }
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> public FunctionColumnMapping( IProperty property, FunctionColumn column, FunctionMapping viewMapping) : base(property, column, viewMapping) { }
internal static FunctionMapping ReadFunctionMapping(XmlReader reader) { if (!IsInNamespace(reader) || (reader.LocalName != "Function")) { throw Error.UnexpectedElement("Function", string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}", new object[] { reader.Prefix, string.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName })); } ValidateAttributes(reader, new string[] { "Name", "Method", "IsComposable" }); FunctionMapping mapping = new FunctionMapping(); mapping.MethodName = RequiredAttribute(reader, "Method"); mapping.Name = OptionalAttribute(reader, "Name"); mapping.IsComposable = OptionalBoolAttribute(reader, "IsComposable", false); if (reader.IsEmptyElement) { reader.Skip(); return(mapping); } reader.ReadStartElement(); reader.MoveToContent(); while (reader.NodeType != XmlNodeType.EndElement) { if ((reader.NodeType == XmlNodeType.Whitespace) || !IsInNamespace(reader)) { reader.Skip(); continue; } string localName = reader.LocalName; if (localName == null) { goto Label_016C; } if (!(localName == "Parameter")) { if (localName == "ElementType") { goto Label_014A; } if (localName == "Return") { goto Label_015E; } goto Label_016C; } mapping.Parameters.Add(ReadParameterMapping(reader)); goto Label_01BC; Label_014A: mapping.Types.Add(ReadElementTypeMapping(null, reader)); goto Label_01BC; Label_015E: mapping.FunReturn = ReadReturnMapping(reader); goto Label_01BC; Label_016C :; throw Error.UnrecognizedElement(string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}", new object[] { reader.Prefix, string.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName })); Label_01BC: reader.MoveToContent(); } reader.ReadEndElement(); return(mapping); }
/** * retrieve function defintions using contract as an identifier to traverse the FunctionMapping. */ public HashSet <FunctionDefinition> returnFunctionDefs(ContractDefinition contract) { if (FunctionMapping.ContainsKey(contract)) { return(FunctionMapping[contract]); } return(new HashSet <FunctionDefinition>()); }
private string FormatMappedFunction(ExpressionContext context, FunctionMapping mapping) { var mappedFunction = mapping.FunctionMapper( Function.FunctionName, _functionCaller, Function.Arguments).Function; var formattedArguments = string.Join(",", (IEnumerable <object>)mappedFunction.Arguments.Select(x => FormatExpression(x, context))); return($"{mappedFunction.FunctionName}({formattedArguments})"); }
private static FunctionDefinition CreateFunctionDefinition(string functionName, int argumentCount, string mappedFunctionName, Func <FunctionDefinition, Func <string, ODataExpression, IEnumerable <object>, ODataExpression> > mapper, AdapterVersion adapterVersion = AdapterVersion.Any) { var functionCall = new ExpressionFunction.FunctionCall(functionName, argumentCount); var functionMapping = new FunctionMapping(mappedFunctionName); var function = new FunctionDefinition(functionCall, functionMapping, adapterVersion); functionMapping.FunctionMapper = mapper(function); return(function); }
public IEnumerable <PhysicianMaster> Search(string firstName, string lastName, string zipcode, int pageNumber, int pageSize, out int totalRecords) { using (var adapter = PersistenceLayer.GetDataAccessAdapter()) { var linqMetaData = new LinqMetaData(adapter); var query = (from pm in linqMetaData.PhysicianMaster where pm.IsActive select pm); if (!string.IsNullOrEmpty(zipcode)) { //query = (from q in query where q.PracticeZip == zipcode select q); var zipInRange = _zipcodeRepository.GetZipCodesInRadius(zipcode, 10); var zipCodesInRange = zipInRange != null?zipInRange.Select(zcir => zcir.Zip).ToList() : null; if (!(zipCodesInRange == null || zipCodesInRange.IsEmpty())) { var mapping = new FunctionMapping(this.GetType(), "IndexOf", 2, " charindex({0}, {1})"); if (linqMetaData.CustomFunctionMappings == null) { linqMetaData.CustomFunctionMappings = new FunctionMappingStore(); } linqMetaData.CustomFunctionMappings.Add(mapping); mapping = new FunctionMapping(typeof(Convert), "ToString", 1, "',' + Convert(varchar, {0}) + ','"); linqMetaData.CustomFunctionMappings.Add(mapping); string zipIdstring = "," + string.Join(",", zipCodesInRange) + ","; query = from pm in linqMetaData.PhysicianMaster where pm.IsActive && IndexOf(Convert.ToString(pm.PracticeZip), zipIdstring) > 0 select pm; } } if (!string.IsNullOrEmpty(firstName)) { query = (from q in query where q.FirstName.Contains(firstName) select q); } if (!string.IsNullOrEmpty(lastName)) { query = (from q in query where q.LastName.Contains(lastName) select q); } query = (from q in query orderby q.FirstName, q.LastName, q.PhysicianMasterId select q); totalRecords = query.Count(); var entities = query.TakePage(pageNumber, pageSize).ToList(); return(Mapper.Map <IEnumerable <PhysicianMasterEntity>, IEnumerable <PhysicianMaster> >(entities)); } }
public void Should_map_complex_parameter() { mapping.Map(x => x.GetCustomersByName( FunctionMapping <object> .Parameter <string>( param => param.Named("Foo").DbType("Bar") ) )); mapping.ToXml().Single() .ShouldHaveElement("Parameter") .ShouldHaveAttribute("Parameter", "name") .ShouldHaveAttribute("Name", "Foo") .ShouldHaveAttribute("DbType", "Bar"); }
private static FunctionMapping FromSourceMapping(FunctionMapping mapping) { var selector = mapping.ResultSelector; var func = mapping.Function; Debug.Assert(selector != null); LiftModelToViewItem(ref selector); if (func is Count) { func = new Sum(); } return(new FunctionMapping(selector, selector, func)); }
//Function to insert a function into the specified contract. public void InsertFunctionInContract(ContractDefinition contract, FunctionDefinition funcDef) { if (FunctionMapping.ContainsKey(contract) == false) { Debug.Assert(!FunctionSignatureMapping.ContainsKey(contract)); FunctionMapping[contract] = new HashSet <FunctionDefinition>(); FunctionSignatureMapping[contract] = new HashSet <string>(); } Debug.Assert(!FunctionMapping[contract].Contains(funcDef), $"Repeated function warning: {funcDef.Name}"); FunctionMapping[contract].Add(funcDef); string signature = Conversion_Utility_Tool.ComputeFunctionSignature(funcDef); FunctionSignatureMapping[contract].Add(signature); Debug.Assert(!FunctionToContractMap.ContainsKey(funcDef), $" Repeated function warning: {funcDef.Name}"); FunctionToContractMap[funcDef] = contract; }
public void Should_obtain_parameter_for_complex_method() { Expression <Func <FunctionMappingParserTester, object> > expr = x => x.GetCustomersByName( FunctionMapping <FunctionParameterMappingTester> .Parameter <string>(param => param.DbType("foo") ) ); var visitor = new FunctionMappingExpressionParser(expr); var results = visitor.Process(); results.Parameters.Length.ShouldEqual(1); var parameter = results.Parameters[0]; parameter.Attributes["Parameter"].ShouldEqual("name"); parameter.Attributes["DbType"].ShouldEqual("foo"); }
public override DynamicMetaObject BindGetMember(GetMemberBinder binder) { ConstructorInfo ctor; Expression[] ctorArguments; if (FunctionMapping.ContainsFunction(binder.Name, 0)) { ctor = CtorWithExpressionAndString; ctorArguments = new Expression[] { Expression.Convert(Expression, LimitType), Expression.Constant(binder.Name) }; } else { Expression<Func<bool, ODataExpression, string>> calculateReference = (hv, e) => hv && !string.IsNullOrEmpty(e.Reference) ? string.Join("/", e.Reference, binder.Name) : binder.Name; var referenceExpression = Expression.Invoke(calculateReference, Expression.Constant(HasValue), Expression.Convert(Expression, LimitType)); ctor = CtorWithString; ctorArguments = new Expression[] { referenceExpression }; } return new DynamicMetaObject( Expression.New(ctor, ctorArguments), BindingRestrictions.GetTypeRestriction(Expression, LimitType)); }
internal static FunctionMapping ReadFunctionMapping(XmlReader reader) { System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element); if (!IsInNamespace(reader) || reader.LocalName != XmlMappingConstant.Function) { throw Error.UnexpectedElement(XmlMappingConstant.Function, String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName)); } ValidateAttributes(reader, new[] { XmlMappingConstant.Name, XmlMappingConstant.Method, XmlMappingConstant.IsComposable }); FunctionMapping fm = new FunctionMapping(); fm.MethodName = RequiredAttribute(reader, XmlMappingConstant.Method); fm.Name = OptionalAttribute(reader, XmlMappingConstant.Name); fm.IsComposable = OptionalBoolAttribute(reader, XmlMappingConstant.IsComposable, false); if (!reader.IsEmptyElement) { reader.ReadStartElement(); reader.MoveToContent(); while (reader.NodeType != XmlNodeType.EndElement) { if (reader.NodeType == XmlNodeType.Whitespace || !IsInNamespace(reader)) { reader.Skip(); continue; } switch (reader.LocalName) { case XmlMappingConstant.Parameter: fm.Parameters.Add(ReadParameterMapping(reader)); break; case XmlMappingConstant.ElementType: fm.Types.Add(ReadElementTypeMapping(null, reader)); break; case XmlMappingConstant.Return: fm.FunReturn = ReadReturnMapping(reader); break; default: throw Error.UnrecognizedElement(String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName)); } reader.MoveToContent(); } reader.ReadEndElement(); } else { // no content is okay reader.Skip(); } return(fm); }
/// <summary> /// The call for this function is generated in order to simplify the filtering below. This is not usually necessary for IQueryable<object> /// However, LLBLGen has problems with IQuerable when the type is casted to object, so the proper typed call is generated above and this generic is called. /// </summary> /// <typeparam name="TEntity"></typeparam> /// <param name="dataTableInit"></param> /// <param name="model"></param> /// <returns></returns> private static JsonResult Query <TEntity>(DataTablesInitializationModel <TEntity> dataTableInit, DataTablesRequestModel model) { // Get source model used to create the view. var source = dataTableInit.Source; // get IQueryable type of object passed in, this makes the work below generalized for any type /*var source2 = source as IQueryable<PatientEntity>; * if(source2 != null) * { * source2 = source2.Where(x => Convert.ToString(x.BirthDate, new DateTimeFormatInfo(){ShortDatePattern = }).Contains("fe")); * * var result = source2.ToList(); * } */ // start with the source, then add on each filter var count = source.Count(); var displayCount = count; if (!String.IsNullOrEmpty(model.sSearch)) { var llblGenProProvider = source.Provider as LLBLGenProProvider; if (llblGenProProvider != null) { var dateConverter = new FunctionMapping(typeof(DateTime), "ToString", 0, @"CONVERT(nvarchar(2), CONVERT(int, SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 6, 2))) + '/' + CONVERT(nvarchar(2), CONVERT(int, SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 9, 2))) + '/' + CONVERT(nvarchar(4), CONVERT(int, SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 1, 4))) + ' ' + CASE WHEN CONVERT(int, SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 12, 2)) > 12 THEN CONVERT(nvarchar(4), CONVERT(int, SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 12, 2)) - 12) ELSE CONVERT(nvarchar(4), CONVERT(int, SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 12, 2))) END +':' +SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 15, 2) + ':' + SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 18, 2) + CASE WHEN CONVERT(int, SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 12, 2)) > 11 THEN ' PM' ELSE ' AM' END"); //var indexOf = new FunctionMapping(typeof(string), "IndexOf", 1, "PATINDEX('%{1}%', {0}) - 1"); //var indexOf2 = new FunctionMapping(typeof(string), "IndexOf", 2, "PATINDEX('%{1}%', {0}) - 1"); if ((llblGenProProvider).CustomFunctionMappings == null) { (llblGenProProvider).CustomFunctionMappings = new FunctionMappingStore(); } (llblGenProProvider).CustomFunctionMappings.Add(dateConverter); //(llblGenProProvider).CustomFunctionMappings.Add(indexOf); //(llblGenProProvider).CustomFunctionMappings.Add(indexOf2); // ^--- Doesn't work for no apparent reason but would make the Search() function a lot simpler. } // search all specified columns for the specified string source = source.Search(dataTableInit.Columns, model.sSearch, !(source.Provider is LLBLGenProProvider)); displayCount = source.Count(); } // sort the result based on the model, this calls OrderBy on multiple columns sequentially if (model.Sorts.Any()) { source = source.Sort(dataTableInit.Columns, model.Sorts); } // filter page based on start and length, this is like the SQL LIMIT directive if (model.iDisplayLength > 0) { source = source.Skip(model.iDisplayStart).Take(model.iDisplayLength); } // now build the response var response = new DataTablesResponseModel { sEcho = model.sEcho.Value, iTotalRecords = count, iTotalDisplayRecords = displayCount }; // loop through each item and output JSON foreach (TEntity entity in source.ToList()) { var row = response.NewRow(); row.SetRowId(string.Empty + entity.GetHashCode()); foreach (var column in dataTableInit.Columns) { // if the column specifies a formatting function if (column.Format != null) { var method = column.Format.Compile(); row.PushColumn(method.Invoke(entity).ToString()); } else { var value = DataBinder.Eval(entity, column.ColumnName); row.PushColumn(value != null ? value.ToString() : ""); } } } return(new JsonResult { Data = response, ContentType = null, ContentEncoding = null, JsonRequestBehavior = JsonRequestBehavior.AllowGet }); }
public void Setup() { mapping = new FunctionMapping<FunctionMappingTester>(); }
public void Setup() { mapping = new FunctionMapping <FunctionMappingTester>(); }
public FunctionDefinition(ExpressionFunction.FunctionCall functionCall, FunctionMapping functionMapping, AdapterVersion adapterVersion = AdapterVersion.Any) { FunctionCall = functionCall; FunctionMapping = functionMapping; AdapterVersion = adapterVersion; }
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine)] // FindType method call. internal MappedFunction(MappedMetaModel model, FunctionMapping map, MethodInfo method) { this.model = model; this.map = map; this.method = method; this.rowTypes = _emptyTypes; if (map.Types.Count == 0 && this.method.ReturnType == typeof(IMultipleResults)) { throw Error.NoResultTypesDeclaredForFunction(method.Name); } else if (map.Types.Count > 1 && this.method.ReturnType != typeof(IMultipleResults)) { throw Error.TooManyResultTypesDeclaredForFunction(method.Name); } else if (map.Types.Count == 1 && this.method.ReturnType != typeof(IMultipleResults)) { Type elementType = TypeSystem.GetElementType(method.ReturnType); this.rowTypes = new List <MetaType>(1) { this.GetMetaType(map.Types[0], elementType) }.AsReadOnly(); } else if (map.Types.Count > 0) { List <MetaType> rowTypes = new List <MetaType>(); foreach (TypeMapping rtm in map.Types) { Type elementType = model.FindType(rtm.Name); if (elementType == null) { throw Error.CouldNotFindElementTypeInModel(rtm.Name); } MetaType mt = this.GetMetaType(rtm, elementType); // Only add unique meta types if (!rowTypes.Contains(mt)) { rowTypes.Add(mt); } } this.rowTypes = rowTypes.AsReadOnly(); } else if (map.FunReturn != null) { this.returnParameter = new MappedReturnParameter(method.ReturnParameter, map.FunReturn); } // Parameters. ParameterInfo[] pis = this.method.GetParameters(); if (pis.Length > 0) { List <MetaParameter> mps = new List <MetaParameter>(pis.Length); if (this.map.Parameters.Count != pis.Length) { throw Error.IncorrectNumberOfParametersMappedForMethod(this.map.MethodName); } for (int i = 0; i < pis.Length; i++) { mps.Add(new MappedParameter(pis[i], this.map.Parameters[i])); } this.parameters = mps.AsReadOnly(); } else { this.parameters = _emptyParameters; } }
// Methods internal MappedFunction(MappedMetaModel model, FunctionMapping map, MethodInfo method) { this.model = model; this.map = map; this.method = method; rowTypes = _emptyTypes; if ((map.Types.Count == 0) && (this.method.ReturnType == typeof(IMultipleResults))) { throw Error.NoResultTypesDeclaredForFunction(method.Name); } if ((map.Types.Count > 1) && (this.method.ReturnType != typeof(IMultipleResults))) { throw Error.TooManyResultTypesDeclaredForFunction(method.Name); } if ((map.Types.Count == 1) && (this.method.ReturnType != typeof(IMultipleResults))) { Type elementType = TypeSystem.GetElementType(method.ReturnType); var list = new List <MetaType>(1) { GetMetaType(map.Types[0], elementType) }; rowTypes = list.AsReadOnly(); } else if (map.Types.Count > 0) { var list2 = new List <MetaType>(); foreach (TypeMapping mapping in map.Types) { Type type2 = model.FindType(mapping.Name); if (type2 == null) { throw Error.CouldNotFindElementTypeInModel(mapping.Name); } MetaType metaType = this.GetMetaType(mapping, type2); if (!list2.Contains(metaType)) { list2.Add(metaType); } } this.rowTypes = list2.AsReadOnly(); } else if (map.FunReturn != null) { this.returnParameter = new MappedReturnParameter(method.ReturnParameter, map.FunReturn); } ParameterInfo[] parameters = this.method.GetParameters(); if (parameters.Length > 0) { var list3 = new List <MetaParameter>(parameters.Length); if (this.map.Parameters.Count != parameters.Length) { throw Error.IncorrectNumberOfParametersMappedForMethod(this.map.MethodName); } for (int i = 0; i < parameters.Length; i++) { list3.Add(new MappedParameter(parameters[i], this.map.Parameters[i])); } this.parameters = list3.AsReadOnly(); } else { this.parameters = _emptyParameters; } }
private string FormatFunction(ExpressionContext context) { var adapterVersion = context.Session?.Adapter.AdapterVersion ?? AdapterVersion.Default; if (FunctionToOperatorMapping.TryGetOperatorMapping(_functionCaller, Function, adapterVersion, out var operatorMapping)) { return(FormatMappedOperator(context, operatorMapping)); } if (FunctionMapping.TryGetFunctionMapping(Function.FunctionName, Function.Arguments.Count, adapterVersion, out var functionMapping)) { return(FormatMappedFunction(context, functionMapping)); } else if (string.Equals(Function.FunctionName, ODataLiteral.Any, StringComparison.OrdinalIgnoreCase) || string.Equals(Function.FunctionName, ODataLiteral.All, StringComparison.OrdinalIgnoreCase)) { return(FormatAnyAllFunction(context)); } else if (string.Equals(Function.FunctionName, ODataLiteral.IsOf, StringComparison.OrdinalIgnoreCase) || string.Equals(Function.FunctionName, ODataLiteral.Cast, StringComparison.OrdinalIgnoreCase)) { return(FormatIsOfCastFunction(context)); } else if (string.Equals(Function.FunctionName, "get_Item", StringComparison.Ordinal) && Function.Arguments.Count == 1) { return(FormatArrayIndexFunction(context)); } else if (string.Equals(Function.FunctionName, "HasFlag", StringComparison.Ordinal) && Function.Arguments.Count == 1) { return(FormatEnumHasFlagFunction(context)); } else if (string.Equals(Function.FunctionName, "ToString", StringComparison.Ordinal) && Function.Arguments.Count == 0) { return(FormatToStringFunction(context)); } else if (Function.Arguments.Count == 1) { var val = Function.Arguments.First(); if (val.Value != null) { var formattedVal = ODataExpression.FromValue( string.Equals(Function.FunctionName, "ToBoolean", StringComparison.Ordinal) ? Convert.ToBoolean(val.Value, CultureInfo.InvariantCulture) : string.Equals(Function.FunctionName, "ToByte", StringComparison.Ordinal) ? Convert.ToByte(val.Value, CultureInfo.InvariantCulture) : string.Equals(Function.FunctionName, "ToChar", StringComparison.Ordinal) ? Convert.ToChar(val.Value, CultureInfo.InvariantCulture) : string.Equals(Function.FunctionName, "ToDateTime", StringComparison.Ordinal) ? Convert.ToDateTime(val.Value, CultureInfo.InvariantCulture) : string.Equals(Function.FunctionName, "ToDecimal", StringComparison.Ordinal) ? Convert.ToDecimal(val.Value, CultureInfo.InvariantCulture) : string.Equals(Function.FunctionName, "ToDouble", StringComparison.Ordinal) ? Convert.ToDouble(val.Value, CultureInfo.InvariantCulture) : string.Equals(Function.FunctionName, "ToInt16", StringComparison.Ordinal) ? Convert.ToInt16(val.Value, CultureInfo.InvariantCulture) : string.Equals(Function.FunctionName, "ToInt32", StringComparison.Ordinal) ? Convert.ToInt32(val.Value, CultureInfo.InvariantCulture) : string.Equals(Function.FunctionName, "ToInt64", StringComparison.Ordinal) ? Convert.ToInt64(val.Value, CultureInfo.InvariantCulture) : string.Equals(Function.FunctionName, "ToSByte", StringComparison.Ordinal) ? Convert.ToSByte(val.Value, CultureInfo.InvariantCulture) : string.Equals(Function.FunctionName, "ToSingle", StringComparison.Ordinal) ? Convert.ToSingle(val.Value, CultureInfo.InvariantCulture) : string.Equals(Function.FunctionName, "ToString", StringComparison.Ordinal) ? Convert.ToString(val.Value, CultureInfo.InvariantCulture) : string.Equals(Function.FunctionName, "ToUInt16", StringComparison.Ordinal) ? Convert.ToUInt16(val.Value, CultureInfo.InvariantCulture) : string.Equals(Function.FunctionName, "ToUInt32", StringComparison.Ordinal) ? Convert.ToUInt32(val.Value, CultureInfo.InvariantCulture) : string.Equals(Function.FunctionName, "ToUInt64", StringComparison.Ordinal) ? Convert.ToUInt64(val.Value, CultureInfo.InvariantCulture) : null); if (formattedVal.Value != null) { return(FormatExpression(formattedVal, context)); } } } throw new NotSupportedException($"The function {Function.FunctionName} is not supported or called with wrong number of arguments"); }