/// <summary> /// Conditionally add previous built clause to this clause. If condition returns true, clause is added. Otherwise, it is not. /// </summary> /// <param name="clause">Previously built clause.</param> /// <param name="condition">Clause condition which determines if clause will be inserted. The parameter passed into this is the value parameter of this method. Returning true adds clause, false skips it.</param> /// <returns>Modified clause if condition was true. Otherwise, returns input clause.</returns> public Clause AddClause(Clause clause, Func <bool> condition) { bool conditionFailed = condition() == false; if (conditionFailed) { return(this); } SimpleDataOrder dataOrder = clause.Build(); if (string.IsNullOrWhiteSpace(dataOrder.Query)) { return(this); } return(GetClone(string.Join($"{Environment.NewLine} ", dataOrder.Query.Split(new[] { Environment.NewLine, "\r\n", "\r", "\n" }, StringSplitOptions.None)), dataOrder.Parameters)); }
/// <summary> /// Used to create a query to update values on multiple tables. /// </summary> /// <param name="order">The information to create query.</param> /// <returns>The <see cref="IAliasedCommandTypeDataOrder"/> created.</returns> public static IAliasedCommandTypeDataOrder UpdateMultiple(IEnumerable <UpdateMultipleOrder> order) { order = order ?? new UpdateMultipleOrder[0]; if (order.Any() == false) { return(new AliasedCommandTypeDataOrder()); } string nullKey = "@null"; var parms = order .SelectMany(o => o.Values) .GroupBy(model => model.Item2) .Where(group => group.Key != null) .Select(group => Tuple.Create("@" + Get.SafeGuid(), group.Key)) .ToArray(); var queries = order .Select(model => { IEnumerable <Tuple <string, string> > updateParameters = model .Values .Select(value => Tuple.Create(value.Item1, parms.FirstOrDefault(p => p.Item2?.Equals(value.Item2) ?? false)?.Item1 ?? nullKey)); string query = $"UPDATE {model.TableName} SET{string.Join(",", updateParameters.Select(tuple => $"\r\n {tuple.Item1} = {tuple.Item2}"))}\r\nWHERE"; SimpleDataOrder clause = Clause.New().AddClause(model.Id.Item2, Clause.EqualStatementCallback(model.Id.Item1, model.TableName)).Build(); query += clause.Query; return(new AliasedDataOrder(query, clause.Parameters)); }).ToArray(); var aggregatedQuery = string.Join("\r\n\r\n", queries.Select(query => query.Query)); var aliases = queries.SelectMany(query => query.Aliases); var parameters = parms.Select(tuple => new KeyValuePair <string, object>(tuple.Item1, tuple.Item2)).Concat(queries.SelectMany(query => query.Parameters)).ToList(); if (aggregatedQuery.Contains(nullKey)) { parameters.Insert(0, new KeyValuePair <string, object>(nullKey, null)); } return(new AliasedCommandTypeDataOrder(SurroundQueryWithTransaction(aggregatedQuery), System.Data.CommandType.Text, parameters, aliases)); }