Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Common / DbProviderServices.cs / 1458001 / DbProviderServices.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//-----------------------------------------------------------------------------
namespace System.Data.Common
{
using System.Collections.Generic;
using System.Data.Common.CommandTrees;
using System.Data.Metadata.Edm;
using System.Xml;
using System.Reflection;
using System.IO;
using System.Data.Entity;
using System.Diagnostics;
///
/// The factory for building command definitions; use the type of this object
/// as the argument to the IServiceProvider.GetService method on the provider
/// factory;
///
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
[CLSCompliant(false)]
abstract public class DbProviderServices
{
///
/// Create a Command Definition object given a command tree.
///
/// command tree for the statement
/// an exectable command definition object
///
/// This method simply delegates to the provider's implementation of CreateDbCommandDefinition.
///
public DbCommandDefinition CreateCommandDefinition(DbCommandTree commandTree)
{
EntityUtil.CheckArgumentNull(commandTree, "commandTree");
ValidateDataSpace(commandTree);
StoreItemCollection storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace);
Debug.Assert(storeMetadata.StoreProviderManifest != null, "StoreItemCollection has null StoreProviderManifest?");
return CreateDbCommandDefinition(storeMetadata.StoreProviderManifest, commandTree);
}
///
/// Create a Command Definition object given a command tree.
///
/// command tree for the statement
/// an exectable command definition object
///
/// This method simply delegates to the provider's implementation of CreateDbCommandDefinition.
///
public DbCommandDefinition CreateCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
try
{
return CreateDbCommandDefinition(providerManifest, commandTree);
}
catch (ProviderIncompatibleException)
{
throw;
}
catch (Exception e)
{
if (EntityUtil.IsCatchableExceptionType(e))
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDidNotCreateACommandDefinition, e);
}
throw;
}
}
///
/// Create a Command Definition object, given the provider manifest and command tree
///
/// provider manifest previously retrieved from the store provider
/// command tree for the statement
/// an exectable command definition object
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
protected abstract DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree);
///
/// Ensures that the data space of the specified command tree is the target (S-) space
///
/// The command tree for which the data space should be validated
internal virtual void ValidateDataSpace(DbCommandTree commandTree)
{
Debug.Assert(commandTree != null, "Ensure command tree is non-null before calling ValidateDataSpace");
if (commandTree.DataSpace != DataSpace.SSpace)
{
throw EntityUtil.ProviderIncompatible(Entity.Strings.ProviderRequiresStoreCommandTree);
}
}
///
/// Create a DbCommand object given a command tree.
///
/// command tree for the statement
/// a command object
internal virtual DbCommand CreateCommand(DbCommandTree commandTree) {
DbCommandDefinition commandDefinition = CreateCommandDefinition(commandTree);
DbCommand command = commandDefinition.CreateCommand();
return command;
}
///
/// Create the default DbCommandDefinition object based on the prototype command
/// This method is intended for provider writers to build a default command definition
/// from a command.
/// Note: This will clone the prototype
///
/// the prototype command
/// an executable command definition object
public virtual DbCommandDefinition CreateCommandDefinition(DbCommand prototype) {
return DbCommandDefinition.CreateCommandDefinition(prototype);
}
///
/// Retrieve the provider manifest token based on the specified connection.
///
/// The connection for which the provider manifest token should be retrieved.
///
/// The provider manifest token that describes the specified connection, as determined by the provider.
///
///
/// This method simply delegates to the provider's implementation of GetDbProviderManifestToken.
///
public string GetProviderManifestToken(DbConnection connection) {
try
{
string providerManifestToken = GetDbProviderManifestToken(connection);
if (providerManifestToken == null)
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDidNotReturnAProviderManifestToken);
}
return providerManifestToken;
}
catch (ProviderIncompatibleException)
{
throw;
}
catch (Exception e)
{
if (EntityUtil.IsCatchableExceptionType(e))
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDidNotReturnAProviderManifestToken, e);
}
throw;
}
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
protected abstract string GetDbProviderManifestToken(DbConnection connection);
public DbProviderManifest GetProviderManifest(string manifestToken) {
try
{
DbProviderManifest providerManifest = GetDbProviderManifest(manifestToken);
if (providerManifest == null)
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDidNotReturnAProviderManifest);
}
return providerManifest;
}
catch (ProviderIncompatibleException)
{
throw;
}
catch (Exception e)
{
if (EntityUtil.IsCatchableExceptionType(e)) {
throw EntityUtil.ProviderIncompatible(System.Data.Entity.Strings.ProviderDidNotReturnAProviderManifest, e);
}
throw;
}
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
protected abstract DbProviderManifest GetDbProviderManifest(string manifestToken);
internal void SetParameterValue(DbParameter parameter, TypeUsage parameterType, object value)
{
EntityUtil.CheckArgumentNull(parameter, "parameter");
EntityUtil.CheckArgumentNull(parameterType, "parameterType");
this.SetDbParameterValue(parameter, parameterType, value);
}
//
internal virtual void SetDbParameterValue(DbParameter parameter, TypeUsage parameterType, object value)
{
parameter.Value = value;
}
///
/// Create an instance of DbProviderServices based on the supplied DbConnection
///
/// The DbConnection to use
/// An instance of DbProviderServices
public static DbProviderServices GetProviderServices(DbConnection connection) {
return GetProviderServices(GetProviderFactory(connection));
}
internal static DbProviderFactory GetProviderFactory(string providerInvariantName)
{
EntityUtil.CheckArgumentNull(providerInvariantName, "providerInvariantName");
DbProviderFactory factory;
try
{
factory = DbProviderFactories.GetFactory(providerInvariantName);
}
catch (ArgumentException e)
{
throw EntityUtil.Argument(Strings.EntityClient_InvalidStoreProvider, e);
}
return factory;
}
///
/// Retrieve the DbProviderFactory based on the specified DbConnection
///
/// The DbConnection to use
/// An instance of DbProviderFactory
public static DbProviderFactory GetProviderFactory(DbConnection connection)
{
EntityUtil.CheckArgumentNull(connection, "connection");
DbProviderFactory factory = connection.ProviderFactory;
if (factory == null)
{
throw EntityUtil.ProviderIncompatible(
System.Data.Entity.Strings.EntityClient_ReturnedNullOnProviderMethod(
"get_ProviderFactory",
connection.GetType().ToString()));
}
return factory;
}
internal static DbProviderServices GetProviderServices(DbProviderFactory factory) {
EntityUtil.CheckArgumentNull(factory, "factory");
IServiceProvider serviceProvider = factory as IServiceProvider;
if (serviceProvider == null) {
throw EntityUtil.ProviderIncompatible(System.Data.Entity.Strings.EntityClient_DoesNotImplementIServiceProvider(
factory.GetType().ToString()));
}
DbProviderServices providerServices = serviceProvider.GetService(typeof(DbProviderServices)) as DbProviderServices;
if (providerServices == null) {
throw EntityUtil.ProviderIncompatible(
System.Data.Entity.Strings.EntityClient_ReturnedNullOnProviderMethod(
"GetService",
factory.GetType().ToString()));
}
return providerServices;
}
///
/// Return an XML reader which represents the CSDL description
///
/// An XmlReader that represents the CSDL description
internal static XmlReader GetConceptualSchemaDescription() {
return DbProviderServices.GetXmlResource("System.Data.Resources.DbProviderServices.ConceptualSchemaDefinition.csdl");
}
internal static XmlReader GetXmlResource(string resourceName) {
Assembly executingAssembly = Assembly.GetExecutingAssembly();
Stream stream = executingAssembly.GetManifestResourceStream(resourceName);
return XmlReader.Create(stream, null, resourceName);
}
///
/// Generates a DDL script which creates schema objects (tables, primary keys, foreign keys)
/// based on the contents of the storeItemCollection and targeted for the version of the backend corresponding to
/// the providerManifestToken.
/// Individual statements should be separated using database-specific DDL command separator.
/// It is expected that the generated script would be executed in the context of existing database with
/// sufficient permissions, and it should not include commands to create the database, but it may include
/// commands to create schemas and other auxiliary objects such as sequences, etc.
///
/// The provider manifest token identifying the target version
/// The collection of all store items based on which the script should be created
///
/// A DDL script which creates schema objects based on contents of storeItemCollection
/// and targeted for the version of the backend corresponding to the providerManifestToken.
///
public string CreateDatabaseScript(string providerManifestToken, StoreItemCollection storeItemCollection)
{
return DbCreateDatabaseScript(providerManifestToken, storeItemCollection);
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
protected virtual string DbCreateDatabaseScript(string providerManifestToken, StoreItemCollection storeItemCollection)
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDoesNotSupportCreateDatabaseScript);
}
///
/// Creates a database indicated by connection and creates schema objects
/// (tables, primary keys, foreign keys) based on the contents of storeItemCollection.
///
/// Connection to a non-existent database that needs to be created
/// and be populated with the store objects indicated by the storeItemCollection
/// Execution timeout for any commands needed to create the database.
/// The collection of all store items based on which the script should be created<
public void CreateDatabase(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection)
{
DbCreateDatabase(connection, commandTimeout, storeItemCollection);
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
protected virtual void DbCreateDatabase(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection)
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDoesNotSupportCreateDatabase);
}
///
/// Returns a value indicating whether given database exists on the server
/// and/or whether schema objects contained in teh storeItemCollection have been created.
/// If the provider can deduct the database only based on the connection, they do not need
/// to additionally verify all elements of the storeItemCollection.
///
/// Connection to a database whose existence is checked by this method
/// Execution timeout for any commands needed to determine the existence of the database
/// The collection of all store items contained in the database
/// whose existence is determined by this method<
/// Whether the database indicated by the connection and the storeItemCollection exist
public bool DatabaseExists(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection)
{
return DbDatabaseExists(connection, commandTimeout, storeItemCollection);
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
protected virtual bool DbDatabaseExists(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection)
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDoesNotSupportDatabaseExists);
}
///
/// Deletes all store objects specified in the store item collection from the database and the database itself.
///
/// Connection to an existing database that needs to be deleted
/// Execution timeout for any commands needed to delete the database
/// The collection of all store items contained in the database that should be deleted<
public void DeleteDatabase(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection)
{
DbDeleteDatabase(connection, commandTimeout, storeItemCollection);
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
protected virtual void DbDeleteDatabase(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection)
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDoesNotSupportDeleteDatabase);
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//-----------------------------------------------------------------------------
namespace System.Data.Common
{
using System.Collections.Generic;
using System.Data.Common.CommandTrees;
using System.Data.Metadata.Edm;
using System.Xml;
using System.Reflection;
using System.IO;
using System.Data.Entity;
using System.Diagnostics;
///
/// The factory for building command definitions; use the type of this object
/// as the argument to the IServiceProvider.GetService method on the provider
/// factory;
///
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
[CLSCompliant(false)]
abstract public class DbProviderServices
{
///
/// Create a Command Definition object given a command tree.
///
/// command tree for the statement
/// an exectable command definition object
///
/// This method simply delegates to the provider's implementation of CreateDbCommandDefinition.
///
public DbCommandDefinition CreateCommandDefinition(DbCommandTree commandTree)
{
EntityUtil.CheckArgumentNull(commandTree, "commandTree");
ValidateDataSpace(commandTree);
StoreItemCollection storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace);
Debug.Assert(storeMetadata.StoreProviderManifest != null, "StoreItemCollection has null StoreProviderManifest?");
return CreateDbCommandDefinition(storeMetadata.StoreProviderManifest, commandTree);
}
///
/// Create a Command Definition object given a command tree.
///
/// command tree for the statement
/// an exectable command definition object
///
/// This method simply delegates to the provider's implementation of CreateDbCommandDefinition.
///
public DbCommandDefinition CreateCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
try
{
return CreateDbCommandDefinition(providerManifest, commandTree);
}
catch (ProviderIncompatibleException)
{
throw;
}
catch (Exception e)
{
if (EntityUtil.IsCatchableExceptionType(e))
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDidNotCreateACommandDefinition, e);
}
throw;
}
}
///
/// Create a Command Definition object, given the provider manifest and command tree
///
/// provider manifest previously retrieved from the store provider
/// command tree for the statement
/// an exectable command definition object
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
protected abstract DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree);
///
/// Ensures that the data space of the specified command tree is the target (S-) space
///
/// The command tree for which the data space should be validated
internal virtual void ValidateDataSpace(DbCommandTree commandTree)
{
Debug.Assert(commandTree != null, "Ensure command tree is non-null before calling ValidateDataSpace");
if (commandTree.DataSpace != DataSpace.SSpace)
{
throw EntityUtil.ProviderIncompatible(Entity.Strings.ProviderRequiresStoreCommandTree);
}
}
///
/// Create a DbCommand object given a command tree.
///
/// command tree for the statement
/// a command object
internal virtual DbCommand CreateCommand(DbCommandTree commandTree) {
DbCommandDefinition commandDefinition = CreateCommandDefinition(commandTree);
DbCommand command = commandDefinition.CreateCommand();
return command;
}
///
/// Create the default DbCommandDefinition object based on the prototype command
/// This method is intended for provider writers to build a default command definition
/// from a command.
/// Note: This will clone the prototype
///
/// the prototype command
/// an executable command definition object
public virtual DbCommandDefinition CreateCommandDefinition(DbCommand prototype) {
return DbCommandDefinition.CreateCommandDefinition(prototype);
}
///
/// Retrieve the provider manifest token based on the specified connection.
///
/// The connection for which the provider manifest token should be retrieved.
///
/// The provider manifest token that describes the specified connection, as determined by the provider.
///
///
/// This method simply delegates to the provider's implementation of GetDbProviderManifestToken.
///
public string GetProviderManifestToken(DbConnection connection) {
try
{
string providerManifestToken = GetDbProviderManifestToken(connection);
if (providerManifestToken == null)
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDidNotReturnAProviderManifestToken);
}
return providerManifestToken;
}
catch (ProviderIncompatibleException)
{
throw;
}
catch (Exception e)
{
if (EntityUtil.IsCatchableExceptionType(e))
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDidNotReturnAProviderManifestToken, e);
}
throw;
}
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
protected abstract string GetDbProviderManifestToken(DbConnection connection);
public DbProviderManifest GetProviderManifest(string manifestToken) {
try
{
DbProviderManifest providerManifest = GetDbProviderManifest(manifestToken);
if (providerManifest == null)
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDidNotReturnAProviderManifest);
}
return providerManifest;
}
catch (ProviderIncompatibleException)
{
throw;
}
catch (Exception e)
{
if (EntityUtil.IsCatchableExceptionType(e)) {
throw EntityUtil.ProviderIncompatible(System.Data.Entity.Strings.ProviderDidNotReturnAProviderManifest, e);
}
throw;
}
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
protected abstract DbProviderManifest GetDbProviderManifest(string manifestToken);
internal void SetParameterValue(DbParameter parameter, TypeUsage parameterType, object value)
{
EntityUtil.CheckArgumentNull(parameter, "parameter");
EntityUtil.CheckArgumentNull(parameterType, "parameterType");
this.SetDbParameterValue(parameter, parameterType, value);
}
//
internal virtual void SetDbParameterValue(DbParameter parameter, TypeUsage parameterType, object value)
{
parameter.Value = value;
}
///
/// Create an instance of DbProviderServices based on the supplied DbConnection
///
/// The DbConnection to use
/// An instance of DbProviderServices
public static DbProviderServices GetProviderServices(DbConnection connection) {
return GetProviderServices(GetProviderFactory(connection));
}
internal static DbProviderFactory GetProviderFactory(string providerInvariantName)
{
EntityUtil.CheckArgumentNull(providerInvariantName, "providerInvariantName");
DbProviderFactory factory;
try
{
factory = DbProviderFactories.GetFactory(providerInvariantName);
}
catch (ArgumentException e)
{
throw EntityUtil.Argument(Strings.EntityClient_InvalidStoreProvider, e);
}
return factory;
}
///
/// Retrieve the DbProviderFactory based on the specified DbConnection
///
/// The DbConnection to use
/// An instance of DbProviderFactory
public static DbProviderFactory GetProviderFactory(DbConnection connection)
{
EntityUtil.CheckArgumentNull(connection, "connection");
DbProviderFactory factory = connection.ProviderFactory;
if (factory == null)
{
throw EntityUtil.ProviderIncompatible(
System.Data.Entity.Strings.EntityClient_ReturnedNullOnProviderMethod(
"get_ProviderFactory",
connection.GetType().ToString()));
}
return factory;
}
internal static DbProviderServices GetProviderServices(DbProviderFactory factory) {
EntityUtil.CheckArgumentNull(factory, "factory");
IServiceProvider serviceProvider = factory as IServiceProvider;
if (serviceProvider == null) {
throw EntityUtil.ProviderIncompatible(System.Data.Entity.Strings.EntityClient_DoesNotImplementIServiceProvider(
factory.GetType().ToString()));
}
DbProviderServices providerServices = serviceProvider.GetService(typeof(DbProviderServices)) as DbProviderServices;
if (providerServices == null) {
throw EntityUtil.ProviderIncompatible(
System.Data.Entity.Strings.EntityClient_ReturnedNullOnProviderMethod(
"GetService",
factory.GetType().ToString()));
}
return providerServices;
}
///
/// Return an XML reader which represents the CSDL description
///
/// An XmlReader that represents the CSDL description
internal static XmlReader GetConceptualSchemaDescription() {
return DbProviderServices.GetXmlResource("System.Data.Resources.DbProviderServices.ConceptualSchemaDefinition.csdl");
}
internal static XmlReader GetXmlResource(string resourceName) {
Assembly executingAssembly = Assembly.GetExecutingAssembly();
Stream stream = executingAssembly.GetManifestResourceStream(resourceName);
return XmlReader.Create(stream, null, resourceName);
}
///
/// Generates a DDL script which creates schema objects (tables, primary keys, foreign keys)
/// based on the contents of the storeItemCollection and targeted for the version of the backend corresponding to
/// the providerManifestToken.
/// Individual statements should be separated using database-specific DDL command separator.
/// It is expected that the generated script would be executed in the context of existing database with
/// sufficient permissions, and it should not include commands to create the database, but it may include
/// commands to create schemas and other auxiliary objects such as sequences, etc.
///
/// The provider manifest token identifying the target version
/// The collection of all store items based on which the script should be created
///
/// A DDL script which creates schema objects based on contents of storeItemCollection
/// and targeted for the version of the backend corresponding to the providerManifestToken.
///
public string CreateDatabaseScript(string providerManifestToken, StoreItemCollection storeItemCollection)
{
return DbCreateDatabaseScript(providerManifestToken, storeItemCollection);
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
protected virtual string DbCreateDatabaseScript(string providerManifestToken, StoreItemCollection storeItemCollection)
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDoesNotSupportCreateDatabaseScript);
}
///
/// Creates a database indicated by connection and creates schema objects
/// (tables, primary keys, foreign keys) based on the contents of storeItemCollection.
///
/// Connection to a non-existent database that needs to be created
/// and be populated with the store objects indicated by the storeItemCollection
/// Execution timeout for any commands needed to create the database.
/// The collection of all store items based on which the script should be created<
public void CreateDatabase(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection)
{
DbCreateDatabase(connection, commandTimeout, storeItemCollection);
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
protected virtual void DbCreateDatabase(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection)
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDoesNotSupportCreateDatabase);
}
///
/// Returns a value indicating whether given database exists on the server
/// and/or whether schema objects contained in teh storeItemCollection have been created.
/// If the provider can deduct the database only based on the connection, they do not need
/// to additionally verify all elements of the storeItemCollection.
///
/// Connection to a database whose existence is checked by this method
/// Execution timeout for any commands needed to determine the existence of the database
/// The collection of all store items contained in the database
/// whose existence is determined by this method<
/// Whether the database indicated by the connection and the storeItemCollection exist
public bool DatabaseExists(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection)
{
return DbDatabaseExists(connection, commandTimeout, storeItemCollection);
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
protected virtual bool DbDatabaseExists(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection)
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDoesNotSupportDatabaseExists);
}
///
/// Deletes all store objects specified in the store item collection from the database and the database itself.
///
/// Connection to an existing database that needs to be deleted
/// Execution timeout for any commands needed to delete the database
/// The collection of all store items contained in the database that should be deleted<
public void DeleteDatabase(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection)
{
DbDeleteDatabase(connection, commandTimeout, storeItemCollection);
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")]
protected virtual void DbDeleteDatabase(DbConnection connection, int? commandTimeout, StoreItemCollection storeItemCollection)
{
throw EntityUtil.ProviderIncompatible(Strings.ProviderDoesNotSupportDeleteDatabase);
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- ComponentDispatcherThread.cs
- RequestCache.cs
- NameValueFileSectionHandler.cs
- WebBrowserSiteBase.cs
- SqlDataSourceFilteringEventArgs.cs
- FixedSOMPageElement.cs
- TypeInfo.cs
- SQLBinaryStorage.cs
- AddInContractAttribute.cs
- SchemaImporterExtensionElementCollection.cs
- basecomparevalidator.cs
- Point3DCollectionConverter.cs
- EntityTypeEmitter.cs
- DefaultHttpHandler.cs
- LeaseManager.cs
- SerialReceived.cs
- Italic.cs
- Gdiplus.cs
- PageSetupDialog.cs
- RequestResponse.cs
- SoapFormatter.cs
- TreeNodeConverter.cs
- EqualityComparer.cs
- TextViewBase.cs
- AdapterDictionary.cs
- TrackingProfile.cs
- SerializationStore.cs
- CRYPTPROTECT_PROMPTSTRUCT.cs
- ManifestSignatureInformation.cs
- CopyOfAction.cs
- InputLanguageCollection.cs
- IWorkflowDebuggerService.cs
- Viewport2DVisual3D.cs
- EditorPartDesigner.cs
- DmlSqlGenerator.cs
- RedistVersionInfo.cs
- TransformerTypeCollection.cs
- RegistryPermission.cs
- CodeDOMUtility.cs
- GlobalizationAssembly.cs
- TrackingDataItemValue.cs
- VisualTreeHelper.cs
- DataGridViewRowPostPaintEventArgs.cs
- securitycriticaldata.cs
- DataBoundControlAdapter.cs
- Deflater.cs
- BindingGroup.cs
- ThumbAutomationPeer.cs
- OrderedDictionary.cs
- _RequestCacheProtocol.cs
- ValueExpressions.cs
- ThreadInterruptedException.cs
- ScrollContentPresenter.cs
- WindowsRebar.cs
- PreProcessor.cs
- ListViewDeleteEventArgs.cs
- ContentFilePart.cs
- ParseNumbers.cs
- GeometryValueSerializer.cs
- Claim.cs
- SecureStringHasher.cs
- XmlUtf8RawTextWriter.cs
- FormsAuthenticationCredentials.cs
- RoleGroup.cs
- FixedPosition.cs
- ExtensionWindow.cs
- SelectionEditingBehavior.cs
- IIS7UserPrincipal.cs
- SafeThemeHandle.cs
- StickyNoteContentControl.cs
- RelatedCurrencyManager.cs
- ColumnHeaderConverter.cs
- BoundColumn.cs
- DataListItemCollection.cs
- UnhandledExceptionEventArgs.cs
- DiagnosticTraceSchemas.cs
- ErrorWebPart.cs
- PageCodeDomTreeGenerator.cs
- AlphaSortedEnumConverter.cs
- SingletonChannelAcceptor.cs
- RemoteWebConfigurationHost.cs
- ConfigurationLocation.cs
- RegionInfo.cs
- WebSysDisplayNameAttribute.cs
- MembershipValidatePasswordEventArgs.cs
- safemediahandle.cs
- ArrayTypeMismatchException.cs
- WSHttpTransportSecurityElement.cs
- LineSegment.cs
- InkCanvasSelectionAdorner.cs
- InvalidWMPVersionException.cs
- SortQueryOperator.cs
- ContextBase.cs
- CompatibleIComparer.cs
- LoginCancelEventArgs.cs
- Inflater.cs
- ViewCellRelation.cs
- EventListener.cs
- ThemeInfoAttribute.cs
- PagesChangedEventArgs.cs