public override MetaFunction GetFunction(MethodInfo method)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
MetaFunction func = null;
this.metaFunctions.TryGetValue(new MetaPosition(method), out func);
return(func);
}
public override MetaFunction GetFunction(MethodInfo method)
{
if (method == null)
{
throw Error.ArgumentNull("method");
}
this.InitFunctions();
MetaFunction function = null;
this.metaFunctions.TryGetValue(new MetaPosition(method), out function);
return(function);
}
public override MetaFunction GetFunction(MethodInfo method)
{
if (method == (MethodInfo)null)
{
throw System.Data.Linq.Mapping.Error.ArgumentNull("method");
}
InitFunctions();
MetaFunction value = null;
metaFunctions.TryGetValue(new MetaPosition(method), out value);
return(value);
}
/// <summary>
/// Create a list of sql parameters for the specified method call expression,
/// taking into account any explicit typing applied to the parameters via the
/// Parameter attribute.
/// </summary>
private List<SqlExpression> GetFunctionParameters(MethodCallExpression mce, MetaFunction function) {
List<SqlExpression> sqlParams = new List<SqlExpression>(mce.Arguments.Count);
// create sql parameters for each method parameter
for (int i = 0, n = mce.Arguments.Count; i < n; i++) {
SqlExpression newParamExpression = this.VisitExpression(mce.Arguments[i]);
// If the parameter explicitly specifies a type in metadata,
// use it as the provider type.
MetaParameter currMetaParam = function.Parameters[i];
if (!string.IsNullOrEmpty(currMetaParam.DbType)) {
SqlSimpleTypeExpression typeExpression = newParamExpression as SqlSimpleTypeExpression;
if (typeExpression != null) {
// determine provider type, and update the parameter expression
ProviderType providerType = typeProvider.Parse(currMetaParam.DbType);
typeExpression.SetSqlType(providerType);
}
}
sqlParams.Add(newParamExpression);
}
return sqlParams;
}
/// <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;
}
/// <summary>
/// Translate a call to a table valued function expression into a sql select.
/// </summary>
private SqlNode TranslateTableValuedFunction(MethodCallExpression mce, MetaFunction function) {
// translate method call into sql function call
List<SqlExpression> sqlParams = GetFunctionParameters(mce, function);
SqlTableValuedFunctionCall functionCall = sql.TableValuedFunctionCall(function.ResultRowTypes[0].InheritanceRoot, mce.Method.ReturnType, function.MappedName, sqlParams, mce);
SqlAlias alias = new SqlAlias(functionCall);
SqlAliasRef aref = new SqlAliasRef(alias);
// Build default projection
SqlExpression projection = this.translator.BuildProjection(aref, function.ResultRowTypes[0].InheritanceRoot, this.allowDeferred, null, mce);
SqlSelect select = new SqlSelect(projection, alias, mce);
return select;
}
internal SqlStoredProcedureCall(MetaFunction function, SqlExpression projection, IEnumerable<SqlExpression> args, Expression source)
: base(SqlNodeType.StoredProcedureCall, projection, args, source) {
if (function == null)
throw Error.ArgumentNull("function");
this.function = function;
}
