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();
}
public static ICommandAction Create(DbCommandTree commandTree)
{
ICommandAction action = null;
if (commandTree is DbQueryCommandTree)
{
action = new QueryCommandAction(commandTree as DbQueryCommandTree);
}
else if (commandTree is DbInsertCommandTree)
{
action = new InsertCommandAction(commandTree as DbInsertCommandTree);
}
else if (commandTree is DbUpdateCommandTree)
{
action = new UpdateCommandAction(commandTree as DbUpdateCommandTree);
}
else if (commandTree is DbDeleteCommandTree)
{
action = new DeleteCommandAction(commandTree as DbDeleteCommandTree);
}
if (action == null)
{
throw new NotSupportedException("Not supported DbCommandTree type");
}
return action;
}
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 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();
}
public override DbCommandDefinitionWrapper CreateCommandDefinitionWrapper(DbCommandDefinition wrappedCommandDefinition, DbCommandTree commandTree)
{
return new DbCommandDefinitionWrapper(
wrappedCommandDefinition,
commandTree,
(tree, definition) => new DataReaderInspectorCommand(tree, definition));
}
/// <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(DbCommandDefinition wrappedCommandDefinition, DbCommandTree commandTree)
{
return new DbCommandDefinitionWrapper(
wrappedCommandDefinition,
commandTree,
(cmd, def) => new DbCommandWrapper(cmd, def));
}
private void TranslateCommandTree(DbCommandTree commandTree, DbCommand command)
{
SqlBaseGenerator sqlGenerator = null;
DbQueryCommandTree select;
DbInsertCommandTree insert;
DbUpdateCommandTree update;
DbDeleteCommandTree delete;
if ((select = commandTree as DbQueryCommandTree) != null)
{
sqlGenerator = new SqlSelectGenerator(select);
}
else if ((insert = commandTree as DbInsertCommandTree) != null)
{
sqlGenerator = new SqlInsertGenerator(insert);
}
else if ((update = commandTree as DbUpdateCommandTree) != null)
{
sqlGenerator = new SqlUpdateGenerator(update);
}
else if ((delete = commandTree as DbDeleteCommandTree) != null)
{
sqlGenerator = new SqlDeleteGenerator(delete);
}
else
{
// TODO: get a message (unsupported DbCommandTree type)
throw new ArgumentException();
}
sqlGenerator.BuildCommand(command);
}
internal static ReadOnlyCollection<DbParameterReferenceExpression> GetParameters(DbCommandTree tree)
{
Debug.Assert(tree != null, "Ensure command tree is non-null before calling ParamterRetriever.GetParameters");
var retriever = new ParameterRetriever();
retriever.VisitCommandTree(tree);
return retriever.paramMappings.Values.ToList().AsReadOnly();
}
internal static ReadOnlyCollection<DbParameterReferenceExpression> GetParameters(DbCommandTree tree)
{
DebugCheck.NotNull(tree);
var retriever = new ParameterRetriever();
retriever.VisitCommandTree(tree);
return new ReadOnlyCollection<DbParameterReferenceExpression>(retriever.paramMappings.Values.ToList());
}
/// <summary>
/// Initializes a new instance of the <see cref="EffortEntityCommand" /> class
/// based on a provided command tree.
/// </summary>
/// <param name="commandtree">
/// The command tree that describes the operation.
/// </param>
public EffortEntityCommand(DbCommandTree commandtree)
{
this.commandAction = CommandActionFactory.Create(commandtree);
foreach (KeyValuePair<string, TypeUsage> param in commandtree.Parameters)
{
this.AddParameter(param.Key);
}
}
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 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;
}
// Apply post-optimizations here:
fragment = TryFlatteningGroupBy(fragment);
return fragment.ToString();
}
private DbCommand CreateDbCommand(DbCommandTree commandTree)
{
if (commandTree == null)
throw new ArgumentNullException("commandTree");
DbCommand command = NpgsqlFactory.Instance.CreateCommand();
foreach (KeyValuePair<string, TypeUsage> parameter in commandTree.Parameters)
{
DbParameter dbParameter = command.CreateParameter();
dbParameter.ParameterName = parameter.Key;
command.Parameters.Add(dbParameter);
}
TranslateCommandTree(commandTree, command);
return command;
}
internal DbCommand CreateDbCommand(Version serverVersion, DbCommandTree commandTree)
{
if (commandTree == null)
throw new ArgumentNullException("commandTree");
NpgsqlCommand command = new NpgsqlCommand();
foreach (KeyValuePair<string, TypeUsage> parameter in commandTree.Parameters)
{
NpgsqlParameter dbParameter = new NpgsqlParameter();
dbParameter.ParameterName = parameter.Key;
dbParameter.NpgsqlDbType = NpgsqlProviderManifest.GetNpgsqlDbType(((PrimitiveType)parameter.Value.EdmType).PrimitiveTypeKind);
command.Parameters.Add(dbParameter);
}
TranslateCommandTree(serverVersion, commandTree, command);
return command;
}
internal DbCommand CreateDbCommand(DbCommandTree commandTree)
{
if (commandTree == null)
throw new ArgumentNullException("commandTree");
DbCommand command = NpgsqlFactory.Instance.CreateCommand();
foreach (KeyValuePair<string, TypeUsage> parameter in commandTree.Parameters)
{
DbParameter dbParameter = command.CreateParameter();
dbParameter.ParameterName = parameter.Key;
dbParameter.DbType = NpgsqlProviderManifest.GetDbType(((PrimitiveType)parameter.Value.EdmType).PrimitiveTypeKind);
command.Parameters.Add(dbParameter);
}
TranslateCommandTree(commandTree, command);
return command;
}
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);
}
}
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;
}
}
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)
{
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);
}
}
private static Type[] PrepareTypeCoercions(DbCommandTree commandTree)
{
var queryTree = commandTree as DbQueryCommandTree;
if (queryTree != null)
{
var projectExpression = queryTree.Query as DbProjectExpression;
if (projectExpression != null)
{
var resultsType = projectExpression.Projection.ResultType.EdmType;
var resultsAsStructuralType = resultsType as StructuralType;
if (resultsAsStructuralType != null)
{
var result = new Type[resultsAsStructuralType.Members.Count];
for (int i = 0; i < resultsAsStructuralType.Members.Count; i++)
{
var member = resultsAsStructuralType.Members[i];
result[i] = ((PrimitiveType)member.TypeUsage.EdmType).ClrEquivalentType;
}
return result;
}
}
}
var functionTree = commandTree as DbFunctionCommandTree;
if (functionTree != null)
{
if (functionTree.ResultType != null)
{
Debug.Assert(MetadataHelpers.IsCollectionType(functionTree.ResultType.EdmType), "Result type of a function is expected to be a collection of RowType or PrimitiveType");
var elementType = MetadataHelpers.GetElementTypeUsage(functionTree.ResultType).EdmType;
if (MetadataHelpers.IsRowType(elementType))
{
var members = ((RowType)elementType).Members;
var result = new Type[members.Count];
for (int i = 0; i < members.Count; i++)
{
var member = members[i];
var primitiveType = (PrimitiveType)member.TypeUsage.EdmType;
result[i] = primitiveType.ClrEquivalentType;
}
return result;
}
else if (MetadataHelpers.IsPrimitiveType(elementType))
{
return new Type[] { ((PrimitiveType)elementType).ClrEquivalentType };
}
else
{
Debug.Fail("Result type of a function is expected to be a collection of RowType or PrimitiveType");
}
}
}
return null;
}
/// <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(DbCommandDefinition wrappedCommandDefinition, DbCommandTree commandTree, Func <DbCommand, DbCommandDefinitionWrapper, DbCommand> commandCreator)
{
this.wrappedCommandDefinition = wrappedCommandDefinition;
this.commandTree = commandTree;
this.commandCreator = commandCreator;
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest manifest, DbCommandTree commandTree)
{
DbCommand prototype = CreateCommand(manifest, commandTree);
DbCommandDefinition result = base.CreateCommandDefinition(prototype);
return(result);
}
/// <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 DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
var wrapperManifest = (DbProviderManifestWrapper)providerManifest;
var createDbCommandDefinitionFunction = this.GetCreateDbCommandDefinitionFunction(wrapperManifest.WrappedProviderManifestInvariantName);
DbCommandDefinition definition = createDbCommandDefinitionFunction(wrapperManifest.WrappedProviderManifest, commandTree);
return(this.CreateCommandDefinitionWrapper(definition, 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(DbCommandDefinition wrappedCommandDefinition, DbCommandTree commandTree)
{
return(new DbCommandDefinitionWrapper(
wrappedCommandDefinition,
commandTree,
(cmd, def) => new DbCommandWrapper(cmd, def)));
}
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);
}
internal static ReadOnlyCollection <DbParameterReferenceExpression> GetParameters(DbCommandTree tree)
{
DebugCheck.NotNull(tree);
var retriever = new ParameterRetriever();
retriever.VisitCommandTree(tree);
return(new ReadOnlyCollection <DbParameterReferenceExpression>(retriever.paramMappings.Values.ToList()));
}
/// <summary>
/// Create a Command Definition object, given the connection and command tree
/// </summary>
/// <param name="providerManifest"> provider manifest that was determined from metadata </param>
/// <param name="commandTree"> command tree for the statement </param>
/// <returns> an executable command definition object </returns>
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
Check.NotNull(providerManifest, "providerManifest");
Check.NotNull(commandTree, "commandTree");
var prototype = CreateCommand(providerManifest, commandTree);
var result = CreateCommandDefinition(prototype);
return(result);
}
// protected SymbolTable Symbols { get; private set; }
#endregion
public virtual string GenerateSQL(DbCommandTree commandTree)
{
throw new NotImplementedException();
}
public abstract DbCommandTree TreeCreated(DbCommandTree commandTree, DbInterceptionContext interceptionContext);
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
return new GlimpseDbCommandDefinition(InnerProviderServices.CreateCommandDefinition(commandTree));
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
return(new WrappingCommandDefinition <TAdoNetBase>(_baseServices.CreateCommandDefinition(providerManifest, commandTree)));
}
/// <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(DbCommandDefinition wrappedCommandDefinition, DbCommandTree commandTree, Func<DbCommand, DbCommandDefinitionWrapper, DbCommand> commandCreator)
{
this.wrappedCommandDefinition = wrappedCommandDefinition;
this.commandTree = commandTree;
this.commandCreator = commandCreator;
}
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)
{
Check.NotNull(providerManifest, "providerManifest");
Check.NotNull(commandTree, "commandTree");
return(CreateDbCommandDefinition(providerManifest, commandTree, new DbInterceptionContext()));
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
return(new CmdDefinition(_inner.CreateCommandDefinition(providerManifest, commandTree)));
}
/// <summary>
/// Create a DbCommand object, given the provider manifest and command tree
/// </summary>
private DbCommand CreateCommand(DbProviderManifest manifest, DbCommandTree commandTree)
{
if (manifest == null)
{
throw new ArgumentNullException("manifest");
}
if (commandTree == null)
{
throw new ArgumentNullException("commandTree");
}
JetProviderManifest jetManifest = (manifest as JetProviderManifest);
if (jetManifest == null)
{
throw new ArgumentException("The provider manifest given is not of type 'JetProviderManifest'.");
}
JetCommand command = new JetCommand();
List <DbParameter> parameters;
CommandType commandType;
command.CommandText = SqlGenerator.GenerateSql(commandTree, out parameters, out commandType);
command.CommandType = commandType;
//if (command.CommandType == CommandType.Text)
// command.CommandText += Environment.NewLine + Environment.NewLine + "-- provider: " + this.GetType().Assembly.FullName;
// 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)
{
OleDbParameter 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 (function != null && function.Parameters.TryGetValue(queryParameter.Key, false, out functionParameter))
{
parameter = CreateJetParameter(functionParameter.Name, functionParameter.TypeUsage, functionParameter.Mode, DBNull.Value);
}
else
{
parameter = CreateJetParameter(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 (parameters != null && parameters.Count > 0)
{
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);
}
internal EntityCommandDefinition(
DbProviderFactory storeProviderFactory,
DbCommandTree commandTree,
DbInterceptionContext interceptionContext,
IDbDependencyResolver resolver = null,
BridgeDataReaderFactory bridgeDataReaderFactory = null,
ColumnMapFactory columnMapFactory = null)
{
this._bridgeDataReaderFactory = bridgeDataReaderFactory ?? new BridgeDataReaderFactory((Translator)null);
this._columnMapFactory = columnMapFactory ?? new ColumnMapFactory();
this._storeProviderServices = (resolver != null ? resolver.GetService <DbProviderServices>((object)storeProviderFactory.GetProviderInvariantName()) : (DbProviderServices)null) ?? storeProviderFactory.GetProviderServices();
try
{
if (commandTree.CommandTreeKind == DbCommandTreeKind.Query)
{
List <ProviderCommandInfo> providerCommands = new List <ProviderCommandInfo>();
ColumnMap resultColumnMap;
int columnCount;
System.Data.Entity.Core.Query.PlanCompiler.PlanCompiler.Compile(commandTree, out providerCommands, out resultColumnMap, out columnCount, out this._entitySets);
this._columnMapGenerators = new EntityCommandDefinition.IColumnMapGenerator[1]
{
(EntityCommandDefinition.IColumnMapGenerator) new EntityCommandDefinition.ConstantColumnMapGenerator(resultColumnMap, columnCount)
};
this._mappedCommandDefinitions = new List <DbCommandDefinition>(providerCommands.Count);
foreach (ProviderCommandInfo providerCommandInfo in providerCommands)
{
DbCommandDefinition commandDefinition = this._storeProviderServices.CreateCommandDefinition(providerCommandInfo.CommandTree, interceptionContext);
if (commandDefinition == null)
{
throw new ProviderIncompatibleException(Strings.ProviderReturnedNullForCreateCommandDefinition);
}
this._mappedCommandDefinitions.Add(commandDefinition);
}
}
else
{
DbFunctionCommandTree functionCommandTree = (DbFunctionCommandTree)commandTree;
FunctionImportMappingNonComposable targetFunctionMapping = EntityCommandDefinition.GetTargetFunctionMapping(functionCommandTree);
IList <FunctionParameter> returnParameters = (IList <FunctionParameter>)functionCommandTree.EdmFunction.ReturnParameters;
int length = returnParameters.Count > 1 ? returnParameters.Count : 1;
this._columnMapGenerators = new EntityCommandDefinition.IColumnMapGenerator[length];
TypeUsage storeResultType = this.DetermineStoreResultType(targetFunctionMapping, 0, out this._columnMapGenerators[0]);
for (int resultSetIndex = 1; resultSetIndex < length; ++resultSetIndex)
{
this.DetermineStoreResultType(targetFunctionMapping, resultSetIndex, out this._columnMapGenerators[resultSetIndex]);
}
List <KeyValuePair <string, TypeUsage> > keyValuePairList = new List <KeyValuePair <string, TypeUsage> >();
foreach (KeyValuePair <string, TypeUsage> parameter in functionCommandTree.Parameters)
{
keyValuePairList.Add(parameter);
}
this._mappedCommandDefinitions = new List <DbCommandDefinition>(1)
{
this._storeProviderServices.CreateCommandDefinition((DbCommandTree) new DbFunctionCommandTree(functionCommandTree.MetadataWorkspace, DataSpace.SSpace, targetFunctionMapping.TargetFunction, storeResultType, (IEnumerable <KeyValuePair <string, TypeUsage> >)keyValuePairList))
};
if (targetFunctionMapping.FunctionImport.EntitySets.FirstOrDefault <EntitySet>() != null)
{
this._entitySets = new Set <EntitySet>();
this._entitySets.Add(targetFunctionMapping.FunctionImport.EntitySets.FirstOrDefault <EntitySet>());
this._entitySets.MakeReadOnly();
}
}
List <EntityParameter> entityParameterList = new List <EntityParameter>();
foreach (KeyValuePair <string, TypeUsage> parameter in commandTree.Parameters)
{
EntityParameter fromQueryParameter = EntityCommandDefinition.CreateEntityParameterFromQueryParameter(parameter);
entityParameterList.Add(fromQueryParameter);
}
this._parameters = new ReadOnlyCollection <EntityParameter>((IList <EntityParameter>)entityParameterList);
}
catch (EntityCommandCompilationException ex)
{
throw;
}
catch (Exception ex)
{
if (ex.IsCatchableExceptionType())
{
throw new EntityCommandCompilationException(Strings.EntityClient_CommandDefinitionPreparationFailed, ex);
}
throw;
}
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
return(new GlimpseDbCommandDefinition(InnerProviderServices.CreateCommandDefinition(commandTree)));
}
/// <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 DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
var wrapperManifest = (DbProviderManifestWrapper)providerManifest;
var createDbCommandDefinitionFunction = this.GetCreateDbCommandDefinitionFunction(wrapperManifest.WrappedProviderManifestInvariantName);
DbCommandDefinition definition = createDbCommandDefinitionFunction(wrapperManifest.WrappedProviderManifest, commandTree);
return this.CreateCommandDefinitionWrapper(definition, commandTree);
}
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);
}
/// <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)
{
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;
}
}
private static Type[] PrepareTypeCoercions(DbCommandTree commandTree)
{
var queryTree = commandTree as DbQueryCommandTree;
if (queryTree != null)
{
var projectExpression = queryTree.Query as DbProjectExpression;
if (projectExpression != null)
{
var resultsType = projectExpression.Projection.ResultType.EdmType;
var resultsAsStructuralType = resultsType as StructuralType;
if (resultsAsStructuralType != null)
{
var members = resultsAsStructuralType.Members;
return members.Select(ExtractExpectedTypeForCoercion).ToArray();
}
}
}
var functionTree = commandTree as DbFunctionCommandTree;
if (functionTree != null)
{
if (functionTree.ResultType != null)
{
Debug.Assert(MetadataHelpers.IsCollectionType(functionTree.ResultType.EdmType), "Result type of a function is expected to be a collection of RowType or PrimitiveType");
var typeUsage = MetadataHelpers.GetElementTypeUsage(functionTree.ResultType);
var elementType = typeUsage.EdmType;
if (MetadataHelpers.IsRowType(elementType))
{
var members = ((RowType)elementType).Members;
return members.Select(ExtractExpectedTypeForCoercion).ToArray();
}
else if (MetadataHelpers.IsPrimitiveType(elementType))
{
return new[] { MakeTypeCoercion(((PrimitiveType)elementType).ClrEquivalentType, typeUsage) };
}
else
{
Debug.Fail("Result type of a function is expected to be a collection of RowType or PrimitiveType");
}
}
}
return null;
}
/// <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 manifest, DbCommandTree commandTree)
{
DbCommand prototype = CreateCommand(manifest, commandTree);
DbCommandDefinition result = this.CreateCommandDefinition(prototype);
return result;
}
/// <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)
{
Check.NotNull(commandTree, "commandTree");
return(CreateCommandDefinition(commandTree, new DbInterceptionContext()));
}
public override DbCommandDefinitionWrapper CreateCommandDefinitionWrapper(DbCommandDefinition wrappedCommandDefinition, DbCommandTree commandTree)
{
return(new DbCommandDefinitionWrapper(
wrappedCommandDefinition,
commandTree,
(tree, definition) => new DataReaderInspectorCommand(tree, definition)));
}
/// <summary>
/// create the database command definition.
/// </summary>
/// <param name="providerManifest">The provider manifest.</param>
/// <param name="commandTree">The command tree.</param>
/// <returns>the command definition.</returns>
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
var cmdDef = _tail.CreateCommandDefinition(providerManifest, commandTree);
var cmd = cmdDef.CreateCommand();
return(CreateCommandDefinition(new ProfiledDbCommand(cmd, cmd.Connection, MiniProfiler.Current)));
}
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);
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));
}
internal EntityCommandDefinition(
DbProviderFactory storeProviderFactory,
DbCommandTree commandTree,
DbInterceptionContext interceptionContext,
IDbDependencyResolver resolver = null,
BridgeDataReaderFactory bridgeDataReaderFactory = null,
ColumnMapFactory columnMapFactory = null)
{
DebugCheck.NotNull(storeProviderFactory);
DebugCheck.NotNull(commandTree);
DebugCheck.NotNull(interceptionContext);
_bridgeDataReaderFactory = bridgeDataReaderFactory ?? new BridgeDataReaderFactory();
_columnMapFactory = columnMapFactory ?? new ColumnMapFactory();
_storeProviderServices =
(resolver != null
? resolver.GetService <DbProviderServices>(storeProviderFactory.GetProviderInvariantName())
: null) ??
storeProviderFactory.GetProviderServices();
try
{
if (DbCommandTreeKind.Query
== commandTree.CommandTreeKind)
{
// Next compile the plan for the command tree
var mappedCommandList = new List <ProviderCommandInfo>();
ColumnMap columnMap;
int columnCount;
PlanCompiler.Compile(commandTree, out mappedCommandList, out columnMap, out columnCount, out _entitySets);
_columnMapGenerators = new IColumnMapGenerator[] { new ConstantColumnMapGenerator(columnMap, columnCount) };
// Note: we presume that the first item in the ProviderCommandInfo is the root node;
Debug.Assert(mappedCommandList.Count > 0, "empty providerCommandInfo collection and no exception?");
// this shouldn't ever happen.
// Then, generate the store commands from the resulting command tree(s)
_mappedCommandDefinitions = new List <DbCommandDefinition>(mappedCommandList.Count);
foreach (var providerCommandInfo in mappedCommandList)
{
var providerCommandDefinition = _storeProviderServices.CreateCommandDefinition(
providerCommandInfo.CommandTree, interceptionContext);
if (null == providerCommandDefinition)
{
throw new ProviderIncompatibleException(Strings.ProviderReturnedNullForCreateCommandDefinition);
}
_mappedCommandDefinitions.Add(providerCommandDefinition);
}
}
else
{
Debug.Assert(
DbCommandTreeKind.Function == commandTree.CommandTreeKind, "only query and function command trees are supported");
var entityCommandTree = (DbFunctionCommandTree)commandTree;
// Retrieve mapping and metadata information for the function import.
var mapping = GetTargetFunctionMapping(entityCommandTree);
IList <FunctionParameter> returnParameters = entityCommandTree.EdmFunction.ReturnParameters;
var resultSetCount = returnParameters.Count > 1 ? returnParameters.Count : 1;
_columnMapGenerators = new IColumnMapGenerator[resultSetCount];
var storeResultType = DetermineStoreResultType(mapping, 0, out _columnMapGenerators[0]);
for (var i = 1; i < resultSetCount; i++)
{
DetermineStoreResultType(mapping, i, out _columnMapGenerators[i]);
}
// Copy over parameters (this happens through a more indirect route in the plan compiler, but
// it happens nonetheless)
var providerParameters = new List <KeyValuePair <string, TypeUsage> >();
foreach (var parameter in entityCommandTree.Parameters)
{
providerParameters.Add(parameter);
}
// Construct store command tree usage.
var providerCommandTree = new DbFunctionCommandTree(
entityCommandTree.MetadataWorkspace, DataSpace.SSpace,
mapping.TargetFunction, storeResultType, providerParameters);
var storeCommandDefinition = _storeProviderServices.CreateCommandDefinition(providerCommandTree);
_mappedCommandDefinitions = new List <DbCommandDefinition>(1)
{
storeCommandDefinition
};
var firstResultEntitySet = mapping.FunctionImport.EntitySets.FirstOrDefault();
if (firstResultEntitySet != null)
{
_entitySets = new Set <EntitySet>();
_entitySets.Add(mapping.FunctionImport.EntitySets.FirstOrDefault());
_entitySets.MakeReadOnly();
}
}
// Finally, build a list of the parameters that the resulting command should have;
var parameterList = new List <EntityParameter>();
foreach (var queryParameter in commandTree.Parameters)
{
var parameter = CreateEntityParameterFromQueryParameter(queryParameter);
parameterList.Add(parameter);
}
_parameters = new ReadOnlyCollection <EntityParameter>(parameterList);
}
catch (EntityCommandCompilationException)
{
// No need to re-wrap EntityCommandCompilationException
throw;
}
catch (Exception e)
{
// we should not be wrapping all exceptions
if (e.IsCatchableExceptionType())
{
// we don't wan't folks to have to know all the various types of exceptions that can
// occur, so we just rethrow a CommandDefinitionException and make whatever we caught
// the inner exception of it.
throw new EntityCommandCompilationException(Strings.EntityClient_CommandDefinitionPreparationFailed, e);
}
throw;
}
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
throw new NotImplementedException();
}
/// <summary>
/// Sets the expected column types
/// </summary>
private void SetExpectedTypes(DbCommandTree commandTree, EFMySqlCommand cmd)
{
if (commandTree is DbQueryCommandTree)
SetQueryExpectedTypes(commandTree as DbQueryCommandTree, cmd);
else if (commandTree is DbFunctionCommandTree)
SetFunctionExpectedTypes(commandTree as DbFunctionCommandTree, cmd);
}
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(((NpgsqlProviderManifest)providerManifest).Version, commandTree));
}
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
{
return(CreateCommandDefinition(CreateDbCommand(commandTree)));
}
internal void TranslateCommandTree(Version serverVersion, DbCommandTree commandTree, DbCommand command, bool createParametersForNonSelect = true)
{
SqlBaseGenerator sqlGenerator = null;
DbQueryCommandTree select;
DbInsertCommandTree insert;
DbUpdateCommandTree update;
DbDeleteCommandTree delete;
if ((select = commandTree as DbQueryCommandTree) != null)
{
sqlGenerator = new SqlSelectGenerator(select);
}
else if ((insert = commandTree as DbInsertCommandTree) != null)
{
sqlGenerator = new SqlInsertGenerator(insert);
}
else if ((update = commandTree as DbUpdateCommandTree) != null)
{
sqlGenerator = new SqlUpdateGenerator(update);
}
else if ((delete = commandTree as DbDeleteCommandTree) != null)
{
sqlGenerator = new SqlDeleteGenerator(delete);
}
else
{
// TODO: get a message (unsupported DbCommandTree type)
throw new ArgumentException();
}
sqlGenerator._createParametersForConstants = select != null ? false : createParametersForNonSelect;
sqlGenerator._command = (NpgsqlCommand)command;
sqlGenerator.Version = serverVersion;
sqlGenerator.BuildCommand(command);
}
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);
}
