public ResourceAccessSecurityAssert(ObjectName resourceName, DbObjectType resourceType, Privileges privileges)
{
ResourceName = resourceName;
ResourceType = resourceType;
Privileges = privileges;
Arguments = new InvokeArgument[0];
}
public void WithNamedArgument()
{
var procName = ObjectName.Parse("APP.proc1");
var arg = new InvokeArgument("a", SqlExpression.Constant("Hello!"));
AdminQuery.Call(procName, arg);
}
public static InvokeResult Execute(this IRoutine routine, InvokeArgument[] args, IRequest request, IVariableResolver resolver, IGroupResolver group)
{
var invoke = new Invoke(routine.ObjectInfo.FullName, args);
var executeContext = new InvokeContext(invoke, routine, resolver, group, request);
return routine.Execute(executeContext);
}
public void WithNamedArguments()
{
var procName = ObjectName.Parse("APP.proc2");
var arg1 = new InvokeArgument("a", SqlExpression.Constant("Hello"));
var arg2 = new InvokeArgument("b", SqlExpression.Constant("World!"));
AdminQuery.Call(procName, arg1, arg2);
}
public ProcedureTriggerInfo(ObjectName triggerName, ObjectName tableName, TriggerEventTime eventTime, TriggerEventType eventType, ObjectName procedureName, InvokeArgument[] args)
: base(triggerName, TriggerType.External, tableName, eventTime, eventType)
{
if (procedureName == null)
throw new ArgumentNullException("procedureName");
ProcedureName = procedureName;
Arguments = args;
}
/// <summary>
/// Constructs a new <see cref="Invoke"/> with the given
/// name of the routine and the arguments.
/// </summary>
/// <param name="routineName">The fully qualified name of the routine
/// to be invoked.</param>
/// <param name="arguments">The arguments to pass to the routine.</param>
public Invoke(ObjectName routineName, InvokeArgument[] arguments)
{
if (routineName == null)
throw new ArgumentNullException("routineName");
VerifyNamesIn(arguments);
RoutineName = routineName;
Arguments = arguments;
}
public RoutineEvent(RoutineEventType eventType, ObjectName routineName, InvokeArgument[] arguments, RoutineType routineType, InvokeResult result)
{
if (routineName == null)
throw new ArgumentNullException("routineName");
EventType = eventType;
RoutineName = routineName;
Arguments = arguments;
RoutineType = routineType;
Result = result;
}
public static InvokeResult Execute(this IRoutine routine, Field[] args)
{
var invokeArgs = new InvokeArgument[0];
if (args != null && args.Length > 0) {
invokeArgs = new InvokeArgument[args.Length];
for (int i = 0; i < args.Length; i++) {
invokeArgs[i] = new InvokeArgument(SqlExpression.Constant(args[i]));
}
}
return routine.Execute(invokeArgs);
}
public void CallExternalWithArguments()
{
var procName = ObjectName.Parse("APP.extProc");
var arg1 = new InvokeArgument("a", SqlExpression.Constant("Hello"));
var arg2 = new InvokeArgument("b", SqlExpression.Constant("World!"));
var result = AdminQuery.Call(procName, arg1, arg2);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Count);
Assert.IsNotNullOrEmpty(ExternProcedureResult);
Assert.AreEqual("Hello World!", ExternProcedureResult);
}
public static InvokeResult Execute(this IRoutine routine, Field[] args)
{
var invokeArgs = new InvokeArgument[0];
if (args != null && args.Length > 0)
{
invokeArgs = new InvokeArgument[args.Length];
for (int i = 0; i < args.Length; i++)
{
invokeArgs[i] = new InvokeArgument(SqlExpression.Constant(args[i]));
}
}
return(routine.Execute(invokeArgs));
}
public static void ProcedureTrigger_WithArguments()
{
var args = new InvokeArgument[] {
new InvokeArgument("a", SqlExpression.Constant(3))
};
var statement = new CreateProcedureTriggerStatement(ObjectName.Parse("APP.trig1"), new ObjectName("tab1"),
ObjectName.Parse("APP.proc1"), args, TriggerEventTime.After, TriggerEventType.Delete) {
ReplaceIfExists = true,
Status = TriggerStatus.Enabled
};
var expected = "CREATE OR REPLACE TRIGGER APP.trig1 AFTER DELETE ON tab1 FOR EACH ROW ENABLE CALL APP.proc1(a => 3)";
Assert.AreEqual(expected, statement.ToString());
}
public CreateProcedureTriggerStatement(ObjectName triggerName, ObjectName tableName, ObjectName procedureName, InvokeArgument[] args, TriggerEventTime eventTime, TriggerEventType eventType)
{
if (triggerName == null)
throw new ArgumentNullException("triggerName");
if (tableName == null)
throw new ArgumentNullException("tableName");
if (procedureName == null)
throw new ArgumentNullException("procedureName");
TriggerName = triggerName;
TableName = tableName;
ProcedureName = procedureName;
ProcedureArguments = args;
EventTime = eventTime;
EventType = eventType;
}
public void WithOutputArgument()
{
var procName = ObjectName.Parse("APP.proc3");
var arg = new InvokeArgument("a", SqlExpression.Constant("Hello"));
var result = AdminQuery.Call(procName, arg);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Count);
Field value;
Assert.IsTrue(result.TryGetValue("b", out value));
Assert.IsFalse(Field.IsNullField(value));
Assert.AreEqual("Hello", ((SqlString) value.Value).ToString());
}
public InvokeResult Execute(InvokeContext context)
{
// Rewrite the function to the object initialization
var sourceArgs = context.Arguments == null ? new InvokeArgument[1] : context.Arguments;
var args = new InvokeArgument[sourceArgs.Length + 1];
Array.Copy(sourceArgs, 0, args, 1, sourceArgs.Length);
args[0] = new InvokeArgument(SqlExpression.Constant(FunctionInfo.RoutineName.FullName));
var initFunction = context.Request.Access().ResolveObjectName(DbObjectType.Routine, ObjectName.Parse("SYSTEM.NEW_OBJECT"));
if (initFunction == null)
throw new InvalidOperationException("The object initialization function was not defined.");
var invoke = new Invoke(initFunction, args);
return invoke.Execute(context.Request, context.VariableResolver, context.GroupResolver);
}
public void CallWithArgs()
{
var name = ObjectName.Parse("APP.proc1");
var args = new InvokeArgument[] {
new InvokeArgument(SqlExpression.Constant(32)),
new InvokeArgument(SqlExpression.Reference(new ObjectName("a")))
};
var statement = new CallStatement(name, args);
SerializeAndAssert(statement, (serialized, deserialized) => {
Assert.IsNotNull(deserialized);
Assert.IsNotNull(deserialized.ProcedureName);
Assert.IsNotNull(deserialized.Arguments);
Assert.IsNotEmpty(deserialized.Arguments);
Assert.AreEqual("APP", deserialized.ProcedureName.ParentName);
Assert.AreEqual("proc1", deserialized.ProcedureName.Name);
});
}
public void CreateProcedureTrigger()
{
var procName = ObjectName.Parse("APP.proc1");
var args = new InvokeArgument[] {
new InvokeArgument(SqlExpression.Constant(2)),
};
var statement = new CreateProcedureTriggerStatement(ObjectName.Parse("APP.trig1"), new ObjectName("tab1"), procName, args,
TriggerEventTime.Before, TriggerEventType.Insert | TriggerEventType.Update);
SerializeAndAssert(statement, (serialized, deserialized) => {
Assert.IsNotNull(deserialized);
Assert.IsNotNull(deserialized.TriggerName);
Assert.IsNotNull(deserialized.TableName);
Assert.IsNotNull(deserialized.ProcedureArguments);
Assert.AreEqual("APP.trig1", deserialized.TriggerName.FullName);
Assert.AreEqual("tab1", deserialized.TableName.FullName);
Assert.AreEqual(TriggerEventTime.Before, deserialized.EventTime);
});
}
public TriggerArgument(InvokeArgument[] args)
{
Arguments = args;
}
private void PrepareBlock(InvokeArgument[] args, IBlock block)
{
if ((args == null || args.Length == 0) &&
Parameters.Length == 0)
return;
if (args == null || args.Length == 0) {
if (!Parameters.Any(x => x.IsInput))
throw new ArgumentException("Invalid number of parameters in the routine invoke.");
return;
}
if (args.Length != Parameters.Count(x => x.IsInput))
throw new ArgumentException("Invalid number of parameters in the routine invoke.");
var passedParameters = new List<string>();
if (args.Any(x => x.IsNamed)) {
var parameters = Parameters.ToDictionary(x => x.Name, y => y);
foreach (var argument in args) {
RoutineParameter parameter;
if (!parameters.TryGetValue(argument.Name, out parameter))
throw new ArgumentException(
String.Format("Invoking routine '{0}' with the named argument '{1}' that is not a parameter of the routine.",
Name, argument.Name));
if (!parameter.IsInput)
throw new ArgumentException(String.Format("Cannot pass any value for parameter '{0}' of routine '{1}'.",
parameter.Name, Name));
if (parameter.IsOutput) {
block.DeclareVariable(parameter.Name, parameter.Type, argument.Value);
} else {
block.DeclareConstantVariable(parameter.Name, parameter.Type, argument.Value);
}
passedParameters.Add(parameter.Name);
}
} else {
var parameters = Parameters.Where(x => x.IsInput).OrderBy(x => x.Offset).ToArray();
for (int i = 0; i < parameters.Length; i++) {
var parameter = parameters[i];
var argument = args[i];
if (parameter.IsOutput) {
block.DeclareVariable(parameter.Name, parameter.Type, argument.Value);
} else {
block.DeclareConstantVariable(parameter.Name, parameter.Type, argument.Value);
}
passedParameters.Add(parameter.Name);
}
}
var output = Parameters.Where(x => x.IsOutput && !passedParameters.Contains(x.Name));
foreach (var parameter in output) {
block.DeclareVariable(parameter.Name, parameter.Type);
}
}
public static SqlFunctionCallExpression FunctionCall(string functionName, InvokeArgument[] args)
{
return FunctionCall(ObjectName.Parse(functionName), args);
}
protected override SqlStatement PrepareExpressions(IExpressionPreparer preparer)
{
var args = new InvokeArgument[ProcedureArguments == null ? 0 : ProcedureArguments.Length];
if (ProcedureArguments != null) {
for (int i = 0; i < args.Length; i++) {
args[i] = (InvokeArgument) (ProcedureArguments[i] as IPreparable).Prepare(preparer);
}
}
return new CreateProcedureTriggerStatement(TriggerName, TableName, ProcedureName, args, EventTime, EventType) {
Status = Status,
ReplaceIfExists = ReplaceIfExists
};
}
internal SqlFunctionCallExpression(ObjectName functioName, InvokeArgument[] arguments)
{
Arguments = arguments;
FunctioName = functioName;
}
public RoutineEvent(ObjectName routineName, InvokeArgument[] arguments)
: this(RoutineEventType.BeforeResolve, routineName, arguments, new RoutineType(), null)
{
}
public RoutineEvent(RoutineEventType eventType, ObjectName routineName, InvokeArgument[] arguments, RoutineType routineType)
: this(eventType, routineName, arguments, routineType, null)
{
}
public RoutineEvent(ObjectName routineName, InvokeArgument[] arguments, RoutineType routineType)
: this(RoutineEventType.BeforeExecute, routineName, arguments, routineType, null)
{
}
public RoutineEvent(ObjectName routineName, InvokeArgument[] arguments, RoutineType routineType, InvokeResult result)
: this(RoutineEventType.AfterExecute, routineName, arguments, routineType, result)
{
}
protected override void GetData(SerializationInfo info)
{
info.AddValue("Procedure", ProcedureName);
var args = new InvokeArgument[0];
if (Arguments != null)
args = Arguments.ToArray();
info.AddValue("Arguments", args);
}
public virtual InvokeArgument VisitInvokeArgument(InvokeArgument argument)
{
var value = Visit(argument.Value);
return new InvokeArgument(argument.Name, value);
}
public virtual InvokeArgument[] VisitInvokeArgumentList(InvokeArgument[] arguments)
{
if (arguments == null || arguments.Length == 0)
return arguments;
var newArgs = new InvokeArgument[arguments.Length];
for (int i = 0; i < arguments.Length; i++) {
newArgs[i] = VisitInvokeArgument(arguments[i]);
}
return newArgs;
}
private static void VerifyNamesIn(InvokeArgument[] arguments)
{
if (arguments == null || arguments.Length == 0)
return;
bool hasName = false;
foreach (var argument in arguments) {
if (argument.IsNamed) {
hasName = true;
} else if (hasName) {
throw new ArgumentException("At least one of the argument is named and another is unnamed.");
}
}
}
public CallStatement(ObjectName procedureName, InvokeArgument[] arguments)
{
ProcedureName = procedureName;
Arguments = arguments;
}
public static SqlFunctionCallExpression FunctionCall(ObjectName functionName, InvokeArgument[] args)
{
return new SqlFunctionCallExpression(functionName, args);
}