public void AppendComparison_creates_parameters_and_adds_AND_for_multiple_comparisons() { var parameters = new EntityCommand().Parameters; var filterBuilder = EntityStoreSchemaQueryGenerator.AppendComparison( new StringBuilder(), "alias1", "propertyName1", "Value1", parameters); EntityStoreSchemaQueryGenerator.AppendComparison( filterBuilder, "alias2", "propertyName2", "Value2", parameters); Assert.Equal( "alias1.propertyName1 LIKE @p0 AND alias2.propertyName2 LIKE @p1", filterBuilder.ToString()); Assert.Equal(2, parameters.Count); Assert.Equal("p0,p1", string.Join(",", parameters.OfType<EntityParameter>().Select(p => p.ParameterName))); Assert.Equal("Value1,Value2", string.Join(",", parameters.OfType<EntityParameter>().Select(p => p.Value))); }
/// <summary> /// The constructor for the data reader, each EntityDataReader must always be associated with a EntityCommand and an underlying /// DbDataReader. It is expected that EntityDataReader only has a reference to EntityCommand and doesn't assume responsibility /// of cleaning the command object, but it does assume responsibility of cleaning up the store data reader object. /// </summary> internal EntityDataReader(EntityCommand command, DbDataReader storeDataReader, CommandBehavior behavior) { Debug.Assert(command != null && storeDataReader != null); _command = command; _storeDataReader = storeDataReader; _storeExtendedDataRecord = storeDataReader as IExtendedDataRecord; _behavior = behavior; }
/// <summary> /// The constructor for the data reader, each EntityDataReader must always be associated with a EntityCommand and an underlying /// DbDataReader. It is expected that EntityDataReader only has a reference to EntityCommand and doesn't assume responsibility /// of cleaning the command object, but it does assume responsibility of cleaning up the store data reader object. /// </summary> internal EntityDataReader(EntityCommand command, DbDataReader storeDataReader, CommandBehavior behavior) { DebugCheck.NotNull(command); DebugCheck.NotNull(storeDataReader); _command = command; _storeDataReader = storeDataReader; _storeExtendedDataRecord = storeDataReader as IExtendedDataRecord; _behavior = behavior; }
public FunctionDetailsReader(EntityCommand command, Version storeSchemaModelVersion) { Debug.Assert(command != null, "command != null"); Debug.Assert(storeSchemaModelVersion != null, "storeSchemaModelVersion != null"); _rowViewFactoryMethod = storeSchemaModelVersion < EntityFrameworkVersion.Version3 ? (values) => new FunctionDetailsV1RowView(values) : (Func<object[], FunctionDetailsRowView>)((values) => new FunctionDetailsV3RowView(values)); _command = command; _reader = _command.ExecuteReader(CommandBehavior.SequentialAccess); }
public void AppendFilterEntry_creates_filter_for_catalog_schema_and_name_if_all_specified() { var parameters = new EntityCommand().Parameters; Assert.Equal( "(alias.CatalogName LIKE @p0 AND alias.SchemaName LIKE @p1 AND alias.Name LIKE @p2)", EntityStoreSchemaQueryGenerator.AppendFilterEntry( new StringBuilder(), "alias", new EntityStoreSchemaFilterEntry("catalog", "schema", "name"), parameters).ToString()); Assert.Equal(3, parameters.Count); }
public void AppendComparison_creates_comparison_fragment_and_corresponding_parameter_for_non_null_value() { var parameters = new EntityCommand().Parameters; Assert.Equal( "alias.propertyName LIKE @p0", EntityStoreSchemaQueryGenerator.AppendComparison( new StringBuilder(), "alias", "propertyName", "Value", parameters).ToString()); Assert.Equal(1, parameters.Count); Assert.Equal("p0", parameters[0].ParameterName); Assert.Equal("Value", parameters[0].Value); }
/// <summary> /// Creates a new instance of EntityClientCacheKey given a entityCommand instance /// </summary> /// <param name="entityCommand"></param> internal EntityClientCacheKey(EntityCommand entityCommand) { // Command Type _commandType = entityCommand.CommandType; // Statement _eSqlStatement = entityCommand.CommandText; // Parameters _parametersToken = GetParametersToken(entityCommand); _parameterCount = entityCommand.Parameters.Count; // Hashcode _hashCode = _commandType.GetHashCode() ^ _eSqlStatement.GetHashCode() ^ _parametersToken.GetHashCode(); }
/// <summary> /// Given an entity command, store provider command and a connection, sets all output parameter values on the entity command. /// The connection is used to determine how to map spatial values. /// </summary> /// <param name="entityCommand"> Entity command on which to set parameter values. Must not be null. </param> /// <param name="storeProviderCommand"> Store provider command from which to retrieve parameter values. Must not be null. </param> /// <param name="connection"> The connection on which the command was run. Must not be null </param> internal static void SetEntityParameterValues( EntityCommand entityCommand, DbCommand storeProviderCommand, EntityConnection connection) { DebugCheck.NotNull(entityCommand); DebugCheck.NotNull(storeProviderCommand); DebugCheck.NotNull(connection); foreach (DbParameter storeParameter in storeProviderCommand.Parameters) { var direction = storeParameter.Direction; if (0 != (direction & ParameterDirection.Output)) { // if the entity command also defines the parameter, propagate store parameter value // to entity parameter var parameterOrdinal = entityCommand.Parameters.IndexOf(storeParameter.ParameterName); if (0 <= parameterOrdinal) { var entityParameter = entityCommand.Parameters[parameterOrdinal]; var parameterValue = storeParameter.Value; var parameterType = entityParameter.GetTypeUsage(); if (Helper.IsSpatialType(parameterType)) { parameterValue = GetSpatialValueFromProviderValue( parameterValue, (PrimitiveType)parameterType.EdmType, connection); } entityParameter.Value = parameterValue; } } } }
internal virtual EntityDataReader CreateEntityDataReader( EntityCommand entityCommand, DbDataReader storeDataReader, CommandBehavior behavior) { return new EntityDataReader(entityCommand, storeDataReader, behavior); }
internal virtual void InvokeOnDataReaderClosingEvent(EntityCommand sender, EventArgs e) { OnDataReaderClosing(sender, e); }
public void AppendFilterEntry_uses_OR_to_connect_multiple_filters() { var parameters = new EntityCommand().Parameters; var filterBuilder = new StringBuilder(); EntityStoreSchemaQueryGenerator.AppendFilterEntry( filterBuilder, "alias", new EntityStoreSchemaFilterEntry(null, null, null), parameters); EntityStoreSchemaQueryGenerator.AppendFilterEntry( filterBuilder, "alias", new EntityStoreSchemaFilterEntry("catalog", "schema", null), parameters); Assert.Equal( "(alias.Name LIKE @p0) OR (alias.CatalogName LIKE @p1 AND alias.SchemaName LIKE @p2)", filterBuilder.ToString()); Assert.Equal(3, parameters.Count); Assert.Equal("p0,p1,p2", string.Join(",", parameters.OfType<EntityParameter>().Select(p => p.ParameterName))); Assert.Equal("%,catalog,schema", string.Join(",", parameters.OfType<EntityParameter>().Select(p => p.Value))); }
/// <summary> /// Returns a string representation of the parameter list /// </summary> /// <param name="entityCommand"></param> /// <returns></returns> private static string GetParametersToken(EntityCommand entityCommand) { if (null == entityCommand.Parameters || 0 == entityCommand.Parameters.Count) { // // means no parameters // return "@@0"; } // Ensure that parameter DbTypes are valid and there are no duplicate names var paramTypeUsage = entityCommand.GetParameterTypeUsage(); Debug.Assert( paramTypeUsage.Count == entityCommand.Parameters.Count, "entityParameter collection and query parameter collection must have the same number of entries"); if (1 == paramTypeUsage.Count) { // if its one parameter only, there is no need to use stringbuilder return "@@1:" + entityCommand.Parameters[0].ParameterName + ":" + GetTypeUsageToken(paramTypeUsage[entityCommand.Parameters[0].ParameterName]); } else { var sb = new StringBuilder(entityCommand.Parameters.Count * EstimatedParameterStringSize); Debug.Assert( paramTypeUsage.Count == entityCommand.Parameters.Count, "entityParameter collection and query parameter collection must have the same number of entries"); sb.Append("@@"); sb.Append(entityCommand.Parameters.Count); sb.Append(":"); var separator = ""; foreach (var param in paramTypeUsage) { sb.Append(separator); sb.Append(param.Key); sb.Append(":"); sb.Append(GetTypeUsageToken(param.Value)); separator = ";"; } return sb.ToString(); } }
public void GenerateQuery_filters_out_inapplicable_filters() { var parameters = new EntityCommand().Parameters; Assert.Equal( "baseQuery", new EntityStoreSchemaQueryGenerator( "baseQuery", string.Empty, EntityStoreSchemaFilterObjectTypes.Table, new[] { new EntityStoreSchemaFilterEntry( null, null, "name", EntityStoreSchemaFilterObjectTypes.Function, EntityStoreSchemaFilterEffect.Exclude), }, new string[0]) .GenerateQuery(parameters)); Assert.Equal(0, parameters.Count); }
public void GenerateQuery_returns_base_query_if_no_orderby_clause_and_no_applicable_filters() { var parameters = new EntityCommand().Parameters; Assert.Equal( "baseQuery", new EntityStoreSchemaQueryGenerator( "baseQuery", string.Empty, EntityStoreSchemaFilterObjectTypes.Table, new EntityStoreSchemaFilterEntry[0], new string[0]) .GenerateQuery(parameters)); Assert.Equal(0, parameters.Count); }
public void Where_clause_created_when_Allow_and_Exclude_present() { var parameters = new EntityCommand().Parameters; Assert.Equal( "NOT ((alias.Name LIKE @p0) OR (alias.Name LIKE @p1))", new EntityStoreSchemaQueryGenerator( string.Empty, string.Empty, EntityStoreSchemaFilterObjectTypes.Table, new[] { new EntityStoreSchemaFilterEntry( null, null, "nameAllowed", EntityStoreSchemaFilterObjectTypes.Table, EntityStoreSchemaFilterEffect.Exclude), new EntityStoreSchemaFilterEntry( null, null, "nameExcluded", EntityStoreSchemaFilterObjectTypes.Table, EntityStoreSchemaFilterEffect.Exclude) }, new[] { "alias" }) .CreateWhereClause(parameters).ToString()); Assert.Equal(2, parameters.Count); Assert.Equal("p0,p1", string.Join(",", parameters.OfType<EntityParameter>().Select(p => p.ParameterName))); Assert.Equal("nameAllowed,nameExcluded", string.Join(",", parameters.OfType<EntityParameter>().Select(p => p.Value))); }
public void Where_clause_uses_AND_to_connect_multiple_aliases_and_Exclude_filter() { var parameters = new EntityCommand().Parameters; Assert.Equal( "NOT ((alias1.Name LIKE @p0))\r\nAND\r\nNOT ((alias2.Name LIKE @p1))", new EntityStoreSchemaQueryGenerator( string.Empty, string.Empty, EntityStoreSchemaFilterObjectTypes.Table, new[] { new EntityStoreSchemaFilterEntry( null, null, "name", EntityStoreSchemaFilterObjectTypes.Table, EntityStoreSchemaFilterEffect.Exclude), }, new[] { "alias1", "alias2" }) .CreateWhereClause(parameters).ToString()); Assert.Equal(2, parameters.Count); Assert.Equal("p0,p1", string.Join(",", parameters.OfType<EntityParameter>().Select(p => p.ParameterName))); Assert.Equal("name,name", string.Join(",", parameters.OfType<EntityParameter>().Select(p => p.Value))); }
public void Where_clause_created_for_single_Exclude_filter() { var parameters = new EntityCommand().Parameters; Assert.Equal( "NOT ((alias.CatalogName LIKE @p0 AND alias.SchemaName LIKE @p1 AND alias.Name LIKE @p2))", new EntityStoreSchemaQueryGenerator( string.Empty, string.Empty, EntityStoreSchemaFilterObjectTypes.Table, new[] { new EntityStoreSchemaFilterEntry( "catalog", "schema", "name", EntityStoreSchemaFilterObjectTypes.Table, EntityStoreSchemaFilterEffect.Exclude) }, new[] { "alias" }) .CreateWhereClause(parameters).ToString()); Assert.Equal(3, parameters.Count); Assert.Equal("p0,p1,p2", string.Join(",", parameters.OfType<EntityParameter>().Select(p => p.ParameterName))); Assert.Equal("catalog,schema,name", string.Join(",", parameters.OfType<EntityParameter>().Select(p => p.Value))); }
/// <summary> /// Given an entity command and entity transaction, passes through relevant state to store provider /// command. /// </summary> /// <param name="entityCommand"> Entity command. Must not be null. </param> /// <param name="entityTransaction"> Entity transaction. Must not be null. </param> /// <param name="storeProviderCommand"> Store provider command that is being setup. Must not be null. </param> internal static void SetStoreProviderCommandState( EntityCommand entityCommand, EntityTransaction entityTransaction, DbCommand storeProviderCommand) { DebugCheck.NotNull(entityCommand); DebugCheck.NotNull(storeProviderCommand); storeProviderCommand.CommandTimeout = entityCommand.CommandTimeout; storeProviderCommand.Connection = (entityCommand.Connection).StoreConnection; storeProviderCommand.Transaction = (null != entityTransaction) ? entityTransaction.StoreTransaction : null; storeProviderCommand.UpdatedRowSource = entityCommand.UpdatedRowSource; }
private static ICollection<EntityStoreSchemaFilterEntry> ExecuteDatabaseMetadataQuery( string esqlQuery, EntityStoreSchemaFilterObjectTypes types, ModelBuilderSettings settings, DoWorkEventArgs args) { var filterEntries = new List<EntityStoreSchemaFilterEntry>(); EntityConnection ec = null; try { Version actualEntityFrameworkConnectionVersion; ec = new StoreSchemaConnectionFactory().Create( DependencyResolver.Instance, settings.RuntimeProviderInvariantName, settings.DesignTimeConnectionString, settings.TargetSchemaVersion, out actualEntityFrameworkConnectionVersion); // if the provider does not support V3 and we are querying for Functions then switch to the pre-V3 query if (actualEntityFrameworkConnectionVersion < EntityFrameworkVersion.Version3 && SelectFunctionsESqlQuery.Equals(esqlQuery, StringComparison.Ordinal)) { esqlQuery = SelectFunctionsESqlQueryBeforeV3; } using (var command = new EntityCommand(null, ec, DependencyResolver.Instance)) { // NOTE: DO NOT set the the command.CommandTimeout value. Some providers don't support a non-zero value, and will throw (eg, SqlCE provider). // The System.Data.SqlClient's default value is 15, so we will still get a timeout for sql server. command.CommandType = CommandType.Text; command.CommandText = esqlQuery; ec.Open(); DbDataReader reader = null; try { reader = command.ExecuteReader(CommandBehavior.SequentialAccess); while (reader.Read()) { if (args != null && args.Cancel) { break; } if (reader.FieldCount == 3) { // the types coming back through the reader may not be a string // (eg, SqlCE returns System.DbNull for catalogName & schemaName), so cast carefully var catalogName = reader.GetValue(0) as String; var schemaName = reader.GetValue(1) as String; var name = reader.GetValue(2) as String; if (String.IsNullOrEmpty(name) == false) { filterEntries.Add( new EntityStoreSchemaFilterEntry( catalogName, schemaName, name, types, EntityStoreSchemaFilterEffect.Allow)); } } else { Debug.Fail("Unexpected field count in reader"); } } } finally { if (reader != null) { try { reader.Close(); reader.Dispose(); } catch (Exception) { Debug.Fail( "Could not close the DbDataReader in ExecuteDatabaseMetadataQuery(). If this is the result of a connection to a database file, it will leave a read lock on the file."); } } } } } finally { if (ec != null) { try { ec.Close(); ec.Dispose(); } catch (Exception) { Debug.Fail( "Could not close the EntityConnection in ExecuteDatabaseMetadataQuery(). If this is a connection to a database file, it will leave a read lock on the file."); } } } return filterEntries; }
public void GenerateQuery_appends_orderby_if_specified() { var parameters = new EntityCommand().Parameters; Assert.Equal( "baseQuery\r\norderBy", new EntityStoreSchemaQueryGenerator( "baseQuery", "orderBy", EntityStoreSchemaFilterObjectTypes.Table, new EntityStoreSchemaFilterEntry[0], new string[0]) .GenerateQuery(parameters)); Assert.Equal(0, parameters.Count); }
public void UserDefinedFunction() { using (EntityConnection conn = new EntityConnection("name=testEntities")) { conn.Open(); string query = @"SELECT e.FirstName AS Name FROM testEntities.Employees AS e WHERE testModel.Store.spFunc(e.Id, '') = 6"; using (EntityCommand cmd = new EntityCommand(query, conn)) { EntityDataReader reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess); Assert.IsTrue(reader.Read()); Assert.AreEqual("Scooby", reader[0]); } } }
/// <summary> /// Closes the <see cref="T:System.Data.Entity.Core.EntityClient.EntityDataReader" /> object. /// </summary> public override void Close() { if (_command != null) { _storeDataReader.Close(); // Notify the command object that we are closing, so clean up operations such as copying output parameters can be done _command.NotifyDataReaderClosing(); if ((_behavior & CommandBehavior.CloseConnection) == CommandBehavior.CloseConnection) { Debug.Assert(_command.Connection != null); _command.Connection.Close(); } _command = null; } }
public EntityStoreSchemaGeneratorDatabaseSchemaLoaderFake(EntityCommand[] entityCommands) : base(new Mock<EntityConnection>().Object, EntityFrameworkVersion.Version3) { _entityCommands = entityCommands; }
public void AppendFilterEntry_uses_wildcard_parameter_value_if_schema_catalog_and_name_are_null() { var parameters = new EntityCommand().Parameters; Assert.Equal( "(alias.Name LIKE @p0)", EntityStoreSchemaQueryGenerator.AppendFilterEntry( new StringBuilder(), "alias", new EntityStoreSchemaFilterEntry(null, null, null), parameters).ToString()); Assert.Equal(1, parameters.Count); Assert.Equal("p0", parameters[0].ParameterName); Assert.Equal("%", parameters[0].Value); }
public void GenerateQuery_appends_orderby_after_where_clause_if_both_are_present() { var parameters = new EntityCommand().Parameters; Assert.Equal( "baseQuery\r\nWHERE\r\nNOT ((alias.Name LIKE @p0))\r\norderby", new EntityStoreSchemaQueryGenerator( "baseQuery", "orderby", EntityStoreSchemaFilterObjectTypes.Function, new[] { new EntityStoreSchemaFilterEntry( null, null, "name", EntityStoreSchemaFilterObjectTypes.Function, EntityStoreSchemaFilterEffect.Exclude), }, new[] { "alias" }) .GenerateQuery(parameters)); Assert.Equal(1, parameters.Count); Assert.Equal("p0", parameters[0].ParameterName); Assert.Equal("name", parameters[0].Value); }
public EntityStoreSchemaGeneratorDatabaseSchemaLoaderFake(EntityCommand entityCommand) : this(new[] { entityCommand }) { }