internal override SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc) { if (Mode == SqlProvider.ProviderMode.Oracle) { sb.Append(spc.Function.MappedName); } else { sb.Append("begin "); var returnType = spc.Function.Method.ReturnType; if (returnType != typeof(void)) { sb.Append(":RETURN_VALUE := "); } WriteName(spc.Function.MappedName); sb.Append("("); int count = spc.Function.Parameters.Count; for (int i = 0; i < count; i++) { MetaParameter parameter = spc.Function.Parameters[i]; if (i > 0) { sb.Append(", "); } Visit(spc.Arguments[i]); } sb.Append("); "); sb.Append("end;"); } return(spc); }
internal override SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc) { this.VisitUserQuery(spc); int num = 0; int count = spc.Function.Parameters.Count; while (num < count) { MetaParameter p = spc.Function.Parameters[num]; var node = spc.Arguments[num] as SqlParameter; if (node != null) { node.Direction = GetParameterDirection(p); Debug.Assert(!string.IsNullOrEmpty(p.MappedName)); node.Name = p.MappedName; if ((node.Direction == ParameterDirection.InputOutput) || (node.Direction == ParameterDirection.Output)) { RetypeOutParameter(node); } } num++; } //var parameter3 = new SqlParameter(typeof(int?), // parameterizer.TypeProvider.From(typeof(int)), // "@RETURN_VALUE", spc.SourceExpression) { Direction = ParameterDirection.Input }; //this.currentParams.Add(new SqlParameterInfo(parameter3)); return(spc); }
internal override SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc) { this.VisitUserQuery(spc); for (int i = 0, n = spc.Function.Parameters.Count; i < n; i++) { MetaParameter mp = spc.Function.Parameters[i]; SqlParameter arg = spc.Arguments[i] as SqlParameter; if (arg != null) { arg.Direction = this.GetParameterDirection(mp); if (arg.Direction == ParameterDirection.InputOutput || arg.Direction == ParameterDirection.Output) { // Text, NText and Image parameters cannot be used as output parameters // so we retype them if necessary. RetypeOutParameter(arg); } } } // add default return value SqlParameter p = new SqlParameter(typeof(int?), this.parameterizer.typeProvider.From(typeof(int)), "@RETURN_VALUE", spc.SourceExpression); p.Direction = System.Data.ParameterDirection.Output; this.currentParams.Add(new SqlParameterInfo(p)); return(spc); }
public static TypeModel GetDomainType(this MetaParameter parameter, ITypeModelRegistry registry) { TypeModel parameterType; if (parameter.Type.Type is Aggregate aggregate && aggregate.UniqueIdentifier != null) { parameterType = aggregate.UniqueIdentifier.Type.Resolve(registry); }
public static XElement Adapt(this MetaParameter parameter) { return(new XElement(Namespace + "Parameter", new XAttribute("Name", parameter.Name), new XAttribute("Direction", (parameter.ParameterType.IsByRef ? "InOut" : "In")), new XAttribute("Parameter", parameter.ParameterType.NonNullableType()), new XAttribute("DbType", parameter.DbType) )); }
public void Enrich(string url, MetaOperation operation, IServiceProvider serviceProvider) { if (!Enabled) { return; } if (operation.url == null) { operation.url = MetaUrl.FromRaw(url); } var transforms = serviceProvider.GetServices <ITextTransform>(); var cases = transforms.Select(x => x.Name.ToLowerInvariant()).ToList(); var multiCaseParameter = new MetaParameter { key = MultiCaseOperator, value = cases.FirstOrDefault() ?? string.Empty, description = $"Transforms responses to alternative cases. Valid values are: {string.Join(", ", cases)}.", disabled = true }; var envelopeParameter = new MetaParameter { key = EnvelopeOperator, value = "1", description = "Transforms responses to include more information in the payload for constrained clients.", disabled = true }; var prettyPrintParameter = new MetaParameter { key = PrettyPrintOperator, value = "1", description = "Enhances readability of responses by adding whitespace and nesting.", disabled = true }; var trimParameter = new MetaParameter { key = TrimOperator, value = "1", description = "Reduces response weight by omitting null and default values.", disabled = true }; operation.url.query ??= operation.url.query = new List <MetaParameter>(); operation.url.query.AddRange(new[] { multiCaseParameter, envelopeParameter, trimParameter, prettyPrintParameter }); }
public static string GetDomainName(this MetaParameter parameter) { if (parameter.Type.Type is Aggregate aggregate && aggregate.UniqueIdentifier != null) { if (!parameter.IsCollection) { return($"{parameter.Name}{aggregate.UniqueIdentifier.Name}"); } } return(parameter.Name); }
//private int index = 0; //internal override string CreateParameterName() //{ // return (FirebirdIdentifier.Instance.ParameterPrefix + "p" + index++); //} #region MyRegion //internal override SqlParameter InsertLookup(SqlValue cp) //{ // SqlParameterInfo info; // if (!map.TryGetValue(cp, out info)) // { // var parameterName = cp.Value == null ? "NULL" : CreateParameterName(); // var parameter = new SqlParameter(cp.ClrType, cp.SqlType, // parameterName, // cp.SourceExpression); // info = new SqlParameterInfo(parameter, cp.Value); // map.Add(cp, info); // currentParams.Add(info); // } // return info.Parameter; //} #endregion internal override SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc) { VisitUserQuery(spc); int num = 0; int count = spc.Function.Parameters.Count; while (num < count) { MetaParameter p = spc.Function.Parameters[num]; var node = spc.Arguments[num] as SqlParameter; if (node != null) { node.Direction = GetParameterDirection(p); Debug.Assert(!string.IsNullOrEmpty(p.MappedName)); node.Name = p.MappedName; if ((node.Direction == ParameterDirection.InputOutput) || (node.Direction == ParameterDirection.Output)) { RetypeOutParameter(node); } } num++; } var returnType = spc.Function.Method.ReturnType; if (returnType != typeof(void)) { if (returnType.IsValueType || returnType == typeof(string)) { IProviderType paramType = parameterizer.TypeProvider.From(returnType); var parameter3 = new SqlParameter(returnType, paramType, ":RETURN_VALUE", spc.SourceExpression) { Direction = ParameterDirection.Output }; currentParams.Add(new SqlParameterInfo(parameter3)); } //else if (returnType.IsGenericType && // ((returnType.GetGenericTypeDefinition() == typeof(IEnumerable<>)) || // (returnType.GetGenericTypeDefinition() == typeof(ISingleResult<>)))) //{ // //paramType = parameterizer.TypeProvider.From(typeof(OracleRefCursor)); //} //else //{ // throw SqlClient.Error.InvalidReturnFromSproc(returnType); //} } return(spc); }
//Método para obteção dos parâmetros de um componente. public List <MetaParameter> getParameters(XmlNodeList nodes) { if (nodes != null) { IEnumerator ienum = (IEnumerator)nodes.GetEnumerator(); List <MetaParameter> parameterList = new List <MetaParameter> (); MetaParameter parameter; XmlNode data; while (ienum.MoveNext()) { XmlNode paramNode = (XmlNode)ienum.Current; parameter = new MetaParameter(); parameter.Id = generator.genId(); parameter.Identifier = paramNode.SelectSingleNode("identifier").InnerText; data = paramNode.SelectSingleNode("variable"); if (data != null) { parameter.Variable = data.InnerText; } data = paramNode.SelectSingleNode("constraint"); if (data != null) { MetaHashComponent limitComponent = new MetaHashComponent(); limitComponent.Id = generator.genId(); data = data.SelectSingleNode("componentConstraint"); limitComponent.Name = data.InnerText; XmlNodeList subParamList = data.SelectNodes("parameter"); limitComponent.Parameters = getParameters(subParamList); parameter.Constrain = limitComponent; } parameterList.Add(parameter); } if (parameterList.Count > 0) { return(parameterList); } } return(null); }
internal static ParameterDirection GetParameterDirection(MetaParameter p) { if (p.Parameter.IsRetval) { return(ParameterDirection.ReturnValue); } if (p.Parameter.IsOut) { return(ParameterDirection.Output); } if (p.Parameter.ParameterType.IsByRef) { return(ParameterDirection.InputOutput); } return(ParameterDirection.Input); }
private Data.ParameterDirection GetParameterDirection(MetaParameter p) { if (p.Parameter.IsRetval) { return(Data.ParameterDirection.ReturnValue); } if (p.Parameter.IsOut) { return(Data.ParameterDirection.Output); } if (p.Parameter.ParameterType.IsByRef) { return(Data.ParameterDirection.InputOutput); } return(Data.ParameterDirection.Input); }
internal override SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc) { sb.Append("EXECUTE "); sb.Append(spc.Function.MappedName); sb.Append(" "); int count = spc.Function.Parameters.Count; for (int i = 0; i < count; i++) { MetaParameter parameter = spc.Function.Parameters[i]; sb.Append(parameter.MappedName); if (i < count - 1) { sb.Append(", "); } parameterNames.Add(((SqlParameter)spc.Arguments[i]).Name); } return(spc); }
private System.Data.ParameterDirection GetParameterDirection(MetaParameter p) { if (p.Parameter.IsRetval) { return(System.Data.ParameterDirection.ReturnValue); } else if (p.Parameter.IsOut) { return(System.Data.ParameterDirection.Output); } else if (p.Parameter.ParameterType.IsByRef) { return(System.Data.ParameterDirection.InputOutput); } else { return(System.Data.ParameterDirection.Input); } }
internal override SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc) { var returnType = spc.Function.Method.ReturnType; if (returnType != typeof(void)) { var parameter3 = new SqlParameter(returnType, parameterizer.TypeProvider.From(returnType), "@RETURN_VALUE", spc.SourceExpression) { Direction = ParameterDirection.Output }; this.currentParams.Add(new SqlParameterInfo(parameter3)); } this.VisitUserQuery(spc); int num = 0; int count = spc.Function.Parameters.Count; while (num < count) { MetaParameter p = spc.Function.Parameters[num]; var node = spc.Arguments[num] as SqlParameter; if (node != null) { node.Direction = GetParameterDirection(p); node.Name = p.MappedName.StartsWith("@") ? p.MappedName : "@" + p.MappedName; if ((node.Direction == ParameterDirection.InputOutput) || (node.Direction == ParameterDirection.Output)) { RetypeOutParameter(node); } } num++; } //var parameter3 = new SqlParameter(typeof(int?), // parameterizer.TypeProvider.From(typeof(int)), // "@RETURN_VALUE", spc.SourceExpression) { Direction = ParameterDirection.Output }; //currentParams.Add(new SqlParameterInfo(parameter3)); return(spc); }
/// <summary> /// Implements the constructor: MetaParameter() /// Direct superclasses: global::MetaDslx.Core.MetaNamedElement, global::MetaDslx.Core.MetaTypedElement, global::MetaDslx.Core.MetaAnnotatedElement /// All superclasses: global::MetaDslx.Core.MetaNamedElement, global::MetaDslx.Core.MetaDocumentedElement, global::MetaDslx.Core.MetaTypedElement, global::MetaDslx.Core.MetaAnnotatedElement /// </summary> public virtual void MetaParameter(MetaParameter @this) { this.MetaNamedElement(@this); this.MetaTypedElement(@this); this.MetaAnnotatedElement(@this); }
public override void RemoveParameter(MetaType metaType, MetaMethod metaMethod, MetaParameter metaParameter) { this.model.RemoveParameter(metaType, metaMethod, metaParameter); }
public override void UpdateParameter(MetaType metaType, MetaMethod metaMethod, MetaParameter oldParameter, MetaParameter newParameter) { this.model.UpdateParameter(metaType, metaMethod, oldParameter, newParameter); }
private static MethodParameter GenerateMethodParameter(ITypeModelRegistry registry, MetaParameter p) { return(new MethodParameter(p.GetDomainName(), p.GetDomainType(registry))); }
public virtual void UpdateParameter(MetaType metaType, MetaMethod metaMethod, MetaParameter oldParameter, MetaParameter newParameter) { }
public virtual void RemoveParameter(MetaType metaType, MetaMethod metaMethod, MetaParameter metaParameter) { }
internal override SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc) { var returnType = spc.Function.Method.ReturnType; if (returnType != typeof(void))//(QueryConverter.IsValidateReturnType(returnType)) { IProviderType paramType; if (returnType.IsValueType || returnType == typeof(string)) { paramType = parameterizer.TypeProvider.From(returnType); } else if (returnType.IsGenericType && ((returnType.GetGenericTypeDefinition() == typeof(IEnumerable <>)) || (returnType.GetGenericTypeDefinition() == typeof(ISingleResult <>)))) { //paramType = parameterizer.TypeProvider.From(typeof(OracleRefCursor)); throw new NotImplementedException(); } else { try { paramType = parameterizer.TypeProvider.From(returnType); } catch (Exception) { throw SqlClient.Error.InvalidReturnFromSproc(returnType); } } var parameter3 = new SqlParameter(returnType, paramType, "@RETURN_VALUE", spc.SourceExpression) { Direction = ParameterDirection.Output }; currentParams.Add(new SqlParameterInfo(parameter3)); } this.VisitUserQuery(spc); //if (returnType != typeof(void)) int num = 0; int count = spc.Function.Parameters.Count; while (num < count) { MetaParameter p = spc.Function.Parameters[num]; var node = spc.Arguments[num] as SqlParameter; if (node != null) { if (string.Equals(p.DbType, "Cursor", System.StringComparison.CurrentCultureIgnoreCase)) { node.Direction = ParameterDirection.Output; } else { node.Direction = GetParameterDirection(p); } Debug.Assert(!string.IsNullOrEmpty(p.MappedName)); node.Name = p.MappedName.StartsWith(":") ? p.MappedName : ":" + p.MappedName;//p.MappedName; if ((node.Direction == ParameterDirection.InputOutput) || (node.Direction == ParameterDirection.Output)) { RetypeOutParameter(node); } } num++; } return(spc); }
public static XElement AdaptAsReturnType(this MetaParameter parameter) { return(new XElement(Namespace + "Return", new XAttribute("DbType", Type.GetTypeCode(parameter.ParameterType.NonNullableType()).ToString()) )); }