protected SqlMethod(SqlMethodInfo methodInfo)
{
if (methodInfo == null)
{
throw new ArgumentNullException(nameof(methodInfo));
}
MethodInfo = methodInfo;
}
public static void MakeProcedureInfo()
{
var name = ObjectName.Parse("a.proc");
var info = new SqlMethodInfo(name);
info.Parameters.Add(new SqlParameterInfo("a", PrimitiveTypes.Integer()));
Assert.Equal(name, info.MethodName);
Assert.NotEmpty(info.Parameters);
}
public static void MatchInvoke()
{
var name = ObjectName.Parse("a.proc");
var info = new SqlMethodInfo(name);
info.Parameters.Add(new SqlParameterInfo("a", PrimitiveTypes.Integer()));
var procedure = new SqlProcedureDelegate(info, methodContext => Task.CompletedTask);
var invoke = new Invoke(name, new[] { new InvokeArgument(SqlObject.BigInt(11)) });
Assert.True(procedure.Matches(null, invoke));
}
private static Dictionary <string, SqlExpression> BuildArguments(SqlMethodInfo methodInfo, Invoke invoke)
{
var result = new Dictionary <string, SqlExpression>();
if (invoke.IsNamed)
{
var invokeArgs = invoke.Arguments.ToDictionary(x => x.Name, y => y.Value);
var methodParams = methodInfo.Parameters.ToDictionary(x => x.Name, y => y);
foreach (var invokeArg in invokeArgs)
{
SqlParameterInfo paramInfo;
if (!methodParams.TryGetValue(invokeArg.Key, out paramInfo))
{
throw new InvalidOperationException(
$"Invoke argument {invokeArg.Key} does not correspond to any parameter of the method");
}
result[invokeArg.Key] = invokeArg.Value;
}
foreach (var methodParam in methodParams)
{
if (!result.ContainsKey(methodParam.Key))
{
var paramInfo = methodParam.Value;
if (paramInfo.IsRequired)
{
throw new InvalidOperationException(
$"The invoke to {methodInfo.MethodName} has no value for required parameter {paramInfo.Name} and no default value was set");
}
result[methodParam.Key] = paramInfo.DefaultValue;
}
}
}
else
{
if (methodInfo.Parameters.Count != invoke.Arguments.Count)
{
throw new NotSupportedException($"Invoke arguments mismatch the number of parameters of {methodInfo.MethodName}");
}
for (int i = 0; i < methodInfo.Parameters.Count; i++)
{
var parmInfo = methodInfo.Parameters[i];
result[parmInfo.Name] = invoke.Arguments[i].Value;
}
}
return(result);
}
public static void GetString()
{
var name = ObjectName.Parse("a.proc");
var info = new SqlMethodInfo(name);
info.Parameters.Add(new SqlParameterInfo("a", PrimitiveTypes.Integer()));
var function = new SqlProcedureDelegate(info, ctx => {
var a = ctx.Value("a");
var b = a.Multiply(SqlObject.BigInt(2));
Console.Out.WriteLine("a * 2 = {0}", b);
});
var sql = $"PROCEDURE a.proc(a INTEGER)";
Assert.Equal(sql, function.ToString());
}
public async Task ExecuteWithNamedArgs()
{
var name = ObjectName.Parse("a.func");
var info = new SqlMethodInfo(name);
info.Parameters.Add(new SqlParameterInfo("a", PrimitiveTypes.Integer()));
var procedure = new SqlProcedureDelegate(info, ctx => {
var a = ctx.Value("a");
var b = a.Multiply(SqlObject.BigInt(2));
Console.Out.WriteLine("a * 2 = {0}", b);
});
Assert.Equal(name, info.MethodName);
var result = await procedure.ExecuteAsync(context, new InvokeArgument("a", SqlObject.Integer(22)));
Assert.NotNull(result);
Assert.False(result.HasReturnedValue);
}
public void Register <TMethod>(SqlMethodInfo methodInfo, params ObjectName[] aliases)
where TMethod : SqlMethod
{
if (methodInfo == null)
{
throw new ArgumentNullException(nameof(methodInfo));
}
var methodName = methodInfo.MethodName.ToUpper();
container.Register <SqlMethod, TMethod>(methodName);
foreach (var alias in aliases)
{
container.Register <SqlMethod, TMethod>(alias.ToUpper());
}
initialized = false;
}
public async void ExecuteWithOutputArgs()
{
var name = ObjectName.Parse("a.proc");
var info = new SqlMethodInfo(name);
info.Parameters.Add(new SqlParameterInfo("a", PrimitiveTypes.Integer()));
info.Parameters.Add(new SqlParameterInfo("b", PrimitiveTypes.Integer(), SqlParameterDirection.Out));
var procedure = new SqlProcedureDelegate(info, ctx => {
var a = ctx.Value("a");
var b = a.Multiply(SqlObject.Integer(2));
ctx.SetOutput("b", SqlExpression.Constant(b));
});
Assert.Equal(name, info.MethodName);
var result = await procedure.ExecuteAsync(context, new InvokeArgument("a", SqlObject.Integer(22)));
Assert.NotNull(result);
Assert.False(result.HasReturnedValue);
Assert.NotEmpty(result.Output);
}
public ParameterCollection(SqlMethodInfo methodInfo)
{
this.methodInfo = methodInfo;
}
internal InvokeInfo(SqlMethodInfo methodInfo, Dictionary <string, SqlType> arguments)
{
MethodInfo = methodInfo;
this.arguments = arguments;
}
protected SqlProcedureBase(SqlMethodInfo methodInfo)
: base(methodInfo)
{
}
public SqlProcedureDelegate(SqlMethodInfo methodInfo, Action <MethodContext> body)
: this(methodInfo, context => {
body(context);
return(Task.CompletedTask);
}) {
}
public SqlProcedureDelegate(SqlMethodInfo methodInfo, Func <MethodContext, Task> body)
: base(methodInfo)
{
this.body = body;
}
