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