public void IsQuery_false_for_non_DbQueryCommandTree() { var collectionExpression = TypeUsage.CreateDefaultTypeUsage( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String) .GetCollectionType()) .NewEmptyCollection(); var commandTrees = new DbCommandTree[] { new DbInsertCommandTree( new MetadataWorkspace(), DataSpace.CSpace, collectionExpression.Bind(), new List<DbModificationClause>().AsReadOnly(), collectionExpression), new DbUpdateCommandTree( new MetadataWorkspace(), DataSpace.CSpace, collectionExpression.Bind(), DbExpressionBuilder.Constant(3), new List<DbModificationClause>().AsReadOnly(), collectionExpression), }; foreach (var commandTree in commandTrees) { Assert.False(new CommandTreeFacts(commandTree).IsQuery); } }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { Check.NotNull(providerManifest, "providerManifest"); Check.NotNull(commandTree, "commandTree"); return CreateDbCommandDefinition(providerManifest, commandTree, new DbInterceptionContext()); }
/// <summary> /// Initializes a new instance of the <see cref="DbCommandInfo"/> class. /// </summary> public DbCommandInfo(DbCommandTree tree, DbCache cache, IDbCachingPolicy policy, DbTransactionInterceptor txHandler) { Debug.Assert(tree != null); Debug.Assert(cache != null); Debug.Assert(txHandler != null); var qryTree = tree as DbQueryCommandTree; if (qryTree != null) { _isModification = false; _affectedEntitySets = GetAffectedEntitySets(qryTree.Query); } else { _isModification = true; var modify = tree as DbModificationCommandTree; if (modify != null) _affectedEntitySets = GetAffectedEntitySets(modify.Target.Expression); else // Functions (stored procedures) are not supported. Debug.Assert(tree is DbFunctionCommandTree); } _cache = cache; _policy = policy; _txHandler = txHandler; }
public override string GenerateSQL(DbCommandTree commandTree) { DbFunctionCommandTree tree = (commandTree as DbFunctionCommandTree); EdmFunction function = tree.EdmFunction; CommandType = CommandType.StoredProcedure; string cmdText = (string)function.MetadataProperties["CommandTextAttribute"].Value; if (String.IsNullOrEmpty(cmdText)) { string schema = (string)function.MetadataProperties["Schema"].Value; if (String.IsNullOrEmpty(schema)) schema = function.NamespaceName; string functionName = (string)function.MetadataProperties["StoreFunctionNameAttribute"].Value; if (String.IsNullOrEmpty(functionName)) functionName = function.Name; return String.Format("`{0}`", functionName); } else { CommandType = CommandType.Text; return cmdText; } }
public void TreeCreated(DbCommandTree commandTree, DbCommandTreeInterceptionContext interceptionContext) { if (interceptionContext.DbContexts.Contains(_context, ReferenceEquals)) { _commandTrees.Add(commandTree); } }
public virtual void VisitCommandTree(DbCommandTree commandTree) { Contract.Requires(commandTree != null); switch (commandTree.CommandTreeKind) { case DbCommandTreeKind.Delete: VisitDeleteCommandTree((DbDeleteCommandTree)commandTree); break; case DbCommandTreeKind.Function: VisitFunctionCommandTree((DbFunctionCommandTree)commandTree); break; case DbCommandTreeKind.Insert: VisitInsertCommandTree((DbInsertCommandTree)commandTree); break; case DbCommandTreeKind.Query: VisitQueryCommandTree((DbQueryCommandTree)commandTree); break; case DbCommandTreeKind.Update: VisitUpdateCommandTree((DbUpdateCommandTree)commandTree); break; default: throw new NotSupportedException(); } }
public override string GenerateSQL(DbCommandTree tree) { DbInsertCommandTree commandTree = tree as DbInsertCommandTree; InsertStatement statement = new InsertStatement(); DbExpressionBinding e = commandTree.Target; statement.Target = (InputFragment)e.Expression.Accept(this); scope.Add("target", statement.Target); foreach (DbSetClause setClause in commandTree.SetClauses) statement.Sets.Add(setClause.Property.Accept(this)); if (values == null) values = new Dictionary<EdmMember, SqlFragment>(); foreach (DbSetClause setClause in commandTree.SetClauses) { DbExpression value = setClause.Value; SqlFragment valueFragment = value.Accept(this); statement.Values.Add(valueFragment); if (value.ExpressionKind != DbExpressionKind.Null) { EdmMember property = ((DbPropertyExpression)setClause.Property).Property; values.Add(property, valueFragment); } } if (commandTree.Returning != null) statement.ReturningSelect = GenerateReturningSql(commandTree, commandTree.Returning); return statement.ToString(); }
internal static EntityCommandDefinition CreateCommandDefinition(DbProviderFactory storeProviderFactory, DbCommandTree commandTree) { Contract.Requires(storeProviderFactory != null); Contract.Requires(commandTree != null); return new EntityCommandDefinition(storeProviderFactory, commandTree); }
internal static EntityCommandDefinition CreateCommandDefinition(DbProviderFactory storeProviderFactory, DbCommandTree commandTree) { DebugCheck.NotNull(storeProviderFactory); DebugCheck.NotNull(commandTree); return new EntityCommandDefinition(storeProviderFactory, commandTree); }
public override string GenerateSQL(DbCommandTree tree) { DbUpdateCommandTree commandTree = tree as DbUpdateCommandTree; UpdateStatement statement = new UpdateStatement(); _onReturningSelect = false; statement.Target = commandTree.Target.Expression.Accept(this); scope.Add("target", statement.Target as InputFragment); if (values == null) values = new Dictionary<EdmMember, SqlFragment>(); foreach (DbSetClause setClause in commandTree.SetClauses) { statement.Properties.Add(setClause.Property.Accept(this)); DbExpression value = setClause.Value; SqlFragment valueFragment = value.Accept(this); statement.Values.Add(valueFragment); if (value.ExpressionKind != DbExpressionKind.Null) { EdmMember property = ((DbPropertyExpression)setClause.Property).Property; values.Add(property, valueFragment); } } statement.Where = commandTree.Predicate.Accept(this); _onReturningSelect = true; if (commandTree.Returning != null) statement.ReturningSelect = GenerateReturningSql(commandTree, commandTree.Returning); return statement.ToString(); }
/// <summary> /// Constructs a new ObjectSpanRewriter that will attempt to apply spanning to the specified query /// (represented as a DbExpression) when <see cref="RewriteQuery" /> is called. /// </summary> /// <param name="toRewrite"> /// A <see cref="DbExpression" /> representing the query to span. /// </param> internal ObjectSpanRewriter(DbCommandTree tree, DbExpression toRewrite, AliasGenerator aliasGenerator) { DebugCheck.NotNull(toRewrite); _toRewrite = toRewrite; _tree = tree; _aliasGenerator = aliasGenerator; }
/// <summary> /// Ensures that the data space of the specified command tree is the model (C-) space /// </summary> /// <param name="commandTree">The command tree for which the data space should be validated</param> internal override void ValidateDataSpace(DbCommandTree commandTree) { if (commandTree.DataSpace != DataSpace.CSpace) { throw new ProviderIncompatibleException(Strings.EntityClient_RequiresNonStoreCommandTree); } }
/// <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); }
internal static EntityCommandDefinition CreateCommandDefinition( DbProviderFactory storeProviderFactory, DbCommandTree commandTree, IDbDependencyResolver resolver = null) { DebugCheck.NotNull(storeProviderFactory); DebugCheck.NotNull(commandTree); return new EntityCommandDefinition(storeProviderFactory, commandTree, resolver); }
internal ParseResult(DbCommandTree commandTree, List<FunctionDefinition> functionDefs) { DebugCheck.NotNull(commandTree); DebugCheck.NotNull(functionDefs); _commandTree = commandTree; _functionDefs = new ReadOnlyCollection<FunctionDefinition>(functionDefs); }
/// <summary> /// Constructs a new ObjectSpanRewriter that will attempt to apply spanning to the specified query /// (represented as a DbExpression) when <see cref="RewriteQuery" /> is called. /// </summary> /// <param name="toRewrite"> A <see cref="DbExpression" /> representing the query to span. </param> internal ObjectSpanRewriter(DbCommandTree tree, DbExpression toRewrite, AliasGenerator aliasGenerator) { Debug.Assert(toRewrite != null, "Expression to rewrite cannot be null"); _toRewrite = toRewrite; _tree = tree; _aliasGenerator = aliasGenerator; }
internal ParseResult(DbCommandTree commandTree, List<FunctionDefinition> functionDefs) { Contract.Requires(commandTree != null); Contract.Requires(functionDefs != null); _commandTree = commandTree; _functionDefs = functionDefs.AsReadOnly(); }
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 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(DbCommandTree commandTree) { Contract.Requires(commandTree != null); ValidateDataSpace(commandTree); var storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace); Contract.Assert(storeMetadata.StoreProviderManifest != null, "StoreItemCollection has null StoreProviderManifest?"); return CreateDbCommandDefinition(storeMetadata.StoreProviderManifest, commandTree); }
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); }
public virtual DbCommandTree Created(DbCommandTree commandTree, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(commandTree); DebugCheck.NotNull(interceptionContext); return _internalDispatcher.Dispatch( commandTree, new DbCommandTreeInterceptionContext(interceptionContext), (i, c) => i.TreeCreated(c)); }
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; }
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 string GenerateSQL(DbCommandTree tree) { DbDeleteCommandTree commandTree = tree as DbDeleteCommandTree; DeleteStatement statement = new DeleteStatement(); statement.Target = commandTree.Target.Expression.Accept(this); scope.Add("target", statement.Target as InputFragment); statement.Where = commandTree.Predicate.Accept(this); return statement.ToString(); }
public CommandTreeFacts(DbCommandTree commandTree) { IsQuery = commandTree is DbQueryCommandTree; var visitor = new CommandTreeVisitor(); if (commandTree.CommandTreeKind == DbCommandTreeKind.Function) { var edmFunction = ((DbFunctionCommandTree)commandTree).EdmFunction; var containerMapping = commandTree.MetadataWorkspace.GetItemCollection(DataSpace.CSSpace).GetItems<EntityContainerMapping>().Single(); var entitySetMappings = containerMapping.EntitySetMappings.Where( esm => esm.ModificationFunctionMappings.Any( mfm => mfm.DeleteFunctionMapping.Function == edmFunction || mfm.InsertFunctionMapping.Function == edmFunction || mfm.UpdateFunctionMapping.Function == edmFunction)); AffectedEntitySets = (from esm in entitySetMappings from etm in esm.EntityTypeMappings from mappingFragment in etm.Fragments.Where(f => f.StoreEntitySet != null) select mappingFragment.StoreEntitySet).Cast<EntitySetBase>().ToList().AsReadOnly(); } else { if (commandTree.CommandTreeKind == DbCommandTreeKind.Query) { ((DbQueryCommandTree)commandTree).Query.Accept(visitor); } else { Debug.Assert(commandTree is DbModificationCommandTree, "Unexpected command tree kind"); ((DbModificationCommandTree)commandTree).Target.Expression.Accept(visitor); } AffectedEntitySets = new ReadOnlyCollection<EntitySetBase>(visitor.EntitySets); UsesNonDeterministicFunctions = visitor.Functions.Any(f => NonDeterministicFunctions.Contains( string.Format("{0}.{1}", f.NamespaceName, f.Name))); } MetadataWorkspace = commandTree.MetadataWorkspace; }
public override string GenerateSQL(DbCommandTree tree) { DbQueryCommandTree commandTree = tree as DbQueryCommandTree; SqlFragment fragment = null; DbExpression e = commandTree.Query; switch (commandTree.Query.ExpressionKind) { case DbExpressionKind.Project: fragment = e.Accept(this); Debug.Assert(fragment is SelectStatement); break; } return fragment.ToString(); }
/// <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; } }
internal ObjectFullSpanRewriter(DbCommandTree tree, DbExpression toRewrite, Span span, AliasGenerator aliasGenerator) : base(tree, toRewrite, aliasGenerator) { Debug.Assert(span != null, "Span cannot be null"); Debug.Assert(span.SpanList.Count > 0, "At least one span path is required"); // Retrieve the effective 'T' of the ObjectQuery<T> that produced // the Command Tree that is being rewritten. This could be either // literally 'T' or Collection<T>. EntityType entityType = null; if (!TryGetEntityType(Query.ResultType, out entityType)) { // If the result type of the query is neither an Entity type nor a collection // type with an Entity element type, then full Span is currently not allowed. throw new InvalidOperationException(Strings.ObjectQuery_Span_IncludeRequiresEntityOrEntityCollection); } // Construct the SpanPathInfo navigation property tree using the // list of Include Span paths from the Span object: // Create a SpanPathInfo instance that represents the root of the tree // and takes its Entity type from the Entity type of the result type of the query. var spanRoot = new SpanPathInfo(entityType); // Populate the tree of navigation properties based on the navigation property names // in the Span paths from the Span object. Commonly rooted span paths are merged, so // that paths of "Customer.Order" and "Customer.Address", for example, will share a // common SpanPathInfo for "Customer" in the Children collection of the root SpanPathInfo, // and that SpanPathInfo will contain one child for "Order" and another for "Address". foreach (var path in span.SpanList) { AddSpanPath(spanRoot, path.Navigations); } // The 'current' span path is initialized to the root of the Include span tree _currentSpanPath.Push(spanRoot); }
public abstract void TreeCreated(DbCommandTree commandTree, DbCommandTreeInterceptionContext interceptionContext);
// <summary> // Internal constructor for a ProviderCommandInfo object // </summary> // <param name="commandTree"> command tree for the provider command </param> internal ProviderCommandInfo(cqt.DbCommandTree commandTree) { _commandTree = commandTree; }
/// <summary> /// private constructor /// </summary> /// <param name="ctree"> the input cqt </param> private PlanCompiler(cqt.DbCommandTree ctree) { m_ctree = ctree; // the input command tree }
/// <summary> /// Initializes a new instance of the DbCommandDefinitionWrapper class. /// </summary> /// <param name="wrappedCommandDefinition">The wrapped command definition.</param> /// <param name="commandTree">The command tree.</param> /// <param name="commandCreator">The command creator delegate.</param> public DbCommandDefinitionWrapper(System.Data.Entity.Core.Common.DbCommandDefinition wrappedCommandDefinition, System.Data.Entity.Core.Common.CommandTrees.DbCommandTree commandTree, Func <DbCommand, DbCommandDefinitionWrapper, DbCommand> commandCreator) { this.wrappedCommandDefinition = wrappedCommandDefinition; this.commandTree = commandTree; this.commandCreator = commandCreator; }
/// <summary> /// Creates the command definition wrapper. /// </summary> /// <param name="wrappedCommandDefinition">The wrapped command definition.</param> /// <param name="commandTree">The command tree.</param> /// <returns> /// The <see cref="DbCommandDefinitionWrapper"/> object. /// </returns> public override DbCommandDefinitionWrapper CreateCommandDefinitionWrapper(DbCommandDefinition wrappedCommandDefinition, System.Data.Entity.Core.Common.CommandTrees.DbCommandTree commandTree) { return(new EFCachingCommandDefinition(wrappedCommandDefinition, commandTree)); }
/// <summary> /// Creates the command definition wrapper. /// </summary> /// <param name="wrappedCommandDefinition">The wrapped command definition.</param> /// <param name="commandTree">The command tree.</param> /// <returns><see cref="DbCommandDefinitionWrapper"/> object.</returns> public virtual DbCommandDefinitionWrapper CreateCommandDefinitionWrapper(System.Data.Entity.Core.Common.DbCommandDefinition wrappedCommandDefinition, System.Data.Entity.Core.Common.CommandTrees.DbCommandTree commandTree) { return(new DbCommandDefinitionWrapper(wrappedCommandDefinition, commandTree, (cmd, def) => EFDbCommandFactory.GetCommandWrapper(cmd, def))); }
/// <summary> /// Creates the command definition wrapper for a given provider manifest and command tree. /// </summary> /// <param name="providerManifest">The provider manifest.</param> /// <param name="commandTree">The command tree.</param> /// <returns><see cref="DbCommandDefinition"/> object.</returns> protected override System.Data.Entity.Core.Common.DbCommandDefinition CreateDbCommandDefinition(System.Data.Entity.Core.Common.DbProviderManifest providerManifest, System.Data.Entity.Core.Common.CommandTrees.DbCommandTree commandTree) { var wrapperManifest = (DbProviderManifestWrapper)providerManifest; var createDbCommandDefinitionFunction = this.GetCreateDbCommandDefinitionFunction(wrapperManifest.WrappedProviderManifestInvariantName); System.Data.Entity.Core.Common.DbCommandDefinition definition = createDbCommandDefinitionFunction(wrapperManifest.WrappedProviderManifest, commandTree); return(this.CreateCommandDefinitionWrapper(definition, commandTree)); }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest dbProviderManifest, System.Data.Entity.Core.Common.CommandTrees.DbCommandTree dbCommandTree) { DbCommandDefinition dbCommandDefinition = base.CreateCommandDefinition(dbProviderManifest, dbCommandTree); return(new EFCachingCommandDefinition(dbCommandDefinition, dbCommandTree)); }
internal EFCachingCommandDefinition(System.Data.Entity.Core.Common.DbCommandDefinition wrappedCommandDefinition, System.Data.Entity.Core.Common.CommandTrees.DbCommandTree commandTree) : base(wrappedCommandDefinition, commandTree, (cmd, def) => EFDbCommandFactory.GetCommandWrapper(cmd, def)) { this.GetAffectedEntitySets(commandTree); }