/// <summary>
/// Creates a new instance of the <see cref="TableValuedFunctionExpression" /> class.
/// </summary>
/// <param name="storeFunction">The <see cref="IStoreFunction" /> associated this function.</param>
/// <param name="arguments">The arguments of the function.</param>
public TableValuedFunctionExpression(IStoreFunction storeFunction, IReadOnlyList <SqlExpression> arguments)
: this(
storeFunction.Name.Substring(0, 1).ToLowerInvariant(),
storeFunction,
arguments)
{
}
public TableValuedFunctionExpression([NotNull] IStoreFunction storeFunction, [NotNull] IReadOnlyList <SqlExpression> arguments)
: this(
storeFunction.Name.Substring(0, 1).ToLowerInvariant(),
Check.NotNull(storeFunction, nameof(storeFunction)),
Check.NotNull(arguments, nameof(arguments)))
{
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
//Since this is always generated while compiling there is no query provider associated
public TableValuedFunctionQueryRootExpression(
IEntityType entityType,
IStoreFunction function,
IReadOnlyCollection <Expression> arguments)
: base(entityType)
{
Function = function;
Arguments = arguments;
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
//Since this is always generated while compiling there is no query provider associated
public TableValuedFunctionQueryRootExpression(
[NotNull] IEntityType entityType, [NotNull] IStoreFunction function, [NotNull] IReadOnlyCollection <Expression> arguments)
: base(entityType)
{
Check.NotNull(function, nameof(function));
Check.NotNull(arguments, nameof(arguments));
Function = function;
Arguments = arguments;
}
/// <summary>
/// <para>
/// Creates a human-readable representation of the given metadata.
/// </para>
/// <para>
/// Warning: Do not rely on the format of the returned string.
/// It is designed for debugging only and may change arbitrarily between releases.
/// </para>
/// </summary>
/// <param name="function"> The metadata item. </param>
/// <param name="options"> Options for generating the string. </param>
/// <param name="indent"> The number of indent spaces to use before each new line. </param>
/// <returns> A human-readable representation. </returns>
public static string ToDebugString(
[NotNull] this IStoreFunction function,
MetadataDebugStringOptions options,
int indent = 0)
{
var builder = new StringBuilder();
var indentString = new string(' ', indent);
builder
.Append(indentString)
.Append("StoreFunction: ");
if (function.ReturnType != null)
{
builder.Append(function.ReturnType);
}
else
{
builder.Append(function.EntityTypeMappings.FirstOrDefault()?.EntityType.DisplayName() ?? "");
}
builder.Append(" ");
if (function.Schema != null)
{
builder
.Append(function.Schema)
.Append(".");
}
builder.Append(function.Name);
if ((options & MetadataDebugStringOptions.SingleLine) == 0)
{
var parameters = function.Parameters.ToList();
if (parameters.Count != 0)
{
builder.AppendLine().Append(indentString).Append(" Parameters: ");
foreach (var parameter in parameters)
{
builder.AppendLine().Append(parameter.ToDebugString(options, indent + 4));
}
}
if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0)
{
builder.Append(function.AnnotationsToDebugString(indent: indent + 2));
}
}
return(builder.ToString());
}
/// <inheritdoc /> public virtual IEnumerable <IAnnotation> For(IStoreFunction function, bool designTime) => Enumerable.Empty <IAnnotation>();
private TableValuedFunctionExpression(string alias, IStoreFunction storeFunction, IReadOnlyList <SqlExpression> arguments)
: base(alias)
{
StoreFunction = storeFunction;
Arguments = arguments;
}
/// <summary>
/// Creates a new instance of the <see cref="TableValuedFunctionExpression" /> class.
/// </summary>
/// <param name="storeFunction">The <see cref="IStoreFunction" /> associated this function.</param>
/// <param name="arguments">The arguments of the function.</param>
public TableValuedFunctionExpression(IStoreFunction storeFunction, IReadOnlyList <SqlExpression> arguments)
: this(
private Expression CreateTableValuedFunctionQueryRootExpression(
IStoreFunction function,
IReadOnlyCollection <Expression> arguments)
// See issue #19970
=> new TableValuedFunctionQueryRootExpression(function.EntityTypeMappings.Single().EntityType, function, arguments);
public virtual IEnumerable <IAnnotation> For(IStoreFunction function) => Enumerable.Empty <IAnnotation>();
public IEnumerable <IAnnotation> For(IStoreFunction function) => _providers.SelectMany(p => p.For(function));
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public FunctionColumn([NotNull] string name, [NotNull] string type, [NotNull] IStoreFunction function)
{
Name = name;
StoreType = type;
Function = function;
}
