public ResourceAccessSecurityAssert(ObjectName resourceName, DbObjectType resourceType, Privileges privileges)
{
ResourceName = resourceName;
ResourceType = resourceType;
Privileges = privileges;
Arguments = new InvokeArgument[0];
}
public override SqlStatement VisitCallStatement(PlSqlParser.CallStatementContext context)
{
var routineName = Name.Object(context.objectName());
var args = new InvokeArgument[0];
if (context.function_argument() != null)
{
args = context.function_argument()
.argument()
.Select(FunctionArgument.Form)
.Select(x => new InvokeArgument(x.Id, x.Expression))
.ToArray();
}
if (args.Length > 0)
{
bool named = args.Any(x => x.IsNamed);
if (named && args.Any(x => !x.IsNamed))
{
throw new ParseCanceledException("Anonymous argument mixed with named arguments");
}
}
return(new CallStatement(routineName, args));
}
public void WithNamedArgument()
{
var procName = ObjectName.Parse("APP.proc1");
var arg = new InvokeArgument("a", SqlExpression.Constant("Hello!"));
AdminQuery.Call(procName, arg);
}
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 virtual InvokeArgument VisitInvokeArgument(InvokeArgument argument)
{
var value = argument.Value;
if (value != null)
{
value = Visit(value);
}
return(new InvokeArgument(argument.Name, value));
}
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 static void CreateProcedureTrigger(this IQuery query, ObjectName triggerName, ObjectName tableName,
ObjectName procedureName, SqlExpression[] procedureArgs,
TriggerEventTime eventTime, TriggerEventType eventType)
{
var args = new InvokeArgument[0];
if (procedureArgs != null)
{
args = procedureArgs.Select(x => new InvokeArgument(x)).ToArray();
}
query.ExecuteStatement(new CreateProcedureTriggerStatement(triggerName, tableName, procedureName, args,
eventTime, eventType));
}
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 virtual InvokeArgument[] VisitInvokeArguments(IList <InvokeArgument> arguments)
{
if (arguments == null)
{
return(null);
}
var result = new InvokeArgument[arguments.Count];
for (int i = 0; i < arguments.Count; i++)
{
result[i] = VisitInvokeArgument(arguments[i]);
}
return(result);
}
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);
}
internal SqlFunctionExpression(ObjectName functionName, InvokeArgument[] arguments)
: base(SqlExpressionType.Function)
{
if (ObjectName.IsNullOrEmpty(functionName))
{
throw new ArgumentNullException(nameof(functionName));
}
if (arguments == null)
{
arguments = new InvokeArgument[0];
}
FunctionName = functionName;
Arguments = arguments;
}
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 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());
}
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
});
}
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 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 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 virtual InvokeArgument VisitInvokeArgument(InvokeArgument argument)
{
var value = Visit(argument.Value);
return(new InvokeArgument(argument.Name, value));
}
public override SqlStatement VisitCreateTriggerStatement(PlSqlParser.CreateTriggerStatementContext context)
{
var triggerName = Name.Object(context.objectName());
var orReplace = context.OR() != null && context.REPLACE() != null;
TriggerStatus status = TriggerStatus.Unknown;
if (context.DISABLE() != null)
{
status = TriggerStatus.Disabled;
}
else if (context.ENABLE() != null)
{
status = TriggerStatus.Enabled;
}
var simpleDml = context.simpleDmlTrigger();
ObjectName onObject = null;
TriggerEventType eventType = new TriggerEventType();
TriggerEventTime eventTime = new TriggerEventTime();
if (simpleDml != null)
{
bool before = simpleDml.BEFORE() != null;
bool after = simpleDml.AFTER() != null;
var events = simpleDml.dmlEventClause().dmlEventElement().Select(x => {
if (x.DELETE() != null)
{
return(TriggerEventType.Delete);
}
if (x.UPDATE() != null)
{
return(TriggerEventType.Update);
}
if (x.INSERT() != null)
{
return(TriggerEventType.Insert);
}
throw new InvalidOperationException();
});
foreach (var type in events)
{
eventType |= type;
}
if (before)
{
eventTime = TriggerEventTime.Before;
}
else if (after)
{
eventTime = TriggerEventTime.After;
}
onObject = Name.Object(simpleDml.dmlEventClause().objectName());
}
var triggerBody = context.triggerBody();
if (triggerBody.triggerBlock() != null)
{
var declarations = triggerBody.triggerBlock().declaration().Select(Visit);
var body = (PlSqlBody)Visit(triggerBody.triggerBlock().body());
var plsqlBody = body.AsPlSqlStatement();
foreach (var declaration in declarations)
{
plsqlBody.Declarations.Add(declaration);
}
return(new CreateTriggerStatement(triggerName, onObject, plsqlBody, eventTime, eventType)
{
ReplaceIfExists = orReplace,
Status = status
});
}
var procName = Name.Object(triggerBody.objectName());
var args = new InvokeArgument[0];
if (triggerBody.function_argument() != null)
{
args = triggerBody.function_argument()
.argument()
.Select(FunctionArgument.Form)
.Select(x => new InvokeArgument(x.Id, x.Expression))
.ToArray();
}
return(new CreateProcedureTriggerStatement(triggerName, onObject, procName, args, eventTime, eventType)
{
ReplaceIfExists = orReplace,
Status = status
});
}
