Microsoft.EntityFrameworkCore.Relational
Base class to be used by database providers when implementing an
This implementation returns false for all 'IsHandledByConvention' methods and
null for all 'GenerateFluentApi' methods. Providers should override for the
annotations that they understand.
Initializes a new instance of this class.
Parameter object containing dependencies for this service.
Parameter object containing dependencies for this service.
Returns false unless overridden to do otherwise.
The .
The .
False.
Returns false unless overridden to do otherwise.
The .
The .
False.
Returns false unless overridden to do otherwise.
The .
The .
False.
Returns false unless overridden to do otherwise.
The .
The .
False.
Returns false unless overridden to do otherwise.
The .
The .
False.
Returns false unless overridden to do otherwise.
The .
The .
False.
Returns null unless overridden to do otherwise.
The .
The .
Null.
Returns null unless overridden to do otherwise.
The .
The .
Null.
Returns null unless overridden to do otherwise.
The .
The .
Null.
Returns null unless overridden to do otherwise.
The .
The .
Null.
Returns null unless overridden to do otherwise.
The .
The .
Null.
Returns null unless overridden to do otherwise.
The .
The .
Null.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
Implemented by database providers to control which s need to
have code generated (as opposed to being handled by convention) and then to generate
the code if needed.
Checks if the given is handled by convention when
applied to the given .
The .
The .
True if the annotation is handled by convention; false if code must be generated.
Checks if the given is handled by convention when
applied to the given .
The .
The .
True if the annotation is handled by convention; false if code must be generated.
Checks if the given is handled by convention when
applied to the given .
The .
The .
Checks if the given is handled by convention when
applied to the given .
The .
The .
Checks if the given is handled by convention when
applied to the given .
The .
The .
Checks if the given is handled by convention when
applied to the given .
The .
The .
Generates fluent API calls for the given .
The for which code should be generated.
The for which code should be generated.
The generated code.
Generates fluent API calls for the given .
The for which code should be generated.
The for which code should be generated.
The generated code.
Generates fluent API calls for the given .
The for which code should be generated.
The for which code should be generated.
The generated code.
Generates fluent API calls for the given .
The for which code should be generated.
The for which code should be generated.
The generated code.
Generates fluent API calls for the given .
The for which code should be generated.
The for which code should be generated.
The generated code.
Generates fluent API calls for the given .
The for which code should be generated.
The for which code should be generated.
The generated code.
Represents a call to a method.
Initializes a new instance of the class.
The method's name.
The method call's arguments. Can be .
Initializes a new instance of the class.
The method's name.
The method call's arguments. Can be .
The next method call to chain after this.
Gets or sets the method's name.
The method's name.
Gets the method call's arguments.
The method call's arguments.
Gets the next method call to chain after this.
The next method call.
Creates a method chain from this method to another.
The next method's name.
The next method call's arguments.
A new fragment representing the method chain.
Creates a method chain from this method to another.
The next method.
A new fragment representing the method chain.
Represents a nested closure code fragment.
Initializes a new instance of the class.
The nested closure parameter's name.
The method call used as the body of the nested closure.
Gets the nested closure parameter's name.
The parameter name.
Gets the method call used as the body of the nested closure.
The method call.
The event payload for
batch events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The entries being updated.
The command count.
The entries being updated.
The command count.
The event payload for events correlated with a .
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The being used.
The currently being used, to null if not known.
The method.
A correlation ID that identifies the instance being used.
A correlation ID that identifies the instance being used.
Indicates whether or not the command was executed asynchronously.
The start time of this event.
The .
A correlation ID that identifies the instance being used.
A correlation ID that identifies the instance being used.
The method.
Indicates whether or not the operation is being executed asynchronously.
The start time of this event.
The event payload for
command end events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The being used.
The .
The currently being used, to null if not known.
The method.
A correlation ID that identifies the instance being used.
A correlation ID that identifies the instance being used.
Indicates whether or not the command was executed asynchronously.
Indicates whether or not the application allows logging of parameter values.
The start time of this event.
The duration this event.
The duration this event.
The event payload for .
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The being used.
The that was executing when it failed.
The currently being used, to null if not known.
The method that was used to execute the command.
A correlation ID that identifies the instance being used.
A correlation ID that identifies the instance being used.
The exception that was thrown when execution failed.
Indicates whether or not the command was executed asynchronously.
Indicates whether or not the application allows logging of parameter values.
The start time of this event.
The duration this event.
The exception that was thrown when execution failed.
The event payload for
command events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The being used.
The .
The currently being used, to null if not known.
The method.
A correlation ID that identifies the instance being used.
A correlation ID that identifies the instance being used.
Indicates whether or not the command was executed asynchronously.
Indicates whether or not the application allows logging of parameter values.
The start time of this event.
The .
Indicates whether or not the application allows logging of parameter values.
The event payload for .
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The being used.
The that was executing when it failed.
The currently being used, to null if not known.
The method that was used to execute the command.
A correlation ID that identifies the instance being used.
A correlation ID that identifies the instance being used.
The result of executing the operation.
Indicates whether or not the command was executed asynchronously.
Indicates whether or not the application allows logging of parameter values.
The start time of this event.
The duration this event.
The result of executing the command.
The event payload class for
connection ending events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The .
The currently being used, to null if not known.
A correlation ID that identifies the instance being used.
Indicates whether or not the operation is happening asynchronously.
The start time of this event.
The duration this event.
The duration this event.
The event payload for .
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The .
The currently being used, to null if not known.
A correlation ID that identifies the instance being used.
The exception that was thrown when the connection failed.
Indicates whether or not the operation is happening asynchronously.
The start time of this event.
The duration this event.
The exception that was thrown when the connection failed.
The event payload base class for
connection events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The .
The currently being used, to null if not known.
A correlation ID that identifies the instance being used.
Indicates whether or not the operation is happening asynchronously.
The start time of this event.
The .
A correlation ID that identifies the instance being used.
Indicates whether or not the operation is happening asynchronously.
The start time of this event.
event payload for .
Constructs a event payload for .
The event definition.
A delegate that generates a log message for this event.
The that created the reader.
The that is being disposed.
The currently being used, to null if not known.
A correlation ID that identifies the instance being used.
A correlation ID that identifies the instance being used.
Gets the number of rows changed, inserted, or deleted by execution of the SQL statement.
Gets the number of read operations performed by this reader.
The start time of this event.
The duration this event.
The that created the reader.
The that is being disposed.
A correlation ID that identifies the instance being used.
A correlation ID that identifies the instance being used.
Gets the number of rows changed, inserted, or deleted by execution of the SQL statement.
Gets the number of read operations performed by this reader.
The start time of this event.
The duration this event.
Abstract base class for for use when implementing a subset
of the interface methods.
Called just before EF intends to call .
Contextual information about the command and execution.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called immediately after EF calls .
This method is still called if an interceptor suppressed creation of a command in
.
In this case, is the result returned by .
Contextual information about the command and execution.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called just before EF intends to call .
The command.
Contextual information about the command and execution.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called just before EF intends to call .
The command.
Contextual information about the command and execution.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called just before EF intends to call .
The command.
Contextual information about the command and execution.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called just before EF intends to call .
The command.
Contextual information about the command and execution.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called just before EF intends to call .
The command.
Contextual information about the command and execution.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called just before EF intends to call .
The command.
Contextual information about the command and execution.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called immediately after EF calls .
This method is still called if an interceptor suppressed execution of a command in .
In this case, is the result returned by .
The command.
Contextual information about the command and execution.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called immediately after EF calls .
This method is still called if an interceptor suppressed execution of a command in .
In this case, is the result returned by .
The command.
Contextual information about the command and execution.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called immediately after EF calls .
This method is still called if an interceptor suppressed execution of a command in .
In this case, is the result returned by .
The command.
Contextual information about the command and execution.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called immediately after EF calls .
This method is still called if an interceptor suppressed execution of a command in .
In this case, is the result returned by .
The command.
Contextual information about the command and execution.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
A providing the result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called immediately after EF calls .
This method is still called if an interceptor suppressed execution of a command in .
In this case, is the result returned by .
The command.
Contextual information about the command and execution.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
A providing the result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called immediately after EF calls .
This method is still called if an interceptor suppressed execution of a command in .
In this case, is the result returned by .
The command.
Contextual information about the command and execution.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
A providing the result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called when execution of a command has failed with an exception. />.
The command.
Contextual information about the command and execution.
Called when execution of a command has failed with an exception. />.
The command.
Contextual information about the command and execution.
The cancellation token.
A representing the asynchronous operation.
Called when execution of a is about to be disposed. />.
The command.
Contextual information about the command and reader.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Enum used by , an subclasses to indicate the
method on
being used to execute the command.
The or
method.
The or
method.
The or
method.
Abstract base class for for use when implementing a subset
of the interface methods.
Called just before EF intends to call .
The connection.
Contextual information about the connection.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called just before EF intends to call .
The connection.
Contextual information about the connection.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called just after EF has called .
The connection.
Contextual information about the connection.
Called just after EF has called .
The connection.
Contextual information about the connection.
The cancellation token.
A representing the asynchronous operation.
Called just before EF intends to call .
The connection.
Contextual information about the connection.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called just before EF intends to call in an async context.
The connection.
Contextual information about the connection.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called just after EF has called in an async context.
The connection.
Contextual information about the connection.
Called just after EF has called .
The connection.
Contextual information about the connection.
A representing the asynchronous operation.
Called when opening of a connection has failed with an exception. />.
The connection.
Contextual information about the connection.
Called when opening of a connection has failed with an exception. />.
The connection.
Contextual information about the connection.
The cancellation token.
A representing the asynchronous operation.
Abstract base class for for use when implementing a subset
of the interface methods.
Called just before EF intends to call .
The connection.
Contextual information about connection and transaction.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called immediately after EF calls .
This method is still called if an interceptor suppressed creation in .
In this case, is the result returned by .
The connection.
Contextual information about connection and transaction.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called just before EF intends to call
.
The connection.
Contextual information about connection and transaction.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called immediately after EF calls
.
This method is still called if an interceptor suppressed creation in .
In this case, is the result returned by .
The connection.
Contextual information about connection and transaction.
The result of the call to
.
This value is typically used as the return value for the implementation of this method.
The cancellation token.
A providing the result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called immediately after is called.
The connection.
Contextual information about connection and transaction.
The that was passed to .
This value is typically used as the return value for the implementation of this method.
The value that will be used as the effective value passed to
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called immediately after is called.
The connection.
Contextual information about connection and transaction.
The that was passed to .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
A containing the value that will be used as the effective value passed
to
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called just before EF intends to call .
The transaction.
Contextual information about connection and transaction.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called immediately after EF calls .
The transaction.
Contextual information about connection and transaction.
Called just before EF intends to call
.
The transaction.
Contextual information about connection and transaction.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called immediately after EF calls .
The transaction.
Contextual information about connection and transaction.
The cancellation token.
A representing the asynchronous operation.
Called just before EF intends to call .
The transaction.
Contextual information about connection and transaction.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called immediately after EF calls .
The transaction.
Contextual information about connection and transaction.
Called just before EF intends to call
.
The transaction.
Contextual information about connection and transaction.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called immediately after EF calls .
The transaction.
Contextual information about connection and transaction.
The cancellation token.
A representing the asynchronous operation.
Called when use of a has failed with an exception. />.
The transaction.
Contextual information about connection and transaction.
Called when use of a has failed with an exception. />.
The transaction.
Contextual information about connection and transaction.
The cancellation token.
A representing the asynchronous operation.
The event payload base class for events that
reference an entity type and a schema
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The entity type.
The schema.
The entity type.
The schema.
Allows interception of commands sent to a relational database.
Command interceptors can be used to view, change, or suppress execution of the , and
to modify the result before it is returned to EF.
Consider inheriting from if not implementing all methods.
Use
to register application interceptors.
Extensions can also register interceptors in the internal service provider.
If both injected and application interceptors are found, then the injected interceptors are run in the
order that they are resolved from the service provider, and then the application interceptors are run last.
Called just before EF intends to call .
Contextual information about the command and execution.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called immediately after EF calls .
This method is still called if an interceptor suppressed creation of a command in .
In this case, is the result returned by .
Contextual information about the command and execution.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called just before EF intends to call .
The command.
Contextual information about the command and execution.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called just before EF intends to call .
The command.
Contextual information about the command and execution.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called just before EF intends to call .
The command.
Contextual information about the command and execution.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called just before EF intends to call .
The command.
Contextual information about the command and execution.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called just before EF intends to call .
The command.
Contextual information about the command and execution.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called just before EF intends to call .
The command.
Contextual information about the command and execution.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called immediately after EF calls .
This method is still called if an interceptor suppressed execution of a command in .
In this case, is the result returned by .
The command.
Contextual information about the command and execution.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called immediately after EF calls .
This method is still called if an interceptor suppressed execution of a command in .
In this case, is the result returned by .
The command.
Contextual information about the command and execution.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called immediately after EF calls .
This method is still called if an interceptor suppressed execution of a command in .
In this case, is the result returned by .
The command.
Contextual information about the command and execution.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called immediately after EF calls .
This method is still called if an interceptor suppressed execution of a command in .
In this case, is the result returned by .
The command.
Contextual information about the command and execution.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
A providing the result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called immediately after EF calls .
This method is still called if an interceptor suppressed execution of a command in .
In this case, is the result returned by .
The command.
Contextual information about the command and execution.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
A providing the result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called immediately after EF calls .
This method is still called if an interceptor suppressed execution of a command in .
In this case, is the result returned by .
The command.
Contextual information about the command and execution.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
A providing the result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called when execution of a command has failed with an exception. />.
The command.
Contextual information about the command and execution.
Called when execution of a command has failed with an exception. />.
The command.
Contextual information about the command and execution.
The cancellation token.
A representing the asynchronous operation.
Called when execution of a is about to be disposed. />.
The command.
Contextual information about the command and reader.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Allows interception of operations on .
Connection interceptors can be used to view, change, or suppress the operation on , and
to modify the result before it is returned to EF.
Consider inheriting from if not implementing all methods.
Use
to register application interceptors.
Extensions can also register interceptors in the internal service provider.
If both injected and application interceptors are found, then the injected interceptors are run in the
order that they are resolved from the service provider, and then the application interceptors are run last.
Called just before EF intends to call .
The connection.
Contextual information about the connection.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called just before EF intends to call .
The connection.
Contextual information about the connection.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called just after EF has called .
The connection.
Contextual information about the connection.
Called just after EF has called .
The connection.
Contextual information about the connection.
The cancellation token.
A representing the asynchronous operation.
Called just before EF intends to call .
The connection.
Contextual information about the connection.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called just before EF intends to call in an async context.
The connection.
Contextual information about the connection.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called just after EF has called in an async context.
The connection.
Contextual information about the connection.
Called just after EF has called .
The connection.
Contextual information about the connection.
A representing the asynchronous operation.
Called when closing of a connection has failed with an exception. />.
The connection.
Contextual information about the connection.
Called when closing of a connection has failed with an exception. />.
The connection.
Contextual information about the connection.
The cancellation token.
A representing the asynchronous operation.
Allows interception of operations related to a .
Transaction interceptors can be used to view, change, or suppress operations on , and
to modify the result before it is returned to EF.
Consider inheriting from if not implementing all methods.
Use
to register application interceptors.
Extensions can also register interceptors in the internal service provider.
If both injected and application interceptors are found, then the injected interceptors are run in the
order that they are resolved from the service provider, and then the application interceptors are run last.
Called just before EF intends to call .
The connection.
Contextual information about connection and transaction.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called immediately after EF calls .
This method is still called if an interceptor suppressed creation in .
In this case, is the result returned by .
The connection.
Contextual information about connection and transaction.
The result of the call to .
This value is typically used as the return value for the implementation of this method.
The result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called just before EF intends to call
.
The connection.
Contextual information about connection and transaction.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation it
was about to perform and use instead.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called immediately after EF calls
.
This method is still called if an interceptor suppressed creation in .
In this case, is the result returned by .
The connection.
Contextual information about connection and transaction.
The result of the call to
.
This value is typically used as the return value for the implementation of this method.
The cancellation token.
A providing the result that EF will use.
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called immediately after is called.
The connection.
Contextual information about connection and transaction.
The that was passed to .
This value is typically used as the return value for the implementation of this method.
The value that will be used as the effective value passed to
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in.
Called immediately after is called.
The connection.
Contextual information about connection and transaction.
The that was passed to .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
A containing the value that will be used as the effective value passed
to
A normal implementation of this method for any interceptor that is not attempting to change the result
is to return the value passed in, often using
Called just before EF intends to call .
The transaction.
Contextual information about connection and transaction.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called immediately after EF calls .
The transaction.
Contextual information about connection and transaction.
Called just before EF intends to call
.
The transaction.
Contextual information about connection and transaction.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called immediately after EF calls .
The transaction.
Contextual information about connection and transaction.
The cancellation token.
A representing the asynchronous operation.
Called just before EF intends to call .
The transaction.
Contextual information about connection and transaction.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called immediately after EF calls .
The transaction.
Contextual information about connection and transaction.
Called just before EF intends to call
.
The transaction.
Contextual information about connection and transaction.
Represents the current result if one exists.
This value will have set to true if some previous
interceptor suppressed execution by calling .
This value is typically used as the return value for the implementation of this method.
The cancellation token.
If is false, the EF will continue as normal.
If is true, then EF will suppress the operation
it was about to perform.
A normal implementation of this method for any interceptor that is not attempting to suppress
the operation is to return the value passed in.
Called immediately after EF calls .
The transaction.
Contextual information about connection and transaction.
The cancellation token.
A representing the asynchronous operation.
Called when use of a has failed with an exception. />.
The transaction.
Contextual information about connection and transaction.
Called when use of a has failed with an exception. />.
The transaction.
Contextual information about connection and transaction.
The cancellation token.
A representing the asynchronous operation.
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.
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.
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.
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.
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.
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.
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.
The 'bool' property '{property}' on entity type '{entityType}' is configured with a database-generated default. This default will always be used for inserts when the property has the value 'false', since this is the CLR default for the 'bool' type. Consider using the nullable 'bool?' type instead so that the default will only be used for inserts when the property value is 'null'.
Opening connection to database '{database}' on server '{server}'.
Opened connection to database '{database}' on server '{server}'.
Closing connection to database '{database}' on server '{server}'.
Closed connection to database '{database}' on server '{server}'.
An error occurred using the connection to database '{database}' on server '{server}'.
Began transaction with isolation level '{isolationLevel}'.
Beginning transaction with isolation level '{isolationLevel}'.
Using an existing transaction with isolation level '{isolationLevel}'.
Committing transaction.
Committing transaction.
Rolling back transaction.
Rolled back transaction.
Disposing transaction.
An error occurred using a transaction.
A data reader was disposed.
An ambient transaction has been detected. The current provider does not support ambient transactions. See http://go.microsoft.com/fwlink/?LinkId=800142
Possible unintended use of method Equals(object) for arguments of different types in expression '{expression}'. This comparison will always return 'false'.
Possible unintended use of a potentially throwing aggregate method (Min, Max, Average) in a subquery. Client evaluation will be used and operator will throw if no data exists. Changing the subquery result type to a nullable type will allow full translation.
Generating down script for migration '{migration}'.
Generating up script for migration '{migration}'.
Applying migration '{migration}'.
Reverting migration '{migration}'.
Migrating using database '{database}' on server '{dataSource}'.
No migrations were applied. The database is already up to date.
No migrations were found in assembly '{migrationsAssembly}'.
Property '{property}' on entity type '{entityType}' is part of a primary or alternate key but has a constant default value set. Constant default values are not useful for primary or alternate keys since these properties must always have non-null unique values.
Creating DbCommand for '{executionType}'.
Created DbCommand for '{executionType}' ({elapsed}ms).
Executing DbCommand [Parameters=[{parameters}], CommandType='{commandType}', CommandTimeout='{commandTimeout}']{newLine}{commandText}
Executed DbCommand ({elapsed}ms) [Parameters=[{parameters}], CommandType='{commandType}', CommandTimeout='{commandTimeout}']{newLine}{commandText}
Failed executing DbCommand ({elapsed}ms) [Parameters=[{parameters}], CommandType='{commandType}', CommandTimeout='{commandTimeout}']{newLine}{commandText}
An error occurred using the connection to database '{database}' on server '{server}'.
Enlisted in an ambient transaction with isolation level '{isolationLevel}'.
Enlisted in an explicit transaction with isolation level '{isolationLevel}'.
Executing update commands individually as the number of batchable commands ({batchableCommandsCount}) is smaller than the minimum batch size ({minBatchSize}).
Executing {batchCommandsCount} update commands as a batch.
A MigrationAttribute isn't specified on the '{class}' class.
The event payload for
migrations assembly events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The in use.
The in use.
The in use.
The event payload for
events of a specific migration.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The in use.
The being processed.
The being processed.
The event payload for
migration scripting events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The in use.
The being processed.
The migration that scripting is starting from.
The migration that scripting is going to.
Indicates whether or not the script is idempotent.
The migration that scripting is starting from.
The migration that scripting is going to.
Indicates whether or not the script is idempotent.
The event payload for
migration events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The migration type.
The migration type.
The event payload for
migration connection events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The in use.
The .
A correlation ID that identifies the instance being used.
The .
A correlation ID that identifies the instance being used.
The event payload for
migration events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The in use.
The in use.
The event payload for
min batch size events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The entries being updated.
The command count.
The minimum batch size.
The minimum batch size.
Event IDs for relational events that correspond to messages logged to an
and events sent to a .
These IDs are also used with to configure the
behavior of warnings.
A database connection is opening.
This event is in the category.
This event uses the payload when used with a .
A database connection has been opened.
This event is in the category.
This event uses the payload when used with a .
A database connection is closing.
This event is in the category.
This event uses the payload when used with a .
A database connection has been closed.
This event is in the category.
This event uses the payload when used with a .
A error occurred while opening or using a database connection.
This event is in the category.
This event uses the payload when used with a .
A is being created.
This event is in the category.
This event uses the payload when used with a .
A has been created.
This event is in the category.
This event uses the payload when used with a .
A database command is executing.
This event is in the category.
This event uses the payload when used with a .
A database command has been executed.
This event is in the category.
This event uses the payload when used with a .
An error occurred while a database command was executing.
This event is in the category.
This event uses the payload when used with a .
A database transaction has been started.
This event is in the category.
This event uses the payload when used with a .
A database transaction is starting.
This event is in the category.
This event uses the payload when used with a .
Entity Framework started using an already existing database transaction.
This event is in the category.
This event uses the payload when used with a .
A database transaction is being committed.
This event is in the category.
This event uses the payload when used with a .
A database transaction has been committed.
This event is in the category.
This event uses the payload when used with a .
A database transaction is being rolled back.
This event is in the category.
This event uses the payload when used with a .
A database transaction has been rolled back.
This event is in the category.
This event uses the payload when used with a .
A database transaction has been disposed.
This event is in the category.
This event uses the payload when used with a .
An error has occurred while using. committing, or rolling back a database transaction.
This event is in the category.
This event uses the payload when used with a .
An application may have expected an ambient transaction to be used when it was actually ignored.
This event is in the category.
This event uses the payload when used with a .
Entity Framework enlisted the connection in an ambient transaction.
This event is in the category.
This event uses the payload when used with a .
The connection was explicitly enlisted in a transaction.
This event is in the category.
This event uses the payload when used with a .
A database data reader has been disposed.
This event is in the category.
This event uses the payload when used with a .
Migrations is using a database connection.
This event is in the category.
This event uses the payload when used with a .
A migration is being reverted.
This event is in the category.
This event uses the payload when used with a .
A migration is being applied.
This event is in the category.
This event uses the payload when used with a .
Migrations is generating a "down" script.
This event is in the category.
This event uses the payload when used with a .
Migrations is generating an "up" script.
This event is in the category.
This event uses the payload when used with a .
Migrations weren't applied.
This event is in the category.
This event uses the payload when used with a .
Migrations weren't found.
This event is in the category.
This event uses the payload when used with a .
A MigrationAttribute isn't specified on the class.
This event is in the category.
This event uses the payload when used with a .
Part of a query is being evaluated on the client instead of on the database server.
This event is in the category.
A query is using equals comparisons in a possibly unintended way.
This event is in the category.
This event uses the payload when used with a .
A query is using a possibly throwing aggregate operation in a sub-query.
This event is in the category.
A single database default column value has been set on a key column.
This event is in the category.
This event uses the payload when used with a .
A bool property is configured with a store-generated default.
This event is in the category.
This event uses the payload when used with a .
Update commands were batched and are now ready for execution
.
This event is in the category.
This event uses the payload when used with a .
Update commands were not batched because there were fewer than
.
This event is in the category.
This event uses the payload when used with a .
This class contains static methods used by EF Core internals and relational database providers to
write information to an and a for
well-known events.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Logs for the event.
The diagnostics logger to use.
The connection.
The type of method that will be called on this command.
The currently being used, to null if not known.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The time that execution began.
An intercepted result.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The type of method that will be called on this command.
The currently being used, to null if not known.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The time that execution began.
The duration of the command creation.
An intercepted result.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The currently being used, to null if not known.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The time that execution began.
An intercepted result.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The currently being used, to null if not known.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The time that execution began.
An intercepted result.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The currently being used, to null if not known.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The time that execution began.
An intercepted result.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The currently being used, to null if not known.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The time that execution began.
The cancellation token.
An intercepted result.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The currently being used, to null if not known.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The time that execution began.
The cancellation token.
An intercepted result.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The currently being used, to null if not known.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The time that execution began.
The cancellation token.
An intercepted result.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The currently being used, to null if not known.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The return value from the underlying method execution.
The time that execution began.
The duration of the command execution, not including consuming results.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The currently being used, to null if not known.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The return value from the underlying method execution.
The time that execution began.
The duration of the command execution, not including consuming results.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The currently being used, to null if not known.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The return value from the underlying method execution.
The time that execution began.
The duration of the command execution, not including consuming results.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The currently being used, to null if not known.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The return value from the underlying method execution.
The time that execution began.
The duration of the command execution, not including consuming results.
The cancellation token.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The currently being used, to null if not known.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The return value from the underlying method execution.
The time that execution began.
The duration of the command execution, not including consuming results.
The cancellation token.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The currently being used, to null if not known.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The return value from the underlying method execution.
The time that execution began.
The duration of the command execution, not including consuming results.
The cancellation token.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The currently being used, to null if not known.
Represents the method that will be called to execute the command.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The exception that caused this failure.
The time that execution began.
The amount of time that passed until the exception was raised.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The currently being used, to null if not known.
Represents the method that will be called to execute the command.
The correlation ID associated with the given .
The correlation ID associated with the being used.
The exception that caused this failure.
The time that execution began.
The amount of time that passed until the exception was raised.
The cancellation token.
A representing the async operation.
Logs for the event.
The diagnostics logger to use.
The connection.
The time that the operation was started.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The time that the operation was started.
The cancellation token.
A representing the async operation.
Logs for the event.
The diagnostics logger to use.
The connection.
The time that the operation was started.
The amount of time before the connection was opened.
Logs for the event.
The diagnostics logger to use.
The connection.
The time that the operation was started.
The amount of time before the connection was opened.
The cancellation token.
A representing the async operation.
Logs for the event.
The diagnostics logger to use.
The connection.
The time that the operation was started.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The time that the operation was started.
A representing the async operation.
Logs for the event.
The diagnostics logger to use.
The connection.
The time that the operation was started.
The amount of time before the connection was closed.
Logs for the event.
The diagnostics logger to use.
The connection.
The time that the operation was started.
The amount of time before the connection was closed.
A representing the async operation.
Logs for the event.
The diagnostics logger to use.
The connection.
The exception representing the error.
The time that the operation was started.
The elapsed time before the operation failed.
A flag indicating the exception is being handled and so it should be logged at Debug level.
Logs for the event.
The diagnostics logger to use.
The connection.
The exception representing the error.
The time that the operation was started.
The elapsed time before the operation failed.
A flag indicating the exception is being handled and so it should be logged at Debug level.
The cancellation token.
A representing the async operation.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction isolation level.
The correlation ID associated with the .
The time that the operation was started.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction isolation level.
The correlation ID associated with the .
The time that the operation was started.
The cancellation token.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
The correlation ID associated with the .
The time that the operation was started.
The amount of time before the connection was opened.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
The correlation ID associated with the .
The time that the operation was started.
The amount of time before the connection was opened.
The cancellation token.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
The correlation ID associated with the .
The time that the operation was started.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
The correlation ID associated with the .
The time that the operation was started.
The cancellation token.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
The correlation ID associated with the .
The time that the operation was started.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
The correlation ID associated with the .
The time that the operation was started.
The cancellation token.
A representing the async operation.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
The correlation ID associated with the .
The time that the operation was started.
The elapsed time from when the operation was started.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
The correlation ID associated with the .
The time that the operation was started.
The elapsed time from when the operation was started.
The cancellation token.
A representing the async operation.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
The correlation ID associated with the .
The time that the operation was started.
The elapsed time from when the operation was started.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
The correlation ID associated with the .
The time that the operation was started.
The elapsed time from when the operation was started.
The cancellation token.
A representing the async operation.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
The correlation ID associated with the .
The time that the operation was started.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
The correlation ID associated with the .
The time that the operation was started.
The cancellation token.
A representing the async operation.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
The correlation ID associated with the .
The time that the operation was started.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
The correlation ID associated with the .
The action being taken.
The exception that represents the error.
The time that the operation was started.
The elapsed time from when the operation was started.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
The correlation ID associated with the .
The action being taken.
The exception that represents the error.
The time that the operation was started.
The elapsed time from when the operation was started.
The cancellation token.
A representing the async operation.
Logs for the event.
The diagnostics logger to use.
The connection.
The time that the operation was started.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
Logs for the event.
The diagnostics logger to use.
The connection.
The transaction.
Logs for the event.
The diagnostics logger to use.
The connection.
The database command object.
The data reader.
The correlation ID associated with the given .
The number of records in the database that were affected.
The number of records that were read.
The time that the operation was started.
The elapsed time from when the operation was started.
The result of execution, which may have been modified by an interceptor.
Logs for the event.
The diagnostics logger to use.
The migrator.
The connection.
Logs for the event.
The diagnostics logger to use.
The migrator.
The migration.
Logs for the event.
The diagnostics logger to use.
The migrator.
The migration.
Logs for the event.
The diagnostics logger to use.
The migrator.
The migration.
The starting migration name.
The ending migration name.
Indicates whether or not an idempotent script is being generated.
Logs for the event.
The diagnostics logger to use.
The migrator.
The migration.
The starting migration name.
The ending migration name.
Indicates whether or not an idempotent script is being generated.
Logs for the event.
The diagnostics logger to use.
The migrator.
Logs for the event.
The diagnostics logger to use.
The migrator.
The assembly in which migrations are stored.
Logs for the event.
The diagnostics logger to use.
Info for the migration type.
Logs for the event.
The diagnostics logger to use.
The expression representing the problematic method call.
Logs for the event.
The diagnostics logger to use.
Logs for the event.
The diagnostics logger to use.
The property.
Logs for the event.
The diagnostics logger to use.
The property.
Logs for the event.
The diagnostics logger to use.
The entries for entities in the batch.
The number of commands.
Logs for the event.
The diagnostics logger to use.
The entries for entities in the batch.
The number of commands.
The minimum batch size.
Contains placeholders for caching of .
This class is public so that it can be inherited by database providers
to add caching for their events. It should not be used for any other purpose.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
The event payload base class for events that
reference a sequence.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The sequence.
The sequence.
The event payload base class for
transaction end events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The .
The currently being used, or null if not known.
A correlation ID that identifies the Entity Framework transaction being used.
A correlation ID that identifies the instance being used.
Indicates whether or not the transaction is being used asynchronously.
The start time of this event.
The duration this event.
The duration of this event.
The event payload for
transaction enlisted events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The .
The .
A correlation ID that identifies the instance being used.
The .
The .
A correlation ID that identifies the instance being used.
The event payload base class for
transaction error events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The .
The currently being used, or null if not known.
A correlation ID that identifies the Entity Framework transaction being used.
A correlation ID that identifies the instance being used.
Indicates whether or not the transaction is being used asynchronously.
One of "Commit" or "Rollback".
The exception that was thrown when the transaction failed.
The start time of this event.
The duration this event.
One of "Commit" or "Rollback".
The exception that was thrown when the transaction failed.
The event payload base class for
transaction events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The .
The currently in use, or null if not known.
A correlation ID that identifies the Entity Framework transaction being used.
A correlation ID that identifies the instance being used.
Indicates whether or not the transaction is being used asynchronously.
The start time of this event.
The , or null if it has not yet been created.
A correlation ID that identifies the Entity Framework transaction being used.
A correlation ID that identifies the instance being used.
Indicates whether or not the transaction is being used asynchronously.
The start time of this event.
The event payload base class for
transaction events.
Constructs the event payload.
The event definition.
A delegate that generates a log message for this event.
The currently in use, or null if not known.
The transaction isolation level.
A correlation ID that identifies the Entity Framework transaction being used.
A correlation ID that identifies the instance being used.
Indicates whether or not the transaction is being used asynchronously.
The start time of this event.
The transaction isolation level.
A correlation ID that identifies the Entity Framework transaction being used.
A correlation ID that identifies the instance being used.
Indicates whether or not the transaction is being used asynchronously.
The start time of this event.
String resources used in EF exceptions, etc.
These strings are exposed publicly for use by database providers and extensions.
It is unusual for application code to need these strings.
Cannot save changes for an entity in state '{entityState}'.
Database operation expected to affect {expectedRows} row(s) but actually affected {actualRows} row(s). Data may have been modified or deleted since entities were loaded. See http://go.microsoft.com/fwlink/?LinkId=527962 for information on understanding and handling optimistic concurrency exceptions.
Multiple relational database provider configurations found. A context can only be configured to use a single database provider.
No relational database providers are configured. Configure a database provider using OnConfiguring or by creating an ImmutableDbContextOptions with a database provider configured and passing it to the context.
Both an existing DbConnection and a connection string have been configured. When an existing DbConnection is used the connection string must be set on that connection.
A relational store has been configured without specifying either the DbConnection or connection string to use.
A named connection string was used, but the name '{name}' was not found in the application's configuration. Note that named connection strings are only supported when using 'IConfiguration' and a service provider, such as in a typical ASP.NET Core application. See https://go.microsoft.com/fwlink/?linkid=850912 for more information.
No mapping to a relational type can be found for the CLR type '{clrType}'.
Relational-specific methods can only be used when the context is using a relational database provider.
An error occurred while updating the entries. See the inner exception for details.
The connection is already in a transaction and cannot participate in another transaction.
The specified transaction is not associated with the current connection. Only transactions associated with the current connection may be used.
Invalid type for sequence. Valid types are 'Int64' (the default), 'Int32', 'Int16', 'Byte' and 'Decimal'.
Unable to deserialize sequence from model metadata. See inner exception for details.
Unable to deserialize check constraint from model metadata. See inner exception for details.
The migration '{migrationName}' was not found.
The current migration SQL generator '{sqlGeneratorType}' is unable to generate SQL for operations of type '{operationType}'.
The specified CommandTimeout value is not valid. It must be a positive number.
The specified MaxBatchSize value is not valid. It must be a positive number.
The required column '{column}' was not present in the results of a 'FromSql' operation.
Cannot use table '{table}' for entity type '{entityType}' since it is being used for entity type '{otherEntityType}' and the name '{keyName}' of the primary key {primaryKey} does not match the name '{otherName}' of the primary key {otherPrimaryKey}.
Cannot use table '{table}' for entity type '{entityType}' since it is being used for entity type '{otherEntityType}' and the comment '{comment}' does not match the comment '{otherComment}'.
Cannot use table '{table}' for entity type '{entityType}' since it is being used for entity type '{otherEntityType}' and there is no relationship between their primary keys.
No value provided for required parameter '{parameter}'.
Cannot use the value provided for parameter '{parameter}' because it isn't assignable to type object[].
'{entityType1}.{property1}' and '{entityType2}.{property2}' are both mapped to column '{columnName}' in '{table}' but are configured to use different data types ('{dataType1}' and '{dataType2}').
The connection does not have any active transactions.
An instance of entity type '{firstEntityType}' is marked as '{firstState}', but an instance of entity type '{secondEntityType}' is marked as '{secondState}' and both are mapped to the same row. Consider using 'DbContextOptionsBuilder.EnableSensitiveDataLogging' to see the key values.
The instance of entity type '{firstEntityType}' with the key value '{firstKeyValue}' is marked as '{firstState}', but the instance of entity type '{secondEntityType}' with the key value '{secondKeyValue}' is marked as '{secondState}' and both are mapped to the same row.
An instance of entity type '{firstEntityType}' and an instance of entity type '{secondEntityType}' are mapped to the same row, but have different property values for the properties {firstProperties} and {secondProperties} mapped to {columns}. Consider using 'DbContextOptionsBuilder.EnableSensitiveDataLogging' to see the conflicting values.
The instance of entity type '{firstEntityType}' and the instance of entity type '{secondEntityType}' are mapped to the same row with the key value '{keyValue}', but have different property values '{firstConflictingValues}' and '{secondConflictingValues}' mapped to {columns}.
An instance of entity type '{firstEntityType}' and an instance of entity type '{secondEntityType}' are mapped to the same row, but have different original property values for the properties {firstProperties} and {secondProperties} mapped to {columns}. Consider using 'DbContextOptionsBuilder.EnableSensitiveDataLogging' to see the conflicting values.
The instance of entity type '{firstEntityType}' and the instance of entity type '{secondEntityType}' are mapped to the same row with the key value '{keyValue}', but have different original property values '{firstConflictingValues}' and '{secondConflictingValues}' mapped to {columns}.
The entity of type '{entityType}' is sharing the table '{tableName}' with entities of type '{missingEntityType}', but there is no entity of this type with the same key value that has been marked as '{state}'. Consider using 'DbContextOptionsBuilder.EnableSensitiveDataLogging' to see the key values.
The entity of type '{entityType}' is sharing the table '{tableName}' with entities of type '{missingEntityType}', but there is no entity of this type with the same key value '{keyValue}' that has been marked as '{state}'.
Cannot set default value '{value}' of type '{valueType}' on property '{property}' of type '{propertyType}' in entity type '{entityType}'.
'{entityType1}.{property1}' and '{entityType2}.{property2}' are both mapped to column '{columnName}' in '{table}' but are configured with different nullability.
'{entityType1}.{property1}' and '{entityType2}.{property2}' are both mapped to column '{columnName}' in '{table}' but are configured to use different computed values ('{value1}' and '{value2}').
'{entityType1}.{property1}' and '{entityType2}.{property2}' are both mapped to column '{columnName}' in '{table}' but are configured to use different default values ('{value1}' and '{value2}').
'{entityType1}.{property1}' and '{entityType2}.{property2}' are both mapped to column '{columnName}' in '{table}' but are configured to use different comments ('{comment1}' and '{comment2}').
{conflictingConfiguration} cannot be set for '{property}' at the same time as {existingConfiguration}. Remove one of these values.
The check constraint '{checkConstraint}' cannot be added to the entity type '{entityType}' because another check constraint with the same name already exists.
The foreign keys {index1} on '{entityType1}' and {index2} on '{entityType2}' are both mapped to '{table}.{foreignKeyName}' but use different columns ({columnNames1} and {columnNames2}).
The foreign keys {index1} on '{entityType1}' and {index2} on '{entityType2}' are both mapped to '{table}.{foreignKeyName}' but with different delete behavior ('{deleteBehavior1}' and '{deleteBehavior2}').
The foreign keys {index1} on '{entityType1}' and {index2} on '{entityType2}' are both mapped to '{table}.{foreignKeyName}' but referencing different principal columns ({principalColumnNames1} and {principalColumnNames2}).
The foreign keys {index1} on '{entityType1}' and {index2} on '{entityType2}' are both mapped to '{table}.{foreignKeyName}' but referencing different principal tables ('{principalTable1}' and '{principalTable2}').
The foreign keys {index1} on '{entityType1}' and {index2} on '{entityType2}' are both mapped to '{table}.{foreignKeyName}' but with different uniqueness.
The indexes {index1} on '{entityType1}' and {index2} on '{entityType2}' are both mapped to '{table}.{indexName}' but with different columns ({columnNames1} and {columnNames2}).
The indexes {index1} on '{entityType1}' and {index2} on '{entityType2}' are both mapped to '{table}.{indexName}' but with different uniqueness.
The keys {key1} on '{entityType1}' and {key2} on '{entityType2}' are both mapped to '{table}.{keyName}' but with different columns ({columnNames1} and {columnNames2}).
No mapping to a relational type can be found for property '{entity}.{property}' with the CLR type '{clrType}'.
Timeout must be greater than or equal to zero. Provided: {seconds} seconds.
Timeout must be less than or equal to Int32.MaxValue (2147483647) seconds. Provided: {seconds} seconds.
The DbFunction '{function}' has an invalid return type '{type}'. Ensure that the return type can be mapped by the current provider.
The DbFunction '{function}' has no name set. Name is a required property of a DbFunction.
The parameter '{parameter}' for the DbFunction '{function}' has an invalid type '{type}'. Ensure the parameter type can be mapped by the current provider.
The DbFunction '{function}' does not have a parameter named '{parameter}'.
The DbFunction '{function}' is generic. Generic methods are not supported.
The provided DbFunction expression '{expression}' is invalid. The expression should be a lambda expression containing a single method call to the target static method. Default values can be provided as arguments if required. E.g. () => SomeClass.SomeMethod(null, 0)
The DbFunction '{function}' defined on type '{type}' must be either a static method or an instance method defined on a DbContext subclass. Instance methods on other types are not supported.
An ambient transaction has been detected. The ambient transaction needs to be completed before beginning a transaction on this connection.
The connection is currently enlisted in a transaction. The enlisted transaction needs to be completed before starting a transaction.
The specified MinBatchSize value is not valid. It must be a positive number.
Expected a non-null value for query parameter '{parameter}'.
The entity type '{entityType}' cannot be mapped to a table because it is derived from '{baseType}'. Only base entity types can be mapped to a table.
The '{mapping}' does not support 2.2 style type mapping. The database provider needs to be updated to support the full set of mapping customization.
The result type of '{elseResultType}' in the else clause is invalid. The expected type is '{resultType}'.
The result type of '{whenResultType}' in a when clause is invalid. The expected type is '{resultType}'.
The operand type of '{whenOperandType}' in a when clause is invalid. The expected type is '{expectedWhenOperandType}'.
The number of argument type mappings does not match the number of arguments.
One of the specified argument type mappings was null.
An instance type mapping was specified without an instance expression.
Entity type '{entityType}' doesn't contain a property mapped to the store-generated concurrency token column '{missingColumn}' that is used by another entity type sharing the table '{table}'. Add a store-generated property mapped to the same column to '{entityType}'. It can be in shadow state.
This connection was used with an ambient transaction. The original ambient transaction needs to be completed before this connection can be used outside of it.
Set operations (Union, Concat, Intersect, Except) are only supported over entity types within the same type hierarchy.
FromSqlRaw or FromSqlInterpolated was called with non-composable SQL and with a query composing over it. Consider calling `AsEnumerable` after the FromSqlRaw or FromSqlInterpolated method to perform the composition on the client side.
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.
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.
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.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
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.
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.
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.
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.
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.
Extension methods for the returned from
that can be used only with relational database providers.
Applies any pending migrations for the context to the database. Will create the database
if it does not already exist.
Note that this API is mutually exclusive with DbContext.Database.EnsureCreated(). EnsureCreated does not use migrations
to create the database and therefore the database that is created cannot be later updated using migrations.
The for the context.
Gets all the migrations that are defined in the configured migrations assembly.
The for the context.
The list of migrations.
Gets all migrations that have been applied to the target database.
The for the context.
The list of migrations.
Asynchronously gets all migrations that have been applied to the target database.
The for the context.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation.
Gets all migrations that are defined in the assembly but haven't been applied to the target database.
The for the context.
The list of migrations.
Asynchronously gets all migrations that are defined in the assembly but haven't been applied to the target database.
The for the context.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation.
Asynchronously applies any pending migrations for the context to the database. Will create the database
if it does not already exist.
Note that this API is mutually exclusive with DbContext.Database.EnsureCreated(). EnsureCreated does not use migrations
to create the database and therefore the database that is created cannot be later updated using migrations.
The for the context.
A to observe while waiting for the task to complete.
A task that represents the asynchronous migration operation.
Executes the given SQL against the database and returns the number of rows affected.
Note that this method does not start a transaction. To use this method with
a transaction, first call or .
Note that the current is not used by this method
since the SQL may not be idempotent and does not run in a transaction. An ExecutionStrategy
can be used explicitly, making sure to also use a transaction if the SQL is not
idempotent.
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
arguments. Any parameter values you supply will automatically be converted to a DbParameter -
context.Database.ExecuteSqlCommand("SELECT * FROM [dbo].[SearchBlogs]({0})", userSuppliedSearchTerm).
You can also consider using ExecuteSqlInterpolated to use interpolated string syntax to create parameters.
The for the context.
The SQL to execute.
Parameters to use with the SQL.
The number of rows affected.
Executes the given SQL against the database and returns the number of rows affected.
Note that this method does not start a transaction. To use this method with
a transaction, first call or .
Note that the current is not used by this method
since the SQL may not be idempotent and does not run in a transaction. An ExecutionStrategy
can be used explicitly, making sure to also use a transaction if the SQL is not
idempotent.
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
arguments. Any parameter values you supply will automatically be converted to a DbParameter -
context.Database.ExecuteSqlCommand($"SELECT * FROM [dbo].[SearchBlogs]({userSuppliedSearchTerm})").
The for the context.
The interpolated string representing a SQL query with parameters.
The number of rows affected.
Executes the given SQL against the database and returns the number of rows affected.
Note that this method does not start a transaction. To use this method with
a transaction, first call or .
Note that the current is not used by this method
since the SQL may not be idempotent and does not run in a transaction. An ExecutionStrategy
can be used explicitly, making sure to also use a transaction if the SQL is not
idempotent.
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
arguments. Any parameter values you supply will automatically be converted to a DbParameter.
You can also consider using ExecuteSqlInterpolated to use interpolated string syntax to create parameters.
The for the context.
The SQL to execute.
Parameters to use with the SQL.
The number of rows affected.
Executes the given SQL against the database and returns the number of rows affected.
Note that this method does not start a transaction. To use this method with
a transaction, first call or .
Note that the current is not used by this method
since the SQL may not be idempotent and does not run in a transaction. An ExecutionStrategy
can be used explicitly, making sure to also use a transaction if the SQL is not
idempotent.
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
arguments. Any parameter values you supply will automatically be converted to a DbParameter -
context.Database.ExecuteSqlCommandAsync($"SELECT * FROM [dbo].[SearchBlogs]({userSuppliedSearchTerm})").
The for the context.
The interpolated string representing a SQL query with parameters.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result is the number of rows affected.
Executes the given SQL against the database and returns the number of rows affected.
Note that this method does not start a transaction. To use this method with
a transaction, first call or .
Note that the current is not used by this method
since the SQL may not be idempotent and does not run in a transaction. An ExecutionStrategy
can be used explicitly, making sure to also use a transaction if the SQL is not
idempotent.
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
arguments. Any parameter values you supply will automatically be converted to a DbParameter -
context.Database.ExecuteSqlCommandAsync("SELECT * FROM [dbo].[SearchBlogs]({0})", userSuppliedSearchTerm).
The for the context.
The SQL to execute.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result is the number of rows affected.
Executes the given SQL against the database and returns the number of rows affected.
Note that this method does not start a transaction. To use this method with
a transaction, first call or .
Note that the current is not used by this method
since the SQL may not be idempotent and does not run in a transaction. An ExecutionStrategy
can be used explicitly, making sure to also use a transaction if the SQL is not
idempotent.
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
arguments. Any parameter values you supply will automatically be converted to a DbParameter -
context.Database.ExecuteSqlCommandAsync("SELECT * FROM [dbo].[SearchBlogs]({0})", userSuppliedSearchTerm).
You can also consider using ExecuteSqlInterpolated to use interpolated string syntax to create parameters.
The for the context.
The SQL to execute.
Parameters to use with the SQL.
A task that represents the asynchronous operation. The task result is the number of rows affected.
Executes the given SQL against the database and returns the number of rows affected.
Note that this method does not start a transaction. To use this method with
a transaction, first call or .
Note that the current is not used by this method
since the SQL may not be idempotent and does not run in a transaction. An ExecutionStrategy
can be used explicitly, making sure to also use a transaction if the SQL is not
idempotent.
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
arguments. Any parameter values you supply will automatically be converted to a DbParameter.
You can also consider using ExecuteSqlInterpolated to use interpolated string syntax to create parameters.
The for the context.
The SQL to execute.
Parameters to use with the SQL.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result is the number of rows affected.
Executes the given SQL against the database and returns the number of rows affected.
Note that this method does not start a transaction. To use this method with
a transaction, first call or .
Note that the current is not used by this method
since the SQL may not be idempotent and does not run in a transaction. An ExecutionStrategy
can be used explicitly, making sure to also use a transaction if the SQL is not
idempotent.
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
arguments. Any parameter values you supply will automatically be converted to a DbParameter -
context.Database.ExecuteSqlRaw("SELECT * FROM [dbo].[SearchBlogs]({0})", userSuppliedSearchTerm).
You can also consider using ExecuteSqlInterpolated to use interpolated string syntax to create parameters.
The for the context.
The SQL to execute.
Parameters to use with the SQL.
The number of rows affected.
Executes the given SQL against the database and returns the number of rows affected.
Note that this method does not start a transaction. To use this method with
a transaction, first call or .
Note that the current is not used by this method
since the SQL may not be idempotent and does not run in a transaction. An ExecutionStrategy
can be used explicitly, making sure to also use a transaction if the SQL is not
idempotent.
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
arguments. Any parameter values you supply will automatically be converted to a DbParameter -
context.Database.ExecuteSqlInterpolated($"SELECT * FROM [dbo].[SearchBlogs]({userSuppliedSearchTerm})").
The for the context.
The interpolated string representing a SQL query with parameters.
The number of rows affected.
Executes the given SQL against the database and returns the number of rows affected.
Note that this method does not start a transaction. To use this method with
a transaction, first call or .
Note that the current is not used by this method
since the SQL may not be idempotent and does not run in a transaction. An ExecutionStrategy
can be used explicitly, making sure to also use a transaction if the SQL is not
idempotent.
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
arguments. Any parameter values you supply will automatically be converted to a DbParameter.
You can also consider using ExecuteSqlInterpolated to use interpolated string syntax to create parameters.
The for the context.
The SQL to execute.
Parameters to use with the SQL.
The number of rows affected.
Executes the given SQL against the database and returns the number of rows affected.
Note that this method does not start a transaction. To use this method with
a transaction, first call or .
Note that the current is not used by this method
since the SQL may not be idempotent and does not run in a transaction. An ExecutionStrategy
can be used explicitly, making sure to also use a transaction if the SQL is not
idempotent.
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
arguments. Any parameter values you supply will automatically be converted to a DbParameter -
context.Database.ExecuteSqlInterpolatedAsync($"SELECT * FROM [dbo].[SearchBlogs]({userSuppliedSearchTerm})").
The for the context.
The interpolated string representing a SQL query with parameters.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result is the number of rows affected.
Executes the given SQL against the database and returns the number of rows affected.
Note that this method does not start a transaction. To use this method with
a transaction, first call or .
Note that the current is not used by this method
since the SQL may not be idempotent and does not run in a transaction. An ExecutionStrategy
can be used explicitly, making sure to also use a transaction if the SQL is not
idempotent.
The for the context.
The SQL to execute.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result is the number of rows affected.
Executes the given SQL against the database and returns the number of rows affected.
Note that this method does not start a transaction. To use this method with
a transaction, first call or .
Note that the current is not used by this method
since the SQL may not be idempotent and does not run in a transaction. An ExecutionStrategy
can be used explicitly, making sure to also use a transaction if the SQL is not
idempotent.
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
arguments. Any parameter values you supply will automatically be converted to a DbParameter -
context.Database.ExecuteSqlRawAsync("SELECT * FROM [dbo].[SearchBlogs]({0})", userSuppliedSearchTerm).
You can also consider using ExecuteSqlInterpolated to use interpolated string syntax to create parameters.
The for the context.
The SQL to execute.
Parameters to use with the SQL.
A task that represents the asynchronous operation. The task result is the number of rows affected.
Executes the given SQL against the database and returns the number of rows affected.
Note that this method does not start a transaction. To use this method with
a transaction, first call or .
Note that the current is not used by this method
since the SQL may not be idempotent and does not run in a transaction. An ExecutionStrategy
can be used explicitly, making sure to also use a transaction if the SQL is not
idempotent.
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
arguments. Any parameter values you supply will automatically be converted to a DbParameter.
You can also consider using ExecuteSqlInterpolated to use interpolated string syntax to create parameters.
The for the context.
The SQL to execute.
Parameters to use with the SQL.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result is the number of rows affected.
Gets the underlying ADO.NET for this .
The for the context.
The
Opens the underlying .
The for the context.
Opens the underlying .
The for the context.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation.
Closes the underlying .
The for the context.
Closes the underlying .
The for the context.
A task that represents the asynchronous operation.
Starts a new transaction with a given .
The for the context.
The to use.
A that represents the started transaction.
Asynchronously starts a new transaction with a given .
The for the context.
The to use.
A to observe while waiting for the task to complete.
A task that represents the asynchronous transaction initialization. The task result contains a
that represents the started transaction.
Sets the to be used by database operations on the .
The for the context.
The to use.
A that encapsulates the given transaction.
Sets the to be used by database operations on the .
The for the context.
The to use.
A token to observe while waiting for the task to complete.
A containing the for the given transaction.
Sets the timeout (in seconds) to use for commands executed with this .
Note that the command timeout is distinct from the connection timeout, which is commonly
set on the database connection string.
The for the context.
The timeout to use, in seconds.
Sets the timeout to use for commands executed with this .
Note that the command timeout is distinct from the connection timeout, which is commonly
set on the database connection string.
The for the context.
The timeout to use.
Returns the timeout (in seconds) set for commands executed with this .
Note that the command timeout is distinct from the connection timeout, which is commonly
set on the database connection string.
The for the context.
The timeout, in seconds, or null if no timeout has been set.
Generates a script to create all tables for the current model.
A SQL script.
Relational database specific extension methods for .
Configures the table that the entity type maps to when targeting a relational database.
The builder for the entity type being configured.
The name of the table.
The same builder instance so that multiple calls can be chained.
Configures the table that the entity type maps to when targeting a relational database.
The entity type being configured.
The builder for the entity type being configured.
The name of the table.
The same builder instance so that multiple calls can be chained.
Configures the table that the entity type maps to when targeting a relational database.
The builder for the entity type being configured.
The name of the table.
The schema of the table.
The same builder instance so that multiple calls can be chained.
Configures the table that the entity type maps to when targeting a relational database.
The entity type being configured.
The builder for the entity type being configured.
The name of the table.
The schema of the table.
The same builder instance so that multiple calls can be chained.
Configures the table that the entity type maps to when targeting a relational database.
The builder for the entity type being configured.
The name of the table.
The same builder instance so that multiple calls can be chained.
Configures the table that the entity type maps to when targeting a relational database.
The entity type being configured.
The entity type that this relationship targets.
The builder for the entity type being configured.
The name of the table.
The same builder instance so that multiple calls can be chained.
Configures the table that the entity type maps to when targeting a relational database.
The builder for the entity type being configured.
The name of the table.
The schema of the table.
The same builder instance so that multiple calls can be chained.
Configures the table that the entity type maps to when targeting a relational database.
The entity type being configured.
The entity type that this relationship targets.
The builder for the entity type being configured.
The name of the table.
The schema of the table.
The same builder instance so that multiple calls can be chained.
Configures the table that the entity type maps to when targeting a relational database.
The builder for the entity type being configured.
The name of the table.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Configures the table that the entity type maps to when targeting a relational database.
The builder for the entity type being configured.
The name of the table.
The schema of the table.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the view or table name can be set for this entity type
from the current configuration source
The builder for the entity type being configured.
The name of the view or table.
Indicates whether the configuration was specified using a data annotation.
true if the configuration can be applied.
Configures the schema of the view or table that the entity type maps to when targeting a relational database.
The builder for the entity type being configured.
The schema of the view or table.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the schema of the view or table name can be set for this entity type
from the current configuration source
The builder for the entity type being configured.
The schema of the view or table.
Indicates whether the configuration was specified using a data annotation.
true if the configuration can be applied.
Configures the view that the entity type maps to when targeting a relational database.
The builder for the entity type being configured.
The name of the view.
The same builder instance so that multiple calls can be chained.
Configures the view that the entity type maps to when targeting a relational database.
The entity type being configured.
The builder for the entity type being configured.
The name of the view.
The same builder instance so that multiple calls can be chained.
Configures the view that the entity type maps to when targeting a relational database.
The builder for the entity type being configured.
The name of the view.
The schema of the view.
The same builder instance so that multiple calls can be chained.
Configures the view that the entity type maps to when targeting a relational database.
The entity type being configured.
The builder for the entity type being configured.
The name of the view.
The schema of the view.
The same builder instance so that multiple calls can be chained.
Configures a database check constraint when targeting a relational database.
The entity type builder.
The name of the check constraint.
The logical constraint sql used in the check constraint.
A builder to further configure the entity type.
Configures a database check constraint when targeting a relational database.
The entity type being configured.
The entity type builder.
The name of the check constraint.
The logical constraint sql used in the check constraint.
A builder to further configure the entity type.
Configures a database check constraint when targeting a relational database.
The entity type builder.
The name of the check constraint.
The logical constraint sql used in the check constraint.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the check constraint was configured,
null otherwise.
Returns a value indicating whether the check constraint can be configured.
The builder for the entity type being configured.
The name of the check constraint.
The logical constraint sql used in the check constraint.
Indicates whether the configuration was specified using a data annotation.
true if the configuration can be applied.
Configures a comment to be applied to the table
The builder for the entity type being configured.
The comment for the table.
A builder to further configure the entity type.
Configures a comment to be applied to the table
The entity type being configured.
The entity type builder.
The comment for the table.
A builder to further configure the entity type.
Configures a comment to be applied to the table
The builder for the entity type being configured.
The comment for the table.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether a comment can be set for this entity type
from the current configuration source
The builder for the entity type being configured.
The comment for the table.
Indicates whether the configuration was specified using a data annotation.
true if the configuration can be applied.
Extension methods for for relational database metadata.
Returns the name of the table to which the entity type is mapped.
The entity type to get the table name for.
The name of the table to which the entity type is mapped.
Returns the default table name that would be used for this entity type.
The entity type to get the table name for.
The default name of the table to which the entity type would be mapped.
Sets the name of the table to which the entity type is mapped.
The entity type to set the table name for.
The name to set.
Sets the name of the table to which the entity type is mapped.
The entity type to set the table name for.
The name to set.
Indicates whether the configuration was specified using a data annotation.
Gets the for the table name.
The entity type to find configuration source for.
The for the table name.
Returns the database schema that contains the mapped table.
The entity type to get the schema for.
The database schema that contains the mapped table.
Returns the default database schema that would be used for this entity type.
The entity type to get the table name for.
The default database schema to which the entity type would be mapped.
Sets the database schema that contains the mapped table.
The entity type to set the schema for.
The value to set.
Sets the database schema that contains the mapped table.
The entity type to set the schema for.
The value to set.
Indicates whether the configuration was specified using a data annotation.
Gets the for the database schema.
The entity type to find configuration source for.
The for the database schema.
Finds an with the given name.
The entity type to find the check constraint for.
The check constraint name.
The or null if no check constraint with the
given name in the given entity type was found.
Finds an with the given name.
The entity type to find the check constraint for.
The check constraint name.
The or null if no check constraint with the
given name in the given entity type was found.
Creates a new check constraint with the given name on entity type. Throws an exception
if a check constraint with the same name exists on the same entity type.
The entity type to add the check constraint to.
The check constraint name.
The logical constraint sql used in the check constraint.
The new check constraint.
Creates a new check constraint with the given name on entity type. Throws an exception
if a check constraint with the same name exists on the same entity type.
The entity type to add the check constraint to.
The check constraint name.
The logical constraint sql used in the check constraint.
Indicates whether the configuration was specified using a data annotation.
The new check constraint.
Removes the with the given name.
The entity type to remove the check constraint from.
The check constraint name to be removed.
True if the is successfully found and removed; otherwise, false.
Removes the with the given name.
The entity type to remove the check constraint from.
The check constraint name.
True if the is successfully found and removed; otherwise, false.
Returns all contained in the entity type.
The entity type to get the check constraints for.
Returns the comment for the column this property is mapped to.
The entity type.
The comment for the column this property is mapped to.
Configures a comment to be applied to the column this property is mapped to.
The entity type.
The comment for the column.
Configures a comment to be applied to the column this property is mapped to.
The entity type.
The comment for the column.
Indicates whether the configuration was specified using a data annotation.
Gets a value indicating whether the entity type is ignored by Migrations.
The entity type.
A value indicating whether the entity type is ignored by Migrations.
Relational database specific extension methods for relationship builders.
Configures the foreign key constraint name for this relationship when targeting a relational database.
The builder being used to configure the relationship.
The name of the foreign key constraint.
The same builder instance so that multiple calls can be chained.
Configures the foreign key constraint name for this relationship when targeting a relational database.
The builder being used to configure the relationship.
The name of the foreign key constraint.
The same builder instance so that multiple calls can be chained.
The principal entity type in this relationship.
The dependent entity type in this relationship.
Configures the foreign key constraint name for this relationship when targeting a relational database.
The builder being used to configure the relationship.
The name of the foreign key constraint.
The same builder instance so that multiple calls can be chained.
Configures the foreign key constraint name for this relationship when targeting a relational database.
The builder being used to configure the relationship.
The name of the foreign key constraint.
The same builder instance so that multiple calls can be chained.
The entity type on one end of the relationship.
The entity type on the other end of the relationship.
Configures the foreign key constraint name for this relationship when targeting a relational database.
The builder being used to configure the relationship.
The name of the foreign key constraint.
The same builder instance so that multiple calls can be chained.
Configures the foreign key constraint name for this relationship when targeting a relational database.
The builder being used to configure the relationship.
The name of the foreign key constraint.
The same builder instance so that multiple calls can be chained.
The entity type on one end of the relationship.
The entity type on the other end of the relationship.
Configures the foreign key constraint name for this relationship when targeting a relational database.
The builder being used to configure the relationship.
The name of the foreign key constraint.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the foreign key constraint name can be set for this relationship
from the current configuration source
The builder being used to configure the relationship.
The name of the foreign key constraint.
Indicates whether the configuration was specified using a data annotation.
true if the configuration can be applied.
Extension methods for for relational database metadata.
Returns the foreign key constraint name.
The foreign key.
The foreign key constraint name.
Returns the default constraint name that would be used for this foreign key.
The foreign key.
The default constraint name that would be used for this foreign key.
Sets the foreign key constraint name.
The foreign key.
The value to set.
Sets the foreign key constraint name.
The foreign key.
The value to set.
Indicates whether the configuration was specified using a data annotation.
Gets the for the constraint name.
The foreign key.
The for the constraint name.
Relational database specific extension methods for .
Configures the name of the index in the database when targeting a relational database.
The builder for the index being configured.
The name of the index.
A builder to further configure the index.
Configures the name of the index in the database when targeting a relational database.
The entity type being configured.
The builder for the index being configured.
The name of the index.
A builder to further configure the index.
Configures the name of the index in the database when targeting a relational database.
The builder for the index being configured.
The name of the index.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given name can be set for the index.
The builder for the index being configured.
The name of the index.
Indicates whether the configuration was specified using a data annotation.
true if the given name can be set for the index.
Configures the filter expression for the index.
The builder for the index being configured.
The filter expression for the index.
A builder to further configure the index.
Configures the filter expression for the index.
The entity type being configured.
The builder for the index being configured.
The filter expression for the index.
A builder to further configure the index.
Configures the filter expression for the index.
The builder for the index being configured.
The filter expression for the index.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given expression can be set as the filter for the index.
The builder for the index being configured.
The filter expression for the index.
Indicates whether the configuration was specified using a data annotation.
true if the given name can be set for the index.
Extension methods for for relational database metadata.
Returns the name for this index.
The index.
The name for this index.
Returns the default name that would be used for this index.
The index.
The default name that would be used for this index.
Sets the index name.
The index.
The value to set.
Sets the index name.
The index.
The value to set.
Indicates whether the configuration was specified using a data annotation.
Gets the for the index name.
The index.
The for the index name.
Returns the index filter expression.
The index.
The index filter expression.
Sets the index filter expression.
The index.
The value to set.
Sets the index filter expression.
The index.
The value to set.
Indicates whether the configuration was specified using a data annotation.
Gets the for the index filter expression.
The index.
The for the index filter expression.
Relational database specific extension methods for .
Configures the name of the key constraint in the database when targeting a relational database.
The builder for the key being configured.
The name of the key.
The same builder instance so that multiple calls can be chained.
Configures the name of the key constraint in the database when targeting a relational database.
The builder for the key being configured.
The name of the key.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given name can be set for the key constraint.
The builder for the key being configured.
The name of the index.
Indicates whether the configuration was specified using a data annotation.
true if the given name can be set for the key constraint.
Extension methods for for relational database metadata.
Returns the key constraint name for this key.
The key.
The key constraint name for this key.
Returns the default key constraint name that would be used for this key.
The key.
The default key constraint name that would be used for this key.
Sets the key constraint name for this key.
The key.
The value to set.
Sets the key constraint name for this key.
The key.
The value to set.
Indicates whether the configuration was specified using a data annotation.
Gets the for the constraint name.
The key.
The for the constraint name.
Relational database specific extension methods for .
Configures a database sequence when targeting a relational database.
The model builder.
The name of the sequence.
The schema of the sequence.
A builder to further configure the sequence.
Configures a database sequence when targeting a relational database.
The model builder.
The name of the sequence.
An action that performs configuration of the sequence.
The same builder instance so that multiple calls can be chained.
Configures a database sequence when targeting a relational database.
The model builder.
The name of the sequence.
The schema of the sequence.
An action that performs configuration of the sequence.
The same builder instance so that multiple calls can be chained.
Configures a database sequence when targeting a relational database.
The type of values the sequence will generate.
The model builder.
The name of the sequence.
The schema of the sequence.
A builder to further configure the sequence.
Configures a database sequence when targeting a relational database.
The type of values the sequence will generate.
The model builder.
The name of the sequence.
An action that performs configuration of the sequence.
The same builder instance so that multiple calls can be chained.
Configures a database sequence when targeting a relational database.
The type of values the sequence will generate.
The model builder.
The name of the sequence.
The schema of the sequence.
An action that performs configuration of the sequence.
The same builder instance so that multiple calls can be chained.
Configures a database sequence when targeting a relational database.
The type of values the sequence will generate.
The model builder.
The name of the sequence.
The schema of the sequence.
A builder to further configure the sequence.
Configures a database sequence when targeting a relational database.
The type of values the sequence will generate.
The model builder.
The name of the sequence.
An action that performs configuration of the sequence.
The same builder instance so that multiple calls can be chained.
Configures a database sequence when targeting a relational database.
The type of values the sequence will generate.
The model builder.
The name of the sequence.
The schema of the sequence.
An action that performs configuration of the sequence.
The same builder instance so that multiple calls can be chained.
Configures a database sequence when targeting a relational database.
The model builder.
The name of the sequence.
The schema of the sequence.
Indicates whether the configuration was specified using a data annotation.
A builder to further configure the sequence.
Configures a database function when targeting a relational database.
The model builder.
The methodInfo this dbFunction uses.
A builder to further configure the function.
Configures a database function when targeting a relational database.
The model builder.
The method this dbFunction uses.
A builder to further configure the function.
Configures a database function when targeting a relational database.
The model builder.
The methodInfo this dbFunction uses.
An action that performs configuration of the sequence.
A builder to further configure the function.
Configures a database function when targeting a relational database.
The model builder.
The methodInfo this dbFunction uses.
Indicates whether the configuration was specified using a data annotation.
A builder to further configure the function.
Configures the default schema that database objects should be created in, if no schema
is explicitly configured.
The model builder.
The default schema.
The same builder instance so that multiple calls can be chained.
Configures the default schema that database objects should be created in, if no schema
is explicitly configured.
The model builder.
The default schema.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given schema can be set as default.
The model builder.
The default schema.
Indicates whether the configuration was specified using a data annotation.
true if the given schema can be set as default.
Configures the maximum length allowed for store identifiers.
The model builder.
The value to set.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the maximum length allowed for store identifiers can be set.
The model builder.
The value to set.
Indicates whether the configuration was specified using a data annotation.
true if the maximum length allowed for store identifiers can be set.
Extension methods for for relational database metadata.
Returns the default schema to use for the model, or null if none has been set.
The model to get the default schema for.
The default schema.
Sets the default schema.
The model to set the default schema for.
The value to set.
Sets the default schema.
The model to set the default schema for.
The value to set.
Indicates whether the configuration was specified using a data annotation.
Returns the configuration source for the default schema.
The model to find configuration source for.
The configuration source for the default schema.
Returns the maximum length allowed for store identifiers.
The model to get the maximum identifier length for.
The maximum identifier length.
Sets the maximum length allowed for store identifiers.
The model to set the default schema for.
The value to set.
Sets the maximum length allowed for store identifiers.
The model to set the default schema for.
The value to set.
Indicates whether the configuration was specified using a data annotation.
Returns the configuration source for .
The model to find configuration source for.
The configuration source for .
Finds an with the given name.
The model to find the sequence in.
The sequence name.
The schema that contains the sequence.
The or null if no sequence with the given name in
the given schema was found.
Finds an with the given name.
The model to find the sequence in.
The sequence name.
The schema that contains the sequence.
The or null if no sequence with the given name in
the given schema was found.
Finds an with the given name.
The model to find the sequence in.
The sequence name.
The schema that contains the sequence.
The or null if no sequence with the given name in
the given schema was found.
Either returns the existing with the given name in the given schema
or creates a new sequence with the given name and schema.
The model to add the sequence to.
The sequence name.
The schema name, or null to use the default schema.
The sequence.
Either returns the existing with the given name in the given schema
or creates a new sequence with the given name and schema.
The model to add the sequence to.
The sequence name.
The schema name, or null to use the default schema.
Indicates whether the configuration was specified using a data annotation.
The sequence.
Removes the with the given name.
The model to find the sequence in.
The sequence name.
The schema that contains the sequence.
The removed or null if no sequence with the given name in
the given schema was found.
Removes the with the given name.
The model to find the sequence in.
The sequence name.
The schema that contains the sequence.
The removed or null if no sequence with the given name in
the given schema was found.
Returns all s contained in the model.
The model to get the sequences in.
Returns all s contained in the model.
The model to get the sequences in.
Returns all s contained in the model.
The model to get the sequences in.
Finds a that is mapped to the method represented by the given .
The model to find the function in.
The for the method that is mapped to the function.
The or null if the method is not mapped.
Finds a that is mapped to the method represented by the given .
The model to find the function in.
The for the method that is mapped to the function.
The or null if the method is not mapped.
Finds a that is mapped to the method represented by the given .
The model to find the function in.
The for the method that is mapped to the function.
The or null if the method is not mapped.
Either returns the existing mapped to the given method
or creates a new function mapped to the method.
The model to add the function to.
The for the method that is mapped to the function.
The .
Either returns the existing mapped to the given method
or creates a new function mapped to the method.
The model to add the function to.
The for the method that is mapped to the function.
Indicates whether the configuration was specified using a data annotation.
The .
Removes the that is mapped to the method represented by the given
.
The model to find the function in.
The for the method that is mapped to the function.
The removed or null if the method is not mapped.
Removes the that is mapped to the method represented by the given
.
The model to find the function in.
The for the method that is mapped to the function.
The removed or null if the method is not mapped.
Returns all s contained in the model.
The model to get the functions in.
Returns all s contained in the model.
The model to get the functions in.
Returns all s contained in the model.
The model to get the functions in.
Relational database specific extension methods for .
Configures the column that the property maps to when targeting a relational database.
The builder for the property being configured.
The name of the column.
The same builder instance so that multiple calls can be chained.
Configures the column that the property maps to when targeting a relational database.
The type of the property being configured.
The builder for the property being configured.
The name of the column.
The same builder instance so that multiple calls can be chained.
Configures the column that the property maps to when targeting a relational database.
The builder for the property being configured.
The name of the column.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given column can be set for the property.
The builder for the property being configured.
The name of the column.
Indicates whether the configuration was specified using a data annotation.
true if the property can be mapped to the given column.
Configures the data type of the column that the property maps to when targeting a relational database.
This should be the complete type name, including precision, scale, length, etc.
The builder for the property being configured.
The name of the data type of the column.
The same builder instance so that multiple calls can be chained.
Configures the data type of the column that the property maps to when targeting a relational database.
This should be the complete type name, including precision, scale, length, etc.
The type of the property being configured.
The builder for the property being configured.
The name of the data type of the column.
The same builder instance so that multiple calls can be chained.
Configures the data type of the column that the property maps to when targeting a relational database.
This should be the complete type name, including precision, scale, length, etc.
The builder for the property being configured.
The name of the data type of the column.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given data type can be set for the property.
The builder for the property being configured.
The name of the data type of the column.
Indicates whether the configuration was specified using a data annotation.
true if the given data type can be set for the property.
Configures the property as capable of storing only fixed-length data, such as strings.
The builder for the property being configured.
A value indicating whether the property is constrained to fixed length values.
The same builder instance so that multiple configuration calls can be chained.
Configures the property as capable of storing only fixed-length data, such as strings.
The type of the property being configured.
The builder for the property being configured.
A value indicating whether the property is constrained to fixed length values.
The same builder instance so that multiple configuration calls can be chained.
Configures the property as capable of storing only fixed-length data, such as strings.
The builder for the property being configured.
A value indicating whether the property is constrained to fixed length values.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the property can be configured as being fixed length or not.
The builder for the property being configured.
A value indicating whether the property is constrained to fixed length values.
Indicates whether the configuration was specified using a data annotation.
true if the property can be configured as being fixed length or not.
Configures the default value expression for the column that the property maps to when targeting a relational database.
The builder for the property being configured.
The SQL expression for the default value of the column.
The same builder instance so that multiple calls can be chained.
Configures the default value expression for the column that the property maps to when targeting a relational database.
The type of the property being configured.
The builder for the property being configured.
The SQL expression for the default value of the column.
The same builder instance so that multiple calls can be chained.
Configures the default value expression for the column that the property maps to when targeting a relational database.
The builder for the property being configured.
The SQL expression for the default value of the column.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given default value expression can be set for the column.
The builder for the property being configured.
The SQL expression for the default value of the column.
Indicates whether the configuration was specified using a data annotation.
true if the given default value expression can be set for the column.
Configures the property to map to a computed column when targeting a relational database.
The builder for the property being configured.
The SQL expression that computes values for the column.
The same builder instance so that multiple calls can be chained.
Configures the property to map to a computed column when targeting a relational database.
The type of the property being configured.
The builder for the property being configured.
The SQL expression that computes values for the column.
The same builder instance so that multiple calls can be chained.
Configures the property to map to a computed column when targeting a relational database.
The builder for the property being configured.
The SQL expression that computes values for the column.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given computed value SQL expression can be set for the column.
The builder for the property being configured.
The SQL expression that computes values for the column.
Indicates whether the configuration was specified using a data annotation.
true if the given computed value SQL expression can be set for the column.
Configures the default value for the column that the property maps
to when targeting a relational database.
When called with no argument, this method tells EF that a column has a default
value constraint of some sort without needing to specify exactly what it is.
This can be useful when mapping EF to an existing database.
The builder for the property being configured.
The default value of the column.
The same builder instance so that multiple calls can be chained.
Configures the default value for the column that the property maps
to when targeting a relational database.
When called with no argument, this method tells EF that a column has a default
value constraint of some sort without needing to specify exactly what it is.
This can be useful when mapping EF to an existing database.
The type of the property being configured.
The builder for the property being configured.
The default value of the column.
The same builder instance so that multiple calls can be chained.
Configures the default value for the column that the property maps to when targeting a relational database.
The builder for the property being configured.
The default value of the column.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given value can be set as default for the column.
The builder for the property being configured.
The default value of the column.
Indicates whether the configuration was specified using a data annotation.
true if the given value can be set as default for the column.
Configures a comment to be applied to the column
The builder for the property being configured.
The comment for the column.
The same builder instance so that multiple calls can be chained.
Configures a comment to be applied to the column
The type of the property being configured.
The builder for the property being configured.
The comment for the column.
The same builder instance so that multiple calls can be chained.
Configures a comment to be applied to the column
The builder for the property being configured.
The comment for the column.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given value can be set as comment for the column.
The builder for the property being configured.
The comment for the column.
Indicates whether the configuration was specified using a data annotation.
true if the given value can be set as default for the column.
Extension methods for for relational database metadata.
Returns the name of the column to which the property is mapped.
The property.
The name of the column to which the property is mapped.
Returns the default column name to which the property would be mapped.
The property.
The default column name to which the property would be mapped.
Sets the column to which the property is mapped.
The property.
The name to set.
Sets the column to which the property is mapped.
The property.
The name to set.
Indicates whether the configuration was specified using a data annotation.
Gets the for the column name.
The property.
The for the column name.
Returns the database type of the column to which the property is mapped.
The property.
The database type of the column to which the property is mapped.
Sets the database type of the column to which the property is mapped.
The property.
The value to set.
Sets the database type of the column to which the property is mapped.
The property.
The value to set.
Indicates whether the configuration was specified using a data annotation.
Gets the for the column name.
The property.
The for the column name.
Returns the SQL expression that is used as the default value for the column this property is mapped to.
The property.
The SQL expression that is used as the default value for the column this property is mapped to.
Sets the SQL expression that is used as the default value for the column this property is mapped to.
The property.
The value to set.
Sets the SQL expression that is used as the default value for the column this property is mapped to.
The property.
The value to set.
Indicates whether the configuration was specified using a data annotation.
Gets the for the default value SQL expression.
The property.
The for the default value SQL expression.
Returns the SQL expression that is used as the computed value for the column this property is mapped to.
The property.
The SQL expression that is used as the computed value for the column this property is mapped to.
Sets the SQL expression that is used as the computed value for the column this property is mapped to.
The property.
The value to set.
Sets the SQL expression that is used as the computed value for the column this property is mapped to.
The property.
The value to set.
Indicates whether the configuration was specified using a data annotation.
Gets the for the computed value SQL expression.
The property.
The for the computed value SQL expression.
Returns the object that is used as the default value for the column this property is mapped to.
The property.
The object that is used as the default value for the column this property is mapped to.
Sets the object that is used as the default value for the column this property is mapped to.
The property.
The value to set.
Sets the object that is used as the default value for the column this property is mapped to.
The property.
The value to set.
Indicates whether the configuration was specified using a data annotation.
Gets the for the default value.
The property.
The for the default value.
Returns a flag indicating if the property as capable of storing only fixed-length data, such as strings.
The property.
A flag indicating if the property as capable of storing only fixed-length data, such as strings.
Sets a flag indicating whether the property as capable of storing only fixed-length data, such as strings.
The property.
A value indicating whether the property is constrained to fixed length values.
Sets a flag indicating whether the property as capable of storing only fixed-length data, such as strings.
The property.
A value indicating whether the property is constrained to fixed length values.
Indicates whether the configuration was specified using a data annotation.
Gets the for .
The property.
The for .
Returns the for the given property on a finalized model.
The property.
The type mapping.
Returns the for the given property on a finalized model.
The property.
The type mapping, or null if none was found.
Checks whether or not the column mapped to the given will be nullable
or not when created in the database.
This can depend not just on the property itself, but also how it is mapped. For example,
non-nullable properties in a TPH type hierarchy will be mapped to nullable columns.
The .
True if the mapped column is nullable; false otherwise.
Finds the that represents the same primary key property
as the given property, but potentially in a shared root table.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The property.
The property found, or null if none was found.
Returns the comment for the column this property is mapped to.
The property.
The comment for the column this property is mapped to.
Configures a comment to be applied to the column this property is mapped to.
The property.
The comment for the column.
Configures a comment to be applied to the column this property is mapped to.
The property.
The comment for the column.
Indicates whether the configuration was specified using a data annotation.
Relational database specific extension methods for LINQ queries.
Creates a LINQ query based on a raw SQL query.
If the database provider supports composing on the supplied SQL, you can compose on top of the raw SQL query using
LINQ operators - context.Blogs.FromSql("SELECT * FROM dbo.Blogs").OrderBy(b => b.Name).
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
arguments. Any parameter values you supply will automatically be converted to a DbParameter -
context.Blogs.FromSql("SELECT * FROM [dbo].[SearchBlogs]({0})", userSuppliedSearchTerm).
This overload also accepts DbParameter instances as parameter values. This allows you to use named
parameters in the SQL query string -
context.Blogs.FromSql("SELECT * FROM [dbo].[SearchBlogs]({@searchTerm})", new SqlParameter("@searchTerm", userSuppliedSearchTerm))
The type of the elements of .
An to use as the base of the raw SQL query (typically a ).
The raw SQL query. NB. A string literal may be passed here because
is implicitly convertible to string.
The values to be assigned to parameters.
An representing the raw SQL query.
Creates a LINQ query based on an interpolated string representing a SQL query.
If the database provider supports composing on the supplied SQL, you can compose on top of the raw SQL query using
LINQ operators - context.Blogs.FromSql("SELECT * FROM dbo.Blogs").OrderBy(b => b.Name).
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include interpolated parameter place holders in the SQL query string. Any interpolated parameter values
you supply will automatically be converted to a DbParameter -
context.Blogs.FromSql($"SELECT * FROM [dbo].[SearchBlogs]({userSuppliedSearchTerm})").
The type of the elements of .
An to use as the base of the interpolated string SQL query (typically a ).
The interpolated string representing a SQL query.
An representing the interpolated string SQL query.
Creates a LINQ query based on a raw SQL query.
If the database provider supports composing on the supplied SQL, you can compose on top of the raw SQL query using
LINQ operators - context.Blogs.FromSqlRaw("SELECT * FROM dbo.Blogs").OrderBy(b => b.Name).
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
arguments. Any parameter values you supply will automatically be converted to a DbParameter -
context.Blogs.FromSqlRaw("SELECT * FROM [dbo].[SearchBlogs]({0})", userSuppliedSearchTerm).
You can also consider using to use interpolated string syntax to create parameters.
This overload also accepts DbParameter instances as parameter values. This allows you to use named
parameters in the SQL query string -
context.Blogs.FromSqlRaw("SELECT * FROM [dbo].[SearchBlogs]({@searchTerm})", new SqlParameter("@searchTerm", userSuppliedSearchTerm))
The type of the elements of .
An to use as the base of the raw SQL query (typically a ).
The raw SQL query.
The values to be assigned to parameters.
An representing the raw SQL query.
Creates a LINQ query based on an interpolated string representing a SQL query.
If the database provider supports composing on the supplied SQL, you can compose on top of the raw SQL query using
LINQ operators - context.Blogs.FromSqlInterpolated($"SELECT * FROM dbo.Blogs").OrderBy(b => b.Name).
As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
attack. You can include interpolated parameter place holders in the SQL query string. Any interpolated parameter values
you supply will automatically be converted to a DbParameter -
context.Blogs.FromSqlInterpolated($"SELECT * FROM [dbo].[SearchBlogs]({userSuppliedSearchTerm})").
The type of the elements of .
An to use as the base of the interpolated string SQL query (typically a ).
The interpolated string representing a SQL query with parameters.
An representing the interpolated string SQL query.
A builder API designed for relational database providers to use when registering services.
Providers should create an instance of this class, use its methods to register
services, and then call to fill out the remaining Entity
Framework services.
Entity Framework ensures that services are registered with the appropriate scope. In some cases a provider
may register a service with a different scope, but great care must be taken that all its dependencies
can handle the new scope, and that it does not cause issue for services that depend on it.
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.
This dictionary is exposed for testing and provider-validation only.
It should not be used from application code.
Used by relational database providers to create a new for
registration of provider services.
The collection to which services will be registered.
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.
Registers default implementations of all services, including relational services, not already
registered by the provider. Relational database providers must call this method as the last
step of service registration--that is, after all provider services have been registered.
This builder, such that further calls can be chained.
Explicitly implemented by to hide
methods that are used by database provider extension methods but not intended to be called by application
developers.
Gets the core options builder.
Base class for the snapshot of the state generated by Migrations.
The snapshot model.
Called lazily by to build the model snapshot
the first time it is requested.
The to use to build the model.
Allows relational database specific configuration to be performed on .
Instances of this class are typically returned from methods that configure the context to use a
particular relational database provider.
Initializes a new instance of the class.
The core options builder.
Gets the core options builder.
Configures the maximum number of statements that will be included in commands sent to the database
during .
The maximum number of statements.
The same builder instance so that multiple calls can be chained.
Configures the minimum number of statements that are needed for a multi-statement command sent to the database
during .
The minimum number of statements.
The same builder instance so that multiple calls can be chained.
Configures the wait time (in seconds) before terminating the attempt to execute a command and generating an error.
The time in seconds to wait for the command to execute.
The same builder instance so that multiple calls can be chained.
Configures the assembly where migrations are maintained for this context.
The name of the assembly.
The same builder instance so that multiple calls can be chained.
Configures the name of the table used to record which migrations have been applied to the database.
The name of the table.
The schema of the table.
The same builder instance so that multiple calls can be chained.
Configures the context to use relational database semantics when comparing null values. By default,
Entity Framework will use C# semantics for null values, and generate SQL to compensate for differences
in how the database handles nulls.
The same builder instance so that multiple calls can be chained.
Configures the context to use the provided .
A function that returns a new instance of an execution strategy.
Sets an option by cloning the extension used to store the settings. This ensures the builder
does not modify options that are already in use elsewhere.
An action to set the option.
The same builder instance so that multiple calls can be chained.
Returns a string that represents the current object.
A string that represents the current object.
Determines whether the specified object is equal to the current object.
The object to compare with the current object.
true if the specified object is equal to the current object; otherwise, false.
Serves as the default hash function.
A hash code for the current object.
Builds the model for a given context.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Initializes a new instance of the class.
Parameter object containing dependencies for this service.
The validator that enforces rules common for all relational providers.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates a new instance of .
Parameter object containing dependencies for this service.
Parameter object containing relational dependencies for this service.
Dependencies used to create a
Validates a model, throwing an exception if any errors are found.
The model to validate.
The logger to use.
Validates the mapping/configuration of functions in the model.
The model to validate.
The logger to use.
Validates the mapping/configuration of properties in the model.
The model to validate.
The logger to use.
Validates the mapping/configuration of default values in the model.
The model to validate.
The logger to use.
Validates the mapping/configuration of shared tables in the model.
The model to validate.
The logger to use.
Validates the compatibility of entity types sharing a given table.
The mapped entity types.
The table name.
The logger to use.
Validates the compatibility of properties sharing columns in a given table.
The mapped entity types.
The table name.
The logger to use.
Validates the compatibility of foreign keys in a given shared table.
The mapped entity types.
The table name.
The logger to use.
Validates the compatibility of indexes in a given shared table.
The mapped entity types.
The table name.
The logger to use.
Validates the compatibility of primary and alternate keys in a given shared table.
The mapped entity types.
The table name.
The logger to use.
Validates the mapping/configuration of inheritance in the model.
The model to validate.
The logger to use.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is .
This means a single instance of each service is used by many instances.
The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
The type mapper.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Represents options managed by the relational database providers.
These options are set using .
Instances of this class are designed to be immutable. To change an option, call one of the 'With...'
methods to obtain a new instance with the option changed.
Creates a new set of options with everything set to default values.
Called by a derived class constructor when implementing the method.
The instance that is being cloned.
Information/metadata about the extension.
Override this method in a derived class to ensure that any clone created is also of that class.
A clone of this instance, which can be modified before being returned as immutable.
The connection string, or null if a was used instead of
a connection string.
Creates a new instance with all options the same as for this instance, but with the given option changed.
It is unusual to call this method directly. Instead use .
The option to change.
A new instance with the option changed.
The , or null if a connection string was used instead of
the full connection object.
Creates a new instance with all options the same as for this instance, but with the given option changed.
It is unusual to call this method directly. Instead use .
The option to change.
A new instance with the option changed.
The command timeout, or null if none has been set.
Creates a new instance with all options the same as for this instance, but with the given option changed.
It is unusual to call this method directly. Instead use .
The option to change.
A new instance with the option changed.
The maximum number of statements that will be included in commands sent to the database
during or null if none has been set.
Creates a new instance with all options the same as for this instance, but with the given option changed.
It is unusual to call this method directly. Instead use .
The option to change.
A new instance with the option changed.
The minimum number of statements that are needed for a multi-statement command sent to the database
during or null if none has been set.
Creates a new instance with all options the same as for this instance, but with the given option changed.
It is unusual to call this method directly. Instead use .
The option to change.
A new instance with the option changed.
Indicates whether or not to use relational database semantics when comparing null values. By default,
Entity Framework will use C# semantics for null values, and generate SQL to compensate for differences
in how the database handles nulls.
Creates a new instance with all options the same as for this instance, but with the given option changed.
It is unusual to call this method directly. Instead use .
The option to change.
A new instance with the option changed.
The name of the assembly that contains migrations, or null if none has been set.
Creates a new instance with all options the same as for this instance, but with the given option changed.
It is unusual to call this method directly. Instead use .
The option to change.
A new instance with the option changed.
The table name to use for the migrations history table, or null if none has been set.
Creates a new instance with all options the same as for this instance, but with the given option changed.
It is unusual to call this method directly. Instead use .
The option to change.
A new instance with the option changed.
The schema to use for the migrations history table, or null if none has been set.
Creates a new instance with all options the same as for this instance, but with the given option changed.
It is unusual to call this method directly. Instead use .
The option to change.
A new instance with the option changed.
A factory for creating the default , or null if none has been
configured.
Creates a new instance with all options the same as for this instance, but with the given option changed.
It is unusual to call this method directly. Instead use .
The option to change.
A new instance with the option changed.
Finds an existing registered on the given options
or throws if none has been registered. This is typically used to find some relational
configuration when it is known that a relational provider is being used.
The context options to look in.
The extension.
Adds the services required to make the selected options work. This is used when there
is no external and EF is maintaining its own service
provider internally. This allows database providers (and other extensions) to register their
required services when EF is creating an service provider.
The collection to add services to.
Gives the extension a chance to validate that all options in the extension are valid.
Most extensions do not have invalid combinations and so this will be a no-op.
If options are invalid, then an exception should be thrown.
The options being validated.
Information/metadata for a .
Creates a new instance containing
info/metadata for the given extension.
The extension.
The extension for which this instance contains metadata.
True, since this is a database provider base class.
Returns a hash code created from any options that would cause a new
to be needed. Most extensions do not have any such options and should return zero.
A hash over options that require a new service provider when changed.
A message fragment for logging typically containing information about
any useful non-default options that have been configured.
Creates a comma-separated list of property names.
The properties to format.
A comma-separated list of property names.
Provides a simple API for configuring a .
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.
The function being configured.
Sets the name of the database function.
The name of the function in the database.
The same builder instance so that multiple configuration calls can be chained.
Sets the schema of the database function.
The schema of the function in the database.
The same builder instance so that multiple configuration calls can be chained.
Sets the store type of the database function.
The store type of the function in the database.
The same builder instance so that multiple configuration calls can be chained.
Sets a callback that will be invoked to perform custom translation of this
function. The callback takes a collection of expressions corresponding to
the parameters passed to the function call. The callback should return an
expression representing the desired translation.
See https://go.microsoft.com/fwlink/?linkid=852477 for more information.
The translation to use.
The same builder instance so that multiple configuration calls can be chained.
Creates a for a parameter with the given name.
The parameter name.
The builder to use for further parameter configuration.
Returns a string that represents the current object.
A string that represents the current object.
Determines whether the specified object is equal to the current object.
The object to compare with the current object.
true if the specified object is equal to the current object; otherwise, false.
Serves as the default hash function.
A hash code for the current object.
Provides a simple API for configuring a .
Instances of this class are returned from methods when using the API
and it is not designed to be directly constructed in your application code.
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.
The function parameter metadata that is being built.
Sets the store type of the function parameter in the database.
The store type of the function parameter in the database.
The same builder instance so that further configuration calls can be chained.
Returns a string that represents the current object.
A string that represents the current object.
Determines whether the specified object is equal to the current object.
The object to compare with the current object.
true if the specified object is equal to the current object; otherwise, false.
Serves as the default hash function.
A hash code for the current object.
Provides a simple API for configuring a .
The function being configured.
Sets the name of the database function.
The name of the function in the database.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given name can be set for the database function.
The name of the function in the database.
Indicates whether the configuration was specified using a data annotation.
true if the given name can be set for the database function.
Sets the schema of the database function.
The schema of the function in the database.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given schema can be set for the database function.
The schema of the function in the database.
Indicates whether the configuration was specified using a data annotation.
true if the given schema can be set for the database function.
Sets the store type of the function in the database.
The store type of the function in the database.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given store type can be set for the database function.
The store type of the function in the database.
Indicates whether the configuration was specified using a data annotation.
true if the given store type can be set for the database function.
Sets the return type mapping of the database function.
The return type mapping of the function in the database.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given return type mapping can be set for the database function.
The return type mapping of the function in the database.
Indicates whether the configuration was specified using a data annotation.
true if the given return type mapping can be set for the database function.
Sets a callback that will be invoked to perform custom translation of this
function. The callback takes a collection of expressions corresponding to
the parameters passed to the function call. The callback should return an
expression representing the desired translation.
See https://go.microsoft.com/fwlink/?linkid=852477 for more information.
The translation to use.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given translation can be set for the database function.
The translation to use.
Indicates whether the configuration was specified using a data annotation.
true if the given translation can be set for the database function.
Provides a simple API for configuring a .
The sequence being configured.
Sets the type of values returned by the sequence.
The type of values returned by the sequence.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given type can be set for the sequence.
The type of values returned by the sequence.
Indicates whether the configuration was specified using a data annotation.
true if the given type can be set for the sequence.
Sets the sequence to increment by the given amount when generating each next value.
The amount to increment between values.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given increment can be set for the sequence.
The amount to increment between values.
Indicates whether the configuration was specified using a data annotation.
true if the given increment can be set for the sequence.
Sets the sequence to start at the given value.
The starting value for the sequence.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given starting value can be set for the sequence.
The starting value for the sequence.
Indicates whether the configuration was specified using a data annotation.
true if the given starting value can be set for the sequence.
Sets the maximum value for the sequence.
The maximum value for the sequence.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given maximum value can be set for the sequence.
The maximum value for the sequence.
Indicates whether the configuration was specified using a data annotation.
true if the given maximum value can be set for the sequence.
Sets the minimum value for the sequence.
The minimum value for the sequence.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given minimum value can be set for the sequence.
The minimum value for the sequence.
Indicates whether the configuration was specified using a data annotation.
true if the given minimum value can be set for the sequence.
Sets whether or not the sequence will start again from the beginning once
the maximum value is reached.
If true, then the sequence with restart when the maximum is reached.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied,
null otherwise.
Returns a value indicating whether the given cyclicity can be set for the sequence.
If true, then the sequence with restart when the maximum is reached.
Indicates whether the configuration was specified using a data annotation.
true if the given cyclicity can be set for the sequence.
Provides a simple API for configuring a .
Creates a new builder for the given .
The to configure.
The sequence.
Sets the to increment by the given amount when generating each next value.
The amount to increment between values.
The same builder so that multiple calls can be chained.
Sets the to start at the given value.
The starting value for the sequence.
The same builder so that multiple calls can be chained.
Sets the maximum value for the .
The maximum value for the sequence.
The same builder so that multiple calls can be chained.
Sets the minimum value for the .
The minimum value for the sequence.
The same builder so that multiple calls can be chained.
Sets whether or not the sequence will start again from the beginning once
the maximum value is reached.
If true, then the sequence with restart when the maximum is reached.
The same builder so that multiple calls can be chained.
Returns a string that represents the current object.
A string that represents the current object.
Determines whether the specified object is equal to the current object.
The object to compare with the current object.
true if the specified object is equal to the current object; otherwise, false.
Serves as the default hash function.
A hash code for the current object.
Provides a simple API for configuring a .
The function parameter metadata that is being built.
Sets the store type of the function parameter in the database.
The store type of the function parameter in the database.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied; null otherwise.
Returns a value indicating whether the store type can be set for this property
from the current configuration source.
The store type of the function parameter in the database.
Indicates whether the configuration was specified using a data annotation.
True if the store type can be set for this property.
Sets the of the function parameter.
The type mapping to use for the function parameter.
Indicates whether the configuration was specified using a data annotation.
The same builder instance if the configuration was applied; null otherwise.
Returns a value indicating whether can be set for this property
from the current configuration source.
The type mapping to use for the function parameter.
Indicates whether the configuration was specified using a data annotation.
True if the type mapping can be set for this property.
A convention configure type mapping for instances.
Creates a new instance of .
Parameter object containing dependencies for this convention.
Parameter object containing relational dependencies for this convention.
Called after a model is finalized.
The builder for the model.
Additional information associated with convention execution.
A service on the EF internal service provider that creates the
for the current relational database provider. This is combined with
instances to produce the full convention set exposed by the
service.
Database providers should implement this service by inheriting from either
this class (for relational providers) or (for non-relational providers).
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Initializes a new instance of the class.
Parameter object containing dependencies for this service.
Parameter object containing relational dependencies for this service.
Parameter object containing relational service dependencies.
Builds and returns the convention set for the current database provider.
The convention set for the current database provider.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
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.
A convention that configures column name and type for a property based on the applied .
Creates a new instance of .
Parameter object containing dependencies for this convention.
Parameter object containing relational dependencies for this convention.
Called after a property is added to the entity type with an attribute on the associated CLR property or field.
The builder for the property.
The attribute.
The member that has the attribute.
Additional information associated with convention execution.
A convention that configures model function mappings based on public static methods on the context marked with
.
Creates a new instance of .
Parameter object containing dependencies for this convention.
Parameter object containing relational dependencies for this convention.
Parameter object containing service dependencies.
Called after a model is initialized.
The builder for the model.
Additional information associated with convention execution.
Called after an annotation is changed on an model.
The builder for the model.
The annotation name.
The new annotation.
The old annotation.
Additional information associated with convention execution.
Called when an is added to the model.
The builder for the .
Additional information associated with convention execution.
A convention that configures the maximum object identifier length supported by the database.
Creates a new instance of .
The maximum object identifier length supported by the database.
Parameter object containing dependencies for this convention.
Parameter object containing relational dependencies for this convention.
Parameter object containing service dependencies.
The maximum object identifier length supported by the database.
Called after a model is initialized.
The builder for the model.
Additional information associated with convention execution.
Creates a new instance of .
Parameter object containing dependencies for this convention.
Parameter object containing relational dependencies for this convention.
A convention that configures the table name and schema for entity types based on the applied .
Creates a new instance of .
Parameter object containing dependencies for this convention.
Parameter object containing relational dependencies for this convention.
Called after an entity type is added to the model if it has an attribute.
The builder for the entity type.
The attribute.
Additional information associated with convention execution.
A convention that configures store value generation as on properties that are
part of the primary key and not part of any foreign keys or were configured to have a database default value.
It also configures properties as if they were configured as computed columns.
Creates a new instance of .
Parameter object containing dependencies for this convention.
Parameter object containing relational dependencies for this convention.
Called after an annotation is changed on a property.
The builder for the property.
The annotation name.
The new annotation.
The old annotation.
Additional information associated with convention execution.
Called after an annotation is changed on an entity type.
The builder for the entity type.
The annotation name.
The new annotation.
The old annotation.
Additional information associated with convention execution.
Returns the store value generation strategy to set for the given property.
The property.
The store value generation strategy to set for the given property.
Returns the store value generation strategy to set for the given property.
The property.
The store value generation strategy to set for the given property.
A convention that manipulates names of database objects for entity types that share a table to avoid clashes.
Creates a new instance of .
Parameter object containing dependencies for this convention.
Parameter object containing relational dependencies for this convention.
Parameter object containing service dependencies.
Called after a model is finalized.
The builder for the model.
Additional information associated with convention execution.
A convention that ensures that properties aren't configured to have a default value and as computed column at the same time.
Creates a new instance of .
Parameter object containing dependencies for this convention.
Parameter object containing relational dependencies for this convention.
Parameter object containing service dependencies.
Called after an annotation is changed on a property.
The builder for the property.
The annotation name.
The new annotation.
The old annotation.
Additional information associated with convention execution.
Called after a model is finalized.
The builder for the model.
Additional information associated with convention execution.
Throws if there is conflicting store generation configuration for this property.
The property to check.
A convention that configures the table name based on the property name.
Creates a new instance of .
Parameter object containing dependencies for this convention.
Parameter object containing relational dependencies for this convention.
Parameter object containing service dependencies.
Called after the base type of an entity type changes.
The builder for the entity type.
The new base entity type.
The old base entity type.
Additional information associated with convention execution.
Called after an entity type is added to the model.
The builder for the entity type.
Additional information associated with convention execution.
Represents a check constraint in the .
Gets the name of the check constraint in the database.
The in which this check constraint is defined.
Gets the constraint sql used in a check constraint in the database.
Represents a check constraint in the .
The in which this check constraint is defined.
Returns the configuration source for this .
The configuration source for .
Represents a relational database function in an in
the a form that can be mutated while the model is being built.
The in which this function is defined.
The builder that can be used to configure this function.
Returns the configuration source for this .
The configuration source for .
Sets the name of the function in the database.
The name of the function in the database.
Indicates whether the configuration was specified using a data annotation.
Returns the configuration source for .
The configuration source for .
Sets the schema of the function in the database.
The schema of the function in the database.
Indicates whether the configuration was specified using a data annotation.
Returns the configuration source for .
The configuration source for .
Sets the store type of the function in the database.
The store type of the function in the database.
Indicates whether the configuration was specified using a data annotation.
Returns the configuration source for .
The configuration source for .
Sets the type mapping of the function in the database.
The type mapping of the function in the database.
Indicates whether the configuration was specified using a data annotation.
Returns the configuration source for .
The configuration source for .
Sets the translation callback for performing custom translation of the method call into a SQL expression fragment.
The translation callback for performing custom translation of the method call into a SQL expression fragment.
Indicates whether the configuration was specified using a data annotation.
Returns the configuration source for .
The configuration source for .
The parameters for this function
Represents a by-convention database function parameter in an .
The to which this parameter belongs.
The for building a by-convention function parameter.
Sets the store type of the parameter in the database.
The store type of the parameter in the database.
Indicates whether the configuration was specified using a data annotation.
Returns the configuration source for .
The configuration source for .
Sets the type mapping of the parameter in the database.
The type mapping of the parameter in the database.
Indicates whether the configuration was specified using a data annotation.
Returns the configuration source for .
The configuration source for .
Represents a database sequence in the in a form that
can be mutated while building the model.
The in which this sequence is defined.
Gets the builder that can be used to configure this sequence.
Returns the configuration source for this .
The configuration source for .
Sets the value at which the sequence will start.
The value at which the sequence will start.
Indicates whether the configuration was specified using a data annotation.
Returns the configuration source for .
The configuration source for .
Sets the amount incremented to obtain each new value in the sequence.
The amount incremented to obtain each new value in the sequence.
Indicates whether the configuration was specified using a data annotation.
Returns the configuration source for .
The configuration source for .
Sets the minimum value supported by the sequence.
The minimum value supported by the sequence.
Indicates whether the configuration was specified using a data annotation.
Returns the configuration source for .
The configuration source for .
Sets the maximum value supported by the sequence.
The maximum value supported by the sequence.
Indicates whether the configuration was specified using a data annotation.
Returns the configuration source for .
The configuration source for .
Sets the of values returned by the sequence.
The of values returned by the sequence.
Indicates whether the configuration was specified using a data annotation.
Returns the configuration source for .
The configuration source for .
Sets whether the sequence will start again from the beginning when the max value is reached.
If true, then the sequence will start again from the beginning when the max value
is reached.
Indicates whether the configuration was specified using a data annotation.
Returns the configuration source for .
The configuration source for .
Represents a relational database function in an .
The name of the function in the database.
The schema of the function in the database.
The in which this function is defined.
The CLR method which maps to the function in the database.
The configured store type string
The type mapping for the function's return type
The parameters for this function
A translation callback for performing custom translation of the method call into a SQL expression fragment.
Represents a database function parameter in an .
The to which this parameter belongs.
The parameter name.
The parameter type.
The store (database) type of this parameter.
The for this parameter.
Represents a relational database function in an in
the a form that can be mutated while the model is being built.
The name of the function in the database.
The schema of the function in the database.
The store type of the function in the database.
The type mapping of the function in the database.
The in which this function is defined.
A translation callback for performing custom translation of the method call into a SQL expression fragment.
Represents a mutable database function parameter in an .
The to which this parameter belongs.
The store (database) type of this parameter.
The for this parameter.
Represents a database sequence in the in a form that
can be mutated while building the model.
The in which this sequence is defined.
The value at which the sequence will start.
The amount incremented to obtain each new value in the sequence.
The minimum value supported by the sequence, or null if none has been set.
The maximum value supported by the sequence, or null if none has been set.
The of values returned by the sequence.
If true, then the sequence will start again from the beginning when the max value
is reached.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
The builder that can be used to configure this function.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Represents a database sequence in the .
The name of the sequence in the database.
The database schema that contains the sequence.
The in which this sequence is defined.
The value at which the sequence will start.
The amount incremented to obtain each new value in the sequence.
The minimum value supported by the sequence, or null if none has been set.
The maximum value supported by the sequence, or null if none has been set.
The of values returned by the sequence.
If true, then the sequence will start again from the beginning when the max value
is reached.
Names for well-known relational model annotations. Applications should not use these names
directly, but should instead use the extension methods on metadata objects.
The prefix used for any relational annotation.
The name for column name annotations.
The name for column type annotations.
The name for default value SQL expression annotations.
The name for computed value SQL expression annotations.
The name for default value annotations.
The name for table name annotations.
The name for schema name annotations.
The name for comment annotations.
The name for default schema annotations.
The name for constraint name annotations.
The prefix for serialized sequence annotations.
The name for check constraint annotations.
The name for filter annotations.
The name for DbFunction annotations.
The maximum length for database identifiers.
A flag indicating whether the property is constrained to fixed length values.
The definition of a database view.
A base class for the repository used to access the '__EFMigrationsHistory' table that tracks metadata
about EF Core Migrations such as which migrations have been applied.
Database providers must inherit from this class to implement provider-specific functionality.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
The default name for the Migrations history table.
Initializes a new instance of this class.
Parameter object containing dependencies for this service.
Parameter object containing service dependencies.
A helper class for generation of SQL.
THe history table name.
The schema that contains the history table, or null if the default schema should be used.
The name of the column that holds the Migration identifier.
The name of the column that contains the Entity Framework product version.
Overridden by database providers to generate SQL that tests for existence of the history table.
Checks whether or not the history table exists.
true if the table already exists, false otherwise.
Checks whether or not the history table exists.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains
true if the table already exists, false otherwise.
Interprets the result of executing .
true if the table already exists, false otherwise.
Overridden by a database provider to generate a SQL script that will create the history table
if and only if it does not already exist.
The SQL script.
Generates a SQL script that will create the history table.
The SQL script.
Configures the entity type mapped to the history table.
Database providers can override this to add or replace configuration.
A builder for the entity type.
Queries the history table for all migrations that have been applied.
The list of applied migrations, as entities.
Queries the history table for all migrations that have been applied.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains
the list of applied migrations, as entities.
Generates SQL to query for the migrations that have been applied.
Generates a SQL script to insert a row into the history table.
The row to insert, represented as a entity.
The generated SQL.
Generates a SQL script to delete a row from the history table.
The migration identifier of the row to delete.
The generated SQL.
Overridden by database providers to generate a SQL Script that will BEGIN a block
of SQL if and only if the migration with the given identifier does not already exist in the history table.
The migration identifier.
The generated SQL.
Overridden by database providers to generate a SQL Script that will BEGIN a block
of SQL if and only if the migration with the given identifier already exists in the history table.
The migration identifier.
The generated SQL.
Overridden by database providers to generate a SQL script to END the SQL block.
The generated SQL.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
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.
The database creator.
A command builder for building raw SQL commands.
The connection to the database.
Options for the current context instance.
The model differ.
The SQL generator for Migrations operations.
Helpers for generating update SQL.
The core convention set to use when creating the model.
The type mapper.
Contains the currently in use.
The model logger
The command logger
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
The core convention set to use when creating the model.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
The type mapper.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
The type mapper.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
The type mapper.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
The command logger.
A new parameter object with the given service replaced.
An entity type that represents a row in the Migrations history table.
Creates a new with the given migration identifier for
the given version of EF Core.
The migration identifier.
The EF Core version, which is obtained from the
of the EF Core assembly.
The migration identifier.
The EF Core version, as obtained from the
of the EF Core assembly.
An interface for the repository used to access the '__EFMigrationsHistory' table that tracks metadata
about EF Core Migrations such as which migrations have been applied.
Database providers typically implement this service by inheriting from .
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Checks whether or not the history table exists.
True if the table already exists, false otherwise.
Checks whether or not the history table exists.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains
True if the table already exists, false otherwise.
Queries the history table for all migrations that have been applied.
The list of applied migrations, as entities.
Queries the history table for all migrations that have been applied.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains
the list of applied migrations, as entities.
Generates a SQL script that will create the history table.
The SQL script.
Generates a SQL script that will create the history table if and only if it does not already exist.
The SQL script.
Generates a SQL script to insert a row into the history table.
The row to insert, represented as a entity.
The generated SQL.
Generates a SQL script to delete a row from the history table.
The migration identifier of the row to delete.
The generated SQL.
Generates a SQL Script that will BEGIN a block
of SQL if and only if the migration with the given identifier does not already exist in the history table.
The migration identifier.
The generated SQL.
Generates a SQL Script that will BEGIN a block
of SQL if and only if the migration with the given identifier already exists in the history table.
The migration identifier.
The generated SQL.
Generates a SQL script to END the SQL block.
The generated SQL.
A service for executing migration commands against a database.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Executes the given commands using the given database connection.
The commands to execute.
The connection to use.
Executes the given commands using the given database connection.
The commands to execute.
The connection to use.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation.
A service typically implemented by database providers that gives access to annotations
used by EF Core Migrations on various elements of the .
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Gets provider-specific Migrations annotations for the given .
The model.
The annotations.
Gets provider-specific Migrations annotations for the given .
The index.
The annotations.
Gets provider-specific Migrations annotations for the given .
The property.
The annotations.
Gets provider-specific Migrations annotations for the given .
The key.
The annotations.
Gets provider-specific Migrations annotations for the given .
The foreign key.
The annotations.
Gets provider-specific Migrations annotations for the given .
The entity type.
The annotations.
Gets provider-specific Migrations annotations for the given .
The sequence.
The annotations.
Gets provider-specific Migrations annotations for the given .
The check constraint.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The model.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The index.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The property.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The key.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The foreign key.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The entity type.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The sequence.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The check constraint.
The annotations.
A service representing an assembly containing EF Core Migrations.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
A dictionary mapping migration identifiers to the of the class
that represents the migration.
The snapshot of the contained in the assembly.
The assembly that contains the migrations, snapshot, etc.
Finds a migration identifier in the assembly with the given a full migration name or
just its identifier.
The name or identifier to lookup.
The identifier of the migration, or null if none was found.
Creates an instance of the migration class.
The for the migration class, as obtained from the dictionary.
The name of the current database provider.
The migration instance.
A service for generating migration identifiers from names and names from identifiers.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Generates an identifier given a migration name.
The migration name.
The identifier.
Gets a migration name based on the given identifier.
The migration identifier.
The migration name.
Checks whether or not the given string is a valid migration identifier.
The candidate string.
True if the string is a valid migration identifier; false otherwise.
A service for finding differences between two s and transforming
those differences into s that can be used to
update the database.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Checks whether or not there are differences between the two models.
The first model.
The second model.
True
Finds the differences between two models.
The model as it was before it was possibly modified.
The model as it is now.
A list of the operations that need to applied to the database to migrate it
from mapping to the source model so that is now mapping to the target model.
A service for generating objects that can
then be executed or scripted from a list of s.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Generates commands from a list of operations.
The operations.
The target model which may be null if the operations exist without a model.
The list of commands to be executed or scripted.
The main service used to generated an EF Core Migrations script or
migrate a database directly.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Migrates the database to either a specified target migration or up to the latest
migration that exists in the .
The target migration to migrate the database to, or null to migrate to the latest.
Migrates the database to either a specified target migration or up to the latest
migration that exists in the .
The target migration to migrate the database to, or null to migrate to the latest.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation
Generates a SQL script to migrate a database either in its entirety, or starting and
ending at specified migrations.
The migration to start from, or null to start from the empty database.
The target migration to migrate the database to, or null to migrate to the latest.
If true, then idempotent scripts will be generated, otherwise
scripts will be generated that assume none of the migrations in the range specified have
already been applied to the database.
The generated script.
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.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
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.
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.
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.
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.
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.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
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.
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.
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.
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.
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.
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.
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.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
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.
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.
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.
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.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
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.
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.
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.
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.
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.
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.
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.
A base class inherited by each EF Core migration.
The migration identifier for the empty database.
The that the database will map to after the migration has been applied.
The s that will migrate the database 'up'.
That is, those operations that need to be applied to the database
to take it from the state left in by the previous migration so that it is up-to-date
with regard to this migration.
The s that will migrate the database 'down'.
That is, those operations that need to be applied to the database
to take it from the state left in by this migration so that it returns to the
state that it was in before this migration was applied.
The name of the current database provider.
This can be used to write conditional code in the migration such that different changes
can be made to the database depending on the type of database being used.
Implemented to builds the .
The to use to build the model.
Builds the operations that will migrate the database 'up'.
That is, builds the operations that will take the database from the state left in by the
previous migration so that it is up-to-date with regard to this migration.
This method must be overridden in each class the inherits from .
The that will build the operations.
Builds the operations that will migrate the database 'down'.
That is, builds the operations that will take the database from the state left in by
this migration so that it returns to the state that it was in before this migration was applied.
This method must be overridden in each class the inherits from if
both 'up' and 'down' migrations are to be supported. If it is not overridden, then calling it
will throw and it will not be possible to migrate in the 'down' direction.
The that will build the operations.
Indicates that a class is a and provides its identifier.
Creates a new instance of this attribute.
The migration identifier.
The migration identifier.
A builder providing a fluentish API for building s.
Creates a new instance of the builder.
The name of the database provider being used.
The name of the database provider being used.
The list of s being built.
Builds an to add a new column to a table.
The CLR type that the column is mapped to.
The column name.
The name of the table that contains the column.
The store/database type of the column.
Indicates whether or not the column can contain Unicode data, or null if not specified or not applicable.
The maximum length of data that can be stored in the column, or null if not specified or not applicable.
Indicates whether or not the column acts as an automatic concurrency token, such as a rowversion/timestamp column
in SQL Server.
The schema that contains the table, or null if the default schema should be used.
Indicates whether or not the column can store NULL values.
The default value for the column.
The SQL expression to use for the column's default constraint.
The SQL expression to use to compute the column value.
Indicates whether or not the column is constrained to fixed-length data.
A comment to associate with the column.
A builder to allow annotations to be added to the operation.
Builds an to add a new foreign key to a table.
The foreign key constraint name.
The table that contains the foreign key.
The column that is constrained.
The table to which the foreign key is constrained.
The schema that contains the table, or null if the default schema should be used.
The schema that contains principal table, or null if the default schema should be used.
The column to which the foreign key column is constrained, or null to constrain to the primary key
column.
The action to take on updates.
The action to take on deletes.
A builder to allow annotations to be added to the operation.
Builds an to add a new composite (multi-column) foreign key to a table.
The foreign key constraint name.
The table that contains the foreign key.
The ordered list of columns that are constrained.
The table to which the foreign key is constrained.
The schema that contains the table, or null if the default schema should be used.
The schema that contains principal table, or null if the default schema should be used.
The columns to which the foreign key columns are constrained, or null to constrain to the primary key
column.
The action to take on updates.
The action to take on deletes.
A builder to allow annotations to be added to the operation.
Builds an to add a new primary key to a table.
The primary key constraint name.
The table that will contain the primary key.
The column that constitutes the primary key.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to add a new composite (multi-column) primary key to a table.
The primary key constraint name.
The table that will contain the primary key.
The ordered list of columns that constitute the primary key.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to add a new unique constraint to a table.
The constraint name.
The table that will contain the constraint.
The column that is constrained.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to add a new composite (multi-column) unique constraint to a table.
The constraint name.
The table that will contain the constraint.
The ordered list of columns that are constrained.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to alter an existing column.
The CLR type that the column is mapped to.
The column name.
The name of the table that contains the column.
The store/database type of the column.
Indicates whether or not the column can contain Unicode data, or null if not specified or not applicable.
The maximum length of data that can be stored in the column, or null if not specified or not applicable.
Indicates whether or not the column acts as an automatic concurrency token, such as a rowversion/timestamp column
in SQL Server.
The schema that contains the table, or null if the default schema should be used.
Indicates whether or not the column can store NULL values.
The default value for the column.
The SQL expression to use for the column's default constraint.
The SQL expression to use to compute the column value.
The CLR type that the column was previously mapped to. Can be null, in which case previous value is considered unknown.
The previous store/database type of the column. Can be null, in which case previous value is considered unknown.
Indicates whether or not the column could previously contain Unicode data, or null if not specified or not applicable.
The previous maximum length of data that can be stored in the column, or null if not specified or not applicable.
Indicates whether or not the column previously acted as an automatic concurrency token, such as a rowversion/timestamp column
in SQL Server. Can be null, in which case previous value is considered unknown.
Indicates whether or not the column could previously store NULL values. Can be null, in which case previous value is
considered unknown.
The previous default value for the column. Can be null, in which case previous value is considered unknown.
The previous SQL expression used for the column's default constraint. Can be null, in which case previous value is considered
unknown.
The previous SQL expression used to compute the column value. Can be null, in which case previous value is considered unknown.
Indicates whether or not the column is constrained to fixed-length data.
Indicates whether or not the column was previously constrained to fixed-length data.
A comment to associate with the column.
The previous comment to associate with the column.
A builder to allow annotations to be added to the operation.
Builds an to alter an existing database.
A builder to allow annotations to be added to the operation.
Builds an to alter an existing sequence.
The sequence name.
The schema that contains the sequence, or null to use the default schema.
The amount to increment by when generating the next value in the sequence, defaulting to 1.
The minimum value of the sequence, or null if not specified.
The maximum value of the sequence, or null if not specified.
Indicates whether or not the sequence will re-start when the maximum value is reached.
The previous amount to increment by when generating the next value in the sequence, defaulting to 1.
The previous minimum value of the sequence, or null if not specified.
The previous maximum value of the sequence, or null if not specified.
Indicates whether or not the sequence would previously re-start when the maximum value is reached.
A builder to allow annotations to be added to the operation.
Builds an to alter an existing table.
The table name.
The schema that contains the table, or null to use the default schema.
A comment to associate with the table.
The previous comment to associate with the table.
A builder to allow annotations to be added to the operation.
Builds an to create a new index.
The index name.
The table that contains the index.
The column that is indexed.
The schema that contains the table, or null to use the default schema.
Indicates whether or not the index enforces uniqueness.
The filter to apply to the index, or null for no filter.
A builder to allow annotations to be added to the operation.
Builds an to create a new composite (multi-column) index.
The index name.
The table that contains the index.
The ordered list of columns that are indexed.
The schema that contains the table, or null to use the default schema.
Indicates whether or not the index enforces uniqueness.
The filter to apply to the index, or null for no filter.
A builder to allow annotations to be added to the operation.
Builds an to ensure that a schema exists.
The name of the schema.
A builder to allow annotations to be added to the operation.
Builds an to create a new sequence.
The sequence name.
The schema that contains the sequence, or null to use the default schema.
The value at which the sequence will start, defaulting to 1.
The amount to increment by when generating the next value in the sequence, defaulting to 1.
The minimum value of the sequence, or null if not specified.
The maximum value of the sequence, or null if not specified.
Indicates whether or not the sequence will re-start when the maximum value is reached.
A builder to allow annotations to be added to the operation.
Builds an to create a new sequence.
The CLR type of the values generated by the sequence.
The sequence name.
The schema that contains the sequence, or null to use the default schema.
The value at which the sequence will start, defaulting to 1.
The amount to increment by when generating the next value in the sequence, defaulting to 1.
The minimum value of the sequence, or null if not specified.
The maximum value of the sequence, or null if not specified.
Indicates whether or not the sequence will re-start when the maximum value is reached.
A builder to allow annotations to be added to the operation.
Builds an to create a new check constraint.
The check constraint name.
The name of the table for the check constraint.
The constraint sql for the check constraint.
The schema that contains the check constraint, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to create a new table.
Type of a typically anonymous type for building columns.
The name of the table.
A delegate using a to create an anonymous type configuring the columns of the table.
The schema that contains the table, or null to use the default schema.
A delegate allowing constraints to be applied over the columns configured by the 'columns' delegate above.
A comment to be applied to the table.
A to allow further configuration to be chained.
Builds an to drop an existing column.
The name of the column to drop.
The table that contains the column.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to drop an existing foreign key constraint.
The name of the foreign key constraint to drop.
The table that contains the foreign key.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to drop an existing index.
The name of the index to drop.
The table that contains the index.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to drop an existing primary key.
The name of the primary key constraint to drop.
The table that contains the key.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to drop an existing schema.
The name of the schema to drop.
A builder to allow annotations to be added to the operation.
Builds an to drop an existing sequence.
The name of the sequence to drop.
The schema that contains the sequence, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to drop an existing check constraint.
The name of the check constraint to drop.
The name of the table for the check constraint to drop.
The schema that contains the check constraint, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to drop an existing table.
The name of the table to drop.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to drop an existing unique constraint.
The name of the constraint to drop.
The table that contains the constraint.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to rename an existing column.
The name of the column to be renamed.
The table that contains the column.
The new name for the column.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to rename an existing index.
The name of the index to be renamed.
The new name for the column.
The table that contains the index.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to rename an existing sequence.
The name of the sequence to be renamed.
The schema that contains the sequence, or null to use the default schema.
The new sequence name or null if only the schema has changed.
The new schema name or null if only the name has changed.
A builder to allow annotations to be added to the operation.
Builds an to rename an existing table.
The name of the table to be renamed.
The schema that contains the table, or null to use the default schema.
The new table name or null if only the schema has changed.
The new schema name, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to re-start an existing sequence.
The name of the sequence.
The value at which the sequence will start, defaulting to 1.
The schema that contains the sequence, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to execute raw SQL.
The SQL string to be executed to perform the operation.
Indicates whether or not transactions will be suppressed while executing the SQL.
A builder to allow annotations to be added to the operation.
Builds an to insert a single seed data value for a single column.
The table into which the data will be inserted.
The name of the column into which the data will be inserted.
The value to insert.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to insert a single row of seed data values.
The table into which the data will be inserted.
The names of the columns into which the data will be inserted.
The values to insert, one value for each column in 'columns'.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to insert multiple rows of seed data values for a single column.
The table into which the data will be inserted.
The name of the column into which the data will be inserted.
The values to insert, one value for each row.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to insert multiple rows of seed data values for multiple columns.
The table into which the data will be inserted.
The names of the columns into which the data will be inserted.
The values to insert where each element of the outer array represents a row, and each inner array contains values for each of the
columns in 'columns'.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to delete a single row of seed data.
The table from which the data will deleted.
The name of the key column used to select the row to delete.
The key value of the row to delete.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to delete a single row of seed data from
a table with a composite (multi-column) key.
The table from which the data will deleted.
The names of the key columns used to select the row to delete.
The key values of the row to delete, one value for each column in 'keyColumns'.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to delete multiple rows of seed data.
The table from which the data will deleted.
The name of the key column used to select the row to delete.
The key values of the rows to delete, one value per row.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to delete multiple rows of seed data from
a table with a composite (multi-column) key.
The table from which the data will deleted.
The names of the key columns used to select the rows to delete.
The key values of the rows to delete, where each element of the outer array represents a row, and each inner array contains values for
each of the key columns in 'keyColumns'.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to update a single row of seed data.
The table containing the data to be updated.
The name of the key column used to select the row to update.
The key value of the row to update.
The column to update.
The new value for the column in the selected row.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to update a single row of seed data.
The table containing the data to be updated.
The name of the key column used to select the row to update.
The key value of the row to update.
The columns to update.
The new values, one for each column in 'columns', for the selected row.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to update a single row of seed data for a table with
a composite (multi-column) key.
The table containing the data to be updated.
The names of the key columns used to select the row to update.
The key values of the row to update, one value for each column in 'keyColumns'.
The column to update.
The new value for the column in the selected row.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to update a single row of seed data for a table with
a composite (multi-column) key.
The table containing the data to be updated.
The names of the key columns used to select the row to update.
The key values of the row to update, one value for each column in 'keyColumns'.
The columns to update.
The new values, one for each column in 'columns', for the selected row.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to update multiple rows of seed data.
The table containing the data to be updated.
The name of the key column used to select the row to update.
The key values of the rows to update, one value per row.
The column to update.
The new values for the column, one for each row specified in 'keyValues'.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to update multiple rows of seed data.
The table containing the data to be updated.
The name of the key column used to select the row to update.
The key values of the rows to update, one value per row.
The columns to update.
The values for each update, where each element of the outer array represents a row specified in
'keyValues', and each inner array contains values for each of the columns in 'columns'.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to update multiple rows of seed data for a table with
a composite (multi-column) key.
The table containing the data to be updated.
The names of the key columns used to select the rows to update.
The key values of the rows to update, where each element of the outer array represents a row, and each inner array contains values for
each of the key columns in 'keyColumns'.
The column to update.
The new values for the column, one for each row specified in 'keyValues'.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Builds an to update multiple rows of seed data for a table with
a composite (multi-column) key.
The table containing the data to be updated.
The names of the key columns used to select the rows to update.
The key values of the rows to update, where each element of the outer array represents a row, and each inner array contains values for
each of the key columns in 'keyColumns'.
The columns to update.
The values for each update, where each element of the outer array represents a row specified in
'keyValues', and each inner array contains values for each of the columns in 'columns'.
The schema that contains the table, or null to use the default schema.
A builder to allow annotations to be added to the operation.
Returns a string that represents the current object.
A string that represents the current object.
Determines whether the specified object is equal to the current object.
The object to compare with the current object.
true if the specified object is equal to the current object; otherwise, false.
Serves as the default hash function.
A hash code for the current object.
Represents a command ready to be sent to the database to migrate it.
Creates a new instance of the command.
The underlying that will be used to execute the command.
The current or null if not known.
The command logger.
Indicates whether or not transactions should be suppressed while executing the command.
Indicates whether or not transactions should be suppressed while executing the command.
The SQL command text that will be executed against the database.
Executes the command and returns the number of rows affected.
The connection to execute against.
The values for the parameters, or null if the command has no parameters.
The number of rows affected.
Executes the command and returns the number of rows affected.
The connection to execute against.
The values for the parameters, or null if the command has no parameters.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains the number of rows affected.
A builder for creating a list of s that can then be
executed to migrate a database.
Creates a new instance of the builder.
Dependencies needed for SQL generations.
Gets the list of built commands.
The s that have been built.
Ends the building of the current command and adds it to the list of built commands.
The next call to one of the builder methods will start building a new command.
Indicates whether or not transactions should be suppressed while executing the built command.
This builder so that additional calls can be chained.
Appends the given object (as a string) to the command being built.
The object to append.
This builder so that additional calls can be chained.
Starts a new line on the command being built.
This builder so that additional calls can be chained.
Appends the given object (as a string) to the command being built, and then starts a new line.
The object to append.
This builder so that additional calls can be chained.
Appends the given object to the command being built as multiple lines of text. That is,
each line in the passed object (as a string) is added as a line to the command being built.
This results in the lines having the correct indentation.
The object to append.
This builder so that additional calls can be chained.
Starts a new indentation block, so all 'Append...' calls until the
block is disposed will be indented one level more than the current level.
The object to dispose to indicate that the indentation should go back up a level.
Increases the current indentation by one level.
This builder so that additional calls can be chained.
Decreases the current indentation by one level.
This builder so that additional calls can be chained.
A base class inherited by database providers that gives access to annotations
used by EF Core Migrations on various elements of the .
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Initializes a new instance of this class.
Parameter object containing dependencies for this service.
Gets provider-specific Migrations annotations for the given .
The default implementation returns an empty collection.
The model.
The annotations.
Gets provider-specific Migrations annotations for the given .
The default implementation returns an empty collection.
The entity type.
The annotations.
Gets provider-specific Migrations annotations for the given .
The default implementation returns an empty collection.
The foreign key.
The annotations.
Gets provider-specific Migrations annotations for the given .
The default implementation returns an empty collection.
The index.
The annotations.
Gets provider-specific Migrations annotations for the given .
The default implementation returns an empty collection.
The key.
The annotations.
Gets provider-specific Migrations annotations for the given .
The default implementation returns an empty collection.
The property.
The annotations.
Gets provider-specific Migrations annotations for the given .
The default implementation returns an empty collection.
The sequence.
The annotations.
Gets provider-specific Migrations annotations for the given .
The default implementation returns an empty collection.
The check constraint.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The default implementation returns an empty collection.
The model.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The default implementation returns an empty collection.
The entity type.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The default implementation returns an empty collection.
The foreign key.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The default implementation returns an empty collection.
The index.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The default implementation returns an empty collection.
The key.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The default implementation returns an empty collection.
The property.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The default implementation returns an empty collection.
The sequence.
The annotations.
Gets provider-specific Migrations annotations for the given
when it is being removed/altered.
The default implementation returns an empty collection.
The check constraint.
The annotations.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is .
This means a single instance of each service is used by many instances.
The implementation must be thread-safe.
This service cannot depend on services registered as .
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.
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
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.
Extension methods for .
Gets a migration identifier in the assembly with the given a full migration name or
just its identifier.
An exception is thrown if the migration was not found--use
if the migration may not exist.
The assembly.
The name or identifier to lookup.
The identifier of the migration.
Generates the SQL in objects that can
then be executed or scripted from a list of s.
This class is typically inherited by database providers to customize the SQL generation.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates a new instance using the given dependencies.
Parameter object containing dependencies for this service.
Parameter object containing dependencies for this service.
The .
Gets a comparer that can be used to compare two product versions.
Generates commands from a list of operations.
The operations.
The target model which may be null if the operations exist without a model.
The list of commands to be executed or scripted.
Builds commands for the given by making calls on the given
.
This method uses a double-dispatch mechanism to call one of the 'Generate' methods that are
specific to a certain subtype of . Typically database providers
will override these specific methods rather than this method. However, providers can override
this methods to handle provider-specific operations.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Builds commands for the given by making calls on the given
.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Indicates whether or not to terminate the command after generating SQL for the operation.
Builds commands for the given by making calls on the given
.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Indicates whether or not to terminate the command after generating SQL for the operation.
Builds commands for the given by making calls on the given
.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Indicates whether or not to terminate the command after generating SQL for the operation.
Builds commands for the given by making calls on the given
, and then terminates the final command.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Builds commands for the given by making calls on the given
, and then terminates the final command.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Can be overridden by database providers to build commands for the given
by making calls on the given .
Note that the default implementation of this method throws . Providers
must override if they are to support this kind of operation.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Can be overridden by database providers to build commands for the given
by making calls on the given .
Note that there is no default implementation of this method. Providers must override if they are to
support this kind of operation.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Can be overridden by database providers to build commands for the given
by making calls on the given .
Note that the default implementation of this method throws . Providers
must override if they are to support this kind of operation.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Builds commands for the given by making calls on the given
, and then terminates the final command.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Can be overridden by database providers to build commands for the given
by making calls on the given .
Note that the default implementation of this method does nothing because there is no common metadata
relating to this operation. Providers only need to override this method if they have some provider-specific
annotations that must be handled.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Can be overridden by database providers to build commands for the given
by making calls on the given .
Note that the default implementation of this method throws . Providers
must override if they are to support this kind of operation.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Builds commands for the given by making calls on the given
.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Indicates whether or not to terminate the command after generating SQL for the operation.
Can be overridden by database providers to build commands for the given
by making calls on the given .
Note that the default implementation of this method throws . Providers
must override if they are to support this kind of operation.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Builds commands for the given by making calls on the given
, and then terminates the final command.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Builds commands for the given by making calls on the given
.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Indicates whether or not to terminate the command after generating SQL for the operation.
Builds commands for the given by making calls on the given
.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Indicates whether or not to terminate the command after generating SQL for the operation.
Builds commands for the given by making calls on the given
.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Indicates whether or not to terminate the command after generating SQL for the operation.
Can be overridden by database providers to build commands for the given
by making calls on the given .
Note that the default implementation of this method throws . Providers
must override if they are to support this kind of operation.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Indicates whether or not to terminate the command after generating SQL for the operation.
Builds commands for the given by making calls on the given
.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Indicates whether or not to terminate the command after generating SQL for the operation.
Builds commands for the given by making calls on the given
, and then terminates the final command.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Builds commands for the given by making calls on the given
, and then terminates the final command.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Builds commands for the given by making calls on the given
.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Indicates whether or not to terminate the command after generating SQL for the operation.
Builds commands for the given by making calls on the given
, and then terminates the final command.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Builds commands for the given by making calls on the given
, and then terminates the final command.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Can be overridden by database providers to build commands for the given
by making calls on the given .
Note that the default implementation of this method throws . Providers
must override if they are to support this kind of operation.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Can be overridden by database providers to build commands for the given
by making calls on the given .
Note that the default implementation of this method throws . Providers
must override if they are to support this kind of operation.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Builds commands for the given by making calls on the given
, and then terminates the final command.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Builds commands for the given by making calls on the given
, and then terminates the final command.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Builds commands for the given by making calls on the given
.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Indicates whether or not to terminate the command after generating SQL for the operation.
Builds commands for the given by making calls on the given
, and then terminates the final command.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Builds commands for the given by making calls on the given
, and then terminates the final command.
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to build the commands.
Generates a SQL fragment configuring a sequence in a .
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment configuring a sequence in a .
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment configuring a sequence with the given options.
The schema that contains the sequence, or null to use the default schema.
The sequence name.
The sequence options.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for the column definitions in an .
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for a column definition in an .
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for a column definition for the given column metadata.
The schema that contains the table, or null to use the default schema.
The table that contains the column.
The column name.
The column metadata.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for a computed column definition for the given column metadata.
The schema that contains the table, or null to use the default schema.
The table that contains the column.
The column name.
The column metadata.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Gets the store/database type of a column given the provided metadata.
The schema that contains the table, or null to use the default schema.
The table that contains the column.
The column name.
The column metadata.
The target model which may be null if the operations exist without a model.
The database/store type for the column.
Generates a SQL fragment for the default constraint of a column.
The default value for the column.
The SQL expression to use for the column's default constraint.
Store/database type of the column.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for the constraints of a .
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for the foreign key constraints of a .
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for a foreign key constraint of an .
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for the primary key constraint of a .
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for a primary key constraint of an .
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for the unique constraints of a .
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for a unique constraint of an .
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for the check constraints of a .
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for a check constraint of an .
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for traits of an index from a ,
, or .
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for extras (filter, included columns, options) of an index from a .
The operation.
The target model which may be null if the operations exist without a model.
The command builder to use to add the SQL fragment.
Generates a SQL fragment for the given referential action.
The referential action.
The command builder to use to add the SQL fragment.
Finds all s that are mapped to the given table.
The target model which may be null if the operations exist without a model.
The schema that contains the table, or null to use the default schema.
The table name.
The list of types, which may be empty if no types are mapped to the given table.
Finds some mapped to the given column.
If multiple properties map to the same column, then the property returned is one chosen
arbitrarily. The model validator ensures that all properties mapped to a given column
have consistent mappings.
The target model which may be null if the operations exist without a model.
The schema that contains the table, or null to use the default schema.
The name of the table that contains the column.
The column name.
The property found, or null if no property maps to the given column.
Generates a SQL fragment to terminate the SQL command.
The command builder to use to add the SQL fragment.
Indicates whether or not transactions should be suppressed while executing the built command.
Concatenates the given column names into a
separated list.
The column names.
The column list.
Checks whether or not supports the passing in the
old column, which was only added in EF Core 1.1.
The target model which may be null if the operations exist without a model.
True If the model was generated by EF Core 1.1 or later; false if the model is null, has
no version specified, or was generated by an EF Core version prior to 1.1.
Checks whether or not and use
the legacy behavior of setting the new name and schema to null when unchanged.
The target model.
True if the legacy behavior is used.
Gets the product version used to generate the current migration. Providers can use this to preserve
compatibility with migrations generated using previous versions.
The target model.
The version.
True if the version could be retrieved.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
The command builder factory.
High level SQL generator.
Helpers for SQL generation.
The type mapper.
Contains the currently in use.
A logger.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
A to add a new column.
The column name.
The schema that contains the table, or null if the default schema should be used.
The table to which the column will be added.
A to add a new foreign key.
The name of the foreign key constraint.
The schema that contains the table, or null if the default schema should be used.
The table to which the foreign key should be added.
The ordered-list of column names for the columns that make up the foreign key.
The schema that contains the table to which this foreign key is constrained,
or null if the default schema should be used.
The table to which the foreign key is constrained.
The ordered-list of column names for the columns to which the columns that make up this foreign key are constrained.
The to use for updates.
The to use for deletes.
A to add a new foreign key.
The schema that contains the table, or null if the default schema should be used.
The table to which the key should be added.
The name of the foreign key constraint.
The ordered-list of column names for the columns that make up the primary key.
A to add a new unique constraint.
The schema that contains the table, or null if the default schema should be used.
The table to which the constraint should be added.
The name of the constraint.
The ordered-list of column names for the columns that make up the constraint.
A to alter an existing column.
The name of the column.
The schema that contains the table, or null if the default schema should be used.
The table which contains the column.
An operation representing the column as it was before being altered.
A to alter an existing database.
An operation representing the database as it was before being altered.
A to alter an existing sequence.
The schema that contains the sequence, or null if the default schema should be used.
The name of the sequence.
An operation representing the sequence as it was before being altered.
A to alter an existing table.
The name of the table.
The schema that contains the table, or null if the default schema should be used.
An operation representing the table as it was before being altered.
A builder for operations.
The operation type to build.
Constructs a builder for the given .
The operation.
Annotates the with the given name/value pair.
The annotation name.
The annotation value.
The same builder so that multiple calls can be chained.
Annotates the with the given name/value pair as
an annotation that was present before the alteration.
The annotation name.
The annotation value.
The same builder so that multiple calls can be chained.
A builder for operations.
Constructs a builder for the given .
The operation.
Adds a to the .
Note that for nullable parameters a null value means not-specified.
The CLR type of the column.
The database type of the column.
Indicates whether or not the column will store Unicode data.
The maximum length for data in the column.
Indicates whether or not the column will act as a rowversion/timestamp concurrency token.
The column name.
Indicates whether or not the column can store NULL values.
The default value for the column.
The SQL expression to use for the column's default constraint.
The SQL expression to use to compute the column value.
Indicates whether or not the column is constrained to fixed-length data.
A comment to be applied to the table.
The same builder so that multiple calls can be chained.
Returns a string that represents the current object.
A string that represents the current object.
Determines whether the specified object is equal to the current object.
The object to compare with the current object.
true if the specified object is equal to the current object; otherwise, false.
Serves as the default hash function.
A hash code for the current object.
A builder for operations.
Type of a typically anonymous type for building columns.
Constructs a new builder for the given and
with the given map of operations for columns.
The .
The map of CLR properties to s.
Configures a single-column foreign key on the table.
The foreign key constraint name.
The column used for the foreign key.
The table to which the foreign key is constrained.
The column to which the foreign key column is constrained.
The schema that contains the table to which the foreign key is constrained.
The to use for updates.
The to use for deletes.
The same builder so that multiple calls can be chained.
Configures a multiple-column (composite) foreign key on the table.
The foreign key constraint name.
The columns used for the foreign key.
The table to which the foreign key is constrained.
The columns to which the foreign key column is constrained.
The schema that contains the table to which the foreign key is constrained.
The to use for updates.
The to use for deletes.
The same builder so that multiple calls can be chained.
Configures a primary key on the table.
The primary key constraint name.
The columns that make up the primary key.
The same builder so that multiple calls can be chained.
Configures a unique constraint on the table.
The constraint name.
The columns that make up the constraint.
The same builder so that multiple calls can be chained.
Configures a check constraint on the table.
The constraint name.
The sql expression used in the CHECK constraint.
The same builder so that multiple calls can be chained.
Annotates the operation with the given name/value pair.
The annotation name.
The annotation value.
The same builder so that multiple calls can be chained.
A builder for s.
The type of to build for.
Creates a new builder instance for the given .
The .
The .
Annotates the operation with the given name/value pair.
The annotation name.
The annotation value.
The same builder so that multiple calls can be chained.
Returns a string that represents the current object.
A string that represents the current object.
Determines whether the specified object is equal to the current object.
The object to compare with the current object.
true if the specified object is equal to the current object; otherwise, false.
Serves as the default hash function.
A hash code for the current object.
A for operations on columns.
See also and .
The CLR of the property or properties mapped to the column.
The store type of the column--for example, 'nvarchar(max)'.
Indicates whether or not the column can contain Unicode data, or null if this is not specified or does
not apply to this column type.
Indicates whether or not the column is constrained to fixed-length data.
The maximum amount of data that the column can store, or null if this is not specified or does
not apply to this column type.
Indicates whether or not this column acts as an automatic concurrency token in the same vein
as 'rowversion'/'timestamp' columns on SQL Server.
Indicates whether or not th column can store NULL values.
The default value for rows inserted without an explicit value for this column, or
null if there is no default.
The SQL expression to use as the default constraint when creating the column,
or null if there is no default constraint.
The SQL expression to use to compute the column value, null if the column
is not computed.
Comment for this column
A for creating a new check constraint.
The name of the check constraint.
The table of the check constraint.
The table schema that contains the check constraint, or null if the default schema should be used.
The logical sql expression used in a CHECK constraint and returns TRUE or FALSE.
Sql used with CHECK constraints cannot reference another table
but can reference other columns in the same table for the same row.
The expression cannot reference an alias data type.
A for creating a new index.
Indicates whether or not the index should enforce uniqueness.
The name of the index.
The schema that contains the index, or null if the default schema should be used.
The table that contains the index.
The ordered list of column names for the column that make up the index.
An expression to use as the index filter.
A for creating a new sequence.
The schema that contains the sequence, or null if the default schema should be used.
The name of the sequence.
The CLR of values returned from the sequence.
The value at which the sequence will start counting, defaulting to 1.
A for creating a new table.
The name of the table.
The schema that contains the table, or null if the default schema should be used.
The representing the creation of the primary key for the table.
An ordered list of for adding columns to the table.
A list of for creating foreign key constraints in the table.
A list of for creating unique constraints in the table.
A list of for creating check constraints in the table.
A for deleting seed data from an existing table.
The table from which data will be deleted.
The schema that contains the table, or null if the default schema should be used.
A list of column names that represent the columns that will be used to identify
the rows that should be deleted.
The rows to be deleted, represented as a list of key value arrays where each
value in the array corresponds to a column in the property.
Generates the commands that correspond to this operation.
The commands that correspond to this operation.
A for dropping an existing check constraint.
The name of the constraint.
The schema that contains the table, or null if the default schema should be used.
The table that contains the constraint.
A for dropping an existing column.
Creates a new instance of the .
The name of the column.
The schema that contains the table, or null if the default schema should be used.
The table that contains that column.
A for dropping an existing foreign key.
The name of the foreign key constraint.
The schema that contains the table, or null if the default schema should be used.
The table that contains the foreign key constraint.
A for dropping an existing index.
The name of the index.
The schema that contains the table, or null if the default schema should be used.
The table that contains the index.
A for dropping a primary key.
The name of the primary key constraint.
The schema that contains the table, or null if the default schema should be used.
The table that contains the primary key.
A for dropping a schema.
The name of the schema.
A for dropping a sequence.
The name of the sequence.
The schema that contains the sequence, or null if the default schema should be used.
A for dropping an existing table.
Creates a new .
The name of the table.
The schema that contains the table, or null if the default schema should be used.
A for dropping an existing unique constraint.
The name of the constraint.
The schema that contains the table, or null if the default schema should be used.
The table that contains the constraint.
A for ensuring that a schema exists. That is, the
schema will be created if and only if it does not already exist.
The name of the schema.
An interface for any that alters some existing database object.
All such operations contain an 'Old...' property that provides access to the configuration to the
database object as it was before being altered. This interface provides a common way to access
annotations on that 'old' database object.
Annotations on the database object as they were before being altered.
A for inserting seed data into a table.
The name of the table into which data will be inserted.
The schema that contains the table, or null if the default schema should be used.
A list of column names that represent the columns into which data will be inserted.
The data to be inserted, represented as a list of value arrays where each
value in the array corresponds to a column in the property.
Generates the commands that correspond to this operation.
The commands that correspond to this operation.
Base class for all Migrations operations that can be performed against a database.
Indicates whether or not the operation might result in loss of data in the database.
A for renaming an existing column.
The old name of the column.
The schema that contains the table, or null if the default schema should be used.
The name of the table that contains the column.
The new name for the column.
A for renaming an existing index.
The old name of the index.
The new name for the index.
The schema that contains the table, or null if the default schema should be used.
The name of the table that contains the index.
A for renaming an existing sequence.
The old name of the sequence.
The schema that contains the sequence, or null if the default schema should be used.
The new sequence name or null if only the schema has changed.
The new schema name or null if only the name has changed.
A for renaming an existing table.
The schema that contains the table, or null if the default schema should be used.
The old name of the table.
The new table name or null if only the schema has changed.
The new table name or null if only the schema has changed.
A for re-starting an existing sequence.
The name of the sequence.
The schema that contains the sequence, or null if the default schema should be used.
The value at which the sequence should re-start, defaulting to 1.
A for operations on sequences.
See also and .
The amount to increment by when generating the next value in the sequence, defaulting to 1.
The maximum value of the sequence, or null if not specified.
The minimum value of the sequence, or null if not specified.
Indicates whether or not the sequence will re-start when the maximum value is reached.
A for raw SQL commands.
The SQL string to be executed to perform this operation.
Indicates whether or not transactions will be suppressed while executing the SQL.
A for operations on tables.
See also and .
Comment for this table
A for updating seed data in an existing table.
The name of the table in which data will be updated.
The schema that contains the table, or null if the default schema should be used.
A list of column names that represent the columns that will be used to identify
the rows that should be updated.
The rows to be updated, represented as a list of key value arrays where each
value in the array corresponds to a column in the property.
A list of column names that represent the columns that contain data to be updated.
The data to be updated, represented as a list of value arrays where each
value in the array corresponds to a column in the property.
Generates the commands that correspond to this operation.
The commands that correspond to this operation.
The action that a database may take when handling a foreign key constraint as
part of an update or delete.
Note that some database engines do not support or correctly honor every action.
Do nothing. That is, just ignore the constraint.
Don't perform the action if it would result in a constraint violation and instead generate an error.
Cascade the action to the constrained rows.
Set null on the constrained rows so that the constraint is not violated after the action completes.
Set a default value on the constrained rows so that the constraint is not violated after the action completes.
Represents plugin member translators.
The service lifetime is and multiple registrations
are allowed. This means a single instance of each service is used by many
instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Gets the member translators.
Provides translations for object members to instances.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Represents plugin method call translators.
The service lifetime is and multiple registrations
are allowed. This means a single instance of each service is used by many
instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Gets the method call translators.
Provides translations for method calls to instances.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
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.
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.
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.
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.
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.
A factory for creating instances.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
A factory for instances.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates a new instance using the given dependencies.
The dependencies to use.
Relational-specific dependencies.
Creates a new .
A QueryContext.
A factory for creating instances.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
A factory for creating instances.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
A factory for creating instances.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
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.
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.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
The expression factory..
The member translation provider.
The method-call translation provider.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
A factory for creating instances.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
A factory for creating instances.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
A factory for creating instances.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
The default alias separator.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
The command-builder factory.
SQL generation helpers.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Creates keys that uniquely identifies a query. This is used to store and lookup
compiled versions of a query in a cache.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Initializes a new instance of the class.
Parameter object containing dependencies for this service.
Parameter object containing relational dependencies for this service.
Dependencies used to create a
Generates the cache key for the given query.
The query to get the cache key for.
A value indicating whether the query will be executed asynchronously.
The cache key.
Generates the cache key for the given query.
The query to get the cache key for.
A value indicating whether the query will be executed asynchronously.
The cache key.
A key that uniquely identifies a query. This is used to store and lookup
compiled versions of a query in a cache.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The non-relational cache key.
True to use relational null logic.
True if the query should be buffered.
Determines if this key is equivalent to a given object (i.e. if they are keys for the same query).
The object to compare this key to.
True if the object is a and is for the same query, otherwise false.
Gets the hash code for the key.
The hash code for the key.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates the service dependencies parameter object for a .
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
Options for the current instance.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Represents a filter for evaluatable expressions.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates a new instance.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The dependencies to use.
The relational-specific dependencies to use.
Dependencies used to create a
Checks whether the given expression can be evaluated.
The expression.
The model.
True if the expression can be evaluated; false otherwise.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
The expression factory..
Registered plugins.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
The expression factory..
Registered plugins.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
The SQL-translating expression visitor factory.
The SQL expression factory.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
The principal data structure used by a compiled relational query during execution.
Creates a new instance.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The dependencies to use.
The relational-specific dependencies to use.
Relational-specific dependencies.
Gets the active relational connection.
The connection.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
The connection.
The execution strategy.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
The SQL expression factory.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
The SQL generator factory.
The SQL expression factory.
The parameter name-generator factory.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
The type mapping source.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
A string representing a raw SQL query. This type enables overload resolution between
the regular and interpolated
and
Implicitly converts a to a
The string.
Implicitly converts a to a
The string format.
Constructs a from a
The string.
The string format.
Base class used by database providers to reverse engineer a database into a .
Connects to the database using the given connection string and creates a
for the database.
The connection string for the database to reverse engineer.
The options specifying which metadata to read.
The database model.
Connects to the database using the given connection and creates a
for the database.
The connection to the database to reverse engineer.
The options specifying which metadata to read.
The database model.
Specifies which metadata to read from the database.
Initializes a new instance of the class.
A list of tables to include. Empty to include all tables.
A list of schemas to include. Empty to include all schemas.
Gets the list of tables to include. If empty, include all tables.
Gets the list of schemas to include. If empty, include all schemas.
A service typically implemented by database providers to reverse engineer a database into
a .
Connects to the database using the given connection string and creates a
for the database.
The connection string for the database to reverse engineer.
The options specifying which metadata to read.
The database model.
Connects to the database using the given connection and creates a
for the database.
The connection to the database to reverse engineer.
The options specifying which metadata to read.
The database model.
Implemented by plugins to generate code fragments for reverse engineering.
Generates a method chain used to configure provider-specific options.
The method chain. May be null.
Generates a method chain to configure additional context options.
The method chain. May be null.
A service typically implemented by database providers to generate code fragments
for reverse engineering.
Generates a method chain used to configure provider-specific options.
The method chain. May be null.
Generates a code fragment like .UseSqlServer("Database=Foo") which can be used in
the method of the generated DbContext.
The connection string to include in the code fragment.
The method chain used to configure provider options.
The code fragment.
Generates a method chain to configure additional context options.
The method chain. May be null.
A simple model for a database column used when reverse engineering an existing database.
The table that contains this column.
The column name.
Indicates whether or not this column can contain NULL values.
The database/store type of the column.
The default constraint for the column, or null if none.
The SQL expression that computes the value of the column, or null if this is not a computed column.
The column comment, or null if none is set.
Indicates when values will be generated by the database for this column, or null if
the database will not generate values.
A simple model for a database foreign key constraint used when reverse engineering an existing database.
The table that contains the foreign key constraint.
The table to which the columns are constrained.
The ordered list of columns that are constrained.
The ordered list of columns in the to which the
of the foreign key are constrained.
The foreign key constraint name.
The action performed by the database when a row constrained by this foreign key
is deleted, or null if there is no action defined.
A simple model for a database index used when reverse engineering an existing database.
The table that contains the index.
The index name.
The ordered list of columns that make up the index.
Indicates whether or not the index constrains uniqueness.
The filter expression, or null if the index has no filter.
A simple model for a database used when reverse engineering an existing database.
The database name, or null if none is set.
The database schema, or null to use the default schema.
The list of tables in the database.
The list of sequences in the database.
A simple model for a database primary key used when reverse engineering an existing database.
The table on which the primary key is defined.
The name of the primary key.
The ordered list of columns that make up the primary key.
A simple model for a database sequence used when reverse engineering an existing database.
The database that contains the sequence.
The sequence name.
The schema that contains the sequence, or null to use the default schema.
The database/store type of the sequence, or null if not set.
The start value for the sequence, or null if not set.
The amount to increment by to generate the next value in, the sequence, or null if not set.
The minimum value supported by the sequence, or null if not set.
The maximum value supported by the sequence, or null if not set.
Indicates whether or not the sequence will start over when the max value is reached, or null if not set.
A simple model for a database table used when reverse engineering an existing database.
The database that contains the table.
The table name.
The table schema, or null to use the default schema.
The table comment, or null if none is set.
The primary key of the table.
The ordered list of columns in the table.
The list of unique constraints defined on the table.
The list of indexes defined on the table.
The list of foreign key constraints defined on the table.
A simple model for a database unique constraint used when reverse engineering an existing database.
The table on which the unique constraint is defined.
The name of the constraint.
The ordered list of columns that make up the constraint.
A simple model for a database view used when reverse engineering an existing database.
Generates provider-specific code fragments.
Initializes a new instance of the class.
The dependencies.
Parameter object containing dependencies for this service.
Generates a method chain used to configure provider-specific options.
The method chain. May be null.
Generates a code fragment like .UseSqlServer("Database=Foo") which can be used in
the method of the generated DbContext.
The connection string to include in the code fragment.
The method chain used to configure provider options.
The code fragment.
Generates a method chain to configure additional context options.
The method chain. May be null.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
Gets the plugins.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Base class used by plugins to generate code fragments for reverse engineering.
Generates a method chain used to configure provider-specific options.
The method chain. May be null.
Generates a method chain to configure additional context options.
The method chain. May be null.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Generates the SQL representation of a literal value.
The literal value.
The generated string.
Represents the mapping between a .NET array type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
The size of data the property is configured to store, or null if no size is configured.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Generates the SQL representation of a literal value.
The literal value.
The generated string.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Generates the SQL representation of a non-null literal value.
The literal value.
The generated string.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Gets the string format to be used to generate SQL literals of this type.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Gets the string format to be used to generate SQL literals of this type.
Extension methods for .
Gets the underlying for the given transaction. Throws if the database being targeted
is not a relational database that uses .
The transaction to get the from.
The underlying .
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Gets the string format to be used to generate SQL literals of this type.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Generates the SQL representation of a literal value.
The literal value.
The generated string.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Generates the SQL representation of a literal value.
The literal value.
The generated string.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Gets the string format to be used to generate SQL literals of this type.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
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.
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.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
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.
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.
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.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
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.
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.
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.
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.
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.
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.
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.
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.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Creates instances of .
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Gets a new .
The newly created .
Creates commands based on raw SQL command text.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates a new command based on SQL command text.
The command text.
The newly created command.
Creates a new command based on SQL command text.
The command text.
Parameters for the command.
The newly created command.
A command to be executed against a relational database.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Gets the command text to be executed.
Gets the parameters for the command.
Executes the command with no results.
Parameters for this method.
The number of rows affected.
Asynchronously executes the command with no results.
Parameters for this method.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains the number of rows affected.
Executes the command with a single scalar result.
Parameters for this method.
The result of the command.
Asynchronously executes the command with a single scalar result.
Parameters for this method.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains the result of the command.
Executes the command with a result.
Parameters for this method.
The result of the command.
Asynchronously executes the command with a result.
Parameters for this method.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains the result of the command.
Builds a command to be executed against a relational database.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The collection of parameters.
Adds the given parameter to this command.
The parameter.
The same builder instance so that multiple calls can be chained.
The source for s to use.
Creates the command.
The newly created command.
Appends an object to the command text.
The object to be written.
The same builder instance so that multiple calls can be chained.
Appends a blank line to the command text.
The same builder instance so that multiple calls can be chained.
Increments the indent of subsequent lines.
The same builder instance so that multiple calls can be chained.
Decrements the indent of subsequent lines.
The same builder instance so that multiple calls can be chained.
Gets the length of the command text.
Creates instances of the class.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates a new .
The newly created builder.
Represents a connection with a relational database.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Gets the connection string for the database.
Gets the underlying used to connect to the database.
The currently in use, or null if not known.
Gets the connection identifier.
Gets the timeout for executing a command against the database.
Opens the connection to the database.
Indicate if the connection errors are expected and should be logged as debug message.
True if the underlying connection was actually opened; false otherwise.
Asynchronously opens the connection to the database.
Indicate if the connection errors are expected and should be logged as debug message.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation, with a value of true if the connection
was actually opened.
Closes the connection to the database.
True if the underlying connection was actually closed; false otherwise.
Closes the connection to the database.
A task that represents the asynchronous operation, with a value of true if the connection
was actually closed.
Gets a value indicating whether the multiple active result sets feature is enabled.
Gets the current transaction.
Gets a semaphore used to serialize access to this connection.
The semaphore.
Performs database/schema creation, and other related operations.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Determines whether the physical database exists. No attempt is made to determine if the database
contains the schema for the current model.
True if the database exists; otherwise false.
Asynchronously determines whether the physical database exists. No attempt is made to determine if
the database contains the schema for the current model.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains
true if the database exists; otherwise false.
Determines whether the database contains any tables. No attempt is made to determine if
tables belong to the current model or not.
A value indicating whether any tables are present in the database.
Asynchronously determines whether the database contains any tables. No attempt is made to determine if
tables belong to the current model or not.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains
a value indicating whether any tables are present in the database.
Creates the physical database. Does not attempt to populate it with any schema.
Asynchronously creates the physical database. Does not attempt to populate it with any schema.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation.
Deletes the physical database.
Asynchronously deletes the physical database.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation.
Creates all tables for the current model in the database. No attempt is made
to incrementally update the schema. It is assumed that none of the tables exist in the database.
Asynchronously creates all tables for the current model in the database. No attempt is made
to incrementally update the schema. It is assumed that none of the tables exist in the database.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation.
Generates a script to create all tables for the current model.
A SQL script.
A parameter in an . Note that this interface just represents a
placeholder for a parameter and not the actual value. This is because the same command can be
reused multiple times with different parameter values.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The name of the parameter.
Adds the parameter as a to a .
The command to add the parameter to.
The value to be assigned to the parameter.
Adds the parameter as a to a .
The command to add the parameter to.
The map of parameter values
A factory for creating instances.
This type is typically used by database providers It is generally not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates a instance.
The connection to the database.
The underlying .
The unique correlation ID for this transaction.
The logger to write to.
A value indicating whether the transaction is owned by this class (i.e. if it can be disposed when this class is disposed).
A new instance.
Creates and manages the current transaction for a relational database.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Begins a new transaction.
The isolation level to use for the transaction.
The newly created transaction.
Asynchronously begins a new transaction.
The isolation level to use for the transaction.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains the newly created transaction.
Specifies an existing to be used for database operations.
The transaction to be used.
An instance of that wraps the provided transaction.
Specifies an existing to be used for database operations.
The transaction to be used.
A to observe while waiting for the task to complete.
An instance of that wraps the provided transaction.
The relational type mapping interface for EF Core, starting with version 2.1. Type mappings describe how a
provider maps CLR types/values to database types/values.
Warning: do not implement this interface directly. Instead, derive from .
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Finds the type mapping for a given .
The property.
The type mapping, or null if none was found.
Finds the type mapping for a given representing
a field or a property of a CLR type.
Note: Only call this method if there is no available, otherwise
call
The field or property.
The type mapping, or null if none was found.
Finds the type mapping for a given .
Note: Only call this method if there is no
or available, otherwise call
or
The CLR type.
The type mapping, or null if none was found.
Finds the type mapping for a given database type name.
Note: Only call this method if there is no available, otherwise
call
The database type name.
The type mapping, or null if none was found.
Finds the type mapping for a given and additional facets.
Note: Only call this method if there is no available, otherwise
call
The CLR type.
The database type name.
If true, then a special mapping for a key or index may be returned.
Specifies Unicode or Ansi mapping, or null for default.
Specifies a size for the mapping, or null for default.
Specifies a row-version, or null for default.
Specifies a fixed length mapping, or null for default.
Specifies a precision for the mapping, or null for default.
Specifies a scale for the mapping, or null for default.
The type mapping, or null if none was found.
Represents a plugin relational type mapping source.
The service lifetime is and multiple registrations
are allowed. This means a single instance of each service is used by many
instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Finds a type mapping for the given info.
The mapping info to use to create the mapping.
The type mapping, or null if none could be found.
Creates instances of the type. An
is tied to a particular result shape and will only create value buffers for that result shape. Instances
for different result shapes are created by .
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Creates a value buffer for the given .
The reader to create a value buffer for.
The newly created value buffer.
Creates instances of the type.
instances are tied to a specific result shape. This factory is responsible for creating the
for a given result shape.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates a new .
Types and mapping for the values to be read.
The newly created .
Provides services to help with generation of SQL commands.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
The terminator to be used for SQL statements.
The terminator to be used for batches of SQL statements.
The default single-line comment prefix.
Generates a valid parameter name for the given candidate name.
The candidate name for the parameter.
A valid name based on the candidate name.
Writes a valid parameter name for the given candidate name.
The to write generated string to.
The candidate name for the parameter.
Generates a valid parameter placeholder name for the given candidate name.
The candidate name for the parameter placeholder.
A valid placeholder name based on the candidate name.
Writes a valid parameter placeholder name for the given candidate name.
The to write generated string to.
The candidate name for the parameter placeholder.
Generates the delimited SQL representation of an identifier (column name, table name, etc.).
The identifier to delimit.
The generated string.
Writes the delimited SQL representation of an identifier (column name, table name, etc.).
The to write generated string to.
The identifier to delimit.
Generates the delimited SQL representation of an identifier (column name, table name, etc.).
The identifier to delimit.
The schema of the identifier.
The generated string.
Writes the delimited SQL representation of an identifier (column name, table name, etc.).
The to write generated string to.
The identifier to delimit.
The schema of the identifier.
Generates a SQL comment.
The comment text.
The generated SQL.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Generates unique names for parameters.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Generates the next unique parameter name.
The generated name.
Resets the generator, meaning it can reuse previously generated names.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is .
This means a single instance of each service is used by many instances.
The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
Creates instances of the type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Initializes a new instance of the class.
Parameter object containing dependencies for this service.
Creates a new .
The newly created generator.
Represents a raw SQL command to be executed against a relational database.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The command to be executed.
The values to be assigned to parameters.
Gets the command to be executed.
Gets the values to be assigned to parameters.
An expected column in the relational data reader.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Creates an instance of .
The type of the column.
Whether the column can contain null values.
The column name if it is used to access the column values, null otherwise.
A used to get the field value for this column.
An instance of .
An expected column in the relational data reader.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
A command to be executed against a relational database.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Constructs a new .
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Service dependencies.
The text of the command to be executed.
Parameters for the command.
Command building dependencies.
Gets the command text to be executed.
Gets the parameters for the command.
Executes the command with no results.
Parameters for this method.
The number of rows affected.
Asynchronously executes the command with no results.
Parameters for this method.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains the number of rows affected.
Executes the command with a single scalar result.
Parameters for this method.
The result of the command.
Asynchronously executes the command with a single scalar result.
Parameters for this method.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains the result of the command.
Executes the command with a result.
Parameters for this method.
The result of the command.
Asynchronously executes the command with a result.
Parameters for this method.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains the result of the command.
Template method called by the execute methods to
create a for the given and configure
timeouts and transactions.
This method is typically used by database providers (and other extensions). It is generally
not used in application code.
Parameters for this method.
The command correlation ID.
The method that will be called on the created command.
The created command.
Builds a command to be executed against a relational database.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Constructs a new .
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Parameter object containing dependencies for this service.
Dependencies for this service.
The source for s to use.
Creates the command.
The newly created command.
Gets the command text.
The collection of parameters.
Adds the given parameter to this command.
The parameter.
The same builder instance so that multiple calls can be chained.
Appends an object to the command text.
The object to be written.
The same builder instance so that multiple calls can be chained.
Appends a blank line to the command text.
The same builder instance so that multiple calls can be chained.
Increments the indent of subsequent lines.
The same builder instance so that multiple calls can be chained.
Decrements the indent of subsequent lines.
The same builder instance so that multiple calls can be chained.
Gets the length of the command text.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
The source for s to use.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Extension methods for the class.
Appends an object to the command text on a new line.
The command builder.
The object to be written.
The same builder instance so that multiple calls can be chained.
Appends an object, that contains multiple lines of text, to the command text.
Each line read from the object is appended on a new line.
The command builder.
The object to be written.
If true, then the final newline character is skipped.
The same builder instance so that multiple calls can be chained.
Increases the indent of the command text.
The command builder.
The same builder instance so that multiple calls can be chained.
Adds a parameter.
The command builder.
The key that identifies this parameter. Note that just represents a
placeholder for a parameter and not the actual value. This is because the same command can be
reused multiple times with different parameter values.
The name to be used for the parameter when the command is executed against the database.
The same builder instance so that multiple calls can be chained.
Adds a parameter.
The command builder.
The key that identifies this parameter. Note that just represents a
placeholder for a parameter and not the actual value. This is because the same command can be
reused multiple times with different parameter values.
The name to be used for the parameter when the command is executed against the database.
The type mapping for the property that values for this parameter will come from.
A value indicating whether the parameter can contain null values.
The same builder instance so that multiple calls can be chained.
Adds a parameter.
The command builder.
The key that identifies this parameter. Note that just represents a
placeholder for a parameter and not the actual value. This is because the same command can be
reused multiple times with different parameter values.
The name to be used for the parameter when the command is executed against the database.
The property that the type for this parameter will come from.
The same builder instance so that multiple calls can be chained.
Adds a parameter that is ultimately represented as multiple s in the
final command.
The command builder.
The key that identifies this parameter. Note that just represents a
placeholder for a parameter and not the actual value. This is because the same command can be
reused multiple times with different parameter values.
The parameters to include in the composite.
The same builder instance so that multiple calls can be chained.
Adds a parameter.
The command builder.
The key that identifies this parameter. Note that just represents a
placeholder for a parameter and not the actual value. This is because the same command can be
reused multiple times with different parameter values.
The DbParameter being added.
The same builder instance so that multiple calls can be chained.
Adds a parameter.
The command builder.
The key that identifies this parameter. Note that just represents a
placeholder for a parameter and not the actual value. This is because the same command can be
reused multiple times with different parameter values.
The name to be used for the parameter when the command is executed against the database.
The property that values for this parameter will come from.
The same builder instance so that multiple calls can be chained.
Factory for instances.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Constructs a new .
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Parameter object containing dependencies for this service.
Dependencies for this service.
Creates a new .
The newly created builder.
A parameter object for the execution methods on .
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Creates a new parameter object for the given parameters.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The connection on which the command will execute.
The SQL parameter values to use, or null if none.
The current instance, or null if it is not known.
A logger, or null if no logger is available.
Creates a new parameter object for the given parameters.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The connection on which the command will execute.
The SQL parameter values to use, or null if none.
The expected columns if the reader needs to be buffered, or null otherwise.
The current instance, or null if it is not known.
A logger, or null if no logger is available.
The connection on which the command will execute.
The SQL parameter values to use, or null if none.
The expected columns if the reader needs to be buffered, or null otherwise.
The current instance, or null if it is not known.
A logger, or null if no logger is available.
Represents a connection with a relational database.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Initializes a new instance of the class.
Parameter object containing dependencies for this service.
The unique identifier for this connection.
The currently in use, or null if not known.
Parameter object containing service dependencies.
Creates a to the database.
The connection.
Gets the connection string for the database.
Gets the underlying used to connect to the database.
Gets the current transaction.
The currently enlisted transaction.
Specifies an existing to be used for database operations.
The transaction to be used.
Indicates whether the store connection supports ambient transactions
Gets the timeout for executing a command against the database.
Begins a new transaction.
The newly created transaction.
Asynchronously begins a new transaction.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains the newly created transaction.
Begins a new transaction.
The isolation level to use for the transaction.
The newly created transaction.
Asynchronously begins a new transaction.
The isolation level to use for the transaction.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains the newly created transaction.
Specifies an existing to be used for database operations.
The transaction to be used.
Specifies an existing to be used for database operations.
The transaction to be used.
A to observe while waiting for the task to complete.
An instance of that wraps the provided transaction.
Commits all changes made to the database in the current transaction.
Discards all changes made to the database in the current transaction.
Opens the connection to the database.
Indicates if the connection errors are expected and should be logged as debug message.
True if the underlying connection was actually opened; false otherwise.
Asynchronously opens the connection to the database.
Indicate if the connection errors are expected and should be logged as debug message.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation, with a value of true if the connection
was actually opened.
Closes the connection to the database.
True if the underlying connection was actually closed; false otherwise.
Closes the connection to the database.
A task that represents the asynchronous operation, with a value of true if the connection
was actually closed.
Gets a value indicating whether the multiple active result sets feature is enabled.
Gets a semaphore used to serialize access to this connection.
The semaphore used to serialize access to this connection.
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
The options for the current context instance.
The logger to which transaction messages will be written.
The logger to which connection messages will be written.
A service for resolving a connection string from a name.
A service for creating instances.
Contains the instance currently in use.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
The main interaction point between a context and the database provider.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Initializes a new instance of the class.
Parameter object containing dependencies for the base of this service.
Parameter object containing relational dependencies for this service.
Parameter object containing relational dependencies for this service.
Persists changes from the supplied entries to the database.
Entries representing the changes to be persisted.
The number of state entries persisted to the database.
Asynchronously persists changes from the supplied entries to the database.
Entries representing the changes to be persisted.
A to observe while waiting for the task to complete.
A task that represents the asynchronous save operation. The task result contains the
number of entries persisted to the database.
Performs database/schema creation, and other related operations.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Initializes a new instance of the class.
Parameter object containing dependencies for this service.
Parameter object containing service dependencies.
Determines whether the physical database exists. No attempt is made to determine if the database
contains the schema for the current model.
True if the database exists; otherwise false.
Asynchronously determines whether the physical database exists. No attempt is made to determine if
the database contains the schema for the current model.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains
true if the database exists; otherwise false.
Creates the physical database. Does not attempt to populate it with any schema.
Asynchronously creates the physical database. Does not attempt to populate it with any schema.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation.
Deletes the physical database.
Asynchronously deletes the physical database.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation.
Creates all tables for the current model in the database. No attempt is made
to incrementally update the schema. It is assumed that none of the tables exist in the database.
Asynchronously creates all tables for the current model in the database. No attempt is made
to incrementally update the schema. It is assumed that none of the tables exist in the database.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation.
Gets the commands that will create all tables from the model.
The generated commands.
Determines whether the database contains any tables. No attempt is made to determine if
tables belong to the current model or not.
A value indicating whether any tables are present in the database.
Asynchronously determines whether the database contains any tables. No attempt is made to determine if
tables belong to the current model or not.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation. The task result contains
a value indicating whether any tables are present in the database.
Ensures that the database for the context does not exist. If it does not exist, no action is taken. If it does
exist then the database is deleted.
Warning: The entire database is deleted an no effort is made to remove just the database objects that are used by
the model for this context.
True if the database is deleted, false if it did not exist.
Asynchronously ensures that the database for the context does not exist. If it does not exist, no action is taken. If it does
exist then the database is deleted.
Warning: The entire database is deleted an no effort is made to remove just the database objects that are used by
the model for this context.
A to observe while waiting for the task to complete.
A task that represents the asynchronous save operation. The task result contains true if the database is deleted,
false if it did not exist.
Ensures that the database for the context exists. If it exists, no action is taken. If it does not
exist then the database and all its schema are created. If the database exists, then no effort is made
to ensure it is compatible with the model for this context.
True if the database is created, false if it already existed.
Asynchronously ensures that the database for the context exists. If it exists, no action is taken. If it does not
exist then the database and all its schema are created. If the database exists, then no effort is made
to ensure it is compatible with the model for this context.
A to observe while waiting for the task to complete.
A task that represents the asynchronous save operation. The task result contains true if the database is created,
false if it already existed.
Generates a script to create all tables for the current model.
A SQL script.
Determines whether or not the database is available and can be connected to.
Note that being able to connect to the database does not mean that it is
up-to-date with regard to schema creation, etc.
True if the database is available; false otherwise.
Determines whether or not the database is available and can be connected to.
Note that being able to connect to the database does not mean that it is
up-to-date with regard to schema creation, etc.
A to observe while waiting for the task to complete.
True if the database is available; false otherwise.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
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.
The model differ.
The Migrations SQL generator.
Gets the model for the context this creator is being used with.
Gets the connection for the database.
Gets the to be used.
Gets the to be used.
Gets the to be used.
The command logger.
Contains the currently in use.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
The to be used.
The to be used.
The to be used.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Reads result sets from a relational database.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The connection.
The command that was executed.
The underlying reader for the result set.
A correlation ID that identifies the instance being used.
The diagnostic source.
Gets the underlying reader for the result set.
Gets the underlying command for the result set.
Calls Read on the underlying DbDataReader.
true if there are more rows; otherwise false.
Calls Read on the underlying DbDataReader.
true if there are more rows; otherwise false.
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
Extension methods for that can only be used with a
relational database provider.
Executes the specified operation in a transaction. Allows to check whether
the transaction has been rolled back if an error occurs during commit.
The strategy that will be used for the execution.
The isolation level to use for the transaction.
A delegate representing an executable operation.
A delegate that tests whether the operation succeeded even though an exception was thrown when the
transaction was being committed.
The operation has not succeeded after the configured number of retries.
Executes the specified asynchronous operation in a transaction. Allows to check whether
the transaction has been rolled back if an error occurs during commit.
The strategy that will be used for the execution.
The isolation level to use for the transaction.
A function that returns a started task.
A delegate that tests whether the operation succeeded even though an exception was thrown when the
transaction was being committed.
A task that will run to completion if the original task completes successfully (either the
first time or after retrying transient failures). If the task fails with a non-transient error or
the retry limit is reached, the returned task will become faulted and the exception must be observed.
The operation has not succeeded after the configured number of retries.
Executes the specified asynchronous operation in a transaction. Allows to check whether
the transaction has been rolled back if an error occurs during commit.
The strategy that will be used for the execution.
The isolation level to use for the transaction.
A function that returns a started task.
A delegate that tests whether the operation succeeded even though an exception was thrown when the
transaction was being committed.
A cancellation token used to cancel the retry operation, but not operations that are already in flight
or that already completed successfully.
A task that will run to completion if the original task completes successfully (either the
first time or after retrying transient failures). If the task fails with a non-transient error or
the retry limit is reached, the returned task will become faulted and the exception must be observed.
The operation has not succeeded after the configured number of retries.
Executes the specified operation in a transaction and returns the result. Allows to check whether
the transaction has been rolled back if an error occurs during commit.
The strategy that will be used for the execution.
The isolation level to use for the transaction.
A delegate representing an executable operation that returns the result of type .
A delegate that tests whether the operation succeeded even though an exception was thrown when the
transaction was being committed.
The return type of .
The result from the operation.
The operation has not succeeded after the configured number of retries.
Executes the specified asynchronous operation in a transaction and returns the result. Allows to check whether
the transaction has been rolled back if an error occurs during commit.
The strategy that will be used for the execution.
The isolation level to use for the transaction.
A function that returns a started task of type .
A delegate that tests whether the operation succeeded even though an exception was thrown when the
transaction was being committed.
A cancellation token used to cancel the retry operation, but not operations that are already in flight
or that already completed successfully.
The result type of the returned by .
A task that will run to completion if the original task completes successfully (either the
first time or after retrying transient failures). If the task fails with a non-transient error or
the retry limit is reached, the returned task will become faulted and the exception must be observed.
The operation has not succeeded after the configured number of retries.
Executes the specified operation in a transaction. Allows to check whether
the transaction has been rolled back if an error occurs during commit.
The strategy that will be used for the execution.
The state that will be passed to the operation.
A delegate representing an executable operation.
A delegate that tests whether the operation succeeded even though an exception was thrown when the
transaction was being committed.
The isolation level to use for the transaction.
The type of the state.
The operation has not succeeded after the configured number of retries.
Executes the specified asynchronous operation in a transaction. Allows to check whether
the transaction has been rolled back if an error occurs during commit.
The strategy that will be used for the execution.
The state that will be passed to the operation.
A function that returns a started task.
A delegate that tests whether the operation succeeded even though an exception was thrown when the
transaction was being committed.
The isolation level to use for the transaction.
A cancellation token used to cancel the retry operation, but not operations that are already in flight
or that already completed successfully.
The type of the state.
A task that will run to completion if the original task completes successfully (either the
first time or after retrying transient failures). If the task fails with a non-transient error or
the retry limit is reached, the returned task will become faulted and the exception must be observed.
The operation has not succeeded after the configured number of retries.
Executes the specified operation in a transaction and returns the result. Allows to check whether
the transaction has been rolled back if an error occurs during commit.
The strategy that will be used for the execution.
The state that will be passed to the operation.
A delegate representing an executable operation that returns the result of type .
A delegate that tests whether the operation succeeded even though an exception was thrown when the
transaction was being committed.
The isolation level to use for the transaction.
The type of the state.
The return type of .
The result from the operation.
The operation has not succeeded after the configured number of retries.
Executes the specified asynchronous operation and returns the result. Allows to check whether
the transaction has been rolled back if an error occurs during commit.
The strategy that will be used for the execution.
The state that will be passed to the operation.
A function that returns a started task of type .
A delegate that tests whether the operation succeeded even though an exception was thrown when the
transaction was being committed.
The isolation level to use for the transaction.
A cancellation token used to cancel the retry operation, but not operations that are already in flight
or that already completed successfully.
The type of the state.
The result type of the returned by .
A task that will run to completion if the original task completes successfully (either the
first time or after retrying transient failures). If the task fails with a non-transient error or
the retry limit is reached, the returned task will become faulted and the exception must be observed.
The operation has not succeeded after the configured number of retries.
Factory for creating instances for use with relational
database providers.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates a new instance of this class with the given service dependencies.
Parameter object containing dependencies for this service.
Parameter object containing service dependencies.
Creates or returns a cached instance of the default for the
current database provider.
Creates an for the current database provider.
Base class for relation type mappings to NTS Geometry and derived types.
The geometry type.
The native type of the database provider.
Creates a new instance of the class.
The converter to use when converting to and from database types.
The store type name.
Initializes a new instance of the class.
The parameters for this mapping.
The converter to use when converting to and from database types.
The underlying Geometry converter.
Creates a with the appropriate type information configured.
The command the parameter should be created on.
The name of the parameter.
The value to be assigned to the parameter.
A value indicating whether the parameter should be a nullable type.
The newly created parameter.
Gets a custom expression tree for the code to convert from the database value
to the model value.
The input expression, containing the database value.
The expression with conversion added.
Creates a an expression tree that can be used to generate code for the literal value.
Currently, only very basic expressions such as constructor calls and factory methods taking
simple constants are supported.
The value for which a literal is needed.
An expression tree that can be used to generate code for the literal value.
The type of the NTS 'WKTReader'.
Returns the Well-Known-Text (WKT) representation of the given object.
The 'Geometry' value.
The WKT.
Returns the SRID representation of the given object.
The 'Geometry' value.
The SRID.
Provides services to help with generation of SQL commands.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Initializes a new instance of the this class.
Parameter object containing dependencies for this service.
The terminator to be used for SQL statements.
The terminator to be used for batches of SQL statements.
The default single-line comment prefix.
Generates a valid parameter name for the given candidate name.
The candidate name for the parameter.
A valid name based on the candidate name.
Writes a valid parameter name for the given candidate name.
The to write generated string to.
The candidate name for the parameter.
Generates a valid parameter placeholder name for the given candidate name.
The candidate name for the parameter placeholder.
A valid name based on the candidate name.
Writes a valid parameter placeholder name for the given candidate name.
The to write generated string to.
The candidate name for the parameter placeholder.
Generates the escaped SQL representation of an identifier (column name, table name, etc.).
The identifier to be escaped.
The generated string.
Writes the escaped SQL representation of an identifier (column name, table name, etc.).
The to write generated string to.
The identifier to be escaped.
Generates the delimited SQL representation of an identifier (column name, table name, etc.).
The identifier to delimit.
The generated string.
Writes the delimited SQL representation of an identifier (column name, table name, etc.).
The to write generated string to.
The identifier to delimit.
Generates the delimited SQL representation of an identifier (column name, table name, etc.).
The identifier to delimit.
The schema of the identifier.
The generated string.
Writes the delimited SQL representation of an identifier (column name, table name, etc.).
The to write generated string to.
The identifier to delimit.
The schema of the identifier.
Generates a SQL comment.
The comment text.
The generated SQL.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is .
This means a single instance of each service is used by many instances.
The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
A transaction against the database.
Instances of this class are typically obtained from and it is not designed
to be directly constructed in your application code.
Initializes a new instance of the class.
The connection to the database.
The underlying .
The correlation ID for the transaction.
The logger to write to.
A value indicating whether the transaction is owned by this class (i.e. if it can be disposed when this class is disposed).
The connection.
The logger.
A correlation ID that allows this transaction to be identified and
correlated across multiple database calls.
Commits all changes made to the database in the current transaction.
Discards all changes made to the database in the current transaction.
Commits all changes made to the database in the current transaction asynchronously.
The cancellation token.
A representing the asynchronous operation.
Discards all changes made to the database in the current transaction asynchronously.
The cancellation token.
A representing the asynchronous operation.
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
Remove the underlying transaction from the connection
Remove the underlying transaction from the connection
A factory for creating instances.
This type is typically used by database providers It is generally not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Initializes a new instance of the class.
Parameter object containing dependencies for this service.
Parameter object containing dependencies for this service.
Creates a instance.
The connection to the database.
The underlying .
The unique correlation ID for this transaction.
The logger to write to.
A value indicating whether the transaction is owned by this class (i.e. if it can be disposed when this class is disposed).
A new instance.
Service dependencies parameter class for .
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is .
This means a single instance of each service is used by many instances.
The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Parameter object for use in the hierarchy.
Creates a new parameter object.
Parameters for the base class.
The name of the database type.
Indicates which values should be appended to the store type name.
The to be used.
A value indicating whether the type should handle Unicode data or not.
The size of data the property is configured to store, or null if no size is configured.
A value indicating whether the type is constrained to fixed-length data.
The precision of data the property is configured to store, or null if no size is configured.
The scale of data the property is configured to store, or null if no size is configured.
Parameters for the base class.
The mapping store type.
The mapping DbType.
The mapping Unicode flag.
The mapping size.
The mapping precision.
The mapping scale.
The mapping fixed-length flag.
Indicates which values should be appended to the store type name.
Creates a new parameter object with the given
mapping info.
The mapping info containing the facets to use.
The new parameter object.
Creates a new parameter object with the given
store type and size.
The new store type name.
The new size.
The new postfix, or null to leave unchanged.
The new parameter object.
Creates a new parameter object with the given
store type and size.
The precision of data the property is configured to store, or null if no size is configured.
The scale of data the property is configured to store, or null if no size is configured.
The new parameter object.
Creates a new parameter object with the given
converter composed with any existing converter and set on the new parameter object.
The converter.
The new parameter object.
Gets the mapping to be used when the only piece of information is that there is a null value.
Initializes a new instance of the class.
The parameters for this mapping.
Processes the store type name to add appropriate postfix/prefix text as needed.
The parameters for this mapping.
The specified store type name.
The calculated based name
The store type name to use.
Initializes a new instance of the class.
The name of the database type.
The .NET type.
The to be used.
A value indicating whether the type should handle Unicode data or not.
The size of data the property is configured to store, or null if no size is configured.
Returns the parameters used to create this type mapping.
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Creates a copy of this mapping.
The name of the database type.
The size of data the property is configured to store, or null if no size is configured.
The newly created mapping.
Creates a copy of this mapping.
The precision of data the property is configured to store, or null if no size is configured.
The scale of data the property is configured to store, or null if no size is configured.
The newly created mapping.
Returns a new copy of this type mapping with the given
added.
The converter to use.
A new type mapping
Clones the type mapping to update facets from the mapping info, if needed.
The mapping info containing the facets to use.
The cloned mapping, or the original mapping if no clone was needed.
Gets the name of the database type.
Gets the name of the database type.
Gets the base name of the database type.
Gets the to be used.
Gets a value indicating whether the type should handle Unicode data or not.
Gets the size of data the property is configured to store, or null if no size is configured.
Gets a value indicating whether the type is constrained to fixed-length data.
Gets the string format to be used to generate SQL literals of this type.
Creates a with the appropriate type information configured.
The command the parameter should be created on.
The name of the parameter.
The value to be assigned to the parameter.
A value indicating whether the parameter should be a nullable type.
The newly created parameter.
Configures type information of a .
The parameter to be configured.
Generates the SQL representation of a literal value.
The literal value.
The generated string.
Generates the SQL representation of a literal value without conversion.
The literal value.
The generated string.
Generates the SQL representation of a non-null literal value.
The literal value.
The generated string.
The method to use when reading values of the given type. The method must be defined
on or one of its subclasses.
The method to use to read the value.
The method to use when reading values of the given type. The method must be defined
on .
The method to use to read the value.
Gets a custom expression tree for reading the value from the input data reader
expression that contains the database value.
The input expression, containing the database value.
The expression with customization added.
Describes metadata needed to decide on a relational type mapping for
a property, type, or provider-specific relational type name.
Creates a new instance of .
The property for which mapping is needed.
Creates a new instance of .
The principal property chain for the property for which mapping is needed.
The provider-specific relational type name for which mapping is needed.
The provider-specific relational type name, with any facets removed.
Specifies a fallback Specifies Unicode or ANSI mapping for the mapping, in case one isn't found at the core
level, or null for default.
Specifies a fixed length mapping, or null for default.
Specifies a fallback size for the mapping, in case one isn't found at the core level, or null for
default.
Specifies a fallback precision for the mapping, in case one isn't found at the core level, or null
for default.
Specifies a fallback scale for the mapping, in case one isn't found at the core level, or null for
default.
Creates a new instance of .
The provider-specific relational type name for which mapping is needed.
The provider-specific relational type name, with any facets removed.
Specifies Unicode or ANSI mapping, or null for default.
Specifies a size for the mapping, or null for default.
Specifies a precision for the mapping, or null for default.
Specifies a scale for the mapping, or null for default.
Creates a new instance of .
The property or field for which mapping is needed.
The provider-specific relational type name for which mapping is needed.
The provider-specific relational type name, with any facets removed.
Specifies Unicode or ANSI mapping, or null for default.
Specifies a size for the mapping, or null for default.
Specifies a precision for the mapping, or null for default.
Specifies a scale for the mapping, or null for default.
Creates a new instance of with the given .
The source info.
The converter to apply.
Creates a new instance of .
The CLR type in the model for which mapping is needed.
The database type name.
The provider-specific relational type name, with any facets removed.
If true, then a special mapping for a key or index may be returned.
Specifies Unicode or ANSI mapping, or null for default.
Specifies a size for the mapping, or null for default.
Specifies a row-version, or null for default.
Specifies a fixed length mapping, or null for default.
Specifies a precision for the mapping, or null for default.
Specifies a scale for the mapping, or null for default.
The provider-specific relational type name for which mapping is needed.
The provider-specific relational type name, with any facets removed.
Indicates the store-size to use for the mapping, or null if none.
The suggested precision of the mapped data type.
The suggested scale of the mapped data type.
Whether or not the mapped data type is fixed length.
Indicates whether or not the mapping is part of a key or index.
Indicates whether or not the mapping supports Unicode, or null if not defined.
Indicates whether or not the mapping will be used for a row version, or null if not defined.
The CLR type in the model.
Returns a new with the given converter applied.
The converter to apply.
The new mapping info.
Compares this to another to check if they represent the same mapping.
The other object.
True if they represent the same mapping; false otherwise.
Compares this to another to check if they represent the same mapping.
The other object.
True if they represent the same mapping; false otherwise.
Returns a hash code for this object.
The hash code.
The base class for relational type mapping starting with version 2.1. Relational providers
should derive from this class and override
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Initializes a new instance of the this class.
Parameter object containing dependencies for this service.
Parameter object containing relational-specific dependencies for this service.
Overridden by relational database providers to find a type mapping for the given info.
The mapping info is populated with as much information about the required type mapping as
is available. Use all the information necessary to create the best mapping. Return null
if no mapping is available.
The mapping info to use to create the mapping.
The type mapping, or null if none could be found.
Dependencies used to create this
Call instead
The mapping info to use to create the mapping.
The type mapping, or null if none could be found.
Finds the type mapping for a given .
Note: providers should typically not need to override this method.
The property.
The type mapping, or null if none was found.
Finds the type mapping for a given .
Note: Only call this method if there is no
or available, otherwise call
or
Note: providers should typically not need to override this method.
The CLR type.
The type mapping, or null if none was found.
Finds the type mapping for a given representing
a field or a property of a CLR type.
Note: Only call this method if there is no available, otherwise
call
Note: providers should typically not need to override this method.
The field or property.
The type mapping, or null if none was found.
Finds the type mapping for a given database type name.
Note: Only call this method if there is no available, otherwise
call
Note: providers should typically not need to override this method.
The database type name.
The type mapping, or null if none was found.
Finds the type mapping for a given and additional facets.
Note: Only call this method if there is no available, otherwise
call
Note: providers should typically not need to override this method.
The CLR type.
The database type name.
If true, then a special mapping for a key or index may be returned.
Specifies Unicode or ANSI mapping, or null for default.
Specifies a size for the mapping, or null for default.
Specifies a row-version, or null for default.
Specifies a fixed length mapping, or null for default.
Specifies a precision for the mapping, or null for default.
Specifies a scale for the mapping, or null for default.
The type mapping, or null if none was found.
Parses a provider-specific store type name, extracting the standard facets
(e.g. size, precision) and returns the base store type name (without any facets).
The default implementation supports sometype(size), sometype(precision) and
sometype(precision, scale). Providers can override this to provide their own
logic.
A provider-specific relational type name, including facets.
The Unicode or ANSI setting parsed from the type name, or null if none was specified.
The size parsed from the type name, or null if none was specified.
The precision parsed from the type name, or null if none was specified.
The scale parsed from the type name, or null if none was specified.
The provider-specific relational type name, with any facets removed.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is .
This means a single instance of each service is used by many instances.
The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
Gets the plugins.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Extension methods for the class.
Gets the relational database type for a given object, throwing if no mapping is found.
The type mapping source.
The object to get the mapping for.
The type mapping to be used.
Gets the relational database type for a given property, throwing if no mapping is found.
The type mapping source.
The property to get the mapping for.
The type mapping to be used.
Gets the relational database type for a given .NET type, throwing if no mapping is found.
The type mapping source.
The type to get the mapping for.
The type mapping to be used.
Gets the mapping that represents the given database type, throwing if no mapping is found.
Note that sometimes the same store type can have different mappings; this method returns the default.
The type mapping source.
The type to get the mapping for.
The type mapping to be used.
Service dependencies parameter class for .
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is .
This means a single instance of each service is used by many instances.
The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a
implementations.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
Gets the type mapping source.
Gets core options.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Indicates which values should be appended to the store type name.
Append nothing.
Append only the size.
Append only the precision.
Append the precision and scale.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
A value indicating whether the type should handle Unicode data or not.
The size of data the property is configured to store, or null if no size is configured.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Generates the escaped SQL representation of a literal value.
The value to be escaped.
The generated string.
Generates the SQL representation of a literal value.
The literal value.
The generated string.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Gets the string format to be used to generate SQL literals of this type.
Creates instances of the type.
instances are tied to a specific result shape. This factory is responsible for creating the
for a given result shape.
This factory results in value buffers that use they strongly typed APIs to read back individual values from the
underlying .
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
The parameter representing the DbDataReader in generated expressions.
Initializes a new instance of the class.
Parameter object containing dependencies for this service.
Parameter object containing dependencies for this service.
Creates a new .
Types and mapping for the values to be read.
The newly created .
Creates value buffer assignment expressions for the given type information.
Types and mapping for the values to be read.
The value buffer assignment expressions.
Associates a with an optional
and an index into the data reader for use when reading and converting values from the database.
Creates a new instance.
The type that is needed in the model after conversion.
The property associated with the type, or null if none.
The type mapping source to use to find a mapping if the property does not have one already bound.
The index of the underlying result set that should be used for this type,
or -1 if no index mapping is needed.
Creates a new instance.
The type that is needed in the model after conversion.
The property associated with the type, or null if none.
The type mapping source to use to find a mapping if the property does not have one already bound.
Whether or not the value is coming from a LEFT OUTER JOIN operation.
The index of the underlying result set that should be used for this type,
or -1 if no index mapping is needed.
Creates a new instance.
The type that is needed in the model after conversion.
The property associated with the type, or null if none.
The type mapping source to use to find a mapping if the property does not have one already bound.
Whether or not the value is coming from a LEFT OUTER JOIN operation.
The index of the underlying result set that should be used for this type,
or -1 if no index mapping is needed.
The type mapping to use or null to infer one.
The type that will be read from the database provider.
The type that is needed in the model after conversion.
The type mapping for the value to be read.
The property associated with the type, or null if none.
The index of the underlying result set that should be used for this type,
or -1 if no index mapping is needed.
Whether or not the value is coming from a LEFT OUTER JOIN operation.
Determines whether the specified object is equal to the current object.
The object to compare with the current object.
True if the specified object is equal to the current object; otherwise, false.
Determines whether the specified object is equal to the current object.
The object to compare with the current object.
True if the specified object is equal to the current object; otherwise, false.
Serves as the default hash function.
A hash code for the current object.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Represents the mapping between a .NET type and a database type.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Initializes a new instance of the class.
The name of the database type.
The to be used.
Initializes a new instance of the class.
Parameter object for .
Creates a copy of this mapping.
The parameters for this mapping.
The newly created mapping.
Specifies hints used by the type mapper when mapping using a .
Creates a new instance. Any hint contained in the instance
can be null to indicate it has not been specified.
The suggested size of the mapped data type.
The suggested precision of the mapped data type.
The suggested scale of the mapped data type.
Whether or not the mapped data type should support Unicode.
Whether or not the mapped data type is fixed length.
An optional factory for creating a specific .
Adds hints from the given object to this one. Hints that are already specified are
not overridden.
The hints to add.
The combined hints.
Whether or not the mapped data type is fixed length.
A for providers which append an SQL query to find out
how many rows were affected (see ).
This type is typically used by database providers; it is generally not used in application code.
Creates a new instance.
Service dependencies.
Consumes the data reader created by .
The data reader.
Consumes the data reader created by .
The data reader.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation.
Consumes the data reader created by ,
propagating values back into the .
The ordinal of the command being consumed.
The data reader.
The ordinal of the next command that must be consumed.
Consumes the data reader created by ,
propagating values back into the .
The ordinal of the command being consumed.
The data reader.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation.
The task contains the ordinal of the next command that must be consumed.
Consumes the data reader created by
without propagating values back into the .
The ordinal of the command being consumed.
The data reader.
The ordinal of the next command that must be consumed.
Consumes the data reader created by
without propagating values back into the .
The ordinal of the command being consumed.
The data reader.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation.
The task contains the ordinal of the next command that must be consumed.
Throws an exception indicating the command affected an unexpected number of rows.
The ordinal of the command.
The expected number of rows affected.
The actual number of rows affected.
Represents an update, insert, or delete operation for a single column. s
contain lists of s.
This type is typically used by database providers; it is generally not used in application code.
Creates a new instance.
The that represents the entity that is being modified.
The property that maps to the column.
A delegate for generating parameter names for the update SQL.
Indicates whether or not a value must be read from the database for the column.
Indicates whether or not a value must be written to the database for the column.
Indicates whether or not the column part of a primary or alternate key.
Indicates whether or not the column is used in the WHERE clause when updating.
Indicates whether or not the column is acting as an optimistic concurrency token.
Indicates whether or not potentially sensitive data (e.g. database values) can be logged.
Creates a new instance.
The name of the column.
The original value of the property mapped to this column.
Gets or sets the current value of the property mapped to this column.
The property that maps to the column.
Indicates whether or not a value must be read from the database for the column.
Indicates whether or not a value must be written to the database for the column.
Indicates whether or not the column part of a primary or alternate key.
Indicates whether or not the column is used in the WHERE clause when updating.
Indicates whether or not potentially sensitive data (e.g. database values) can be logged.
The that represents the entity that is being modified.
The property that maps to the column.
Indicates whether or not a value must be read from the database for the column.
Indicates whether or not a value must be written to the database for the column.
Indicates whether or not the column is used in the WHERE clause when updating.
Indicates whether or not the column is acting as an optimistic concurrency token.
Indicates whether or not the column part of a primary or alternate key.
Indicates whether the original value of the property must be passed as a parameter to the SQL
Indicates whether the current value of the property must be passed as a parameter to the SQL
The parameter name to use for the current value parameter (), if needed.
The parameter name to use for the original value parameter (), if needed.
The name of the column.
The original value of the property mapped to this column.
Gets or sets the current value of the property mapped to this column.
Adds a modification affecting the same database value.
The modification for the shared column.
A service for executing one or more batches of insert/update/delete commands against a database.
This type is typically used by database providers; it is generally not used in application code.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Executes the commands in the batches against the given database connection.
The batches to execute.
The database connection to use.
The total number of rows affected.
Executes the commands in the batches against the given database connection.
The batches to execute.
The database connection to use.
A to observe while waiting for the task to complete.
A task that represents the asynchronous save operation. The task result contains the
total number of rows affected.
A service for preparing a list of s for the entities
represented by the given list of s.
This type is typically used by database providers; it is generally not used in application code.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates the command batches needed to insert/update/delete the entities represented by the given
list of s.
The entries that represent the entities to be modified.
The model data.
The list of batches to execute.
A service for creating instances.
This type is typically used by database providers; it is generally not used in application code.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates a new instance.
The new instance.
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.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
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.
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.
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.
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.
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.
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.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
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.
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.
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.
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.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates the service dependencies parameter object for a .
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.
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
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.
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.
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.
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.
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.
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.
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.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
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.
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.
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.
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.
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.
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.
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.
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.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
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.
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.
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.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
A service used to generate SQL for insert, update, and delete commands, and related SQL
operations needed for
This type is typically used by database providers; it is generally not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Generates SQL that will obtain the next value in the given sequence.
The name of the sequence.
The schema that contains the sequence, or null to use the default schema.
The SQL.
Generates a SQL fragment that will get the next value from the given sequence and appends it to
the full command being built by the given .
The builder to which the SQL fragment should be appended.
The name of the sequence.
The schema that contains the sequence, or null to use the default schema.
Appends a SQL fragment for the start of a batch to
the full command being built by the given .
The builder to which the SQL fragment should be appended.
Appends a SQL command for deleting a row to the commands being built.
The builder to which the SQL should be appended.
The command that represents the delete operation.
The ordinal of this command in the batch.
The for the command.
Appends a SQL command for inserting a row to the commands being built.
The builder to which the SQL should be appended.
The command that represents the delete operation.
The ordinal of this command in the batch.
The for the command.
Appends a SQL command for updating a row to the commands being built.
The builder to which the SQL should be appended.
The command that represents the delete operation.
The ordinal of this command in the batch.
The for the command.
Represents a conceptual command to the database to insert/update/delete a row.
This type is typically used by database providers; it is generally not used in application code.
Initializes a new instance.
The name of the table containing the data to be modified.
The schema containing the table, or null to use the default schema.
A delegate to generate parameter names.
Indicates whether or not potentially sensitive data (e.g. database values) can be logged.
A for s.
Initializes a new instance.
The name of the table containing the data to be modified.
The schema containing the table, or null to use the default schema.
The list of s needed to perform the insert, update, or delete.
Indicates whether or not potentially sensitive data (e.g. database values) can be logged.
The name of the table containing the data to be modified.
The schema containing the table, or null to use the default schema.
The s that represent the entities that are mapped to the row
to update.
The that indicates whether the row will be
inserted (),
updated (),
or deleted (().
The list of s needed to perform the insert, update, or delete.
Indicates whether or not the database will return values for some mapped properties
that will then need to be propagated back to the tracked entities.
Adds an to this command representing an entity to be inserted, updated, or deleted.
The entry representing the entity to add.
Adds an to this command representing an entity to be inserted, updated, or deleted.
The entry representing the entity to add.
A value indicating whether this is the main entry for the row.
Reads values returned from the database in the given and
propagates them back to into the appropriate
from which the values can be propagated on to tracked entities.
The buffer containing the values read from the database.
A base class for a collection of s that can be executed
as a batch.
This type is typically used by database providers; it is generally not used in application code.
The list of conceptual insert/update/delete s in the batch.
Adds the given insert/update/delete to the batch.
The command to add.
True if the command was successfully added; false if there was no
room in the current batch to add the command and it must instead be added to a new batch.
Sends insert/update/delete commands to the database.
The database connection to use.
Sends insert/update/delete commands to the database.
The database connection to use.
A to observe while waiting for the task to complete.
A task that represents the asynchronous save operation.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
A logger.
The command builder factory.
The SQL generator helper.
The update SQL generator.
The value buffer factory.
Contains the currently in use.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
A base class for implementations that make use
of a data reader.
This type is typically used by database providers; it is generally not used in application code.
Creates a new instance.
Service dependencies.
Service dependencies.
The update SQL generator.
Gets or sets the cached command text for the commands in the batch.
The ordinal of the last command for which command text was built.
The list of conceptual insert/update/delete s in the batch.
The s for each command in .
Adds the given insert/update/delete to the batch.
The command to add.
True if the command was successfully added; false if there was no
room in the current batch to add the command and it must instead be added to a new batch.
Resets the builder to start building a new batch.
Checks whether or not a new command can be added to the batch.
The command to potentially add.
True if the command can be added; false otherwise.
Checks whether or not the command text is valid.
True if the command text is valid; false otherwise.
Gets the command text for all the commands in the current batch and also caches it
on .
The command text.
Updates the command text for the command at the given position in the
list.
The position of the command to generate command text for.
Gets the total number of parameters needed for the batch.
The total parameter count.
Generates a for the batch.
The command.
Executes the command generated by against a
database using the given connection.
The connection to the database to update.
Executes the command generated by against a
database using the given connection.
The connection to the database to update.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation.
Consumes the data reader created by .
The data reader.
Consumes the data reader created by .
The data reader.
A to observe while waiting for the task to complete.
A task that represents the asynchronous operation.
Creates the that will be used for creating a
to consume the data reader.
The list of s for all the columns
being modified such that a ValueBuffer with appropriate slots can be created.
The factory.
Indicates what kind of impact on the result set a given command will have.
This type is typically used by database providers; it is generally not used in application code.
The command does not have any result set mapping.
The command maps to a result in the result set, but this is not the last result.
The command maps to the last result in the result set.
An implementation of that does not
support batching by limiting the number of commands in the batch to one.
This type is typically used by database providers; it is generally not used in application code.
Creates a new instance.
Service dependencies.
Only returns true if the no command has already been added.
The command to potentially add.
True if no command has already been added.
Returns true since only a single command is generated so the command text must be valid.
True
A base class for the service that is typically inherited from
by database providers.
This type is typically used by database providers; it is generally not used in application code.
The service lifetime is . This means a single instance
is used by many instances. The implementation must be thread-safe.
This service cannot depend on services registered as .
Initializes a new instance of the this class.
Parameter object containing dependencies for this service.
Parameter object containing service dependencies.
Helpers for generating update SQL.
Appends a SQL command for inserting a row to the commands being built.
The builder to which the SQL should be appended.
The command that represents the delete operation.
The ordinal of this command in the batch.
The for the command.
Appends a SQL command for updating a row to the commands being built.
The builder to which the SQL should be appended.
The command that represents the delete operation.
The ordinal of this command in the batch.
The for the command.
Appends a SQL command for deleting a row to the commands being built.
The builder to which the SQL should be appended.
The command that represents the delete operation.
The ordinal of this command in the batch.
The for the command.
Appends a SQL command for inserting a row to the commands being built.
The builder to which the SQL should be appended.
The name of the table.
The table schema, or null to use the default schema.
The operations for each column.
Appends a SQL command for updating a row to the commands being built.
The builder to which the SQL should be appended.
The name of the table.
The table schema, or null to use the default schema.
The operations for each column.
The operations used to generate the WHERE clause for the update.
Appends a SQL command for deleting a row to the commands being built.
The builder to which the SQL should be appended.
The name of the table.
The table schema, or null to use the default schema.
The operations used to generate the WHERE clause for the delete.
Appends a SQL command for selecting the number of rows affected.
The builder to which the SQL should be appended.
The name of the table.
The table schema, or null to use the default schema.
The ordinal of the command for which rows affected it being returned.
The for this command.
Appends a SQL command for selecting affected data.
The builder to which the SQL should be appended.
The name of the table.
The table schema, or null to use the default schema.
The operations representing the data to be read.
The operations used to generate the WHERE clause for the select.
The ordinal of the command for which rows affected it being returned.
The for this command.
Appends a SQL fragment for starting an INSERT.
The builder to which the SQL should be appended.
The name of the table.
The table schema, or null to use the default schema.
The operations representing the data to be inserted.
Appends a SQL fragment for starting an DELETE.
The builder to which the SQL should be appended.
The name of the table.
The table schema, or null to use the default schema.
Appends a SQL fragment for starting an UPDATE.
The builder to which the SQL should be appended.
The name of the table.
The table schema, or null to use the default schema.
The operations representing the data to be updated.
Appends a SQL fragment for starting an SELECT.
The builder to which the SQL should be appended.
The operations representing the data to be read.
Appends a SQL fragment for starting an FROM clause.
The builder to which the SQL should be appended.
The name of the table.
The table schema, or null to use the default schema.
Appends a SQL fragment for a VALUES.
The builder to which the SQL should be appended.
The operations for which there are values.
Appends values after a call.
The builder to which the SQL should be appended.
The operations for which there are values.
Appends a WHERE clause.
The builder to which the SQL should be appended.
The operations from which to build the conditions.
Appends a WHERE clause involving rows affected.
The builder to which the SQL should be appended.
The operations from which to build the conditions.
Appends a WHERE condition checking rows affected.
The builder to which the SQL should be appended.
The expected number of rows affected.
Appends a WHERE condition for the given column.
The builder to which the SQL should be appended.
The column for which the condition is being generated.
If true, then the original value will be used in the condition, otherwise the current value will be used.
Appends a WHERE condition for the identity (i.e. key value) of the given column.
The builder to which the SQL should be appended.
The column for which the condition is being generated.
Appends SQL text that defines the start of a batch.
The builder to which the SQL should be appended.
Generates SQL that will obtain the next value in the given sequence.
The name of the sequence.
The schema that contains the sequence, or null to use the default schema.
The SQL.
Generates a SQL fragment that will get the next value from the given sequence and appends it to
the full command being built by the given .
The builder to which the SQL fragment should be appended.
The name of the sequence.
The schema that contains the sequence, or null to use the default schema.
Service dependencies parameter class for
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
Do not construct instances of this class directly from either provider or application code as the
constructor signature may change as new dependencies are added. Instead, use this type in
your constructor so that an instance will be created and injected automatically by the
dependency injection container. To create an instance with some dependent services replaced,
first resolve the object from the dependency injection container, then replace selected
services using the 'With...' methods. Do not call the constructor at any point in this process.
The service lifetime is .
This means a single instance of each service is used by many instances.
The implementation must be thread-safe.
This service cannot depend on services registered as .
Creates the service dependencies parameter object for a .
Do not call this constructor directly from either provider or application code as it may change
as new dependencies are added. Instead, use this type in your constructor so that an instance
will be created and injected automatically by the dependency injection container. To create
an instance with some dependent services replaced, first resolve the object from the dependency
injection container, then replace selected services using the 'With...' methods. Do not call
the constructor at any point in this process.
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.
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.
Helpers for generating update SQL.
The type mapping source.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Clones this dependency parameter object with one service replaced.
A replacement for the current dependency of this type.
A new parameter object with the given service replaced.
Selects value generators to be used to generate values for properties of entities.
This type is typically used by database providers (and other extensions). It is generally
not used in application code.
The service lifetime is . This means that each
instance will use its own instance of this service.
The implementation may depend on other services registered with any lifetime.
The implementation does not need to be thread-safe.
Initializes a new instance of the class.
Parameter object containing dependencies for this service.
Creates a new value generator for the given property.
The property to get the value generator for.
The entity type that the value generator will be used for. When called on inherited properties on derived entity types,
this entity type may be different from the declared entity type on
The newly created value generator.