protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
Check.NotNull(providerManifest, "providerManifest");
Check.NotNull(commandTree, "commandTree");
return CreateDbCommandDefinition(providerManifest, commandTree, new DbInterceptionContext());
}
static LegacyDbProviderManifestWrapperTests()
{
LegacyProviderManifest =
((Legacy.DbProviderServices)
((IServiceProvider)Legacy.DbProviderFactories.GetFactory("System.Data.SqlClient"))
.GetService(typeof(Legacy.DbProviderServices)))
.GetProviderManifest("2008");
ProviderManifestWrapper = new LegacyDbProviderManifestWrapper(LegacyProviderManifest);
const string emptyCsdl =
@"<Schema xmlns=""http://schemas.microsoft.com/ado/2009/11/edm"" Namespace=""dummy"" />";
using (var reader = XmlReader.Create(new StringReader(emptyCsdl)))
{
EdmPrimitiveTypes =
new EdmItemCollection(new[] { reader }).GetItems<PrimitiveType>().ToDictionary(t => t.Name, t => t);
}
using (var reader = XmlReader.Create(new StringReader(emptyCsdl)))
{
LegacyEdmPrimitiveTypes =
new LegacyMetadata.EdmItemCollection(new[] { reader })
.GetItems<LegacyMetadata.PrimitiveType>()
.ToDictionary(t => t.Name, t => t);
}
}
/// <summary>
/// Creates the provider manifest wrapper.
/// </summary>
/// <param name="providerInvariantName">Provider invariant name.</param>
/// <param name="providerManifest">The provider manifest to be wrapped.</param>
/// <returns><see cref="DbProviderManifest"/> wrapper for given provider invariant name wrapping given provider manifest.</returns>
public virtual DbProviderManifest CreateProviderManifest(string providerInvariantName, DbProviderManifest providerManifest)
{
return new DbProviderManifestWrapper(
this.ProviderInvariantName,
providerInvariantName,
providerManifest);
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
return new CachingCommandDefinition(
_providerServices.CreateCommandDefinition(providerManifest, commandTree),
new CommandTreeFacts(commandTree),
_cacheTransactionHandler,
_cachingPolicy);
}
/// <summary>
/// Create a Command Definition object, given the connection and command tree
/// </summary>
/// <param name="connection"> connection to the underlying provider </param>
/// <param name="commandTree"> command tree for the statement </param>
/// <returns> an executable command definition object </returns>
/// <exception cref="ArgumentNullException">connection and commandTree arguments must not be null</exception>
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
Check.NotNull(providerManifest, "providerManifest");
Check.NotNull(commandTree, "commandTree");
var storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace);
return CreateCommandDefinition(storeMetadata.StoreProviderFactory, commandTree);
}
private void InitializeProviderServices(string providerManifestToken)
{
using (var connection = CreateConnection())
{
_providerServices = DbProviderServices.GetProviderServices(connection);
_providerManifest = _providerServices.GetProviderManifest(providerManifestToken);
}
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
Debug.Assert(providerManifest != null, "CreateCommandDefinition passed null provider manifest to CreateDbCommandDefinition?");
Debug.Assert(commandTree != null, "CreateCommandDefinition did not validate commandTree argument?");
var prototype = CreateCommand(providerManifest, commandTree);
var result = CreateCommandDefinition(prototype);
return result;
}
protected override DbCommandDefinition CreateDbCommandDefinition(
DbProviderManifest providerManifest, DbCommandTree commandTree)
{
if (commandTree == null)
throw new ArgumentNullException("commandTree");
SqlGenerator generator = null;
if (commandTree is DbQueryCommandTree)
generator = new SelectGenerator();
else if (commandTree is DbInsertCommandTree)
generator = new InsertGenerator();
else if (commandTree is DbUpdateCommandTree)
generator = new UpdateGenerator();
else if (commandTree is DbDeleteCommandTree)
generator = new DeleteGenerator();
else if (commandTree is DbFunctionCommandTree)
generator = new FunctionGenerator();
string sql = generator.GenerateSQL(commandTree);
EFMySqlCommand cmd = new EFMySqlCommand();
cmd.CommandText = sql;
if (generator is FunctionGenerator)
cmd.CommandType = (generator as FunctionGenerator).CommandType;
SetExpectedTypes(commandTree, cmd);
EdmFunction function = null;
if (commandTree is DbFunctionCommandTree)
function = (commandTree as DbFunctionCommandTree).EdmFunction;
// Now make sure we populate the command's parameters from the CQT's parameters:
foreach (KeyValuePair<string, TypeUsage> queryParameter in commandTree.Parameters)
{
DbParameter parameter = cmd.CreateParameter();
parameter.ParameterName = queryParameter.Key;
parameter.Direction = ParameterDirection.Input;
parameter.DbType = Metadata.GetDbType(queryParameter.Value);
FunctionParameter funcParam;
if (function != null &&
function.Parameters.TryGetValue(queryParameter.Key, false, out funcParam))
{
parameter.ParameterName = funcParam.Name;
parameter.Direction = Metadata.ModeToDirection(funcParam.Mode);
parameter.DbType = Metadata.GetDbType(funcParam.TypeUsage);
}
cmd.Parameters.Add(parameter);
}
// Now add parameters added as part of SQL gen
foreach (DbParameter p in generator.Parameters)
cmd.Parameters.Add(p);
return CreateCommandDefinition(cmd);
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
var entityCommandDefinition = EntityCommandDefinition;
if (entityCommandDefinition == null)
{
entityCommandDefinition = new Mock<EntityCommandDefinition>(MockBehavior.Loose, null, null, null).Object;
}
return entityCommandDefinition;
}
private void InitializeProviderServices(string providerManifestToken)
{
Check.NotEmpty(providerManifestToken, "providerManifestToken");
using (var connection = CreateConnection())
{
_providerManifest
= DbProviderServices
.GetProviderServices(connection)
.GetProviderManifest(providerManifestToken);
}
}
// used by EntityStoreSchemaGenerator to start with an empty (primitive types only) StoreItemCollection and
// add types discovered from the database
internal StoreItemCollection(DbProviderFactory factory, DbProviderManifest manifest, string providerManifestToken)
: base(DataSpace.SSpace)
{
Debug.Assert(factory != null, "factory is null");
Debug.Assert(manifest != null, "manifest is null");
_providerFactory = factory;
_providerManifest = manifest;
_providerManifestToken = providerManifestToken;
_cachedCTypeFunction = new Memoizer<EdmFunction, EdmFunction>(ConvertFunctionSignatureToCType, null);
LoadProviderManifest(_providerManifest);
}
internal override DbCommandDefinition CreateDbCommandDefinition(
DbProviderManifest providerManifest,
DbCommandTree commandTree,
DbInterceptionContext interceptionContext)
{
DebugCheck.NotNull(providerManifest);
DebugCheck.NotNull(commandTree);
DebugCheck.NotNull(interceptionContext);
var storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace);
return CreateCommandDefinition(storeMetadata.StoreProviderFactory, commandTree, interceptionContext);
}
public override IEnumerable<MigrationStatement> Generate(IEnumerable<MigrationOperation> migrationOperations, string providerManifestToken)
{
List<MigrationStatement> stmts = new List<MigrationStatement>();
MySqlConnection con = new MySqlConnection();
providerManifest = DbProviderServices.GetProviderServices(con).GetProviderManifest(providerManifestToken);
foreach (MigrationOperation op in migrationOperations)
{
OpDispatcher opdis = dispatcher[op.GetType().Name];
stmts.Add(opdis(op));
}
return stmts;
}
public static DbProviderInfo GetProviderInfo(
this DbConnection connection, out DbProviderManifest providerManifest)
{
Contract.Requires(connection != null);
var providerServices = DbProviderServices.GetProviderServices(connection);
var providerManifestToken = providerServices.GetProviderManifestTokenChecked(connection);
var providerInfo = new DbProviderInfo(connection.GetProviderInvariantName(), providerManifestToken);
providerManifest = providerServices.GetProviderManifest(providerManifestToken);
return providerInfo;
}
// used by EntityStoreSchemaGenerator to start with an empty (primitive types only) StoreItemCollection and
// add types discovered from the database
internal StoreItemCollection(
DbProviderFactory factory, DbProviderManifest manifest, string providerInvariantName, string providerManifestToken)
: base(DataSpace.SSpace)
{
DebugCheck.NotNull(factory);
DebugCheck.NotNull(manifest);
_providerFactory = factory;
_providerManifest = manifest;
_providerInvariantName = providerInvariantName;
_providerManifestToken = providerManifestToken;
_cachedCTypeFunction = new Memoizer<EdmFunction, EdmFunction>(ConvertFunctionSignatureToCType, null);
LoadProviderManifest(_providerManifest);
}
public static DbProviderInfo GetProviderInfo(
this DbConnection connection, out DbProviderManifest providerManifest)
{
DebugCheck.NotNull(connection);
var providerManifestToken = DbConfiguration
.GetService<IManifestTokenService>()
.GetProviderManifestToken(connection);
var providerInfo = new DbProviderInfo(connection.GetProviderInvariantName(), providerManifestToken);
providerManifest = DbProviderServices.GetProviderServices(connection).GetProviderManifest(providerManifestToken);
return providerInfo;
}
/// <summary>
/// Converts a set of migration operations into Microsoft SQL Server specific SQL.
/// </summary>
/// <param name = "migrationOperations">The operations to be converted.</param>
/// <param name = "providerManifestToken">Token representing the version of SQL Server being targeted (i.e. "2005", "2008").</param>
/// <returns>A list of SQL statements to be executed to perform the migration operations.</returns>
public override IEnumerable<MigrationStatement> Generate(
IEnumerable<MigrationOperation> migrationOperations, string providerManifestToken)
{
_statements = new List<MigrationStatement>();
_generatedSchemas = new HashSet<string>();
_variableCounter = 0;
using (var connection = CreateConnection())
{
_providerManifest
= DbProviderServices.GetProviderServices(connection)
.GetProviderManifest(providerManifestToken);
}
migrationOperations.Each<dynamic>(o => Generate(o));
return _statements;
}
/// <summary>
/// Create a Command Definition object given a command tree.
/// </summary>
/// <param name="commandTree"> command tree for the statement </param>
/// <returns> an executable command definition object </returns>
/// <remarks>
/// This method simply delegates to the provider's implementation of CreateDbCommandDefinition.
/// </remarks>
public DbCommandDefinition CreateCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
Contract.Requires(providerManifest != null);
Contract.Requires(commandTree != null);
try
{
return CreateDbCommandDefinition(providerManifest, commandTree);
}
catch (ProviderIncompatibleException)
{
throw;
}
catch (Exception e)
{
if (e.IsCatchableExceptionType())
{
throw new ProviderIncompatibleException(Strings.ProviderDidNotCreateACommandDefinition, e);
}
throw;
}
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
Debug.Assert(providerManifest != null, "providerManifest != null");
Debug.Assert(
providerManifest is LegacyDbProviderManifestWrapper, "providerManifest expected to be LegacyDbProviderManifestWrapper");
Debug.Assert(commandTree != null, "commandTree != null");
Debug.Assert(commandTree is DbQueryCommandTree, "Only query trees are supported");
Debug.Assert(commandTree.DataSpace == DataSpace.SSpace, "SSpace tree expected");
try
{
var legacyMetadata = commandTree.MetadataWorkspace.ToLegacyMetadataWorkspace();
var legacyQuery =
((DbQueryCommandTree)commandTree).Query.Accept(
new LegacyDbExpressionConverter(
(LegacyMetadata.StoreItemCollection)
legacyMetadata.GetItemCollection(LegacyMetadata.DataSpace.SSpace)));
var legacyCommandTree =
(LegacyCommandTrees.DbCommandTree)LegacyDbQueryCommandTreeCtor.Invoke(
new object[]
{
legacyMetadata,
LegacyMetadata.DataSpace.SSpace,
legacyQuery
});
return new LegacyDbCommandDefinitionWrapper(
_wrappedProviderServices.CreateCommandDefinition(
((LegacyDbProviderManifestWrapper)providerManifest).WrappedManifest,
legacyCommandTree));
}
catch (SystemData.ProviderIncompatibleException exception)
{
throw new ProviderIncompatibleException(exception.Message, exception.InnerException);
}
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest manifest, DbCommandTree commandTree)
{
DbCommand prototype = CreateCommand(manifest, commandTree);
DbCommandDefinition result = this.CreateCommandDefinition(prototype);
return result;
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
if (providerManifest == null)
throw new ArgumentNullException("providerManifest");
if (commandTree == null)
throw new ArgumentNullException("commandTree");
List<DbParameter> parameters;
CommandType commandType;
string commandText = SqlGenerator.GenerateSql(commandTree, out parameters, out commandType);
DbCommand command = null;
if (commandType == NuoDbMultipleCommands.MultipleTexts)
command = new NuoDbMultipleCommands(PrepareTypeCoercions(commandTree));
else
command = new NuoDbCommand(PrepareTypeCoercions(commandTree));
command.CommandText = commandText;
command.CommandType = commandType;
// Get the function (if any) implemented by the command tree since this influences our interpretation of parameters
EdmFunction function = null;
if (commandTree is DbFunctionCommandTree)
{
function = ((DbFunctionCommandTree)commandTree).EdmFunction;
}
foreach (KeyValuePair<string, TypeUsage> queryParameter in commandTree.Parameters)
{
NuoDbParameter parameter;
// Use the corresponding function parameter TypeUsage where available (currently, the SSDL facets and
// type trump user-defined facets and type in the EntityCommand).
FunctionParameter functionParameter;
if (null != function && function.Parameters.TryGetValue(queryParameter.Key, false, out functionParameter))
{
parameter = CreateSqlParameter(functionParameter.Name, functionParameter.TypeUsage, functionParameter.Mode, DBNull.Value);
}
else
{
parameter = CreateSqlParameter(queryParameter.Key, queryParameter.Value, ParameterMode.In, DBNull.Value);
}
command.Parameters.Add(parameter);
}
// Now add parameters added as part of SQL gen (note: this feature is only safe for DML SQL gen which
// does not support user parameters, where there is no risk of name collision)
if (null != parameters && 0 < parameters.Count)
{
if (!(commandTree is DbInsertCommandTree) &&
!(commandTree is DbUpdateCommandTree) &&
!(commandTree is DbDeleteCommandTree))
{
throw new InvalidOperationException("SqlGenParametersNotPermitted");
}
foreach (DbParameter parameter in parameters)
{
command.Parameters.Add(parameter);
}
}
return CreateCommandDefinition(command);
}
public override IEnumerable<MigrationStatement> Generate(IEnumerable<MigrationOperation> migrationOperations, string providerManifestToken)
{
MySqlConnection con = new MySqlConnection();
List<MigrationStatement> stmts = new List<MigrationStatement>();
_providerManifestToken = providerManifestToken;
_providerManifest = DbProviderServices.GetProviderServices(con).GetProviderManifest(providerManifestToken);
//verify if there is one or more add/alter column operation, if there is then look for primary key operations. Alter in case that the user wants to change the current PK column
if ((from cols in migrationOperations.OfType<AddColumnOperation>() select cols).Count() > 0 || (from cols in migrationOperations.OfType<AlterColumnOperation>() select cols).Count() > 0)
_pkOperations = (from pks in migrationOperations.OfType<AddPrimaryKeyOperation>() select pks).ToList();
foreach (MigrationOperation op in migrationOperations)
{
if (!_dispatcher.ContainsKey(op.GetType().Name))
throw new NotImplementedException(op.GetType().Name);
OpDispatcher opdis = _dispatcher[op.GetType().Name];
stmts.Add(opdis(op));
}
if (_specialStmts.Count > 0)
{
foreach (var item in _specialStmts)
stmts.Add(item);
}
return stmts;
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
return new Mock<EntityCommandDefinition>(MockBehavior.Loose, null, null).Object;
}
protected override DbCommandDefinition CreateDbCommandDefinition(
DbProviderManifest providerManifest, DbCommandTree commandTree);
/// <summary>Creates command definition from specified manifest and command tree.</summary>
/// <returns>The created command definition.</returns>
/// <param name="providerManifest">The manifest.</param>
/// <param name="commandTree">The command tree.</param>
public DbCommandDefinition CreateCommandDefinition(
DbProviderManifest providerManifest,
DbCommandTree commandTree)
{
Check.NotNull(providerManifest, "providerManifest");
Check.NotNull(commandTree, "commandTree");
try
{
return CreateDbCommandDefinition(providerManifest, commandTree);
}
catch (ProviderIncompatibleException)
{
throw;
}
catch (Exception e)
{
if (e.IsCatchableExceptionType())
{
throw new ProviderIncompatibleException(Strings.ProviderDidNotCreateACommandDefinition, e);
}
throw;
}
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
var command = CreateCommand(providerManifest, commandTree);
return(CreateCommandDefinition(command));
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
return(CreateCommandDefinition(CreateDbCommand(((NpgsqlProviderManifest)providerManifest).Version, commandTree)));
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
throw new NotImplementedException();
}
internal static DbCommand CreateCommand(DbProviderManifest manifest, DbCommandTree commandTree)
{
ArgumentUtility.CheckNotNull("manifest", manifest);
ArgumentUtility.CheckNotNull("commandTree", commandTree);
var vfpManifest = manifest as VfpProviderManifest;
if (vfpManifest == null)
{
throw new ArgumentException("The provider manifest given is not of type 'VfpProviderManifest'.");
}
var command = new VfpCommand();
List <DbParameter> parameters;
CommandType commandType;
command.CommandText = SqlGenerator.GenerateSql(vfpManifest, commandTree, out parameters, out commandType);
command.CommandType = commandType;
//if (command.CommandType == CommandType.Text) {
// command.CommandText += Environment.NewLine + Environment.NewLine;
//}
// Get the function (if any) implemented by the command tree since this influences our interpretation of parameters
EdmFunction function = null;
if (commandTree is DbFunctionCommandTree)
{
function = ((DbFunctionCommandTree)commandTree).EdmFunction;
}
var parameterHelper = new VfpParameterHelper();
// Now make sure we populate the command's parameters from the CQT's parameters:
foreach (var queryParameter in commandTree.Parameters)
{
VfpClient.VfpParameter parameter;
// Use the corresponding function parameter TypeUsage where available (currently, the SSDL facets and
// type trump user-defined facets and type in the EntityCommand).
FunctionParameter functionParameter;
if (null != function && function.Parameters.TryGetValue(queryParameter.Key, false, out functionParameter))
{
parameter = parameterHelper.CreateVfpParameter(functionParameter.Name, functionParameter.TypeUsage, functionParameter.Mode, DBNull.Value);
}
else
{
parameter = parameterHelper.CreateVfpParameter(queryParameter.Key, queryParameter.Value, ParameterMode.In, DBNull.Value);
}
command.Parameters.Add(parameter);
}
foreach (var parameter in parameters)
{
command.Parameters.Add(parameter);
}
return(command);
}
public void Configure(
DbDatabaseMapping databaseMapping,
ICollection <EntitySet> entitySets,
DbProviderManifest providerManifest,
EntityType entityType,
ref EntityTypeMapping entityTypeMapping,
bool isMappingAnyInheritedProperty,
int configurationIndex,
int configurationCount,
IDictionary <string, object> commonAnnotations)
{
EntityType baseType = (EntityType)entityType.BaseType;
bool flag = baseType == null && configurationIndex == 0;
MappingFragment typeMappingFragment1 = this.FindOrCreateTypeMappingFragment(databaseMapping, ref entityTypeMapping, configurationIndex, entityType, providerManifest);
EntityType table = typeMappingFragment1.Table;
bool isTableSharing;
EntityType createTargetTable = this.FindOrCreateTargetTable(databaseMapping, typeMappingFragment1, entityType, table, out isTableSharing);
bool isSharingTableWithBase = this.DiscoverIsSharingWithBase(databaseMapping, entityType, createTargetTable);
HashSet <EdmPropertyPath> contain = this.DiscoverAllMappingsToContain(databaseMapping, entityType, createTargetTable, isSharingTableWithBase);
List <ColumnMappingBuilder> list = typeMappingFragment1.ColumnMappings.ToList <ColumnMappingBuilder>();
foreach (EdmPropertyPath edmPropertyPath in contain)
{
EdmPropertyPath propertyPath = edmPropertyPath;
ColumnMappingBuilder columnMappingBuilder = typeMappingFragment1.ColumnMappings.SingleOrDefault <ColumnMappingBuilder>((Func <ColumnMappingBuilder, bool>)(pm => pm.PropertyPath.SequenceEqual <EdmProperty>((IEnumerable <EdmProperty>)propertyPath)));
if (columnMappingBuilder == null)
{
throw Error.EntityMappingConfiguration_DuplicateMappedProperty((object)entityType.Name, (object)propertyPath.ToString());
}
list.Remove(columnMappingBuilder);
}
if (!flag)
{
bool isSplitting;
EntityType parentTable = EntityMappingConfiguration.FindParentTable(databaseMapping, table, entityTypeMapping, createTargetTable, isMappingAnyInheritedProperty, configurationIndex, configurationCount, out isSplitting);
if (parentTable != null)
{
DatabaseOperations.AddTypeConstraint(databaseMapping.Database, entityType, parentTable, createTargetTable, isSplitting);
}
}
if (table != createTargetTable)
{
if (this.Properties == null)
{
AssociationMappingOperations.MoveAllDeclaredAssociationSetMappings(databaseMapping, entityType, table, createTargetTable, !isTableSharing);
ForeignKeyPrimitiveOperations.MoveAllDeclaredForeignKeyConstraintsForPrimaryKeyColumns(entityType, table, createTargetTable);
}
if (isMappingAnyInheritedProperty)
{
IEnumerable <EntityType> baseTables = databaseMapping.GetEntityTypeMappings(baseType).SelectMany <EntityTypeMapping, MappingFragment>((Func <EntityTypeMapping, IEnumerable <MappingFragment> >)(etm => (IEnumerable <MappingFragment>)etm.MappingFragments)).Select <MappingFragment, EntityType>((Func <MappingFragment, EntityType>)(mf => mf.Table));
AssociationSetMapping associationSetMapping = databaseMapping.EntityContainerMappings.SelectMany <EntityContainerMapping, AssociationSetMapping>((Func <EntityContainerMapping, IEnumerable <AssociationSetMapping> >)(asm => asm.AssociationSetMappings)).FirstOrDefault <AssociationSetMapping>((Func <AssociationSetMapping, bool>)(a =>
{
if (!baseTables.Contains <EntityType>(a.Table))
{
return(false);
}
if (baseType != a.AssociationSet.ElementType.SourceEnd.GetEntityType())
{
return(baseType == a.AssociationSet.ElementType.TargetEnd.GetEntityType());
}
return(true);
}));
if (associationSetMapping != null)
{
AssociationType elementType = associationSetMapping.AssociationSet.ElementType;
throw Error.EntityMappingConfiguration_TPCWithIAsOnNonLeafType((object)elementType.Name, (object)elementType.SourceEnd.GetEntityType().Name, (object)elementType.TargetEnd.GetEntityType().Name);
}
ForeignKeyPrimitiveOperations.CopyAllForeignKeyConstraintsForPrimaryKeyColumns(databaseMapping.Database, table, createTargetTable);
}
}
if (list.Any <ColumnMappingBuilder>())
{
EntityType extraTable = (EntityType)null;
if (configurationIndex < configurationCount - 1)
{
ColumnMappingBuilder pm = list.First <ColumnMappingBuilder>();
extraTable = EntityMappingConfiguration.FindTableForTemporaryExtraPropertyMapping(databaseMapping, entityType, table, createTargetTable, pm);
MappingFragment typeMappingFragment2 = EntityMappingOperations.CreateTypeMappingFragment(entityTypeMapping, typeMappingFragment1, databaseMapping.Database.GetEntitySet(extraTable));
bool requiresUpdate = extraTable != table;
foreach (ColumnMappingBuilder propertyMappingBuilder in list)
{
EntityMappingOperations.MovePropertyMapping(databaseMapping, (IEnumerable <EntitySet>)entitySets, typeMappingFragment1, typeMappingFragment2, propertyMappingBuilder, requiresUpdate, true);
}
}
else
{
EntityType unmappedTable = (EntityType)null;
foreach (ColumnMappingBuilder columnMappingBuilder in list)
{
extraTable = EntityMappingConfiguration.FindTableForExtraPropertyMapping(databaseMapping, entityType, table, createTargetTable, ref unmappedTable, columnMappingBuilder);
MappingFragment mappingFragment = entityTypeMapping.MappingFragments.SingleOrDefault <MappingFragment>((Func <MappingFragment, bool>)(tmf => tmf.Table == extraTable));
if (mappingFragment == null)
{
mappingFragment = EntityMappingOperations.CreateTypeMappingFragment(entityTypeMapping, typeMappingFragment1, databaseMapping.Database.GetEntitySet(extraTable));
mappingFragment.SetIsUnmappedPropertiesFragment(true);
}
if (extraTable == table)
{
EntityMappingConfiguration.CopyDefaultDiscriminator(typeMappingFragment1, mappingFragment);
}
bool requiresUpdate = extraTable != table;
EntityMappingOperations.MovePropertyMapping(databaseMapping, (IEnumerable <EntitySet>)entitySets, typeMappingFragment1, mappingFragment, columnMappingBuilder, requiresUpdate, true);
}
}
}
EntityMappingOperations.UpdatePropertyMappings(databaseMapping, (IEnumerable <EntitySet>)entitySets, table, typeMappingFragment1, !isTableSharing);
this.ConfigureDefaultDiscriminator(entityType, typeMappingFragment1);
this.ConfigureConditions(databaseMapping, entityType, typeMappingFragment1, providerManifest);
EntityMappingOperations.UpdateConditions(databaseMapping.Database, table, typeMappingFragment1);
ForeignKeyPrimitiveOperations.UpdatePrincipalTables(databaseMapping, entityType, table, createTargetTable, isMappingAnyInheritedProperty);
EntityMappingConfiguration.CleanupUnmappedArtifacts(databaseMapping, table);
EntityMappingConfiguration.CleanupUnmappedArtifacts(databaseMapping, createTargetTable);
EntityMappingConfiguration.ConfigureAnnotations((EdmType)createTargetTable, commonAnnotations);
EntityMappingConfiguration.ConfigureAnnotations((EdmType)createTargetTable, this._annotations);
createTargetTable.SetConfiguration((object)this);
}
protected virtual void Visit(DbProviderManifest providerManifest)
{
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
return(new GlimpseDbCommandDefinition(InnerProviderServices.CreateCommandDefinition(commandTree)));
}
/** <inheritDoc /> */
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest,
DbCommandTree commandTree)
{
return(new DbCommandDefinitionProxy(_services.CreateCommandDefinition(providerManifest, commandTree),
new DbCommandInfo(commandTree, _cache, _policy, _txHandler)));
}
//protected override bool ShouldValidateEntity(DbEntityEntry entityEntry)
//{
// return base.ShouldValidateEntity(entityEntry);
//}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
//modelBuilder.Entity<BlogPost>().ToTable("tbl_blog_post");
var typesToRegister = Assembly.GetExecutingAssembly().GetTypes()
.Where(type => !String.IsNullOrEmpty(type.Namespace))
.Where(type => type.BaseType != null && type.BaseType.IsGenericType &&
type.BaseType.GetGenericTypeDefinition() == typeof(EntityTypeConfiguration <>));
foreach (var type in typesToRegister)
{
dynamic configInstance = Activator.CreateInstance(type);
modelBuilder.Configurations.Add(configInstance);
}
//modelBuilder.ComplexType<BillingAddress>()
// .Property(p => p.CreditCardNumber)
// .HasColumnName("CardNumber");
//modelBuilder.ComplexType<Address>()
// .Property(p => p.StreetAddress)
// .HasColumnName("StreetAddress");
//var count = this.Database.SqlQuery<int>("SELECT COUNT(*) FROM Customers");
//These are all to find out the EF objects
ConfigurationRegistrar registrar = modelBuilder.Configurations;
ConventionsConfiguration conventions = modelBuilder.Conventions;
DbModel dbModel = modelBuilder.Build(this.Database.Connection);
EdmModel edmModel = dbModel.ConceptualModel;
EntityContainerMapping containerMapping = dbModel.ConceptualToStoreMapping;
DbProviderInfo dbProviderInfo = dbModel.ProviderInfo;
DbProviderManifest dbProviderManifest = dbModel.ProviderManifest;
EdmModel dbModelStoreModel = dbModel.StoreModel;
DbCompiledModel dbCompiledModel = dbModel.Compile();
PropertyConventionConfiguration propertyConvention = modelBuilder.Properties();
TypeConventionConfiguration typeConvention = modelBuilder.Types();
//modelBuilder.RegisterEntityType();
//registrar.AddFromAssembly()
//conventions.AddFromAssembly();
//propertyConvention
// .Where(info => info.GetType() is typeof(string))
// .Configure(cfg => cfg.HasMaxLength(200));
//typeConvention.Configure(cfg => cfg.MapToStoredProcedures());
//All Configurations
//System.Data.Entity.ModelConfiguration.Configuration
//All Conventions
//System.Data.Entity.ModelConfiguration.Conventions
//modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();
base.OnModelCreating(modelBuilder);
}
private static void ConfigureDependentKeys(DbDatabaseMapping databaseMapping, DbProviderManifest providerManifest)
{
DebugCheck.NotNull(databaseMapping);
DebugCheck.NotNull(providerManifest);
// PERF: this code written this way since it's part of a hotpath, consider its performance when refactoring. See codeplex #2298.
var entityTypesList = databaseMapping.Database.EntityTypes as IList <EntityType> ?? databaseMapping.Database.EntityTypes.ToList();
// ReSharper disable ForCanBeConvertedToForeach
for (var entityTypesListIterator = 0;
entityTypesListIterator < entityTypesList.Count;
++entityTypesListIterator)
{
var entityType = entityTypesList[entityTypesListIterator];
var foreignKeyBuilders = entityType.ForeignKeyBuilders as IList <ForeignKeyBuilder> ?? entityType.ForeignKeyBuilders.ToList();
for (var foreignKeyBuildersIterator = 0;
foreignKeyBuildersIterator < foreignKeyBuilders.Count;
++foreignKeyBuildersIterator)
{
var foreignKeyConstraint = foreignKeyBuilders[foreignKeyBuildersIterator];
var dependentColumns = foreignKeyConstraint.DependentColumns;
var dependentColumnsList = dependentColumns as IList <EdmProperty> ?? dependentColumns.ToList();
for (var i = 0; i < dependentColumnsList.Count; ++i)
{
var c = dependentColumnsList[i];
var primitivePropertyConfiguration =
c.GetConfiguration() as PrimitivePropertyConfiguration;
if ((primitivePropertyConfiguration != null) &&
(primitivePropertyConfiguration.ColumnType != null))
{
continue;
}
var principalColumn = foreignKeyConstraint.PrincipalTable.KeyProperties.ElementAt(i);
c.PrimitiveType = providerManifest.GetStoreTypeFromName(principalColumn.TypeName);
c.CopyFrom(principalColumn);
}
}
}
// ReSharper restore ForCanBeConvertedToForeach
}
private static void ConfigureDependentKeys(DbDatabaseMapping databaseMapping, DbProviderManifest providerManifest)
{
DebugCheck.NotNull(databaseMapping);
DebugCheck.NotNull(providerManifest);
foreach (var foreignKeyConstraint in databaseMapping.Database.EntityTypes.SelectMany(t => t.ForeignKeyBuilders))
{
foreignKeyConstraint
.DependentColumns
.Each(
(c, i) =>
{
var primitivePropertyConfiguration =
c.GetConfiguration() as PrimitivePropertyConfiguration;
if ((primitivePropertyConfiguration != null) &&
(primitivePropertyConfiguration.ColumnType != null))
{
return;
}
var principalColumn = foreignKeyConstraint.PrincipalTable.KeyProperties.ElementAt(i);
c.PrimitiveType = providerManifest.GetStoreTypeFromName(principalColumn.TypeName);
c.CopyFrom(principalColumn);
});
}
}
/// <summary>
/// Initializes a new instance of the DbProviderManifestWrapper class.
/// </summary>
/// <param name="wrapperProviderInvariantName">Wrapper provider invariant name.</param>
/// <param name="providerInvariantName">Provider invariant name.</param>
/// <param name="wrappedProviderManifest">The wrapped provider manifest.</param>
public DbProviderManifestWrapper(string wrapperProviderInvariantName, string providerInvariantName, DbProviderManifest wrappedProviderManifest)
{
this.wrapperProviderInvariantName = wrapperProviderInvariantName;
this.providerInvariantName = providerInvariantName;
this.wrappedProviderManifest = wrappedProviderManifest;
}
/// <summary>
/// Creates the provider manifest wrapper.
/// </summary>
/// <param name="providerInvariantName">Provider invariant name.</param>
/// <param name="providerManifest">The provider manifest to be wrapped.</param>
/// <returns><see cref="DbProviderManifest"/> wrapper for given provider invariant name wrapping given provider manifest.</returns>
public virtual DbProviderManifest CreateProviderManifest(string providerInvariantName, DbProviderManifest providerManifest)
{
return(new DbProviderManifestWrapper(
this.ProviderInvariantName,
providerInvariantName,
providerManifest));
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
return new GlimpseDbCommandDefinition(InnerProviderServices.CreateCommandDefinition(commandTree));
}
protected override void Visit(DbProviderManifest providerManifest)
{
// the provider manifest will be checked by all the other types lining up.
// no need to store more info.
}
/// <summary>Creates a command definition object for the specified provider manifest and command tree.</summary>
/// <returns>An executable command definition object.</returns>
/// <param name="providerManifest">Provider manifest previously retrieved from the store provider.</param>
/// <param name="commandTree">Command tree for the statement.</param>
protected abstract DbCommandDefinition CreateDbCommandDefinition(
DbProviderManifest providerManifest,
DbCommandTree commandTree);
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
return(new WrappingCommandDefinition <TAdoNetBase>(_baseServices.CreateCommandDefinition(providerManifest, commandTree)));
}
public override string GenerateProcedureBody(ICollection<DbModificationCommandTree> commandTrees, string rowsAffectedParameter, string providerManifestToken)
{
MySqlConnection con = new MySqlConnection();
MigrationStatement stmt = new MigrationStatement();
_providerManifest = DbProviderServices.GetProviderServices(con).GetProviderManifest(providerManifestToken);
var cmdStr = "";
SqlGenerator generator = new SelectGenerator();
foreach (var commandTree in commandTrees)
{
switch (commandTree.CommandTreeKind)
{
case DbCommandTreeKind.Insert:
generator = new InsertGenerator();
cmdStr = generator.GenerateSQL(commandTree);
break;
case DbCommandTreeKind.Delete:
generator = new DeleteGenerator();
cmdStr = generator.GenerateSQL(commandTree);
break;
case DbCommandTreeKind.Update:
generator = new UpdateGenerator();
cmdStr = generator.GenerateSQL(commandTree);
break;
case DbCommandTreeKind.Query:
generator = new SelectGenerator();
cmdStr = generator.GenerateSQL(commandTree);
break;
case DbCommandTreeKind.Function:
generator = new FunctionGenerator();
cmdStr = generator.GenerateSQL(commandTree);
break;
}
stmt.Sql += cmdStr.Replace("dbo.", "") + ";";
}
return stmt.Sql;
}
private DbCommand CreateCommand(DbProviderManifest manifest, DbCommandTree commandTree)
{
if (manifest == null)
{
throw new ArgumentNullException("manifest");
}
if (commandTree == null)
{
throw new ArgumentNullException("commandTree");
}
var expectedTypes = PrepareTypeCoercions(commandTree);
FbCommand command = FbCommand.CreateWithTypeCoercions(expectedTypes);
List <DbParameter> parameters;
CommandType commandType;
command.CommandText = SqlGenerator.GenerateSql(commandTree, out parameters, out commandType);
command.CommandType = commandType;
// Get the function (if any) implemented by the command tree since this influences our interpretation of parameters
EdmFunction function = null;
if (commandTree is DbFunctionCommandTree)
{
function = ((DbFunctionCommandTree)commandTree).EdmFunction;
}
// Now make sure we populate the command's parameters from the CQT's parameters:
foreach (KeyValuePair <string, TypeUsage> queryParameter in commandTree.Parameters)
{
FbParameter parameter;
// Use the corresponding function parameter TypeUsage where available (currently, the SSDL facets and
// type trump user-defined facets and type in the EntityCommand).
FunctionParameter functionParameter;
if (null != function && function.Parameters.TryGetValue(queryParameter.Key, false, out functionParameter))
{
parameter = CreateSqlParameter(functionParameter.Name, functionParameter.TypeUsage, functionParameter.Mode, DBNull.Value);
}
else
{
parameter = CreateSqlParameter(queryParameter.Key, queryParameter.Value, ParameterMode.In, DBNull.Value);
}
command.Parameters.Add(parameter);
}
// Now add parameters added as part of SQL gen (note: this feature is only safe for DML SQL gen which
// does not support user parameters, where there is no risk of name collision)
if (null != parameters && 0 < parameters.Count)
{
if (!(commandTree is DbInsertCommandTree) &&
!(commandTree is DbUpdateCommandTree) &&
!(commandTree is DbDeleteCommandTree))
{
throw new InvalidOperationException("SqlGenParametersNotPermitted");
}
foreach (DbParameter parameter in parameters)
{
command.Parameters.Add(parameter);
}
}
return(command);
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
return CreateCommandDefinition(CreateDbCommand(commandTree));
}
protected override DbCommandDefinition CreateDbCommandDefinition(
DbProviderManifest providerManifest, DbCommandTree commandTree)
{
if (commandTree == null)
{
throw new ArgumentNullException("commandTree");
}
SqlGenerator generator = null;
if (commandTree is DbQueryCommandTree)
{
generator = new SelectGenerator();
}
else if (commandTree is DbInsertCommandTree)
{
generator = new InsertGenerator();
}
else if (commandTree is DbUpdateCommandTree)
{
generator = new UpdateGenerator();
}
else if (commandTree is DbDeleteCommandTree)
{
generator = new DeleteGenerator();
}
else if (commandTree is DbFunctionCommandTree)
{
generator = new FunctionGenerator();
}
string sql = generator.GenerateSQL(commandTree);
EFMySqlCommand cmd = new EFMySqlCommand();
cmd.CommandText = sql;
if (generator is FunctionGenerator)
{
cmd.CommandType = (generator as FunctionGenerator).CommandType;
}
SetExpectedTypes(commandTree, cmd);
EdmFunction function = null;
if (commandTree is DbFunctionCommandTree)
{
function = (commandTree as DbFunctionCommandTree).EdmFunction;
}
// Now make sure we populate the command's parameters from the CQT's parameters:
foreach (KeyValuePair <string, TypeUsage> queryParameter in commandTree.Parameters)
{
DbParameter parameter = cmd.CreateParameter();
parameter.ParameterName = queryParameter.Key;
parameter.Direction = ParameterDirection.Input;
parameter.DbType = Metadata.GetDbType(queryParameter.Value);
#if NET_45_OR_GREATER
if (queryParameter.Value.EdmType is PrimitiveType &&
((PrimitiveType)queryParameter.Value.EdmType).PrimitiveTypeKind == PrimitiveTypeKind.Geometry)
{
((MySqlParameter)parameter).MySqlDbType = MySqlDbType.Geometry;
}
#endif
FunctionParameter funcParam;
if (function != null &&
function.Parameters.TryGetValue(queryParameter.Key, false, out funcParam))
{
parameter.ParameterName = funcParam.Name;
parameter.Direction = Metadata.ModeToDirection(funcParam.Mode);
parameter.DbType = Metadata.GetDbType(funcParam.TypeUsage);
}
cmd.Parameters.Add(parameter);
}
// Now add parameters added as part of SQL gen
foreach (DbParameter p in generator.Parameters)
{
cmd.Parameters.Add(p);
}
return(CreateCommandDefinition(cmd));
}
private DbCommand CreateCommand(DbProviderManifest manifest, DbCommandTree commandTree)
{
if (manifest == null)
throw new ArgumentNullException("manifest");
if (commandTree == null)
throw new ArgumentNullException("commandTree");
SQLiteCommand command = new SQLiteCommand();
try
{
List<DbParameter> parameters;
CommandType commandType;
command.CommandText = SqlGenerator.GenerateSql((SQLiteProviderManifest)manifest, commandTree, out parameters, out commandType);
command.CommandType = commandType;
// Get the function (if any) implemented by the command tree since this influences our interpretation of parameters
EdmFunction function = null;
if (commandTree is DbFunctionCommandTree)
{
function = ((DbFunctionCommandTree)commandTree).EdmFunction;
}
// Now make sure we populate the command's parameters from the CQT's parameters:
foreach (KeyValuePair<string, TypeUsage> queryParameter in commandTree.Parameters)
{
SQLiteParameter parameter;
// Use the corresponding function parameter TypeUsage where available (currently, the SSDL facets and
// type trump user-defined facets and type in the EntityCommand).
FunctionParameter functionParameter;
if (null != function && function.Parameters.TryGetValue(queryParameter.Key, false, out functionParameter))
{
parameter = CreateSqlParameter(functionParameter.Name, functionParameter.TypeUsage, functionParameter.Mode, DBNull.Value);
}
else
{
parameter = CreateSqlParameter(queryParameter.Key, queryParameter.Value, ParameterMode.In, DBNull.Value);
}
command.Parameters.Add(parameter);
}
// Now add parameters added as part of SQL gen (note: this feature is only safe for DML SQL gen which
// does not support user parameters, where there is no risk of name collision)
if (null != parameters && 0 < parameters.Count)
{
if (!(commandTree is DbInsertCommandTree) &&
!(commandTree is DbUpdateCommandTree) &&
!(commandTree is DbDeleteCommandTree))
{
throw new InvalidOperationException("SqlGenParametersNotPermitted");
}
foreach (DbParameter parameter in parameters)
{
command.Parameters.Add(parameter);
}
}
return command;
}
catch
{
command.Dispose();
throw;
}
}
public AssociationTypeMappingGenerator(DbProviderManifest providerManifest)
: base(providerManifest)
{
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
return CreateCommandDefinition(CreateDbCommand(((NpgsqlProviderManifest)providerManifest).Version, commandTree));
}
protected override void ConfigureColumn(EdmProperty column, EntityType table, DbProviderManifest providerManifest)
{
if (IsRowVersion != null &&
IsRowVersion.Value)
{
ColumnType = ColumnType ?? "rowversion";
}
base.ConfigureColumn(column, table, providerManifest);
if (IsRowVersion != null &&
IsRowVersion.Value)
{
column.MaxLength = null;
}
}
private DbCommand CreateCommand(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
// DEVNOTE/CAUTION: This method could be called either from Remote or Local Provider.
// Ensure that the code works well with the both provider types.
// The methods called from the below code also need to be capable
// of handling both provider types.
//
// NOTE: Remote Provider is loaded at runtime, if available.
// This is done to remove hard dependency on Remote Provider and
// it might not be present in all scenarios. All Remote Provider
// type checks need to be done using RemoteProviderHelper class.
//
Check.NotNull(providerManifest, "providerManifest");
Check.NotNull(commandTree, "commandTree");
if (commandTree is DbFunctionCommandTree)
{
throw ADP1.NotSupported(EntityRes.GetString(EntityRes.StoredProceduresNotSupported));
}
var command = _isLocalProvider
? new SqlCeMultiCommand()
: (DbCommand)RemoteProviderHelper.CreateRemoteProviderType(RemoteProvider.SqlCeCommand);
command.Connection = null; // don't hold on to the connection when we're going to cache this forever;
List <DbParameter> parameters;
CommandType commandType;
var commandTexts = SqlGenerator.GenerateSql(commandTree, out parameters, out commandType, _isLocalProvider);
if (_isLocalProvider)
{
Debug.Assert(command is SqlCeMultiCommand, "SqlCeMultiCommand expected");
// Set the multiple command texts for the command object
((SqlCeMultiCommand)command).CommandTexts = commandTexts;
}
else
{
// Set the command text for the RDP case.
Debug.Assert(commandTexts.Length == 1, "BatchQueries are not supported in designer scenarios");
command.CommandText = commandTexts[0];
}
command.CommandType = commandType;
// Now make sure we populate the command's parameters from the CQT's parameters:
//
foreach (var queryParameter in commandTree.Parameters)
{
DbParameter parameter;
const bool ignoreMaxLengthFacet = false;
parameter = CreateSqlCeParameter(
queryParameter.Key, queryParameter.Value, DBNull.Value, ignoreMaxLengthFacet, _isLocalProvider);
command.Parameters.Add(parameter);
}
// Now add parameters added as part of SQL gen (note: this feature is only safe for DML SQL gen which
// does not support user parameters, where there is no risk of name collision)
//
if (null != parameters &&
0 < parameters.Count)
{
if (!(commandTree is DbDeleteCommandTree ||
commandTree is DbInsertCommandTree ||
commandTree is DbUpdateCommandTree))
{
throw ADP1.InternalError(ADP1.InternalErrorCode.SqlGenParametersNotPermitted);
}
foreach (var parameter in parameters)
{
command.Parameters.Add(parameter);
}
}
return(command);
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
return(new CmdDefinition(_inner.CreateCommandDefinition(providerManifest, commandTree)));
}
