/// <summary>
/// Generates table function mapping.
/// </summary>
/// <param name="tableFunction">Function model.</param>
/// <param name="functionsGroup">Functions region.</param>
/// <param name="context">Data context class.</param>
private void BuildTableFunction(
TableFunctionModel tableFunction,
RegionGroup functionsGroup,
CodeClass context)
{
// generated code sample:
/*
* #region Function1
* private static readonly MethodInfo _function1 = MemberHelper.MethodOf<DataContext>(ctx => ctx.Function1(default));
*
* [Sql.TableFunction("Function1")]
* public IQueryable<Parent> Function1(int? id)
* {
* return this.GetTable<Parent>(this, _function1, id);
* }
* #endregion
*/
// create function region
var region = functionsGroup.New(tableFunction.Method.Name);
// if function schema load failed, generate error pragma with exception details
if (tableFunction.Error != null)
{
if (_options.DataModel.GenerateProceduresSchemaError)
{
region.Pragmas().Add(AST.Error($"Failed to load return table schema: {tableFunction.Error}"));
}
// as we cannot generate table function without knowing it's schema, we skip failed function
return;
}
// if function result schema matches known entity, we use entity class for result
// otherwise we generate custom record mapping
if (tableFunction.Result == null || tableFunction.Result.CustomTable == null && tableFunction.Result.Entity == null)
{
throw new InvalidOperationException($"Table function {tableFunction.Name} result record type not set");
}
// GetTable API for table functions need MethodInfo instance of generated method as parameter
// to not load it on each call, we cache MethodInfo instance in static field
var methodInfo = region
.Fields(false)
.New(AST.Name(tableFunction.MethodInfoFieldName), WellKnownTypes.System.Reflection.MethodInfo)
.Private()
.Static()
.ReadOnly();
// generate mapping method with metadata
var method = DefineMethod(region.Methods(false), tableFunction.Method);
_metadataBuilder.BuildTableFunctionMetadata(tableFunction.Metadata, method);
// generate method parameters, return type and body
// table record type
IType returnEntity;
if (tableFunction.Result.Entity != null)
{
returnEntity = _entityBuilders[tableFunction.Result.Entity].Type.Type;
}
else
{
returnEntity = BuildCustomResultClass(tableFunction.Result.CustomTable !, region.Classes(), true).resultClassType;
}
// set return type
// T4 used ITable<T> for return type, but there is no reason to use ITable<T> over IQueryable<T>
// Even more: ITable<T> is not correct return type here
var returnType = _options.DataModel.TableFunctionReturnsTable
? WellKnownTypes.LinqToDB.ITable(returnEntity)
: WellKnownTypes.System.Linq.IQueryable(returnEntity);
method.Returns(returnType);
// parameters for GetTable call in mapping body
var parameters = new ICodeExpression[3 + tableFunction.Parameters.Count];
parameters[0] = context.This; // `this` extension method parameter
parameters[1] = context.This; // context parameter
parameters[2] = methodInfo.Field.Reference; // method info field
// add table function parameters (if any)
var fieldInitParameters = new ICodeExpression[tableFunction.Parameters.Count];
for (var i = 0; i < tableFunction.Parameters.Count; i++)
{
var param = tableFunction.Parameters[i];
// parameters added to 3 places:
// - to mapping method
// - to GetTable call in mapping
// - to mapping call in MethodInfo initializer we add parameter's default value
var parameter = DefineParameter(method, param.Parameter);
parameters[i + 3] = parameter.Reference;
// TODO: potential issue: target-typed `default` could cause errors with overloads
fieldInitParameters[i] = AST.Default(param.Parameter.Type, true);
}
// generate mapping body
method.Body()
.Append(
AST.Return(
AST.ExtCall(
WellKnownTypes.LinqToDB.DataExtensions,
WellKnownTypes.LinqToDB.DataExtensions_GetTable,
WellKnownTypes.LinqToDB.ITable(returnEntity),
new[] { returnEntity },
false,
parameters)));
// generate MethodInfo field initializer
var lambdaParam = AST.LambdaParameter(AST.Name(TABLE_FUNCTION_METHOD_INFO_CONTEXT_PARAMETER), context.Type);
// Expression<Func<context, returnType>>
var lambda = AST
.Lambda(WellKnownTypes.System.Linq.Expressions.Expression(WellKnownTypes.System.Func(returnType, context.Type)), true)
.Parameter(lambdaParam);
lambda.Body()
.Append(
AST.Return(
AST.Call(
lambdaParam.Reference,
method.Method.Name,
returnType,
fieldInitParameters)));
methodInfo.AddInitializer(
AST.Call(
new CodeTypeReference(WellKnownTypes.LinqToDB.Expressions.MemberHelper),
WellKnownTypes.LinqToDB.Expressions.MemberHelper_MethodOf,
WellKnownTypes.System.Reflection.MethodInfo,
new[] { functionsGroup.OwnerType.Type },
false,
lambda.Method));
// TODO: similar tables
}
/// <summary>
/// Generates association extension method in extensions class for one side of association.
/// </summary>
/// <param name="extensionEntityAssociations">Association methods groupsfor each entity.</param>
/// <param name="extensionAssociations">Association extensions region provider.</param>
/// <param name="thisEntity">Entity class for this side of assocation (used for extension <c>this</c> parameter).</param>
/// <param name="resultEntity">Entity class for other side of assocation (used for extension result type).</param>
/// <param name="type">Association result type.</param>
/// <param name="extensionModel">Extension method model.</param>
/// <param name="metadata">Association methodo metadata.</param>
/// <param name="associationModel">Association model.</param>
/// <param name="backReference">Identifies current side of assocation.</param>
private void BuildAssociationExtension(
Dictionary <EntityModel, MethodGroup> extensionEntityAssociations,
Func <RegionGroup> extensionAssociations,
ClassBuilder thisEntity,
ClassBuilder resultEntity,
IType type,
MethodModel extensionModel,
AssociationMetadata metadata,
AssociationModel associationModel,
bool backReference)
{
// create (if missing) assocations region for specific owner (this) entity
var key = backReference ? associationModel.Target : associationModel.Source;
if (!extensionEntityAssociations.TryGetValue(key, out var associations))
{
extensionEntityAssociations.Add(
key,
associations = extensionAssociations()
.New(string.Format(EXTENSIONS_ENTITY_ASSOCIATIONS_REGION, thisEntity.Type.Name.Name))
.Methods(false));
}
// define extension method
var methodBuilder = DefineMethod(associations, extensionModel).Returns(type);
// and it's metadata
_metadataBuilder.BuildAssociationMetadata(metadata, methodBuilder);
// build method parameters...
var thisParam = AST.Parameter(thisEntity.Type.Type, AST.Name(EXTENSIONS_ENTITY_THIS_PARAMETER), CodeParameterDirection.In);
var ctxParam = AST.Parameter(WellKnownTypes.LinqToDB.IDataContext, AST.Name(EXTENSIONS_ENTITY_CONTEXT_PARAMETER), CodeParameterDirection.In);
methodBuilder.Parameter(thisParam);
methodBuilder.Parameter(ctxParam);
// ... and body
if (associationModel.FromColumns == null || associationModel.ToColumns == null)
{
// association doesn't specify relation columns (e.g. defined usign expression method)
// so we should generate exception for non-query execution
methodBuilder
.Body()
.Append(
AST.Throw(
AST.New(
WellKnownTypes.System.InvalidOperationException,
AST.Constant(EXCEPTION_QUERY_ONLY_ASSOCATION_CALL, true))));
}
else
{
// generate association query for non-query invocation
// As method body here could conflict with custom return type for many-to-one assocation
// we forcebly override return type here to IQueryable<T>
if (associationModel.ManyToOne && backReference)
{
methodBuilder.Returns(WellKnownTypes.System.Linq.IQueryable(resultEntity.Type.Type));
}
var lambdaParam = AST.LambdaParameter(AST.Name(EXTENSIONS_ASSOCIATION_FILTER_PARAMETER), resultEntity.Type.Type);
// generate assocation key columns filter, which compare
// `this` entity parameter columns with return table entity columns
var fromObject = backReference ? lambdaParam : thisParam;
var toObject = !backReference ? lambdaParam : thisParam;
ICodeExpression?filter = null;
for (var i = 0; i < associationModel.FromColumns.Length; i++)
{
var fromColumn = _columnProperties[associationModel.FromColumns[i]];
var toColumn = _columnProperties[associationModel.ToColumns[i]];
var cond = AST.Equal(
AST.Member(fromObject.Reference, fromColumn.Reference),
AST.Member(toObject.Reference, toColumn.Reference));
filter = filter == null ? cond : AST.And(filter, cond);
}
// generate filter lambda function
var filterLambda = AST
.Lambda(
WellKnownTypes.System.Linq.Expressions.Expression(
WellKnownTypes.System.Func(WellKnownTypes.System.Boolean, resultEntity.Type.Type)),
true)
.Parameter(lambdaParam);
filterLambda.Body().Append(AST.Return(filter !));
// ctx.GetTable<ResultEntity>()
var body = AST.ExtCall(
WellKnownTypes.LinqToDB.DataExtensions,
WellKnownTypes.LinqToDB.DataExtensions_GetTable,
WellKnownTypes.LinqToDB.ITable(resultEntity.Type.Type),
new[] { resultEntity.Type.Type },
false,
ctxParam.Reference);
// append First/FirstOrDefault (for optional association)
// for non-many relation
if (!backReference || !associationModel.ManyToOne)
{
var optional = backReference ? associationModel.TargetMetadata.CanBeNull : associationModel.SourceMetadata.CanBeNull;
// .First(t => t.PK == thisEntity.PK)
// or
// .FirstOrDefault(t => t.PK == thisEntity.PK)
body = AST.ExtCall(
WellKnownTypes.System.Linq.Queryable,
optional ? WellKnownTypes.System.Linq.Queryable_FirstOrDefault : WellKnownTypes.System.Linq.Queryable_First,
resultEntity.Type.Type.WithNullability(optional),
new[] { resultEntity.Type.Type },
true,
body,
filterLambda.Method);
}
else
{
// .Where(t => t.PK == thisEntity.PK)
body = AST.ExtCall(
WellKnownTypes.System.Linq.Queryable,
WellKnownTypes.System.Linq.Queryable_Where,
WellKnownTypes.System.Linq.IQueryable(resultEntity.Type.Type),
new [] { resultEntity.Type.Type },
true,
body,
filterLambda.Method);
}
methodBuilder.Body().Append(AST.Return(body));
}
}
/// <summary>
/// Generates sync or async stored procedure mapping method.
/// </summary>
/// <param name="storedProcedure">Stored procedure model.</param>
/// <param name="dataContextType">Data context class type.</param>
/// <param name="methodsGroup">Method group to add new mapping method.</param>
/// <param name="useOrdinalMapping">If <c>true</c>, by-ordinal mapping used for result mapping instead of by-name mapping.</param>
/// <param name="customTable">Custom result record model.</param>
/// <param name="returnElementType">Type of result record for procedure with result.</param>
/// <param name="customRecordProperties">Column properties for custom result record type.</param>
/// <param name="classes">Procedure classes group.</param>
/// <param name="asyncResult">Optional result class model for async signature.</param>
/// <param name="async">If <c>true</c>, generate async version of mapping.</param>
private void BuildStoredProcedureMethod(
StoredProcedureModel storedProcedure,
IType dataContextType,
MethodGroup methodsGroup,
bool useOrdinalMapping,
ResultTableModel?customTable,
IType?returnElementType,
CodeProperty[]?customRecordProperties,
ClassGroup classes,
AsyncProcedureResult?asyncResult,
bool async)
{
var hasParameters = storedProcedure.Parameters.Count > 0 || storedProcedure.Return != null;
// generate ToList materialization call or mark method async in two cases:
// - when return type of mapping is List<T>
// - when procedure has non-input parameters
var toListRequired = _options.DataModel.GenerateProcedureResultAsList && storedProcedure.Results.Count == 1 && (storedProcedure.Results[0].Entity != null || storedProcedure.Results[0].CustomTable != null);
var toListOrAsyncRequired = toListRequired ||
storedProcedure.Return != null ||
storedProcedure.Parameters.Any(p => p.Parameter.Direction != CodeParameterDirection.In);
// declare mapping method
var method = DefineMethod(
methodsGroup,
storedProcedure.Method,
async,
async && toListOrAsyncRequired);
// declare data context parameter (extension `this` parameter)
var ctxParam = AST.Parameter(
// see method notes above regarding type of this parameter
dataContextType,
AST.Name(STORED_PROCEDURE_CONTEXT_PARAMETER),
CodeParameterDirection.In);
method.Parameter(ctxParam);
var body = method.Body();
// array of procedure parameters (DataParameter objects)
CodeVariable?parametersVar = null;
CodeAssignmentStatement[]? parameterRebinds = null;
Dictionary <FunctionParameterModel, int>?rebindedParametersIndexes = null;
if (hasParameters)
{
var resultParametersCount = storedProcedure.Parameters.Count(p => p.Parameter.Direction != CodeParameterDirection.In) + (storedProcedure.Return != null ? 1 : 0);
// bindings of parameter values to output parameters of method after procedure call
parameterRebinds = resultParametersCount > 0 ? new CodeAssignmentStatement[resultParametersCount] : Array <CodeAssignmentStatement> .Empty;
var rebindIndex = 0;
if (resultParametersCount > 0)
{
rebindedParametersIndexes = new(resultParametersCount);
}
// DataParameter collection initialization
var parameterValues = new ICodeExpression[storedProcedure.Parameters.Count + (storedProcedure.Return != null ? 1 : 0)];
parametersVar = AST.Variable(AST.Name(STORED_PROCEDURE_PARAMETERS_VARIABLE), WellKnownTypes.LinqToDB.Data.DataParameterArray, true);
// build non-return parameters
for (var i = 0; i < storedProcedure.Parameters.Count; i++)
{
var p = storedProcedure.Parameters[i];
ILValue?rebindTo = null;
var rebindRequired = p.Parameter.Direction != CodeParameterDirection.In;
CodeParameter param;
if (async && p.Parameter.Direction != CodeParameterDirection.In)
{
param = DefineParameter(method, p.Parameter.WithDirection(CodeParameterDirection.In));
}
else
{
param = DefineParameter(method, p.Parameter);
}
if (rebindRequired)
{
rebindTo = param.Reference;
}
parameterValues[i] = BuildProcedureParameter(
param,
param.Type.Type,
p.Direction,
rebindTo,
p.DbName,
p.DataType,
p.Type,
parametersVar,
i,
parameterRebinds !,
rebindIndex);
if (p.Parameter.Direction != CodeParameterDirection.In)
{
rebindedParametersIndexes !.Add(p, rebindIndex);
rebindIndex++;
}
}
// build return parameter
if (storedProcedure.Return != null)
{
CodeParameter?param = null;
if (!async)
{
param = DefineParameter(method, storedProcedure.Return.Parameter);
}
parameterValues[storedProcedure.Parameters.Count] = BuildProcedureParameter(
param,
storedProcedure.Return.Parameter.Type,
System.Data.ParameterDirection.ReturnValue,
param?.Reference ?? AST.Variable(AST.Name("fake"), storedProcedure.Return.Parameter.Type, false).Reference,
storedProcedure.Return.DbName ?? STORED_PROCEDURE_DEFAULT_RETURN_PARAMETER,
storedProcedure.Return.DataType,
storedProcedure.Return.Type,
parametersVar,
storedProcedure.Parameters.Count,
parameterRebinds !,
rebindIndex);
rebindedParametersIndexes !.Add(storedProcedure.Return, rebindIndex);
}
var parametersArray = AST.Assign(
parametersVar,
AST.Array(WellKnownTypes.LinqToDB.Data.DataParameter, true, false, parameterValues));
body.Append(parametersArray);
}
CodeParameter?cancellationTokenParameter = null;
if (async)
{
cancellationTokenParameter = DefineParameter(
method,
new ParameterModel(CANCELLATION_TOKEN_PARAMETER, WellKnownTypes.System.Threading.CancellationToken, CodeParameterDirection.In),
AST.Default(WellKnownTypes.System.Threading.CancellationToken, true));
}
ICodeExpression?returnValue = null;
IType returnType;
if (storedProcedure.Results.Count == 0 || (storedProcedure.Results.Count == 1 && storedProcedure.Results[0].CustomTable == null && storedProcedure.Results[0].Entity == null))
{
// for stored procedure call without result set we use ExecuteProc API
// prepare call parameters
var parametersCount = (hasParameters ? 3 : 2) + (async ? 1 : 0);
var executeProcParameters = new ICodeExpression[parametersCount];
executeProcParameters[0] = ctxParam.Reference;
executeProcParameters[1] = AST.Constant(BuildFunctionName(storedProcedure.Name), true);
if (async)
{
executeProcParameters[2] = cancellationTokenParameter !.Reference;
}
if (hasParameters)
{
executeProcParameters[async ? 3 : 2] = parametersVar !.Reference;
}
returnType = WellKnownTypes.System.Int32;
if (async)
{
returnValue = AST.ExtCall(
WellKnownTypes.LinqToDB.Data.DataConnectionExtensions,
WellKnownTypes.LinqToDB.Data.DataConnectionExtensions_ExecuteProcAsync,
WellKnownTypes.System.Int32,
executeProcParameters);
if (asyncResult != null)
{
var rowCountVar = AST.Variable(
AST.Name(STORED_PROCEDURE_RESULT_VARIABLE),
WellKnownTypes.System.Int32,
true);
body.Append(AST.Assign(rowCountVar, AST.AwaitExpression(returnValue)));
returnValue = rowCountVar.Reference;
}
}
else
{
returnValue = AST.ExtCall(
WellKnownTypes.LinqToDB.Data.DataConnectionExtensions,
WellKnownTypes.LinqToDB.Data.DataConnectionExtensions_ExecuteProc,
WellKnownTypes.System.Int32,
executeProcParameters);
}
}
else if (storedProcedure.Results.Count == 1)
{
// QueryProc type- and regular parameters
IType[] queryProcTypeArgs;
ICodeExpression[] queryProcParameters;
if (useOrdinalMapping)
{
// for ordinal mapping we call QueryProc API with mapper lambda parameter:
// manual mapping
// Example:
/*
* dataReader => new CustomResult()
* {
* Column1 = Converter.ChangeTypeTo<int>(dataReader.GetValue(0), dataConnection.MappingSchema),
* Column2 = Converter.ChangeTypeTo<string>(dataReader.GetValue(1), dataConnection.MappingSchema),
* }
*/
queryProcParameters = new ICodeExpression[(hasParameters ? 4 : 3) + (async ? 1 : 0)];
// generate positional mapping lambda
// TODO: switch to ColumnReader.GetValue in future to utilize more precise mapping
// based on column mapping attributes
var drParam = AST.LambdaParameter(
AST.Name(STORED_PROCEDURE_CUSTOM_MAPPER_PARAMETER),
// TODO: add IDataReader support here for linq2db v3
WellKnownTypes.System.Data.Common.DbDataReader);
var initializers = new CodeAssignmentStatement[customTable !.Columns.Count];