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 = Data.ParameterDirection.Output;
this.currentParams.Add(new SqlParameterInfo(p));
return(spc);
}
internal virtual SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc) {
for (int i = 0, n = spc.Arguments.Count; i < n; i++) {
spc.Arguments[i] = this.VisitExpression(spc.Arguments[i]);
}
spc.Projection = this.VisitExpression(spc.Projection);
for (int i = 0, n = spc.Columns.Count; i < n; i++) {
spc.Columns[i] = (SqlUserColumn) this.Visit(spc.Columns[i]);
}
return spc;
}
//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);
}
internal override SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc)
{
List <SqlExpression> args = new List <SqlExpression>(spc.Arguments.Count);
foreach (SqlExpression expr in spc.Arguments)
{
args.Add(this.VisitExpression(expr));
}
SqlExpression projection = this.VisitExpression(spc.Projection);
SqlStoredProcedureCall n = new SqlStoredProcedureCall(spc.Function, projection, args, spc.SourceExpression);
this.nodeMap[spc] = n;
foreach (SqlUserColumn suc in spc.Columns)
{
n.Columns.Add((SqlUserColumn)this.Visit(suc));
}
return(n);
}
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);
}
internal override SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc) {
sb.Append("EXEC @RETURN_VALUE = ");
this.WriteName(spc.Function.MappedName);
sb.Append(" ");
int pc = spc.Function.Parameters.Count;
System.Diagnostics.Debug.Assert(spc.Arguments.Count >= pc);
for (int i = 0; i < pc; i++) {
MetaParameter mp = spc.Function.Parameters[i];
if (i > 0) sb.Append(", ");
this.WriteVariableName(mp.MappedName);
sb.Append(" = ");
this.Visit(spc.Arguments[i]);
if (mp.Parameter.IsOut || mp.Parameter.ParameterType.IsByRef)
sb.Append(" OUTPUT");
}
if (spc.Arguments.Count > pc) {
if (pc > 0) sb.Append(", ");
this.WriteVariableName(spc.Function.ReturnParameter.MappedName);
sb.Append(" = ");
this.Visit(spc.Arguments[pc]);
sb.Append(" OUTPUT");
}
return spc;
}
internal override SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc)
{
WriteName(spc.Function.MappedName);
return(spc);
}
internal override SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc) {
List<SqlExpression> args = new List<SqlExpression>(spc.Arguments.Count);
foreach (SqlExpression expr in spc.Arguments) {
args.Add(this.VisitExpression(expr));
}
SqlExpression projection = this.VisitExpression(spc.Projection);
SqlStoredProcedureCall n = new SqlStoredProcedureCall(spc.Function, projection, args, spc.SourceExpression);
this.nodeMap[spc] = n;
foreach (SqlUserColumn suc in spc.Columns) {
n.Columns.Add((SqlUserColumn)this.Visit(suc));
}
return n;
}
/// <summary>
/// Translate a call to a stored procedure
/// </summary>
private SqlNode TranslateStoredProcedureCall(MethodCallExpression mce, MetaFunction function) {
if (!this.outerNode) {
throw Error.SprocsCannotBeComposed();
}
// translate method call into sql function call
List<SqlExpression> sqlParams = GetFunctionParameters(mce, function);
SqlStoredProcedureCall spc = new SqlStoredProcedureCall(function, null, sqlParams, mce);
Type returnType = mce.Method.ReturnType;
if (returnType.IsGenericType &&
(returnType.GetGenericTypeDefinition() == typeof(IEnumerable<>) ||
returnType.GetGenericTypeDefinition() == typeof(ISingleResult<>))) {
// Since this is a single rowset returning sproc, we use the one
// and only root metatype.
MetaType rowType = function.ResultRowTypes[0].InheritanceRoot;
SqlUserRow rowExp = new SqlUserRow(rowType, this.typeProvider.GetApplicationType((int)ConverterSpecialTypes.Row), spc, mce);
spc.Projection = this.translator.BuildProjection(rowExp, rowType, this.allowDeferred, null, mce);
}
else if (!(
typeof(IMultipleResults).IsAssignableFrom(returnType)
|| returnType == typeof(int)
|| returnType == typeof(int?)
)) {
throw Error.InvalidReturnFromSproc(returnType);
}
return spc;
}
internal virtual SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc) {
for (int i = 0, n = spc.Arguments.Count; i < n; i++) {
spc.Arguments[i] = this.VisitExpression(spc.Arguments[i]);
}
spc.Projection = this.VisitExpression(spc.Projection);
for (int i = 0, n = spc.Columns.Count; i < n; i++) {
spc.Columns[i] = (SqlUserColumn) this.Visit(spc.Columns[i]);
}
return spc;
}
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);
}
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;
}