public static IDataType NativeTypeNameToDataType(Schema.DataTypes dataTypes, string nativeDataTypeName) { if (nativeDataTypeName.ToLower().StartsWith("row")) { var rowType = new RowType(); rowType.Columns.AddRange(ParseColumnTypes(dataTypes, nativeDataTypeName.Substring(4, nativeDataTypeName.Length - 5))); return(rowType); } else if (nativeDataTypeName.ToLower().StartsWith("table")) { var tableType = new TableType(); tableType.Columns.AddRange(ParseColumnTypes(dataTypes, nativeDataTypeName.Substring(6, nativeDataTypeName.Length - 7))); return(tableType); } else if (nativeDataTypeName.ToLower().StartsWith("list")) { var elementType = NativeTypeNameToDataType(dataTypes, nativeDataTypeName.Substring(5, nativeDataTypeName.Length - 6)); return(new ListType(elementType)); } else { return(NativeScalarTypeNameToDataType(dataTypes, nativeDataTypeName)); } }
private DAE.Runtime.Data.Row CreateSearchRow() { // Determine the last search control with a search value SearchControl pendingIncremental = null; SearchControl control; for (int i = _searchControls.Count - 1; i >= 0; i--) { control = (SearchControl)_searchControls[i]; if (control.Value != null) { pendingIncremental = control; break; } } if (pendingIncremental != null) { // FROM WINDOWS CLIENT // Build a row consisting of order columns up to and including the pending control RowType rowType = new RowType(); foreach (OrderColumn column in _order.Columns) { rowType.Columns.Add(new DAE.Schema.Column(column.Column.Name, column.Column.DataType)); if (column.Column.Name == pendingIncremental.ColumnName) { break; } } DAE.Runtime.Data.Row row = new DAE.Runtime.Data.Row(Source.Process.ValueManager, rowType); try { Source.DataView.InitializeFromMaster(row); foreach (DAE.Schema.Column column in rowType.Columns) { if (!Source.DataView.IsDetailKey(column.Name)) { if (!FindSearchControl(column.Name).ExtractValue(row)) { return(null); } } } return(row); } catch { row.Dispose(); throw; } // END FROM WINDOWS CLIENT } else { return(null); } }
protected virtual void DeserializeRows(XElement rowsNode) { if (rowsNode == null) { return; } foreach (var rowNode in rowsNode.Elements("row")) { RowType type = RowType.None; Enum.TryParse(rowNode.Attribute("rtype")?.Value, out type); switch (type) { case RowType.Row: var row = new Row.rMindRow(); row.Deserialize(rowNode); AddRow(row); break; case RowType.Separator: AddSeparator(); break; } } }
private void SingleCell(RowType row, ColumnType col, PropertyInfo pi, ref int rowIdx) { object cell = pi.GetValue(this, null); m_TickList.Add(new Position(rowIdx, (int)col - 1), cell == null ? null : ((CellBase)cell).Cell); rowIdx++; }
/// <summary> /// Draws a rectangular gradient background color. /// </summary> /// <param name="pdfRowType">Main table's row types</param> /// <param name="sharedData">PdfCells Shared Data</param> /// <param name="position">The coordinates of the cell</param> /// <param name="canvases">An array of PdfContentByte to add text or graphics</param> public static void ApplyGradientBackground(RowType pdfRowType, CellSharedData sharedData, Rectangle position, PdfContentByte[] canvases) { BaseColor startColor = null; BaseColor endColor = null; switch (pdfRowType) { case RowType.HeaderRow: if (sharedData.Template.HeaderBackgroundColor.Count < 2) return; startColor = sharedData.Template.HeaderBackgroundColor[0]; endColor = sharedData.Template.HeaderBackgroundColor[1]; break; case RowType.PreviousPageSummaryRow: if (sharedData.Template.PreviousPageSummaryRowBackgroundColor.Count < 2) return; startColor = sharedData.Template.PreviousPageSummaryRowBackgroundColor[0]; endColor = sharedData.Template.PreviousPageSummaryRowBackgroundColor[1]; break; case RowType.SummaryRow: case RowType.AllGroupsSummaryRow: if (sharedData.Template.SummaryRowBackgroundColor.Count < 2) return; startColor = sharedData.Template.SummaryRowBackgroundColor[0]; endColor = sharedData.Template.SummaryRowBackgroundColor[1]; break; case RowType.PageSummaryRow: if (sharedData.Template.PageSummaryRowBackgroundColor.Count < 2) return; startColor = sharedData.Template.PageSummaryRowBackgroundColor[0]; endColor = sharedData.Template.PageSummaryRowBackgroundColor[1]; break; } DrawGradientBackground(position, canvases, startColor, endColor); }
internal IniRow(RowType type, string arg0, string arg1 = null, StringUtil.EscapeHint hint = StringUtil.EscapeHint.None) { this.rowType = type; this.arg0 = arg0; this.arg1 = arg1; this.hint = hint; }
public static CSVData AddRow(CSVData data, RowType row) { CSVData ret = new CSVData(data); ret.AddRow(row); return(ret); }
public string PickLightColor(int clockLightNumber, RowType rowType) { switch (rowType) { case RowType.TopLightLow: return(LightColor.Yellow); case RowType.TopHourRow: return(LightColor.Red); case RowType.BottomHourRow: return(LightColor.Red); case RowType.TopMinuteRow: { return((clockLightNumber != 0 && clockLightNumber % 3 == 0) ? LightColor.Red : LightColor.Yellow); } case RowType.BottomMinuteRow: return(LightColor.Yellow); default: return(LightColor.None); } }
protected void VisitNewInstanceExpression(SelectStatement select, DbNewInstanceExpression expression) { Debug.Assert(expression.ResultType.EdmType is RowType); RowType row = expression.ResultType.EdmType as RowType; for (int i = 0; i < expression.Arguments.Count; i++) { ColumnFragment col; SqlFragment fragment = expression.Arguments[i].Accept(this); if (fragment is ColumnFragment) { col = fragment as ColumnFragment; } else { col = new ColumnFragment(null, null); col.Literal = fragment; } col.ColumnAlias = row.Properties[i].Name; select.Columns.Add(col); } }
/// <summary> /// Specialization of <see cref="CreatePlaceholder" /> for a relationship set extent. /// </summary> /// <param name="associationSet"></param> /// <returns></returns> private PropagatorResult CreateAssociationSetPlaceholder(AssociationSet associationSet) { Debug.Assert(null != associationSet, "Caller must verify parameters are not null"); var endMetadata = associationSet.ElementType.AssociationEndMembers; PropagatorResult[] endReferenceValues = new PropagatorResult[endMetadata.Count]; // Create a reference expression for each end in the relationship for (int endOrdinal = 0; endOrdinal < endMetadata.Count; endOrdinal++) { var end = endMetadata[endOrdinal]; EntityType entityType = (EntityType)((RefType)end.TypeUsage.EdmType).ElementType; // Retrieve key values for this end PropagatorResult[] keyValues = new PropagatorResult[entityType.KeyMembers.Count]; for (int memberOrdinal = 0; memberOrdinal < entityType.KeyMembers.Count; memberOrdinal++) { EdmMember keyMember = entityType.KeyMembers[memberOrdinal]; PropagatorResult keyValue = CreateMemberPlaceholder(keyMember); keyValues[memberOrdinal] = keyValue; } RowType endType = entityType.GetKeyRowType(m_parent.MetadataWorkspace); PropagatorResult refKeys = PropagatorResult.CreateStructuralValue(keyValues, endType, false); endReferenceValues[endOrdinal] = refKeys; } PropagatorResult result = PropagatorResult.CreateStructuralValue(endReferenceValues, associationSet.ElementType, false); return(result); }
private static LegacyMetadata.RowType ToLegacyRowType( this RowType rowType, LegacyMetadata.EdmType[] legacyStoreTypes = null) { Debug.Assert(rowType != null, "rowType != null"); var properties = rowType.Properties.Select( p => (LegacyMetadata.EdmProperty)LegacyEdmProperyCtor.Invoke( BindingFlags.CreateInstance, null, new object[] { p.Name, p.TypeUsage.EdmType.GetDataSpace() == DataSpace.CSpace ? p.TypeUsage.ToLegacyEdmTypeUsage() : p.TypeUsage.ToLegacyStoreTypeUsage(legacyStoreTypes) }, CultureInfo.InvariantCulture)).ToArray(); return ((LegacyMetadata.RowType)LegacyRowTypeCtor.Invoke( BindingFlags.CreateInstance, null, new object[] { properties }, CultureInfo.InvariantCulture)); }
private void AddCustomRowObject(CustomFormObject formObject, int NumberOfRows, RowType rowType) { for (int i = 0; i < NumberOfRows; i++) { formObject.Rows.Add(CreateRowObject(rowType)); } }
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_anonymous_types() { var metadataWorkspaceMock = new Mock <MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create()); var edmProperties = new [] { new EdmProperty("P1Int", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), new FacetValues { Nullable = false })), new EdmProperty("P2Bool", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean))) }; var cSpaceEntityType = new RowType(edmProperties); var entityTypeUsage = TypeUsage.Create(cSpaceEntityType); var recordMap = new RecordColumnMap( entityTypeUsage, "E", new[] { new ScalarColumnMap(cSpaceEntityType.Properties[0].TypeUsage, cSpaceEntityType.Properties[0].Name, 0, 0) }, new ScalarColumnMap(cSpaceEntityType.Properties[1].TypeUsage, cSpaceEntityType.Properties[1].Name, 0, 1)); var collectionMap = new SimpleCollectionColumnMap( entityTypeUsage, "MockCollectionType", recordMap, null, null); var factory = new Translator().TranslateColumnMap <object>( collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false); Assert.NotNull(factory); Assert.Equal(new[] { typeof(int), null }, factory.ColumnTypes); Assert.Equal(new[] { true, true }, factory.NullableColumns); }
private NewInstancePredicate CreateNewRowExpression(List <KeyValuePair <string, Predicate> > columns, NewExpression linq) { //var propertyValues = new List<Predicate>(columns.Count); //for (var i = 0; i < columns.Count; i++) //{ // var column = columns[i]; // propertyValues.Add(column.Value); //} //var rowType = new RowType(properties, initializerMetadata) //return new NewInstancePredicate(null, new PredicateList(propertyValues)); var propertyValues = new List <Predicate>(columns.Count); var properties = new List <EdmProperty>(columns.Count); for (var i = 0; i < columns.Count; i++) { var column = columns[i]; propertyValues.Add(column.Value); properties.Add(new EdmProperty(column.Key, column.Value.ResultType)); } var rowType = new RowType(properties, linq); var typeUsage = TypeUsage.Create(rowType); return(typeUsage.New(propertyValues)); }
internal override TypeUsage GetTypeUsage() { if (this._typeUsage == null) { List <EdmProperty> edmPropertyList = new List <EdmProperty>(); foreach (RowTypePropertyElement property in this._properties) { EdmProperty edmProperty = new EdmProperty(property.FQName, property.GetTypeUsage()); edmProperty.AddMetadataProperties(property.OtherContent); edmPropertyList.Add(edmProperty); } RowType rowType = new RowType((IEnumerable <EdmProperty>)edmPropertyList); if (this.Schema.DataModel == SchemaDataModelOption.EntityDataModel) { rowType.DataSpace = DataSpace.CSpace; } else { rowType.DataSpace = DataSpace.SSpace; } rowType.AddMetadataProperties(this.OtherContent); this._typeUsage = TypeUsage.Create((EdmType)rowType); } return(this._typeUsage); }
public DataReader(Resultset rs) { _rs = rs; _binder = new Binder(rs); _rct = rs.RowType; _result_f = true; }
public void EdmModel_NameIsTooLong_not_triggered_for_row_and_collection_types() { var intType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32); var properties = new EdmProperty[100]; for (int i = 0; i < 100; i++) { properties[i] = EdmProperty.Primitive("Property" + i, intType); } var rowType = new RowType(properties); foreach (var type in new EdmType[] { rowType, rowType.GetCollectionType() }) { var validationContext = new EdmModelValidationContext(new EdmModel(DataSpace.SSpace), true); DataModelErrorEventArgs errorEventArgs = null; validationContext.OnError += (_, e) => errorEventArgs = e; EdmModelSyntacticValidationRules .EdmModel_NameIsTooLong .Evaluate(validationContext, type); Assert.Null(errorEventArgs); } }
internal override TypeUsage GetTypeUsage() { if (_typeUsage == null) { var listOfProperties = new List <EdmProperty>(); foreach (var property in _properties) { var edmProperty = new EdmProperty(property.FQName, property.GetTypeUsage()); edmProperty.AddMetadataProperties(property.OtherContent); //edmProperty.DeclaringType listOfProperties.Add(edmProperty); } RowType rowType = new RowType(listOfProperties); if (Schema.DataModel == SchemaDataModelOption.EntityDataModel) { rowType.DataSpace = DataSpace.CSpace; } else { Debug.Assert(Schema.DataModel == SchemaDataModelOption.ProviderDataModel, "Only DataModel == SchemaDataModelOption.ProviderDataModel is expected"); rowType.DataSpace = DataSpace.SSpace; } rowType.AddMetadataProperties(this.OtherContent); _typeUsage = TypeUsage.Create(rowType); } return(_typeUsage); }
private EdmType ConvertOSpaceToCSpaceType(EdmType clrType) { EdmType edmType; if (Helper.IsCollectionType((GlobalItem)clrType)) { edmType = (EdmType) new CollectionType(this.ConvertOSpaceToCSpaceType(((CollectionType)clrType).TypeUsage.EdmType)); } else if (Helper.IsRowType((GlobalItem)clrType)) { List <EdmProperty> edmPropertyList = new List <EdmProperty>(); RowType rowType = (RowType)clrType; foreach (EdmProperty property in rowType.Properties) { EdmType cspaceType = this.ConvertOSpaceToCSpaceType(property.TypeUsage.EdmType); EdmProperty edmProperty = new EdmProperty(property.Name, TypeUsage.Create(cspaceType)); edmPropertyList.Add(edmProperty); } edmType = (EdmType) new RowType((IEnumerable <EdmProperty>)edmPropertyList, rowType.InitializerMetadata); } else { edmType = !Helper.IsRefType((GlobalItem)clrType) ? ((ObjectTypeMapping)this.GetMap((GlobalItem)clrType)).EdmType : (EdmType) new RefType((EntityType)this.ConvertOSpaceToCSpaceType((EdmType)((RefType)clrType).ElementType)); } return(edmType); }
private EdmType CreateReturnRowType(string propertyName, EdmType edmType) { if (edmType.BuiltInTypeKind == BuiltInTypeKind.EntityType) { var propertyToSoreTypeUsage = FindStoreTypeUsages((EntityType)edmType); return (RowType.Create( ((EntityType)edmType).Properties.Select( m => EdmProperty.Create(m.Name, propertyToSoreTypeUsage[m])), null)); } if (edmType.BuiltInTypeKind == BuiltInTypeKind.ComplexType) { return (RowType.Create( ((StructuralType)edmType).Members.Select( m => EdmProperty.Create(m.Name, GetStorePrimitiveTypeUsage(m.TypeUsage))), null)); } if (edmType.BuiltInTypeKind == BuiltInTypeKind.EnumType) { return(RowType.Create(new[] { EdmProperty.Create(propertyName, GetStorePrimitiveTypeUsage(TypeUsage.CreateDefaultTypeUsage(((EnumType)edmType).UnderlyingType))) }, null)); } return (RowType.Create( new[] { EdmProperty.Create(propertyName, GetStorePrimitiveTypeUsage(TypeUsage.CreateDefaultTypeUsage(edmType))) }, null)); }
/// <summary>Convert CSpace TypeMetadata into OSpace TypeMetadata</summary> /// <param name="cdmType"></param> /// <returns>OSpace type metadata</returns> private EdmType ConvertCSpaceToOSpaceType(EdmType cdmType) { EdmType clrType = null; if (Helper.IsCollectionType(cdmType)) { EdmType elemType = ConvertCSpaceToOSpaceType(((CollectionType)cdmType).TypeUsage.EdmType); clrType = new CollectionType(elemType); } else if (Helper.IsRowType(cdmType)) { List <EdmProperty> clrProperties = new List <EdmProperty>(); foreach (EdmProperty column in ((RowType)cdmType).Properties) { EdmType clrPropertyType = ConvertCSpaceToOSpaceType(column.TypeUsage.EdmType); EdmProperty clrProperty = new EdmProperty(column.Name, TypeUsage.Create(clrPropertyType)); clrProperties.Add(clrProperty); } clrType = new RowType(clrProperties, ((RowType)cdmType).InitializerMetadata); } else if (Helper.IsRefType(cdmType)) { clrType = new RefType((EntityType)ConvertCSpaceToOSpaceType(((RefType)cdmType).ElementType)); } else if (Helper.IsPrimitiveType(cdmType)) { clrType = m_objectCollection.GetMappedPrimitiveType(((PrimitiveType)cdmType).PrimitiveTypeKind); } else { clrType = ((ObjectTypeMapping)GetMap(cdmType)).ClrType; } Debug.Assert((null != clrType), "null converted clr type"); return(clrType); }
public Binder(RowType.TypeInfo[] fields) { List<ColumnBinding> list = new List<ColumnBinding>(); foreach (RowType.TypeInfo ti in fields) if (ti.NestedType == null) { if (!ti.IsHidden) { ColumnBinding b = new ColumnBinding(); b.Name = ti.Name; b.rnum = ti.Ordinal; b.snum = -1; b.fieldType = ti; b.caseSensitive = ti.IsCaseSensitive; list.Add(b); } } else foreach (RowType.TypeInfo ti_det in ti.NestedType.Fields) { if (!ti.IsHidden) { ColumnBinding b = new ColumnBinding(); b.TableName = ti.Name; b.Name = ti_det.Name; b.rnum = ti.Ordinal; b.snum = ti_det.Ordinal; b.caseSensitive = ti_det.IsCaseSensitive; b.fieldType = ti_det; list.Add(b); } } _columnBinding = list.ToArray(); FlagAmbiguos(); }
private static Type GetClrType <TElement>(EdmType ospaceEdmType) { Type type; if (ospaceEdmType.BuiltInTypeKind == BuiltInTypeKind.RowType) { RowType rowType = (RowType)ospaceEdmType; if (rowType.InitializerMetadata != null && rowType.InitializerMetadata.ClrType != (Type)null) { type = rowType.InitializerMetadata.ClrType; } else { Type c = typeof(TElement); type = typeof(IDataRecord).IsAssignableFrom(c) || c == typeof(object) ? (Type)null : typeof(TElement); } } else { type = ospaceEdmType.ClrType; if (type == (Type)null) { type = typeof(TElement); } } return(type); }
public int GetDataSize() { if (!m_IsOpen) { return(0); } // if (m_Rows == null) { return(0); } // int size = 0; for (int i = 0; i < m_Rows.Count; i++) { RowType rt = GetRowType(m_Rows[i]); if (rt != RowType.DataRow) { continue; } // string str = m_Rows[i].Substring((int)RowIndexes.ByteCountIndex, 2); size += (int)ToByte(str); } // return(size); }
// <summary> // Convert CSpace TypeMetadata into OSpace TypeMetadata // </summary> // <returns> OSpace type metadata </returns> private EdmType ConvertOSpaceToCSpaceType(EdmType clrType) { EdmType cdmType = null; if (Helper.IsCollectionType(clrType)) { var elemType = ConvertOSpaceToCSpaceType(((CollectionType)clrType).TypeUsage.EdmType); cdmType = new CollectionType(elemType); } else if (Helper.IsRowType(clrType)) { var cdmProperties = new List <EdmProperty>(); var rowType = (RowType)clrType; foreach (var column in rowType.Properties) { var cdmPropertyType = ConvertOSpaceToCSpaceType(column.TypeUsage.EdmType); var cdmProperty = new EdmProperty(column.Name, TypeUsage.Create(cdmPropertyType)); cdmProperties.Add(cdmProperty); } cdmType = new RowType(cdmProperties, rowType.InitializerMetadata); } else if (Helper.IsRefType(clrType)) { cdmType = new RefType((EntityType)(ConvertOSpaceToCSpaceType(((RefType)clrType).ElementType))); } else { cdmType = ((ObjectTypeMapping)GetMap(clrType)).EdmType; } Debug.Assert((null != cdmType), "null converted clr type"); return(cdmType); }
public void SetOpennedRowBool(RowType rowType, GameObject[] row) { if (rowType == RowType.Vertical) { if (!verticalRowOpenned) { verticalRowOpenned = true; verticalRow = row; foreach (var pos in verticalRow) { pos.GetComponentInChildren <Card>().HighlightCard(); } } } else if (rowType == RowType.Horizontal) { if (!horizontalRowOpenned) { horizontalRowOpenned = true; horizontalRow = row; foreach (var pos in horizontalRow) { pos.GetComponentInChildren <Card>().HighlightCard(); } } } }
public override DbExpression Visit(DbGroupByExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; DbGroupExpressionBinding newInput = this.VisitGroupExpressionBinding(expression.Input); this.EnterScope(newInput.Variable); IList <DbExpression> newKeys = this.VisitExpressionList(expression.Keys); this.ExitScope(); this.EnterScope(newInput.GroupVariable); IList <DbAggregate> newAggs = this.VisitList <DbAggregate>(expression.Aggregates, this.VisitAggregate); this.ExitScope(); if (!object.ReferenceEquals(expression.Input, newInput) || !object.ReferenceEquals(expression.Keys, newKeys) || !object.ReferenceEquals(expression.Aggregates, newAggs)) { RowType groupOutput = TypeHelpers.GetEdmType <RowType>(TypeHelpers.GetEdmType <CollectionType>(expression.ResultType).TypeUsage); var boundKeys = groupOutput.Properties.Take(newKeys.Count).Select(p => p.Name).Zip(newKeys).ToList(); var boundAggs = groupOutput.Properties.Skip(newKeys.Count).Select(p => p.Name).Zip(newAggs).ToList(); result = CqtBuilder.GroupBy(newInput, boundKeys, boundAggs); } NotifyIfChanged(expression, result); return(result); }
public CellAttribute(RowType row, ColumnType col, Type type) : this(row, col) { ValueType = type; Default = GetDefault(type); Format = ""; }
protected override EdmType VisitType(EdmType type) { EdmType retType = type; if (BuiltInTypeKind.RefType == type.BuiltInTypeKind) { RefType refType = (RefType)type; EntityType mappedEntityType = (EntityType)this.VisitType(refType.ElementType); if (!object.ReferenceEquals(refType.ElementType, mappedEntityType)) { retType = new RefType(mappedEntityType); } } else if (BuiltInTypeKind.CollectionType == type.BuiltInTypeKind) { CollectionType collectionType = (CollectionType)type; TypeUsage mappedElementType = this.VisitTypeUsage(collectionType.TypeUsage); if (!object.ReferenceEquals(collectionType.TypeUsage, mappedElementType)) { retType = new CollectionType(mappedElementType); } } else if (BuiltInTypeKind.RowType == type.BuiltInTypeKind) { RowType rowType = (RowType)type; List <KeyValuePair <string, TypeUsage> > mappedPropInfo = null; for (int idx = 0; idx < rowType.Properties.Count; idx++) { EdmProperty originalProp = rowType.Properties[idx]; TypeUsage mappedPropType = this.VisitTypeUsage(originalProp.TypeUsage); if (!object.ReferenceEquals(originalProp.TypeUsage, mappedPropType)) { if (mappedPropInfo == null) { mappedPropInfo = new List <KeyValuePair <string, TypeUsage> >( rowType.Properties.Select( prop => new KeyValuePair <string, TypeUsage>(prop.Name, prop.TypeUsage) )); } mappedPropInfo[idx] = new KeyValuePair <string, TypeUsage>(originalProp.Name, mappedPropType); } } if (mappedPropInfo != null) { IEnumerable <EdmProperty> mappedProps = mappedPropInfo.Select(propInfo => new EdmProperty(propInfo.Key, propInfo.Value)); retType = new RowType(mappedProps, rowType.InitializerMetadata); } } else { if (!_metadata.TryGetType(type.Name, type.NamespaceName, type.DataSpace, out retType) || null == retType) { throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Copier_TypeNotFound(TypeHelpers.GetFullName(type))); } } return(retType); }
public static bool RowToRender(this RowType row, QueryDescription query, Type groupingType) { if (query == null || query.Grouping == null || query.Grouping.Keys == null || query.Grouping.Keys.Count == 0) { return(row.For.Metadata.ModelType != groupingType); } return(row.For.Metadata.ModelType == groupingType); }
private void AddSpannedRowType(RowType spannedType, TypeUsage originalType) { if (this._spanIndex == null) { this._spanIndex = new SpanIndex(); } this._spanIndex.AddSpannedRowType(spannedType, originalType); }
private void AddSpanMap(RowType rowType, Dictionary <int, AssociationEndMember> columnMap) { if (this._spanIndex == null) { this._spanIndex = new SpanIndex(); } this._spanIndex.AddSpanMap(rowType, columnMap); }
public DataReader(Resultset rs, QueryContext context) { _rs = rs; _context = context; _binder = new Binder(rs); _rct = rs.RowType; _result_f = true; }
private void addRow(RowType row) { if (Rows == null) { Rows = new List <RowType>(); } Rows.Add(row); }
// <summary> // Create a new VarInfo for a structured type Var // </summary> // <param name="v"> The structured type Var </param> // <param name="newType"> "Mapped" type for v </param> // <param name="newVars"> List of vars corresponding to v </param> // <param name="newProperties"> Flattened Properties </param> // <param name="newVarsIncludeNullSentinelVar"> Do the new vars include a var that represents a null sentinel either for this type or for any nested type </param> // <returns> the VarInfo </returns> internal VarInfo CreateStructuredVarInfo( Var v, RowType newType, List <Var> newVars, List <EdmProperty> newProperties, bool newVarsIncludeNullSentinelVar) { VarInfo varInfo = new StructuredVarInfo(newType, newVars, newProperties, newVarsIncludeNullSentinelVar); m_map.Add(v, varInfo); return(varInfo); }
public RowBase(Tweet tweet,string ownerScreenName,SettingData setting,Action<RowAction> rowActionCallBack,RowType type) { this.ownerScreenName = ownerScreenName; this.RowType = type; this.Tweet = tweet; this.setting = setting; InitializeBase(rowActionCallBack); }
/// <summary> /// Ajoute une nouvelle ligne d'informations dans la console /// </summary> /// <param name="message">Le message des données</param> /// /// <param name="type">Le type de la ligne</param> public void WriteLine(string message, RowType type = RowType.Normal) { ListViewItem item = new ListViewItem(); item.ImageIndex = (int)type; item.SubItems.Add(DateTime.Now.ToString()); item.SubItems.Add(message); item.ForeColor = ColorList.ElementAt(((int)type < this.ColorList.Count - 1) ? (int)type + 1 : 0); this.ListViewConsole.Items.Add(item).EnsureVisible(); }
public static void DeclareServerRowtype(Type controllerType, RowType row) { var pair = new KeyValuePair<Type, string>(controllerType, row.RowId); if (!serverTemplates.ContainsKey(pair)) { if (!typeof(Controller).GetTypeInfo().IsAssignableFrom(controllerType)) throw new ArgumentException(string.Format(Resources.NotAController, controllerType.Name), nameof(controllerType)); serverTemplates[pair] = row; } }
public BaseBlock(String text, String highlight, RowType type) : base() { this.Type = type; this.Style = Styles.Command; this._text = text; this._highlight = highlight; Render(); }
protected override void PrepareCommand(RowType.TypeInfo[] fields, DbCommand command, Object[] parameters) { command.CommandText = _commandText; for (int k = 0; k < _parameterBindings.Length; k++) { DbParameter parameter = command.CreateParameter(); parameter.ParameterName = _helper.FormatParameter( String.Format("p{0}", command.Parameters.Count)); parameter.Direction = ParameterDirection.Input; parameter.Value = parameters[_parameterBindings[k]]; command.Parameters.Add(parameter); } }
/// <summary> /// Adds a footer/summary row /// </summary> /// <param name="pdfRowType"></param> public void AddFooterRow(RowType pdfRowType) { if (SharedData.SummarySettings == null || SharedData.SummarySettings.OverallSummarySettings == null || !SharedData.SummarySettings.OverallSummarySettings.ShowOnEachPage) return; if (SharedData.MainTableEvents != null) SharedData.MainTableEvents.RowStarted(new EventsArguments { PdfDoc = SharedData.PdfDoc, PdfWriter = SharedData.PdfWriter, Table = MainTable, RowType = pdfRowType, ColumnCellsSummaryData = SharedData.ColumnCellsSummaryData, PreviousTableRowData = _previousTableRowData, PageSetup = SharedData.PageSetup, PdfFont = SharedData.PdfFont, PdfColumnsAttributes = SharedData.PdfColumnsAttributes }); for (var columnNumber = 0; columnNumber < SharedData.ColumnsCount; columnNumber++) { var backgroundColor = SharedData.Template.SummaryRowBackgroundColor; var foreColor = SharedData.Template.SummaryRowFontColor; var col = SharedData.PdfColumnsAttributes[columnNumber]; int location = -1; switch (SharedData.SummarySettings.OverallSummarySettings.SummaryLocation) { case SummaryLocation.AtFirstDefinedAggregateCell: if (columnNumber == getFirstDefinedAggregateCell()) location = columnNumber; break; case SummaryLocation.AtRowNumberColumn: if (columnNumber == 0) location = 0; break; case SummaryLocation.AtSpecifiedLabelColumnProperty: if (SharedData.SummarySettings.OverallSummarySettings.LabelColumnProperty == col.PropertyName) location = columnNumber; break; } if (location != -1) TableCellHelper.AddSummaryCell(backgroundColor[0], foreColor, location, CellType.SummaryRowCell, pdfRowType); else TableCellHelper.AddSummaryCell(backgroundColor[0], foreColor, null, columnNumber, pdfRowType, CellType.SummaryRowCell); } if (SharedData.MainTableEvents != null) SharedData.MainTableEvents.RowAdded(new EventsArguments { PdfDoc = SharedData.PdfDoc, PdfWriter = SharedData.PdfWriter, Table = MainTable, RowType = pdfRowType, ColumnCellsSummaryData = SharedData.ColumnCellsSummaryData, PreviousTableRowData = _previousTableRowData, PageSetup = SharedData.PageSetup, PdfFont = SharedData.PdfFont, PdfColumnsAttributes = SharedData.PdfColumnsAttributes }); }
private CustomRowObject CreateRowObject(RowType rowType) { return new CustomRowObject { RowType = rowType }; }
/// <summary> /// Adds a new Summary PdfPCell to the MainTable /// </summary> /// <param name="backgroundColor"></param> /// <param name="foreColor"></param> /// <param name="columnNumber"></param> /// <param name="pdfCellType"></param> /// <param name="pdfRowType"></param> /// <returns></returns> public CellAttributes AddSummaryCell(BaseColor backgroundColor, BaseColor foreColor, int columnNumber, CellType pdfCellType, RowType pdfRowType) { var horizontalAlignment = SharedData.SummarySettings.OverallSummarySettings.LabelHorizontalAlignment; var text = SharedData.SummarySettings.OverallSummarySettings.Label; if (ShowAllGroupsSummaryRow) { horizontalAlignment = SharedData.SummarySettings.AllGroupsSummarySettings.LabelHorizontalAlignment; text = SharedData.SummarySettings.AllGroupsSummarySettings.Label; } if (pdfCellType == CellType.PageSummaryCell) { text = SharedData.SummarySettings.PageSummarySettings.Label; horizontalAlignment = SharedData.SummarySettings.PageSummarySettings.LabelHorizontalAlignment; } return AddGeneralCell( backgroundColor, foreColor, text, columnNumber, pdfRowType, pdfCellType, horizontalAlignment: horizontalAlignment.HasValue ? horizontalAlignment.Value : HorizontalAlignment.None); }
String GetData(String key, RowType rt) { if (rt == RowType.Output) { int index = 2; foreach (DataGridViewRow row in dataGridView1.Rows) { String cur_key = Convert.ToString(row.Cells[0].Value); if (cur_key == null || cur_key.CompareTo("") == 0) { continue; } if (cur_key.CompareTo(key) == 0) { return Convert.ToString(row.Cells[2].Value); } } logger.Warn("GetData {0}, {1}", key, index); } else { logger.Warn("Not supported"); } return null; }
/// <summary> /// Adds a new Summary PdfPCell to the MainTable /// </summary> /// <param name="backgroundColor"></param> /// <param name="foreColor"></param> /// <param name="rawData"></param> /// <param name="columnNumber"></param> /// <param name="pdfRowType"></param> /// <param name="pdfCellType"></param> /// <returns></returns> public CellAttributes AddSummaryCell(BaseColor backgroundColor, BaseColor foreColor, object rawData, int columnNumber, RowType pdfRowType, CellType pdfCellType) { return AddGeneralCell(backgroundColor, foreColor, rawData, columnNumber, pdfRowType, pdfCellType); }
private Type CreateRowType(RowType rowType, FacetInfo facets) { Dictionary<string, Type> members = new Dictionary<string, Type>(); foreach (EdmMember member in rowType.Members) { members.Add(member.GetColumnName(), this.Convert(member.TypeUsage)); } Type result = DataRowFactory.Create(members); return result; }
public ChartIconDropDownRowCells(RowType typeOfRow) { TypeOfRow = typeOfRow; }
public bool GetLocator(string qualifiedName, ref RowType.Locator loc) { ColumnBinding b = Get(qualifiedName); if (b != null) { loc.master = b.rnum; if (b.snum != -1) loc.detail = b.snum; return true; } else return false; }
/// <summary> /// Parses a XElement that contains type information /// Accepts an element that is a CollectionType, RowType, ReferenceType, and TypeRef /// </summary> /// <param name="typeElement">XElement that contains a Type element</param> /// <returns>DataType represented by the XElement</returns> protected DataType ParseType(XElement typeElement) { if (typeElement.Name.LocalName == "CollectionType") { string elementTypeName = typeElement.GetOptionalAttributeValue("ElementType", null); if (elementTypeName != null) { bool isNullable = XmlConvert.ToBoolean(typeElement.GetOptionalAttributeValue("Nullable", "true")); DataType dataType = this.ParseType(elementTypeName, isNullable, typeElement.Attributes()); return DataTypes.CollectionType.WithElementDataType(dataType); } else { var elementType = typeElement.Elements().Single(e => this.IsXsdlNamespace(e.Name.NamespaceName)); return DataTypes.CollectionType.WithElementDataType(this.ParseType(elementType)); } } else if (typeElement.Name.LocalName == "RowType") { var row = new RowType(); foreach (var propertyElement in typeElement.Elements().Where(el => this.IsXsdlElement(el, "Property"))) { row.Properties.Add(this.ParseProperty(propertyElement)); } return DataTypes.RowType.WithDefinition(row); } else if (typeElement.Name.LocalName == "ReferenceType") { DataType dataType = this.ParseType(typeElement.GetRequiredAttributeValue("Type"), true, null); return DataTypes.ReferenceType.WithEntityType((dataType as EntityDataType).Definition); } else if (typeElement.Name.LocalName == "TypeRef") { bool isNullable = XmlConvert.ToBoolean(typeElement.GetOptionalAttributeValue("Nullable", "true")); DataType dataType = this.ParseType(typeElement.GetRequiredAttributeValue("Type"), isNullable, typeElement.Attributes()); return dataType; } else { throw new TaupoNotSupportedException("Unsupported data type element: " + typeElement.Name.LocalName); } }
public TableType(String qualifiedName, String catalogName, String schemaName, String tableName, DataSourceInfo dataSource, RowType tableRowType, bool smart) { QualifiedName = qualifiedName; CatalogName = catalogName; SchemaName = schemaName; TableName = tableName; DataSource = dataSource; TableRowType = tableRowType; Smart = smart; }
private TableType GetDataProviderTableType(DataSourceInfo dsi, String identifier) { DataProviderHelper helper = new DataProviderHelper(dsi.ProviderInvariantName, dsi.ConnectionString); using (DbConnection connection = dsi.CreateConnection()) { DbCommand command = connection.CreateCommand(); StringBuilder sb = new StringBuilder(); sb.Append("SELECT * FROM "); sb.Append(identifier); if (helper.OrderByColumnsInSelect) sb.Append(" ORDER BY 1"); command.CommandText = sb.ToString(); try { DbDataReader reader; connection.Open(); bool hasKeyInfo = false; try { reader = command.ExecuteReader(CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo); hasKeyInfo = true; } catch (Exception ex) { Trace.TraceWarning("GetDataProviderTableType.ExecuteReader: {0}", ex.Message); reader = command.ExecuteReader(CommandBehavior.SchemaOnly); } DataTable dt_src = reader.GetSchemaTable(); DataTable dt = RowType.CreateSchemaTable(); int n = 0; foreach (DataRow r in dt_src.Rows) { DataRow r1 = dt.NewRow(); foreach (DataColumn col in dt_src.Columns) { DataColumn dest = dt.Columns[col.ColumnName]; if (dt.Columns.IndexOf(col.ColumnName) != -1 && col.ColumnName != "ColumnName") r1[dest] = r[col]; } r1["ColumnOrdinal"] = n++; string columnName = (string)r["ColumnName"]; r1["ColumnName"] = helper.NativeFormatIdentifier(columnName); r1["ProviderColumnName"] = columnName; r1["IsCaseSensitive"] = helper.IdentifierCase == IdentifierCase.Sensitive; dt.Rows.Add(r1); } reader.Close(); RowType rtype = new RowType(dt); if (hasKeyInfo && rtype.Fields[0].BaseTableName != null) return new TableType(identifier, rtype.Fields[0].BaseCatalogName, rtype.Fields[0].BaseSchemaName, rtype.Fields[0].BaseTableName, dsi, rtype, helper.Smart); else { string schema = null; string catalog = null; string tableName = null; string[] identifierPart = helper.SplitIdentifier(identifier); int length = identifierPart.Length; if (length == 3) catalog = identifierPart[identifierPart.Length - length--]; if (length == 2) schema = identifierPart[identifierPart.Length - length--]; if (length == 1) tableName = identifierPart[identifierPart.Length - length]; return new TableType(identifier, catalog, schema, tableName, dsi, rtype, helper.Smart); } } catch (Exception ex) { Trace.TraceWarning("GetDataProviderTableType: {0}", ex.Message); return null; } } }
public DataProviderQueryAccessor(DataSourceInfo dataSourceInfo, Notation notation, Symbol squery) : base() { _rowType = null; _connectionString = dataSourceInfo.ConnectionString; _providerInvariantName = dataSourceInfo.ProviderInvariantName; _helper = new DataProviderHelper(_providerInvariantName, _connectionString); SqlQueryWriter writer = new SqlQueryWriter(notation); writer.ProviderHelper = _helper; if (squery.Tag == Tag.Stmt) writer.WriteStmt(squery); else writer.WriteQueryExp(squery); _commandText = writer.ToString(); _parameterBindings = writer.Bindings.ToArray(); }
internal RowCache(Resultset rs) { _rowType = rs._rtype; }
public TableType(String qualifiedName, String tableName, DataSourceInfo dataSource, RowType tableRowType) { QualifiedName = qualifiedName; TableName = tableName; DataSource = dataSource; TableRowType = tableRowType; }
protected override RowType CreateRowType() { if (_rowType == null) { DataProviderHelper helper = new DataProviderHelper(_providerInvariantName, _connectionString); DbConnection connection = DataProviderHelper.CreateDbConnection(_providerInvariantName); connection.ConnectionString = _connectionString; connection.Open(); DbCommand command = connection.CreateCommand(); command.CommandText = _commandText; for (int k = 0; k < _parameterBindings.Length; k++) { DbParameter parameter = command.CreateParameter(); parameter.ParameterName = _helper.FormatParameter( String.Format("p{0}", command.Parameters.Count)); parameter.Direction = ParameterDirection.Input; command.Parameters.Add(parameter); } DbDataReader reader = command.ExecuteReader(CommandBehavior.SchemaOnly | CommandBehavior.CloseConnection); try { DataTable dt_src = reader.GetSchemaTable(); DataTable dt = RowType.CreateSchemaTable(); int n = 0; foreach (DataRow r in dt_src.Rows) { DataRow r1 = dt.NewRow(); foreach (DataColumn col in dt_src.Columns) { DataColumn dest = dt.Columns[col.ColumnName]; if (dt.Columns.IndexOf(col.ColumnName) != -1 && col.ColumnName != "ColumnName") r1[dest] = r[col]; } r1["ColumnOrdinal"] = n++; string columnName = (string)r["ColumnName"]; r1["ColumnName"] = helper.NativeFormatIdentifier(columnName); r1["ProviderColumnName"] = columnName; r1["IsCaseSensitive"] = helper.IdentifierCase == IdentifierCase.Sensitive; dt.Rows.Add(r1); } _rowType = new RowType(dt); } finally { reader.Close(); } } return _rowType; }
/// <summary> /// Gets the <see cref="CollectionDataType"/> with row data type as element type. /// </summary> /// <param name="rowType">Row data type definition.</param> /// <returns>The data type.</returns> public static CollectionDataType CollectionOfRows(RowType rowType) { return CollectionType.WithElementDataType(RowType.WithDefinition(rowType)); }
void RegisterDataKey(String key, RowType row_type) { int index = dataGridView1.Rows.Add(); dataGridView1.Rows[index].Cells[0].Value = key; if (row_type == RowType.Output || row_type == RowType.Important) { DataGridViewCellStyle style = new DataGridViewCellStyle(); style.BackColor = Color.LightGray; if (row_type == RowType.Important) { style.Font = new Font(dataGridView1.Font, FontStyle.Bold); } dataGridView1.Rows[index].DefaultCellStyle = style; } }
// Public Methods (7) /// <summary> /// Adds a new PdfPCell to the MainTable /// </summary> /// <param name="backgroundColor"></param> /// <param name="foreColor"></param> /// <param name="rawData"></param> /// <param name="columnNumber"></param> /// <param name="pdfRowType"></param> /// <param name="pdfCellType"></param> /// <param name="rowValues"></param> /// <param name="horizontalAlignment"></param> /// <param name="pdfFontStyle"></param> /// <param name="rotation"></param> /// <param name="setItemTemplate"></param> /// <param name="colSpan"></param> /// <returns></returns> public CellAttributes AddGeneralCell( BaseColor backgroundColor, BaseColor foreColor, object rawData, int columnNumber, RowType pdfRowType, CellType pdfCellType, IList<CellData> rowValues = null, HorizontalAlignment horizontalAlignment = HorizontalAlignment.None, DocumentFontStyle pdfFontStyle = DocumentFontStyle.None, int rotation = 0, bool setItemTemplate = false, int colSpan = 1) { var col = SharedData.PdfColumnsAttributes[columnNumber]; var cellData = new CellAttributes { RowData = new CellRowData { TableRowData = rowValues, Value = rawData, PdfRowType = pdfRowType, ColumnNumber = columnNumber }, SharedData = new CellSharedData { PdfColumnAttributes = col, DataRowNumber = CurrentRowInfoData.LastOverallDataRowNumber, GroupNumber = CurrentRowInfoData.LastGroupRowNumber, PdfDoc = SharedData.PdfDoc, PdfWriter = SharedData.PdfWriter, SummarySettings = SharedData.SummarySettings, Template = SharedData.Template }, ItemTemplate = setItemTemplate ? col.ColumnItemsTemplate : null, BasicProperties = new CellBasicProperties { PdfFont = SharedData.PdfFont, Rotation = rotation, PdfFontStyle = (pdfFontStyle == DocumentFontStyle.None) ? DocumentFontStyle.Normal : pdfFontStyle, BackgroundColor = backgroundColor, BorderColor = SharedData.Template.CellBorderColor, FontColor = foreColor, RunDirection = SharedData.PageSetup.PagePreferences.RunDirection, ShowBorder = SharedData.Template.ShowGridLines, HorizontalAlignment = (horizontalAlignment == HorizontalAlignment.None) ? col.CellsHorizontalAlignment : horizontalAlignment, FixedHeight = pdfRowType == RowType.DataTableRow ? col.FixedHeight : 0, MinimumHeight = pdfRowType == RowType.DataTableRow ? col.MinimumHeight : 0 } }; if (SharedData.MainTableEvents != null) SharedData.MainTableEvents.CellCreated(new EventsArguments { PdfDoc = SharedData.PdfDoc, PdfWriter = SharedData.PdfWriter, Cell = cellData, CellType = pdfCellType, RowType = pdfRowType, ColumnNumber = columnNumber, ColumnCellsSummaryData = SharedData.ColumnCellsSummaryData, PreviousTableRowData = CurrentRowInfoData.PreviousTableRowData, PageSetup = SharedData.PageSetup, PdfFont = SharedData.PdfFont, PdfColumnsAttributes = SharedData.PdfColumnsAttributes }); var cell = cellData.CreateSafePdfPCell(new TextBlockField()); cell.CellEvent = new MainTableCellsEvent(cellData) { SummaryCellsData = SharedData.ColumnCellsSummaryData, IsGroupingEnabled = SharedData.IsGroupingEnabled, CurrentRowInfoData = CurrentRowInfoData }; if (colSpan > 1) cell.Colspan = colSpan; MainTable.AddCell(cell); if (SharedData.MainTableEvents != null) SharedData.MainTableEvents.CellAdded(new EventsArguments { PdfDoc = SharedData.PdfDoc, PdfWriter = SharedData.PdfWriter, Cell = cellData, CellType = pdfCellType, RowType = pdfRowType, ColumnNumber = columnNumber, ColumnCellsSummaryData = SharedData.ColumnCellsSummaryData, PreviousTableRowData = CurrentRowInfoData.PreviousTableRowData, PageSetup = SharedData.PageSetup, PdfFont = SharedData.PdfFont, PdfColumnsAttributes = SharedData.PdfColumnsAttributes }); return cellData; }
protected override void PrepareCommand(RowType.TypeInfo[] fields, DbCommand command, Object[] parameters) { DataProviderHelper helper = new DataProviderHelper(_providerInvariantName, _connectionString); Binder binder = new Binder(fields); StringBuilder sb = new StringBuilder(); sb.Append("SELECT "); for (int k = 0; k < fields.Length; k++) { if (k > 0) sb.Append(", "); if (fields[k].ProviderColumnName != null) sb.Append(helper.FormatIdentifier(fields[k].ProviderColumnName)); else sb.Append(helper.FormatIdentifier(fields[k].Name)); } sb.AppendLine(); sb.Append(" FROM "); sb.Append(TableType.ToString(helper)); if (TableType.Smart) { if (FilterPredicate != null || AccessPredicate != null) sb.AppendLine(" WHERE "); if (FilterPredicate != null) { if (AccessPredicate != null) sb.Append("("); command.Parameters.Clear(); sb.AppendLine(WriteExpr(binder, helper, FilterPredicate, parameters, command)); if (AccessPredicate != null) sb.Append(")"); } if (AccessPredicate != null) { if (FilterPredicate != null) sb.AppendLine(" AND ("); for (int s = 0; s < AccessPredicateValues.Length; s++) { if (s > 0) sb.Append(" OR "); sb.Append("("); for (int k = 0; k < AccessPredicate.Length; k++) { if (k > 0) sb.Append(" AND "); sb.Append(helper.FormatIdentifier(AccessPredicate[k])); Object predicateValue = AccessPredicateValues[s][k]; if (predicateValue == DBNull.Value) sb.Append(" IS NULL"); else { sb.Append("="); sb.Append(WriteLiteral(helper, predicateValue)); } } sb.Append(")"); } if (FilterPredicate != null) sb.Append(")"); } } if (SortColumns != null) { sb.AppendLine(" ORDER BY "); for (int k = 0; k < SortColumns.Length; k++) { if (k > 0) sb.Append(", "); sb.Append(helper.FormatIdentifier(SortColumns[k].ColumnName)); if (SortColumns[k].Direction == SortDirection.Descending) sb.Append(" DESC"); } sb.AppendLine(); } command.CommandText = sb.ToString(); }
public String GetName(RowType.Locator loc) { foreach (ColumnBinding b in _columnBinding) if (loc.master == b.rnum && (loc.detail ?? -1) == b.snum) { if (b.TableName != null) return String.Format("{0}.{1}", b.TableName, b.Name); else return b.Name; } return null; }