public MigrationCommandListBuilder([NotNull] IRelationalCommandBuilderFactory commandBuilderFactory) { Check.NotNull(commandBuilderFactory, nameof(commandBuilderFactory)); _commandBuilderFactory = commandBuilderFactory; _commandBuilder = commandBuilderFactory.Create(); }
public virtual MigrationCommandListBuilder EndCommand(bool suppressTransaction = false) { if (_commandBuilder.GetLength() != 0) { _commands.Add(new MigrationCommand(_commandBuilder.Build(), suppressTransaction)); _commandBuilder = _commandBuilderFactory.Create(); } return this; }
public virtual RelationalCommandListBuilder EndCommand() { if (_commandBuilder.GetLength() != 0) { _commands.Add(_commandBuilder.BuildRelationalCommand()); _commandBuilder = _commandBuilderFactory.Create(); } return this; }
/// <summary> /// Gets a relational command for a <see cref="SelectExpression"/>. /// </summary> /// <param name="selectExpression"> A select expression to print in command text. </param> /// <returns> A relational command with a SQL represented by the select expression. </returns> public virtual IRelationalCommand GetCommand([NotNull] SelectExpression selectExpression) { Check.NotNull(selectExpression, nameof(selectExpression)); _relationalCommandBuilder = _relationalCommandBuilderFactory.Create(); GenerateTagsHeaderComment(selectExpression); if (selectExpression.IsNonComposedFromSql()) { GenerateFromSql((FromSqlExpression)selectExpression.Tables[0]); } else { VisitSelect(selectExpression); } return(_relationalCommandBuilder.Build()); }
public static IRelationalCommandBuilder AddParameter( [NotNull] this IRelationalCommandBuilder commandBuilder, [NotNull] string name, [CanBeNull] object value, [NotNull] IProperty property) { Check.NotNull(commandBuilder, nameof(commandBuilder)); Check.NotEmpty(name, nameof(name)); Check.NotNull(property, nameof(property)); commandBuilder.AddParameter( name, value, t => t.GetMapping(property), property.IsNullable, invariantName: null); return(commandBuilder); }
/// <summary> /// Adds a parameter. /// </summary> /// <param name="commandBuilder"> The command builder. </param> /// <param name="invariantName"> /// The key that identifies this parameter. Note that <see cref="IRelationalParameter" /> just represents a /// placeholder for a parameter and not the actual value. This is because the same command can be /// reused multiple times with different parameter values. /// </param> /// <param name="name"> /// The name to be used for the parameter when the command is executed against the database. /// </param> /// <param name="relationalTypeMapping"> The relational type mapping for this parameter. </param> /// <param name="nullable"> A value indicating whether the parameter could contain a null value. </param> /// <returns> The same builder instance so that multiple calls can be chained. </returns> public static IRelationalCommandBuilder AddParameter( [NotNull] this IRelationalCommandBuilder commandBuilder, [NotNull] string invariantName, [NotNull] string name, [NotNull] RelationalTypeMapping relationalTypeMapping, bool?nullable) { Check.NotNull(commandBuilder, nameof(commandBuilder)); Check.NotEmpty(invariantName, nameof(invariantName)); Check.NotEmpty(name, nameof(name)); Check.NotNull(relationalTypeMapping, nameof(relationalTypeMapping)); return(commandBuilder.AddParameter( new TypeMappedRelationalParameter( invariantName, name, relationalTypeMapping, nullable))); }
/// <summary> /// Adds a parameter that is ultimately represented as multiple <see cref="DbParameter" />s in the /// final command. /// </summary> /// <param name="commandBuilder"> The command builder. </param> /// <param name="invariantName"> /// The key that identifies this parameter. Note that <see cref="IRelationalParameter" /> just represents a /// placeholder for a parameter and not the actual value. This is because the same command can be /// reused multiple times with different parameter values. /// </param> /// <param name="subParameters"> The parameters to include in the composite. </param> /// <returns> The same builder instance so that multiple calls can be chained. </returns> public static IRelationalCommandBuilder AddCompositeParameter( [NotNull] this IRelationalCommandBuilder commandBuilder, [NotNull] string invariantName, [NotNull] IReadOnlyList <IRelationalParameter> subParameters) { Check.NotNull(commandBuilder, nameof(commandBuilder)); Check.NotEmpty(invariantName, nameof(invariantName)); Check.NotNull(subParameters, nameof(subParameters)); if (subParameters.Count > 0) { commandBuilder.AddParameter( new CompositeRelationalParameter( invariantName, subParameters)); } return(commandBuilder); }
private IRelationalCommand CreateCommand(Object dataContext, String sql, IReadOnlyList <KeyValuePair <String, Object> > parameters, out Dictionary <String, Object> parameterValues) { var dbContext = (DbContext)dataContext; var commandBuilderFactory = dbContext.GetService <IRelationalCommandBuilderFactory>(); IRelationalCommandBuilder commandBuilder = commandBuilderFactory.Create(); commandBuilder.Append(sql); var parameterNameGenerator = dbContext.GetService <IParameterNameGeneratorFactory>().Create(); var sqlHelper = dbContext.GetService <ISqlGenerationHelper>(); parameterValues = new Dictionary <String, Object>(parameters.Count); for (int i = 0; i < parameters.Count; i++) { String invariantName = parameterNameGenerator.GenerateNext(); String name = sqlHelper.GenerateParameterName(invariantName); commandBuilder.AddParameter(invariantName, name); parameterValues.Add(invariantName, GetParameterCore(parameters[i], name, i)); } return(commandBuilder.Build()); }
/// <summary> /// Appends an object, that contains multiple lines of text, to the command text. /// Each line read from the object is appended on a new line. /// </summary> /// <param name="commandBuilder"> The command builder. </param> /// <param name="value"> The object to be written. </param> /// <param name="skipFinalNewline"> If <see langword="true" />, then the final newline character is skipped. </param> /// <returns> The same builder instance so that multiple calls can be chained. </returns> public static IRelationalCommandBuilder AppendLines( this IRelationalCommandBuilder commandBuilder, string value, bool skipFinalNewline = false) { Check.NotNull(commandBuilder, nameof(commandBuilder)); Check.NotNull(value, nameof(value)); using (var reader = new StringReader(value)) { var first = true; string?line; while ((line = reader.ReadLine()) != null) { if (first) { first = false; } else { commandBuilder.AppendLine(); } if (line.Length != 0) { commandBuilder.Append(line); } } } if (!skipFinalNewline) { commandBuilder.AppendLine(); } return(commandBuilder); }
public static IRelationalCommandBuilder AddParameter( [NotNull] this IRelationalCommandBuilder commandBuilder, [NotNull] string name, [CanBeNull] object value, [NotNull] Type type) { Check.NotNull(commandBuilder, nameof(commandBuilder)); Check.NotEmpty(name, nameof(name)); Check.NotNull(type, nameof(type)); bool?isNullable = null; if (type.IsNullableType()) { isNullable = true; type = type.UnwrapNullableType(); } return(commandBuilder.AddParameter( name, value, t => t.GetMapping(type), isNullable)); }
public Indenter(IRelationalCommandBuilder builder) { _builder = builder; _builder.IncrementIndent(); }
/// <summary> /// Adds a parameter. /// </summary> /// <param name="commandBuilder">The command builder.</param> /// <param name="invariantName"> /// The key that identifies this parameter. Note that <see cref="IRelationalParameter" /> just represents a /// placeholder for a parameter and not the actual value. This is because the same command can be /// reused multiple times with different parameter values. /// </param> /// <param name="dbParameter">The DbParameter being added.</param> /// <returns>The same builder instance so that multiple calls can be chained.</returns> public static IRelationalCommandBuilder AddRawParameter( this IRelationalCommandBuilder commandBuilder, string invariantName, DbParameter dbParameter) => commandBuilder.AddParameter( new RawRelationalParameter(invariantName, dbParameter));
/// <summary> /// Gets the length of the command text. /// </summary> /// <param name="commandBuilder"> The command builder. </param> /// <returns> The length of the command text. </returns> public static int GetLength([NotNull] this IRelationalCommandBuilder commandBuilder) => Check.NotNull(commandBuilder, nameof(commandBuilder)).Instance.Length;
/// <summary> /// Increases the indent of the command text. /// </summary> /// <param name="commandBuilder"> The command builder. </param> /// <returns> The same builder instance so that multiple calls can be chained. </returns> public static IDisposable Indent([NotNull] this IRelationalCommandBuilder commandBuilder) => Check.NotNull(commandBuilder, nameof(commandBuilder)).Instance.Indent();
/// <summary> /// Increases the indent of the command text. /// </summary> /// <param name="commandBuilder"> The command builder. </param> /// <returns> The same builder instance so that multiple calls can be chained. </returns> public static IDisposable Indent(this IRelationalCommandBuilder commandBuilder) => new Indenter(Check.NotNull(commandBuilder, nameof(commandBuilder)));
/// <summary> /// Increases the indent of the command text. /// </summary> /// <param name="commandBuilder">The command builder.</param> /// <returns>The same builder instance so that multiple calls can be chained.</returns> public static IDisposable Indent(this IRelationalCommandBuilder commandBuilder) => new Indenter(commandBuilder);
public static Expression VisitSelect(IZackQuerySqlGenerator sqlGenerator, ISqlGenerationHelper _sqlGenerationHelper, SelectExpression selectExpression) { if (BatchUtils.IsNonComposedSetOperation(selectExpression)) { sqlGenerator.P_GenerateSetOperation((SetOperationBase)selectExpression.Tables[0]); return(selectExpression); } IRelationalCommandBuilder Sql = sqlGenerator.P_Sql; IDisposable disposable = null; if (selectExpression.Alias != null) { Sql.AppendLine("("); disposable = sqlGenerator.P_Sql.Indent(); } Sql.Append("SELECT "); if (selectExpression.IsDistinct) { Sql.Append("DISTINCT "); } sqlGenerator.P_GenerateTop(selectExpression); if (selectExpression.Projection.Any()) { BatchUtils.GenerateList(selectExpression.Projection, Sql, delegate(ProjectionExpression e) { var oldSQL = Sql.Build().CommandText; //zack's code sqlGenerator.Visit(e); string column = BatchUtils.Diff(oldSQL, Sql.Build().CommandText); //zack's code sqlGenerator.ProjectionSQL.Add(column); //zack's code }); } else { Sql.Append("1"); sqlGenerator.ProjectionSQL.Add("1"); //zack's code } if (selectExpression.Tables.Any()) { Sql.AppendLine().Append("FROM "); BatchUtils.GenerateList(selectExpression.Tables, Sql, delegate(TableExpressionBase e) { sqlGenerator.Visit(e); }, delegate(IRelationalCommandBuilder sql) { sql.AppendLine(); }); } else { sqlGenerator.P_GeneratePseudoFromClause(); } if (selectExpression.Predicate != null) { Sql.AppendLine().Append("WHERE "); var oldSQL = Sql.Build().CommandText; //zack's code sqlGenerator.Visit(selectExpression.Predicate); sqlGenerator.PredicateSQL = BatchUtils.Diff(oldSQL, Sql.Build().CommandText); //zack's code } if (selectExpression.GroupBy.Count > 0) { Sql.AppendLine().Append("GROUP BY "); BatchUtils.GenerateList(selectExpression.GroupBy, Sql, delegate(SqlExpression e) { sqlGenerator.Visit(e); }); } if (selectExpression.Having != null) { Sql.AppendLine().Append("HAVING "); sqlGenerator.Visit(selectExpression.Having); } sqlGenerator.P_GenerateOrderings(selectExpression); sqlGenerator.P_GenerateLimitOffset(selectExpression); if (selectExpression.Alias != null) { disposable.Dispose(); Sql.AppendLine().Append(")" + sqlGenerator.P_AliasSeparator + _sqlGenerationHelper.DelimitIdentifier(selectExpression.Alias)); } return(selectExpression); }
public static IRelationalCommandBuilder AddParameter( this IRelationalCommandBuilder commandBuilder, string invariantName, string name) => throw new InvalidOperationException("Use overload which takes TypeMapping argument.");
public MyRelationalCommandBuilderFactory(IRelationalCommandBuilder builder) { _builder = builder; }