public virtual DatabaseCommand GenerateAlterTable(AlterTableExpression model) { StringBuilder sb = new StringBuilder(); foreach (var column in model.DropColumns) { sb.AppendFormat(DropColumnFormat, Dialect.QuoteTableName(model.TableName), Dialect.QuoteColumnName(column)); sb.AppendLine(";"); } foreach (var column in model.AlterColumns) { string columnDefinition = ColumnGenerator.Generate(column); sb.AppendFormat(AlterColumnFormat, Dialect.QuoteTableName(model.TableName), columnDefinition); sb.AppendLine(";"); } foreach (var column in model.AddColumns) { string columnDefinition = ColumnGenerator.Generate(column); sb.AppendFormat(AddColumnFormat, Dialect.QuoteTableName(model.TableName), columnDefinition); sb.AppendLine(";"); } return(new DatabaseCommand(sb.ToString())); }
public virtual DatabaseCommand GenerateCreateTable(CreateTableExpression model) { string columns = ColumnGenerator.Generate(model.Columns); string cmd = string.Format(CreateTableFormat, Dialect.QuoteTableName(model.TableName), columns); return(new DatabaseCommand(cmd)); }
[InlineData(20, 11)] //// Huge width, not divisible three public void TestGetColumnToHandleRarelyReturnsSameColumnForTwoPlayersAfterSecondTime(int width, int numberOfPlayers) { // Arrange Assert.False(width < numberOfPlayers); var handledColumns = new HashSet <int>(); int repeatCount = 0; // Act for (int k = 0; k < numberOfPlayers; ++k) { var columnGenerator = new ColumnGenerator(k, width, numberOfPlayers); int col1 = columnGenerator.GetColumnToHandle(1); int col2 = columnGenerator.GetColumnToHandle(2); repeatCount += handledColumns.Contains(col1) ? 1 : 0; repeatCount += handledColumns.Contains(col2) ? 1 : 0; handledColumns.Add(col1); handledColumns.Add(col2); } // Assert int val = Math.Max((numberOfPlayers * 2) - width, numberOfPlayers * 2 / width); Assert.True(repeatCount <= val, $"Should not repeat, \n expected {repeatCount} <= {val} "); }
public void ApplyColumn(OpenApiSchema schema, OpenApiSchema columnSchema, ColumnGenerator column) { if ((column.Attribute.Keys & DBColumnKeys.Password) == DBColumnKeys.Password || (column.Attribute.Keys & DBColumnKeys.File) == DBColumnKeys.File) { return; } ApplyColumnAttribute(schema, columnSchema, column.Attribute, column.PropertyInfo); if (column.Culture != null) { columnSchema.Extensions.Add("x-culture", new OpenApiString(column.Culture.ToString())); } var defaultValue = column.PropertyInfo.GetCustomAttribute <DefaultValueAttribute>(); if (defaultValue != null && defaultValue.Value != null) { ApplyDefault(columnSchema, defaultValue.Value); } schema.Properties.Add(column.PropertyName, columnSchema); //if (TypeHelper.GetPassword(column.Property)) //{ // schema.Extensions.Add("x-data", column.PropertyName); //} }
public void ApplyColumn(Schema schema, Schema columnSchema, ColumnGenerator column) { if ((column.Attribute.Keys & DBColumnKeys.Password) == DBColumnKeys.Password || (column.Attribute.Keys & DBColumnKeys.File) == DBColumnKeys.File) { return; } if (column.GetDataType() == typeof(string) && column.Size > 0) { columnSchema.MaxLength = column.Size; } if ((column.Attribute.Keys & DBColumnKeys.Access) == DBColumnKeys.Access || (column.Attribute.Keys & DBColumnKeys.Date) == DBColumnKeys.Date || (column.Attribute.Keys & DBColumnKeys.Stamp) == DBColumnKeys.Stamp || (column.Attribute.Keys & DBColumnKeys.System) == DBColumnKeys.System || column.PropertyInfo?.GetSetMethod() == null) { columnSchema.ReadOnly = true; } if (((column.Attribute.Keys & DBColumnKeys.Notnull) == DBColumnKeys.Notnull || (column.Attribute.Keys & DBColumnKeys.ItemType) == DBColumnKeys.ItemType) || (column.Attribute.Keys & DBColumnKeys.Primary) == DBColumnKeys.Primary) { if (schema.Required == null) { schema.Required = new List <string>(); } schema.Required.Add(column.PropertyName); } if ((column.Attribute.Keys & DBColumnKeys.Primary) == DBColumnKeys.Primary) { schema.Extensions.Add("x-id", column.PropertyName); } if ((column.Attribute.Keys & DBColumnKeys.ItemType) == DBColumnKeys.ItemType) { schema.Extensions.Add("x-type", column.PropertyName); } schema.Properties.Add(column.PropertyName, columnSchema); var defaultValue = column.PropertyInfo.GetCustomAttribute <DefaultValueAttribute>(); if (defaultValue != null && defaultValue.Value != null) { if (defaultValue.Value.GetType().IsEnum) { columnSchema.Default = EnumItem.Format(defaultValue.Value); } else { columnSchema.Default = defaultValue.Value.ToString(); } } //if (TypeHelper.GetPassword(column.Property)) //{ // schema.Extensions.Add("x-data", column.PropertyName); //} }
private void AddColumn(ColumnDefinition columnDefinition, int?index = null) { var column = ColumnGenerator.CreateColumnForDefinition(columnDefinition); SetAssociatedColumn(column, columnDefinition); if (!index.HasValue) { AssociatedObject.Columns.Add(column); } else { AssociatedObject.Columns.Insert(index.Value, column); } }
[InlineData(40, 11)] //// Huge width, not divisible three public void TestGetColumnToHandleNeverReturnsSameColumnForTwoPlayersInitialy(int width, int numberOfPlayers) { Assert.False(width < numberOfPlayers); // A & A & A var handledColumns = new HashSet <int>(); for (int k = 0; k < numberOfPlayers; ++k) { var columnGenerator = new ColumnGenerator(k, width, numberOfPlayers); int col = columnGenerator.GetColumnToHandle(1); Assert.DoesNotContain(col, handledColumns); handledColumns.Add(col); } }
[InlineData(15, 20)] //// Huge number of players public void TestGetColumnToHandleNeverReturnsSameColumnForParticularPlayer(int width, int numberOfPlayers) { // A & A & A for (int k = 0; k < numberOfPlayers; ++k) { var columnGenerator = new ColumnGenerator(k, width, numberOfPlayers); var handledColumns = new HashSet <int>(); for (int i = 1; i <= width; ++i) { int col = columnGenerator.GetColumnToHandle(i); Assert.DoesNotContain(col, handledColumns); handledColumns.Add(col); } } }
private static SelectExpression ExtractOrders(SelectExpression sel, out List <OrderExpression>?innerOrders) { if (sel.Top != null || (sel.OrderBy.Count == 0)) { innerOrders = null; return(sel); } else { ColumnGenerator cg = new ColumnGenerator(sel.Columns); Dictionary <OrderExpression, ColumnDeclaration> newColumns = sel.OrderBy.ToDictionary(o => o, o => cg.NewColumn(o.Expression)); innerOrders = newColumns.Select(kvp => new OrderExpression(kvp.Key.OrderType, kvp.Value.GetReference(sel.Alias))).ToList(); return(new SelectExpression(sel.Alias, sel.IsDistinct, sel.Top, sel.Columns.Concat(newColumns.Values), sel.From, sel.Where, null, sel.GroupBy, sel.SelectOptions)); } }
public MessagePackGridViewModel(object data) { var type = data.GetType(); Type elementType = type; var(isEnumerable, interfaceType) = type.IsEnumerable(); if (isEnumerable) { elementType = interfaceType.GetGenericArguments()[0]; _data.AddRange(ReflectionHelper.GetEnumerableValues(data).Select((x, i) => new TreeViewItem <object>(i + 1, 0, x.ToString(), x))); } else //not collection { _data.Add(new TreeViewItem <object>(1, 0, "", data)); } //Header _columns.AddRange(ColumnGenerator.GetColumnGenerator(elementType).GenerateColumns(elementType)); }
private ReadOnlyCollection <ColumnDeclaration> AnswerAndExpand(ReadOnlyCollection <ColumnDeclaration> columns, Alias currentAlias, Dictionary <ColumnExpression, ColumnExpression?> askedColumns) { ColumnGenerator cg = new ColumnGenerator(columns); foreach (var col in askedColumns.Keys.ToArray()) { if (col.Alias == currentAlias) { //Expression expr = columns.SingleEx(cd => (cd.Name ?? "-") == col.Name).Expression; //askedColumns[col] = expr is SqlConstantExpression ? expr : col; askedColumns[col] = col; } else { ColumnExpression?colExp = CurrentScope[col]; //if (expr is ColumnExpression colExp) //{ ColumnDeclaration?cd = cg.Columns.FirstOrDefault(c => c !.Expression.Equals(colExp)); if (cd == null) { cd = cg.MapColumn(colExp !); } askedColumns[col] = new ColumnExpression(col.Type, currentAlias, cd.Name); //} //else //{ // askedColumns[col] = expr; //} } } if (columns.Count != cg.Columns.Count()) { return(cg.Columns.NotNull().ToReadOnly()); } return(columns); }
protected internal override Expression VisitSelect(SelectExpression select) { bool isOuterMost = select == outerMostSelect; if (select.IsOrderAlsoByKeys || select.HasIndex || select.Top != null && hasProjectionInProjector) { if (gatheredKeys == null) { gatheredKeys = new List <ColumnExpression>(); } } List <ColumnExpression>?savedKeys = null; if (gatheredKeys != null && (select.IsDistinct || select.GroupBy.HasItems() || select.IsAllAggregates)) { savedKeys = gatheredKeys.ToList(); } if ((AggregateFinder.GetAggregates(select.Columns)?.Any(a => a.AggregateFunction.OrderMatters()) ?? false) && select.From is SelectExpression from) { var oldOuterMostSelect = outerMostSelect; outerMostSelect = from; select = (SelectExpression)base.VisitSelect(select); outerMostSelect = oldOuterMostSelect; } else { select = (SelectExpression)base.VisitSelect(select); } if (savedKeys != null) { gatheredKeys = savedKeys; } List <ColumnDeclaration>?newColumns = null; if (select.GroupBy.HasItems()) { gatheredOrderings = null; if (gatheredKeys != null) { ColumnGenerator cg = new ColumnGenerator(select.Columns); var newKeys = new List <ColumnDeclaration>(); foreach (var ge in select.GroupBy) { var cd = cg.Columns.NotNull().FirstOrDefault(a => DbExpressionComparer.AreEqual(a.Expression, ge)); if (cd != null) { newKeys.Add(cd); } else { newKeys.Add(cg.NewColumn(ge)); } } if (cg.Columns.Count() != select.Columns.Count) { newColumns = cg.Columns.NotNull().ToList(); } gatheredKeys.AddRange(newKeys.Select(cd => new ColumnExpression(cd.Expression.Type, select.Alias, cd.Name))); } } if (select.IsAllAggregates) { if (gatheredKeys != null) { gatheredKeys.AddRange(select.Columns.Select(cd => new ColumnExpression(cd.Expression.Type, select.Alias, cd.Name))); } } if (select.IsDistinct) { gatheredOrderings = null; if (gatheredKeys != null) { gatheredKeys.AddRange(select.Columns.Select(cd => cd.GetReference(select.Alias))); } } if (select.IsReverse && !gatheredOrderings.IsNullOrEmpty()) { gatheredOrderings = gatheredOrderings.Select(o => new OrderExpression( o.OrderType == OrderType.Ascending ? OrderType.Descending : OrderType.Ascending, o.Expression)).ToReadOnly(); } if (select.OrderBy.Count > 0) { this.PrependOrderings(select.OrderBy); } ReadOnlyCollection <OrderExpression>?orderings = null; if (isOuterMost && !IsCountSumOrAvg(select) || select.Top != null) { AppendKeys(); orderings = gatheredOrderings; gatheredOrderings = null; } if (AreEqual(select.OrderBy, orderings) && !select.IsReverse && newColumns == null) { return(select); } return(new SelectExpression(select.Alias, select.IsDistinct, select.Top, (IEnumerable <ColumnDeclaration>?)newColumns ?? select.Columns, select.From, select.Where, orderings, select.GroupBy, select.SelectOptions & ~SelectOptions.Reverse)); }
public virtual DatabaseCommand GenerateAlterColumn(string tableName, string columnName, Models.DbType type, int length, object defaultValue, bool allowNull) { string columnDefinition = ColumnGenerator.Generate(columnName, type, length, defaultValue, allowNull); return(new DatabaseCommand(string.Format(AlterColumnFormat, tableName, columnDefinition))); }
public virtual DatabaseCommand GenerateAddColumn(string tableName, string columnName, Models.DbType type, bool allowNull) { string columnDefinition = ColumnGenerator.Generate(columnName, type, allowNull); return(new DatabaseCommand(string.Format(AddColumnFormat, tableName, columnDefinition))); }
private static void GenerateReferenceProperty(OpenApiSchema schema, SchemaFilterContext context, ColumnGenerator column) { var refPropertyType = column.ReferencePropertyInfo.PropertyType; var referenceSchema = context.SchemaGenerator.GenerateSchema(refPropertyType, context.SchemaRepository); var propertySchema = new OpenApiSchema() { AllOf = new List <OpenApiSchema> { referenceSchema } }; propertySchema.Extensions.Add("x-id", new OpenApiString(column.PropertyName)); schema.Properties.Add(column.ReferencePropertyInfo.Name, propertySchema); }
protected internal override Expression VisitProjection(ProjectionExpression proj) { if (currentSource == null) { currentSource = WithoutOrder(proj.Select); Expression projector = this.Visit(proj.Projector); if (projector != proj.Projector) { proj = new ProjectionExpression(proj.Select, projector, proj.UniqueFunction, proj.Type); } currentSource = null; return(proj); } else { HashSet <ColumnExpression> columns = ExternalColumnGatherer.Gatherer(proj, currentSource.Alias); if (columns.Count == 0) { Expression projector = Visit(proj.Projector); ConstantExpression key = Expression.Constant(0); Type kvpType = typeof(KeyValuePair <,>).MakeGenericType(key.Type, projector.Type); ConstructorInfo ciKVP = kvpType.GetConstructor(new[] { key.Type, projector.Type }) !; Type projType = proj.UniqueFunction == null ? typeof(IEnumerable <>).MakeGenericType(kvpType) : kvpType; var childProj = new ProjectionExpression(proj.Select, Expression.New(ciKVP, key, projector), proj.UniqueFunction, projType); return(new ChildProjectionExpression(childProj, Expression.Constant(0), inMList != null, inMList ?? proj.Type, new LookupToken())); } else { SelectExpression external; IEnumerable <ColumnExpression> externalColumns; if (!IsKey(currentSource, columns)) { Alias aliasDistinct = aliasGenerator.GetUniqueAlias(currentSource.Alias.Name + "D"); ColumnGenerator generatorDistinct = new ColumnGenerator(); List <ColumnDeclaration> columnDistinct = columns.Select(ce => generatorDistinct.MapColumn(ce)).ToList(); external = new SelectExpression(aliasDistinct, true, null, columnDistinct, currentSource, null, null, null, 0); Dictionary <ColumnExpression, ColumnExpression> distinctReplacements = columnDistinct.ToDictionary( cd => (ColumnExpression)cd.Expression, cd => cd.GetReference(aliasDistinct)); proj = (ProjectionExpression)ColumnReplacer.Replace(proj, distinctReplacements); externalColumns = distinctReplacements.Values.ToHashSet(); } else { external = currentSource; externalColumns = columns; } ColumnGenerator generatorSM = new ColumnGenerator(); List <ColumnDeclaration> columnsSMExternal = externalColumns.Select(ce => generatorSM.MapColumn(ce)).ToList(); List <ColumnDeclaration> columnsSMInternal = proj.Select.Columns.Select(cd => generatorSM.MapColumn(cd.GetReference(proj.Select.Alias))).ToList(); SelectExpression @internal = ExtractOrders(proj.Select, out List <OrderExpression>?innerOrders); Alias aliasSM = aliasGenerator.GetUniqueAlias(@internal.Alias.Name + "SM"); SelectExpression selectMany = new SelectExpression(aliasSM, false, null, columnsSMExternal.Concat(columnsSMInternal), new JoinExpression(JoinType.CrossApply, external, @internal, null), null, innerOrders, null, 0); SelectExpression old = currentSource; currentSource = WithoutOrder(selectMany); var selectManyReplacements = selectMany.Columns.ToDictionary( cd => (ColumnExpression)cd.Expression, cd => cd.GetReference(aliasSM)); Expression projector = ColumnReplacer.Replace(proj.Projector, selectManyReplacements); projector = Visit(projector); currentSource = old; Expression key = TupleReflection.TupleChainConstructor(columnsSMExternal.Select(cd => MakeEquatable(cd.GetReference(aliasSM)))); Type kvpType = typeof(KeyValuePair <,>).MakeGenericType(key.Type, projector.Type); ConstructorInfo ciKVP = kvpType.GetConstructor(new[] { key.Type, projector.Type }) !; Type projType = proj.UniqueFunction == null ? typeof(IEnumerable <>).MakeGenericType(kvpType) : kvpType; var childProj = new ProjectionExpression(selectMany, Expression.New(ciKVP, key, projector), proj.UniqueFunction, projType); return(new ChildProjectionExpression(childProj, TupleReflection.TupleChainConstructor(columns.Select(a => MakeEquatable(a))), inMList != null, inMList ?? proj.Type, new LookupToken())); } } }