/// <summary> /// Read worksheet and return data in class T /// with properties set to the values in worksheet. /// </summary> /// <typeparam name="T"> /// Class that as properties matching column names. Properties might be decorated with /// a CollumnAttribute /// </typeparam> /// <returns> /// Returns instances of type T with the porperties set /// that match a column name of the sheet /// </returns> public IEnumerable <T> Entities <T>() where T : class, new() { var t = typeof(T); var columnMap = new ColumnMap(t); foreach (var row in ElementsOfDataRows) { var entity = new T(); var hasValue = false; foreach (var cell in KeyedValues(row, (XElement e, int i) => { var name = i < Header.Length ? Header[i] : null; if (columnMap.GetContentType(name) == ColumnAttribute.ContentTypes.Data) { return(this._xlsx.CellContents.Value(e)); } return(this._xlsx.CellContents.Formula(e)); })) { var destination = columnMap.GetPropertyInfo(cell.Key); if (destination == null) { continue; } destination.SetValue(entity, Convert.ChangeType(cell.Value, destination.PropertyType)); hasValue = true; } if (hasValue) { yield return(entity); } } }
/// <summary> /// Find all vars that were referenced in the column map. Looks for VarRefColumnMap /// in the ColumnMap tree, and tracks those vars /// NOTE: The "vec" parameter must be supplied by the caller. The caller is responsible for /// clearing out this parameter (if necessary) before calling into this function /// </summary> /// <param name="columnMap"> the column map to traverse </param> /// <param name="vec"> the set of referenced columns </param> internal static void FindVars(ColumnMap columnMap, VarVec vec) { var tracker = new ColumnMapVarTracker(); columnMap.Accept(tracker, vec); return; }
// <summary> // Returns a string uniquely identifying the given ColumnMap. // </summary> internal static string GetColumnMapKey(ColumnMap columnMap, SpanIndex spanIndex) { var builder = new ColumnMapKeyBuilder(spanIndex); columnMap.Accept(builder, 0); return(builder._builder.ToString()); }
internal static void Process( System.Data.Entity.Core.Query.PlanCompiler.PlanCompiler compilerState, out List <ProviderCommandInfo> childCommands, out ColumnMap resultColumnMap, out int columnCount) { new CodeGen(compilerState).Process(out childCommands, out resultColumnMap, out columnCount); }
public object FromDB(ColumnMap map, object dbValue) { if (dbValue == null || dbValue == DBNull.Value) { return(null); } return(Enum.Parse(map.FieldType, (string)dbValue)); }
/// <summary> /// Registers any member with a ColumnAttribute as a ColumnMap. /// <param name="entityType">The entity that is being mapped.</param> /// <param name="member">The current member that is being inspected.</param> /// <param name="columnAtt">A ColumnAttribute (is null of one does not exist).</param> /// <param name="columnMaps">A list of ColumnMaps.</param> /// </summary> protected override void CreateColumnMap(Type entityType, MemberInfo member, ColumnAttribute columnAtt, ColumnMapCollection columnMaps) { if (columnAtt != null) { ColumnMap columnMap = new ColumnMap(member, columnAtt); columnMaps.Add(columnMap); } }
[Test] //testing this because it's surprising that it works. Unity magic... public void processing_rules_from_column_map_calls_correct_processors() { ColumnMap map = AssetDatabase.LoadAssetAtPath <ColumnMap>(columnMapPath); Assert.AreEqual("hello", map.rules[0].rule.Process(testVals)); Assert.AreEqual("test12", map.rules[1].rule.Process(testVals)); Assert.AreEqual("12", map.rules[2].rule.Process(testVals)); }
public object FromDB(ColumnMap map, object dbValue) { if (dbValue == null || dbValue == DBNull.Value) { return(null); } return(Enum.ToObject(map.FieldType, (int)dbValue)); }
/// <summary> /// コンストラクタ、親ノード、挿入先テーブルと列の並びを指定して初期化する /// </summary> /// <param name="parent">親ノード</param> /// <param name="table">挿入先テーブル</param> /// <param name="columnsExpression">列と設定値を指定する t => new[] { t.A == a, t.B == b } の様な式</param> public InsertInto(IQueryNode parent, TableDef <TColumns> table, Expression <Func <TColumns, bool[]> > columnsExpression) { this.Parent = parent; // new [] { bool, bool... } の様な形式以外はエラーとする var body = columnsExpression.Body; if (body.NodeType != ExpressionType.NewArrayInit) { throw new ApplicationException(); } // 登録 var owner = this.Owner; owner.RegisterTable(table); // bool[] の各要素初期化式を取得する var newexpr = body as NewArrayExpression; var expressions = newexpr.Expressions; var map = new Dictionary <Expression, object> { { columnsExpression.Parameters[0], table.Columns } }; var availableColumns = owner.AllColumns; var tableColumnMap = table.ColumnMap; var columnsOrder = new ColumnMap(); var values = new ElementCode[expressions.Count]; for (int i = 0; i < values.Length; i++) { // t.A == a の様に Equal を代入として扱いたいのでそれ以外はエラーとする var expression = expressions[i]; if (expression.NodeType != ExpressionType.Equal) { throw new ApplicationException(); } var binary = expression as BinaryExpression; // 左辺は代入先の列でなければならない var left = new ElementCode(ParameterReplacer.Replace(binary.Left, map), tableColumnMap); var column = left.FindColumns().FirstOrDefault(); if (column == null) { throw new ApplicationException(); } // 右辺は式 values[i] = new ElementCode(ParameterReplacer.Replace(binary.Right, map), availableColumns); // 列の生成元を右辺の式にして列を登録 columnsOrder.Add(column); } this.Table = table; this.ColumnMap = columnsOrder; this.ValueNode = new ValueSetter(this, columnsOrder, values); }
public void MapDataTableToTable(string tableName, DataTable dataTable, ColumnMapping columnMapping) { DataTable emptyDataTable = _databaseCommander.ExecuteSql($"SELECT * FROM {tableName} WHERE 1 = 0"); List <string> databaseColumnNames = emptyDataTable.Columns.Cast <DataColumn>().Select(dc => dc.ColumnName).ToList(); List <string> fileColumnNames = dataTable.Columns.Cast <DataColumn>().Select(dc => dc.ColumnName).ToList(); // Ensure proper casing of source columns foreach (string fileColumnName in fileColumnNames) { ColumnMap columnMap = columnMapping.ColumnMaps.FirstOrDefault(cm => cm.Source.Equals(fileColumnName, StringComparison.InvariantCultureIgnoreCase)); if (columnMap != null && columnMap.Source != fileColumnName) { columnMap.Source = fileColumnName; } } // Ensure proper casing of destination columns foreach (string databaseColumnName in databaseColumnNames) { ColumnMap columnMap = columnMapping.ColumnMaps.FirstOrDefault(cm => cm.Destination.Equals(databaseColumnName, StringComparison.InvariantCultureIgnoreCase)); if (columnMap != null && columnMap.Destination != databaseColumnName) { columnMap.Destination = databaseColumnName; } } // Ensure existence of source columns foreach (string sourceColumnName in columnMapping.ColumnMaps.Select(cm => cm.Source)) { if (!fileColumnNames.Contains(sourceColumnName)) { throw new InvalidOperationException($"The source column '{sourceColumnName}' does not exist"); } } // Ensure existence of destination columns foreach (string destinationColumnName in columnMapping.ColumnMaps.Select(cm => cm.Destination)) { if (!databaseColumnNames.Contains(destinationColumnName)) { throw new InvalidOperationException($"The destination column '{destinationColumnName}' does not exist"); } } // AutoMap any columns that are not already mapped from the source to the destination foreach (string fileColumnName in fileColumnNames) { string databaseColumnName = databaseColumnNames.FirstOrDefault(s => s.Equals(fileColumnName, StringComparison.InvariantCultureIgnoreCase)); if (databaseColumnName != null && columnMapping.ColumnMaps.All(cm => cm.Source != fileColumnName) && columnMapping.ColumnMaps.All(cm => cm.Destination != databaseColumnName)) { columnMapping.ColumnMaps.Add(new ColumnMap(fileColumnName, databaseColumnName)); } } }
public static string FindFKValueInOther(string lookupValue, ColumnMap cmap, SqlConnection connection, bool genNewFK, string lookupColName, Guid NKDProjectID) { string fkTable = cmap.fkRelationTable; string fkColumnKey = cmap.fkRelationColumn; if (lookupColName == null) { lookupColName = cmap.targetColumnName; } string statement1 = "SELECT " + fkColumnKey + " FROM " + fkTable + " WHERE " + lookupColName + " = \'" + lookupValue + "\' AND ProjectID = \'" + NKDProjectID.ToString() + "\'"; SqlCommand sqc = new SqlCommand(statement1, connection); SqlDataReader reader = sqc.ExecuteReader(); List <string> results = new List <string>(); while (reader.Read()) { string fkName = reader[0].ToString(); results.Add(fkName); } reader.Close(); if (results.Count == 0 && genNewFK == true) { // // there is no matching entry in this dictionary. Make a new entry // Guid gg = Guid.NewGuid(); // string p1 = gg.ToString(); // results.Add(p1); // char[] splitters = { '-' }; // string[] items = p1.Split(splitters); // string p2 = ""; // foreach (string it in items) // { // p2 += it; // } // string stdValMock = p2; // if (p2.Length > 15) // { // p2 = p2.Substring(0, 15); // } // string query = "INSERT INTO " + fkTable + " (" + fkColumnKey + "," + stdLookupColumnPrediction + "," + nameLookupColumnPrediction + ") VALUES " + // " (\'" + gg.ToString() + "\',\'" + p2 + "\',\'" + columnValue + "\' )"; // SqlCommand sqc2 = new SqlCommand(query, connection); // sqc2.ExecuteNonQuery(); } string res = null; if (results.Count > 0) { res = results.First(); } return(res); }
public object FromDB(ColumnMap map, object dbValue) { if (dbValue != null && dbValue != DBNull.Value) { return(Enum.ToObject(map.FieldType, (Int64)dbValue)); } return(null); }
public object FromDB(ColumnMap map, object dbValue) { if (dbValue is string version) { return(Version.Parse(version)); } return(null); }
private ColumnMap BuildResultColumnMap(PhysicalProjectOp projectOp) { // convert the column map into a real column map // build up a dictionary mapping Vars to their real positions in the commands Dictionary <Var, KeyValuePair <int, int> > varMap = BuildVarMap(); ColumnMap realColumnMap = ColumnMapTranslator.Translate(projectOp.ColumnMap, varMap); return(realColumnMap); }
private KeyValuePair <Shaper <RecordState>, CoordinatorFactory <RecordState> > CreateShaperInfo( DbDataReader storeDataReader, ColumnMap columnMap, MetadataWorkspace workspace) { Shaper <RecordState> key = this._translator.TranslateColumnMap <RecordState>(columnMap, workspace, (SpanIndex)null, MergeOption.NoTracking, true, true).Create(storeDataReader, (ObjectContext)null, workspace, MergeOption.NoTracking, true, true); return(new KeyValuePair <Shaper <RecordState>, CoordinatorFactory <RecordState> >(key, key.RootCoordinator.TypedCoordinatorFactory)); }
public virtual DbDataReader Create( DbDataReader storeDataReader, ColumnMap columnMap, MetadataWorkspace workspace, IEnumerable <ColumnMap> nextResultColumnMaps) { KeyValuePair <Shaper <RecordState>, CoordinatorFactory <RecordState> > shaperInfo = this.CreateShaperInfo(storeDataReader, columnMap, workspace); return((DbDataReader) new BridgeDataReader(shaperInfo.Key, shaperInfo.Value, 0, this.GetNextResultShaperInfo(storeDataReader, workspace, nextResultColumnMaps).GetEnumerator())); }
internal static void Compile( DbCommandTree ctree, out List <ProviderCommandInfo> providerCommands, out ColumnMap resultColumnMap, out int columnCount, out Set <EntitySet> entitySets) { System.Data.Entity.Core.Query.PlanCompiler.PlanCompiler.Assert(ctree != null, "Expected a valid, non-null Command Tree input"); new System.Data.Entity.Core.Query.PlanCompiler.PlanCompiler(ctree).Compile(out providerCommands, out resultColumnMap, out columnCount, out entitySets); }
private void Append(string prefix, ColumnMap columnMap) { Append(prefix); Append("["); if (null != columnMap) { columnMap.Accept(this, 0); } Append("]"); }
/// <summary> /// Constructor /// </summary> /// <param name="type">datatype of column</param> /// <param name="name">column name</param> /// <param name="elementMap">column map for collection element</param> /// <param name="keys">List of keys</param> /// <param name="foreignKeys">List of foreign keys</param> internal CollectionColumnMap( TypeUsage type, string name, ColumnMap elementMap, SimpleColumnMap[] keys, SimpleColumnMap[] foreignKeys) : base(type, name) { Debug.Assert(elementMap != null, "Must specify column map for element"); m_element = elementMap; m_keys = keys ?? new SimpleColumnMap[0]; m_foreignKeys = foreignKeys ?? new SimpleColumnMap[0]; }
/// <summary> /// Constructor /// </summary> /// <param name="type"> datatype of column </param> /// <param name="name"> column name </param> /// <param name="elementMap"> column map for collection element </param> /// <param name="keys"> List of keys </param> /// <param name="foreignKeys"> List of foreign keys </param> internal CollectionColumnMap( TypeUsage type, string name, ColumnMap elementMap, SimpleColumnMap[] keys, SimpleColumnMap[] foreignKeys) : base(type, name) { DebugCheck.NotNull(elementMap); m_element = elementMap; m_keys = keys ?? new SimpleColumnMap[0]; m_foreignKeys = foreignKeys ?? new SimpleColumnMap[0]; }
/// <summary> /// Create a column map for a complextype column /// </summary> /// <param name="typeInfo">Type information for the type</param> /// <param name="name">column name</param> /// <param name="superTypeColumnMap">Supertype info if any</param> /// <param name="discriminatorMap">Dictionary of typeidvalue->column map</param> /// <param name="allMaps">List of all maps</param> /// <returns></returns> private ComplexTypeColumnMap CreateComplexTypeColumnMap(TypeInfo typeInfo, string name, ComplexTypeColumnMap superTypeColumnMap, Dictionary <object, TypedColumnMap> discriminatorMap, List <TypedColumnMap> allMaps) { List <ColumnMap> propertyColumnMapList = new List <ColumnMap>(); IEnumerable myProperties = null; SimpleColumnMap nullSentinelColumnMap = null; if (typeInfo.HasNullSentinelProperty) { nullSentinelColumnMap = CreateSimpleColumnMap(md.Helper.GetModelTypeUsage(typeInfo.NullSentinelProperty), c_NullSentinelColumnName); } // Copy over information from my supertype if it already exists if (superTypeColumnMap != null) { foreach (ColumnMap c in superTypeColumnMap.Properties) { propertyColumnMapList.Add(c); } myProperties = TypeHelpers.GetDeclaredStructuralMembers(typeInfo.Type); } else { // need to get all members otherwise myProperties = TypeHelpers.GetAllStructuralMembers(typeInfo.Type); } // Now add on all of my "specific" properties foreach (md.EdmMember property in myProperties) { ColumnMap propertyColumnMap = CreateColumnMap(md.Helper.GetModelTypeUsage(property), property.Name); propertyColumnMapList.Add(propertyColumnMap); } // Create a map for myself ComplexTypeColumnMap columnMap = new ComplexTypeColumnMap(typeInfo.Type, name, propertyColumnMapList.ToArray(), nullSentinelColumnMap); // if a dictionary is supplied, add myself to the dictionary if (discriminatorMap != null) { discriminatorMap[typeInfo.TypeId] = columnMap; } if (allMaps != null) { allMaps.Add(columnMap); } // Finally walk through my subtypes - use the same column name foreach (TypeInfo subTypeInfo in typeInfo.ImmediateSubTypes) { CreateComplexTypeColumnMap(subTypeInfo, name, columnMap, discriminatorMap, allMaps); } return(columnMap); }
internal CollectionInfo( Var collectionVar, ColumnMap columnMap, VarList flattenedElementVars, VarVec keys, List<SortKey> sortKeys, object discriminatorValue) { m_collectionVar = collectionVar; m_columnMap = columnMap; m_flattenedElementVars = flattenedElementVars; m_keys = keys; m_sortKeys = sortKeys; m_discriminatorValue = discriminatorValue; }
protected void InitializeColumnMap(DataReaderWrapperParameters parameters) { var columns = new List <string>(); if (parameters?.Columns != null) { columns.AddRange(parameters.Columns); } if (columns.Count <= 0) { for (int i = 0; i < _Reader.FieldCount; i++) { columns.Add(_Reader.GetName(i)); } } if ((parameters.SkipColumns?.Length ?? 0) > 0) { var dictSkip = new StringNoCaseDictionary <int>(); foreach (string skipColumn in parameters.SkipColumns) { if (!dictSkip.ContainsKey(skipColumn)) { dictSkip.Add(skipColumn, 1); } else { dictSkip[skipColumn]++; } } for (int i = columns.Count - 1; i >= 0; i--) { if (dictSkip.ContainsKey(columns[i])) { columns.RemoveAt(i); } } } for (int i = 0; i < columns.Count; i++) { string columnName = columns[i]; int ordinal = _Reader.GetOrdinal(columnName); if (ordinal < 0) { throw new Exception($"Cannot find column '{columnName}'"); } ColumnMap.Add(i, ordinal); ColumnMapReverse.Add(ordinal, i); } }
/// <summary> /// The primary factory method to produce the BridgeDataReader; given a store data /// reader and a column map, create the BridgeDataReader, hooking up the IteratorSources /// and ResultColumn Hierarchy. All construction of top level data readers go through /// this method. /// </summary> /// <param name="storeDataReader"></param> /// <param name="columnMap">column map of the first result set</param> /// <param name="nextResultColumnMaps">enumerable of the column maps for NextResult() calls.</param> /// <returns></returns> static internal DbDataReader Create(DbDataReader storeDataReader, ColumnMap columnMap, MetadataWorkspace workspace, IEnumerable <ColumnMap> nextResultColumnMaps) { Debug.Assert(storeDataReader != null, "null storeDataReaders?"); Debug.Assert(columnMap != null, "null columnMap?"); Debug.Assert(workspace != null, "null workspace?"); var shaperInfo = CreateShaperInfo(storeDataReader, columnMap, workspace); DbDataReader result = new BridgeDataReader(shaperInfo.Key, shaperInfo.Value, /*depth:*/ 0, GetNextResultShaperInfo(storeDataReader, workspace, nextResultColumnMaps).GetEnumerator()); return(result); }
private void RenamePoco(TInput row, IDictionary <string, object> resultAsDict) { for (int i = 0; i < TypeInfo.PropertyLength; i++) { ColumnMap cm = MappingDict.ContainsKey(TypeInfo.Properties[i].Name) ? MappingDict[TypeInfo.Properties[i].Name] : null; if (cm == null || cm?.RemoveColumn == false) { resultAsDict.Add(cm?.NewName ?? TypeInfo.Properties[i].Name, TypeInfo.Properties[i].GetValue(row)); } } }
public object FromDB(ColumnMap map, object dbValue) { if (dbValue == DBNull.Value) { return(Quality.Unknown); } var val = Convert.ToInt32(dbValue); return((Quality)val); }
private bool IsDefaultValueDisabled(string column, string property, string[] disabledFieldNames) { if (disabledFieldNames.Contains(property)) return true; string columnWithoutIndex, columnIndex; if (ColumnMap.ParseSourceName(property, out columnWithoutIndex, out columnIndex)) return disabledFieldNames.Contains(columnWithoutIndex); return false; }
public GLib.Value GetColumnValue(ITreeGridItem item, int dataColumn, int row) { int column; if (ColumnMap.TryGetValue(dataColumn, out column)) { var colHandler = (IGridColumnHandler)Widget.Columns[column].Handler; return(colHandler.GetValue(item, dataColumn, row)); } return(new GLib.Value((string)null)); }
public IActionResult Post(ColumnMap columnMaps) { try { ExcelHelper.Instance.SaveDataToDb(columnMaps, _settings.Value.DefaultConnection); return(Content("success")); } catch (Exception ex) { return(StatusCode(500, ex.Message)); } }
void PopulateTableColumns() { if (SelectedConnection != null) { ColumnMap CM = new ColumnMap(this.DataSourceId, SelectedConnection, ConnectionStringKeys, DatabaseTableName, TotalRecordsInBatch); _ColumnMapInfos.Clear(); foreach (ColumnMapInfo ci in CM) { _ColumnMapInfos.Add(ci); } } }
public ValueSetter(IQueryNode parent, ColumnMap columns, ElementCode[] values) { if (columns.Count != values.Length) { throw new ApplicationException(); } this.Parent = parent; for (int i = 0; i < values.Length; i++) { this.ColumnMap.Add(columns[i].Clone(values[i])); } }
public ColumnMap GetMap() { MemberExpression temp = _memberAccess; string propertyMap = ""; while (temp != null) { propertyMap = "." + temp.Member.Name + propertyMap; temp = temp.Expression as MemberExpression; } propertyMap = propertyMap.TrimStart('.'); _propertyName = propertyMap; if (_mapType == MapType.UseMap && propertyMap.Contains(".")) { throw new Exception("Nested Property And UseMap Is Not Compatible"); } ColumnMap columnMap = null; if (_mapType == MapType.ColumnName) { string columnName = _columnName; if (propertyMap.Contains(".")) { string[] strings = propertyMap.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries); RowMap tempRm = RowMapper.GetTempRowMap(strings, columnName); columnMap = new ColumnMap() { PropertyName = strings[0], InnerType = InnerMapType.Internal, InternalRowMap = tempRm }; } else { columnMap = new ColumnMap() { ColumnName = columnName, PropertyName = propertyMap } }; } else if (_mapType == MapType.UseMap) { columnMap = new ColumnMap() { PropertyName = propertyMap, InnerType = InnerMapType.Internal, }; } return(columnMap); }
internal virtual void Visit(ComplexTypeColumnMap columnMap, TArgType arg) { ColumnMap nullSentinel = columnMap.NullSentinel; if (null != nullSentinel) { nullSentinel.Accept(this, arg); } foreach (var p in columnMap.Properties) { p.Accept(this, arg); } }
private KeyValuePair<Shaper<RecordState>, CoordinatorFactory<RecordState>> CreateShaperInfo( DbDataReader storeDataReader, ColumnMap columnMap, MetadataWorkspace workspace) { DebugCheck.NotNull(storeDataReader); DebugCheck.NotNull(columnMap); DebugCheck.NotNull(workspace); var shaperFactory = _translator.TranslateColumnMap<RecordState>(columnMap, workspace, null, MergeOption.NoTracking, streaming: true, valueLayer: true); var recordShaper = shaperFactory.Create( storeDataReader, null, workspace, MergeOption.NoTracking, readerOwned: true, streaming: true); return new KeyValuePair<Shaper<RecordState>, CoordinatorFactory<RecordState>>( recordShaper, recordShaper.RootCoordinator.TypedCoordinatorFactory); }
/// <summary> /// The primary factory method to produce the BridgeDataReader; given a store data /// reader and a column map, create the BridgeDataReader, hooking up the IteratorSources /// and ResultColumn Hierarchy. All construction of top level data readers go through /// this method. /// </summary> /// <param name="storeDataReader"> </param> /// <param name="columnMap"> column map of the first result set </param> /// <param name="nextResultColumnMaps"> enumerable of the column maps for NextResult() calls. </param> /// <returns> </returns> public virtual DbDataReader Create( DbDataReader storeDataReader, ColumnMap columnMap, MetadataWorkspace workspace, IEnumerable<ColumnMap> nextResultColumnMaps) { DebugCheck.NotNull(storeDataReader); DebugCheck.NotNull(columnMap); DebugCheck.NotNull(workspace); DebugCheck.NotNull(nextResultColumnMaps); var shaperInfo = CreateShaperInfo(storeDataReader, columnMap, workspace); DbDataReader result = new BridgeDataReader( shaperInfo.Key, shaperInfo.Value, /*depth:*/ 0, GetNextResultShaperInfo(storeDataReader, workspace, nextResultColumnMaps).GetEnumerator()); return result; }
/// <summary> /// The primary factory method to produce the BridgeDataReader; given a store data /// reader and a column map, create the BridgeDataReader, hooking up the IteratorSources /// and ResultColumn Hierarchy. All construction of top level data readers go through /// this method. /// </summary> /// <param name="storeDataReader"></param> /// <param name="columnMap">column map of the first result set</param> /// <param name="nextResultColumnMaps">enumerable of the column maps for NextResult() calls.</param> /// <returns></returns> public virtual DbDataReader Create( DbDataReader storeDataReader, ColumnMap columnMap, MetadataWorkspace workspace, IEnumerable<ColumnMap> nextResultColumnMaps) { Contract.Requires(storeDataReader != null); Contract.Requires(columnMap != null); Contract.Requires(workspace != null); Contract.Requires(nextResultColumnMaps != null); var shaperInfo = CreateShaperInfo(storeDataReader, columnMap, workspace); DbDataReader result = new BridgeDataReader( shaperInfo.Key, shaperInfo.Value, /*depth:*/ 0, GetNextResultShaperInfo(storeDataReader, workspace, nextResultColumnMaps).GetEnumerator()); return result; }
private KeyValuePair<Shaper<RecordState>, CoordinatorFactory<RecordState>> CreateShaperInfo( DbDataReader storeDataReader, ColumnMap columnMap, MetadataWorkspace workspace) { Contract.Requires(storeDataReader != null); Contract.Requires(columnMap != null); Contract.Requires(workspace != null); var cacheManager = workspace.GetQueryCacheManager(); const MergeOption NoTracking = MergeOption.NoTracking; var shaperFactory = _translator.TranslateColumnMap<RecordState>(cacheManager, columnMap, workspace, null, NoTracking, true); var recordShaper = shaperFactory.Create(storeDataReader, null, workspace, MergeOption.NoTracking, true); return new KeyValuePair<Shaper<RecordState>, CoordinatorFactory<RecordState>>( recordShaper, recordShaper.RootCoordinator.TypedCoordinatorFactory); }
/// <summary> /// The real driver. This routine walks the tree, converts each subcommand /// into a CTree, and converts the columnmap into a real column map. /// Finally, it produces a "real" plan that can be used by the bridge execution, and /// returns this plan /// /// The root of the tree must be a PhysicalProjectOp. Each child of this Op /// represents a command to be executed, and the ColumnMap of this Op represents /// the eventual columnMap to be used for result assembly /// </summary> /// <param name="childCommands">CQTs for store commands</param> /// <param name="resultColumnMap">column map for result assembly</param> private void Process(out List<ProviderCommandInfo> childCommands, out ColumnMap resultColumnMap, out int columnCount) { var projectOp = (PhysicalProjectOp)Command.Root.Op; m_subCommands = new List<Node>(new[] { Command.Root }); childCommands = new List<ProviderCommandInfo>( new[] { ProviderCommandInfoUtils.Create( Command, Command.Root // input node ) }); // Build the final column map, and count the columns we expect for it. resultColumnMap = BuildResultColumnMap(projectOp); columnCount = projectOp.Outputs.Count; }
static void Main(string[] args) { // Read a table from sql server via a query, then make an exact copy // of that table. // Step 1. Read source table schema // Step 2. Create exact same schema on destination // Step 3. Copy Data // Prepare reflow engine ReflowEngine engine = new ReflowEngine(); // Test DB Path string test = "text"; // "access"; string sourceConnectionString = string.Empty; ILinkProvider sourceProvider = null; if (test == "access") { string accessDBPath = AppDomain.CurrentDomain.BaseDirectory + "db1.accdb"; sourceConnectionString = string.Format("Provider=Microsoft.ACE.OLEDB.12.0;Data Source={0};Persist Security Info=False;", accessDBPath); sourceProvider = new Provider.Access.AccessLinkProvider(); } else if (test == "text") { // TODO: Test and implement text driver string txtDBPath = AppDomain.CurrentDomain.BaseDirectory + "text\\HumanResources_Employee.txt"; sourceConnectionString = "@File="+txtDBPath + ";@Type=Delimited;RowSeperator=\r\n;ColumnSeperator=,;FirstRowHasNames=True"; // TODO: Fixed length - Need to implement //sourceConnectionString = "@File="+txtDBPath + ";@Type=Fixed;"; sourceProvider = new Provider.Text.TextProvider(); } IDataLink linkSource = sourceProvider.CreateLink ( sourceConnectionString); ILinkProvider sqlProvider = new Provider.SqlServer.SqlLinkProvider(); string destConnectionString = "Server=localhost;Database=REflow;Trusted_Connection=True;"; IDataLink linkDestination = sqlProvider.CreateLink(destConnectionString); // Driver={Microsoft Text Driver (*.txt; *.csv)};Dbq=c:\txtFilesFolder\;Extensions=asc,csv,tab,txt; string selectQuery = "Select * from HumanResources_Employee"; // First lets discover the schema of the query [source table] DiscoverSchemaTask task1 = new DiscoverSchemaTask(); task1.Name = "DiscoverSchema"; task1.Query = selectQuery; task1.Link = linkSource; // Then we need to create a table in the destinaton database. TableCreateTask task2 = new TableCreateTask(); task2.Name = "CreateTableAbc"; task2.TableName = "abc"; task2.Link = linkDestination; task2.ShouldDropExisting = true; // Now we need to map task1 output to be the input of task2 since // task1 will discover column names and we need to map discovered // columns to the Columns property of task 2. We can do this one of // two way. // First, we can use a delegate to call onbeforeexecute for task2 and // assign task result of task 1 to the column property of task 2. But that // would be problematic for the scenario where we want to serialize the task // and deserialize. // Second, We can we task link object map output of task1 to go into certain // properties of task 2. This can be serialized. We would use this technique TaskLink link = new TaskLink(); link.LastTask = task1; link.NextTask = task2; // Map the output called DiscoveredColumns ( found in TaskResult.Output["DiscoveredColumns"]) to // task2.Columns once task1 has been executed link.TaskPipe["Columns"] = "Columns"; link.Bind(); // Now we will execute the data copy task. Will need to do the column mapping // Interestingly, since our output columns are same as input columns at source, // we can use the automap property to map the columns automatically. DataFlowTask task3 = new DataFlowTask() { Name = "DataCopyTask" }; ILinkReader reader = sourceProvider.CreateReader(linkSource, selectQuery); // Since we are using same query ILinkWriter writer = sqlProvider.CreateWriter(linkDestination, task2.TableName); // Dest table task3.Input = reader; task3.Output = writer; /* We would notmally create column mapping here and and map source and * destination and put custom expressions if needed. But since we are doing a * direct table copy, we can just use Automap property. */ // ColumnMappings maps = new ColumnMappings(); task3.IsAutoMap = true; task3.TableName = task2.TableName; // TODO: Add column mapping support // Add scripting transformation ColumnMap map = new ColumnMap(); map.Destination = "Title"; Expression exp = new Expression() { Code = "NationalIDNumber & \" \" & UCASE(Title) & CSTR(LEN(Title))"}; map.TransformExpression = exp; task3.Mapping.Add(map); engine.Tasks.Add(task1); engine.Tasks.Add(task2); engine.Tasks.Add(task3); ExecutionEventListener eventListener = new ExecutionEventListener(); eventListener.OnTaskExecutionEvent+= delegate (string taskname, string eventName, string description) { Console.WriteLine(string.Format("{0,15} |{1,10} | {2}", taskname, eventName, description)); }; eventListener.LoggingLevel = ExecutionEventListener.LogLevel.Verbose; engine.Execute(eventListener); }
/// <summary> /// Create a column map for a record type. Simply iterates through the /// list of fields, and produces a column map for each field /// </summary> /// <param name="typeInfo">Type information for the record type</param> /// <param name="name">column name</param> /// <returns></returns> private RecordColumnMap CreateRecordColumnMap(TypeInfo typeInfo, string name) { PlanCompiler.Assert(typeInfo.Type.EdmType is md.RowType, "not RowType"); SimpleColumnMap nullSentinelColumnMap = null; if (typeInfo.HasNullSentinelProperty) { nullSentinelColumnMap = CreateSimpleColumnMap(md.Helper.GetModelTypeUsage(typeInfo.NullSentinelProperty), c_NullSentinelColumnName); } md.ReadOnlyMetadataCollection<md.EdmProperty> properties = TypeHelpers.GetProperties(typeInfo.Type); ColumnMap[] propertyColumnMapList = new ColumnMap[properties.Count]; for (int i = 0; i < propertyColumnMapList.Length; ++i) { md.EdmMember property = properties[i]; propertyColumnMapList[i] = CreateColumnMap(md.Helper.GetModelTypeUsage(property), property.Name); } RecordColumnMap result = new RecordColumnMap(typeInfo.Type, name, propertyColumnMapList, nullSentinelColumnMap); return result; }
public ActionResult Import() { string importJson = Request["hidImport"]; JavaScriptSerializer serializer = new JavaScriptSerializer(); dynamic jsonObject = serializer.Deserialize<dynamic>(importJson); //ImportInfo jsonObject; // Do the import string sourceConnectionString = "@File=" + jsonObject["ImportFileLocation"] + ";@Type=Delimited;RowSeperator=" + jsonObject["RowDelimiter"] +";ColumnSeperator="+ jsonObject["ColumnDelimiter"] +";FirstRowHasNames=" + jsonObject["FirstRowHasColumnNames"].ToString(); string destConnectionString = ConfigurationManager.AppSettings["SqlConnection"]; ILinkProvider sourceProvider = null; ILinkProvider destProvider = null; destProvider = new SqlLinkProvider(); sourceProvider = new TextProvider(); IDataLink linkSource = sourceProvider.CreateLink(sourceConnectionString); IDataLink linkDestination = destProvider.CreateLink(destConnectionString); SqlDataLink sqlLink = new SqlDataLink(); sqlLink.Initialize(ConfigurationManager.AppSettings["SqlConnection"]); sqlLink.Connect(); DataFlowTask copy = new DataFlowTask() { Name = "DataCopyTask" }; ILinkReader reader = sourceProvider.CreateReader(linkSource, ""); // Since we are using same query string destTable = jsonObject["DestinationTableName"].ToString(); ILinkWriter writer = destProvider.CreateWriter(linkDestination, destTable); // Dest table copy.Input = reader; copy.Output = writer; copy.TableName = destTable; copy.IsAutoMap = false; dynamic maps = jsonObject["Maps"]; foreach (dynamic map in maps) { ColumnMap cmap = new ColumnMap(); cmap.Destination = map["FieldName"]; Expression exp = new Expression() { Code = map["TargetExpression"] }; cmap.TransformExpression = exp; copy.Mapping.Add(cmap); } StringBuilder sb = new StringBuilder(); ReflowEngine engine = new ReflowEngine(); engine.Tasks.Add(copy); ExecutionEventListener eventListener = new ExecutionEventListener(); eventListener.OnTaskExecutionEvent += delegate(string taskname, string eventName, string description) { sb.Append(string.Format("{0,15} |{1,10} | {2} <br>", taskname, eventName, description)); }; eventListener.LoggingLevel = ExecutionEventListener.LogLevel.Verbose; engine.Execute(eventListener); linkSource.Disconnect(); linkDestination.Disconnect(); //System.IO.File.Delete(jsonObject["ImportFileLocation"]); Session.Remove("import_file_path"); this.ViewBag.Log= sb.ToString(); return View(); }
/// <summary> /// Structured columnmap constructor /// </summary> /// <param name="type">datatype for this column</param> /// <param name="name">column name</param> /// <param name="properties">list of properties</param> internal StructuredColumnMap(TypeUsage type, string name, ColumnMap[] properties) : base(type, name) { Debug.Assert(properties != null, "No properties (gasp!) for a structured type"); m_properties = properties; }
// <summary> // Typed columnMap constructor // </summary> // <param name="type"> Datatype of column </param> // <param name="name"> column name </param> // <param name="properties"> List of column maps - one for each property </param> internal TypedColumnMap(TypeUsage type, string name, ColumnMap[] properties) : base(type, name, properties) { }
private static KeyValuePair<Shaper<RecordState>, CoordinatorFactory<RecordState>> CreateShaperInfo(DbDataReader storeDataReader, ColumnMap columnMap, MetadataWorkspace workspace) { Debug.Assert(storeDataReader != null, "null storeDataReaders?"); Debug.Assert(columnMap != null, "null columnMap?"); Debug.Assert(workspace != null, "null workspace?"); System.Data.Common.QueryCache.QueryCacheManager cacheManager = workspace.GetQueryCacheManager(); const System.Data.Objects.MergeOption NoTracking = System.Data.Objects.MergeOption.NoTracking; ShaperFactory<RecordState> shaperFactory = Translator.TranslateColumnMap<RecordState>(cacheManager, columnMap, workspace, null, NoTracking, true); Shaper<RecordState> recordShaper = shaperFactory.Create(storeDataReader, null, workspace, System.Data.Objects.MergeOption.NoTracking, true); return new KeyValuePair<Shaper<RecordState>, CoordinatorFactory<RecordState>>(recordShaper, recordShaper.RootCoordinator.TypedCoordinatorFactory); }
// <summary> // Structured columnmap constructor // </summary> // <param name="type"> datatype for this column </param> // <param name="name"> column name </param> // <param name="properties"> list of properties </param> internal StructuredColumnMap(TypeUsage type, string name, ColumnMap[] properties) : base(type, name) { DebugCheck.NotNull(properties); m_properties = properties; }
/// <summary> /// The real driver. /// </summary> /// <param name="providerCommands"> list of provider commands </param> /// <param name="resultColumnMap"> column map for the result </param> /// <param name="entitySets"> the entity sets exposed in this query </param> private void Compile( out List<ProviderCommandInfo> providerCommands, out ColumnMap resultColumnMap, out int columnCount, out Set<md.EntitySet> entitySets) { Initialize(); // initialize the ITree var beforePreProcessor = String.Empty; var beforeAggregatePushdown = String.Empty; var beforeNormalization = String.Empty; var beforeNTE = String.Empty; var beforeProjectionPruning1 = String.Empty; var beforeNestPullup = String.Empty; var beforeProjectionPruning2 = String.Empty; var beforeTransformationRules1 = String.Empty; var beforeProjectionPruning3 = String.Empty; var beforeTransformationRules2 = String.Empty; var beforeJoinElimination1 = String.Empty; var beforeTransformationRules3 = String.Empty; var beforeJoinElimination2 = String.Empty; var beforeTransformationRules4 = String.Empty; var beforeCodeGen = String.Empty; // // We always need the pre-processor and the codegen phases. // It is generally a good thing to run through the transformation rules, and // the projection pruning phases. // The "optional" phases are AggregatePushdown, Normalization, NTE, NestPullup and JoinElimination // m_neededPhases = (1 << (int)PlanCompilerPhase.PreProcessor) | // (1 << (int)PlanCompilerPhase.AggregatePushdown) | // (1 << (int)PlanCompilerPhase.Normalization) | // (1 << (int)PlanCompilerPhase.NTE) | (1 << (int)PlanCompilerPhase.ProjectionPruning) | // (1 << (int)PlanCompilerPhase.NestPullup) | (1 << (int)PlanCompilerPhase.Transformations) | // (1 << (int)PlanCompilerPhase.JoinElimination) | (1 << (int)PlanCompilerPhase.CodeGen); // Perform any necessary preprocessing StructuredTypeInfo typeInfo; Dictionary<md.EdmFunction, md.EdmProperty[]> tvfResultKeys; beforePreProcessor = SwitchToPhase(PlanCompilerPhase.PreProcessor); PreProcessor.Process(this, out typeInfo, out tvfResultKeys); entitySets = typeInfo.GetEntitySets(); if (IsPhaseNeeded(PlanCompilerPhase.AggregatePushdown)) { beforeAggregatePushdown = SwitchToPhase(PlanCompilerPhase.AggregatePushdown); AggregatePushdown.Process(this); } if (IsPhaseNeeded(PlanCompilerPhase.Normalization)) { beforeNormalization = SwitchToPhase(PlanCompilerPhase.Normalization); Normalizer.Process(this); } // Eliminate "structured" types. if (IsPhaseNeeded(PlanCompilerPhase.NTE)) { beforeNTE = SwitchToPhase(PlanCompilerPhase.NTE); NominalTypeEliminator.Process(this, typeInfo, tvfResultKeys); } // Projection pruning - eliminate unreferenced expressions if (IsPhaseNeeded(PlanCompilerPhase.ProjectionPruning)) { beforeProjectionPruning1 = SwitchToPhase(PlanCompilerPhase.ProjectionPruning); ProjectionPruner.Process(this); } // Nest Pull-up on the ITree if (IsPhaseNeeded(PlanCompilerPhase.NestPullup)) { beforeNestPullup = SwitchToPhase(PlanCompilerPhase.NestPullup); NestPullup.Process(this); //If we do Nest Pull-up, we should again do projection pruning beforeProjectionPruning2 = SwitchToPhase(PlanCompilerPhase.ProjectionPruning); ProjectionPruner.Process(this); } // Run transformations on the tree if (IsPhaseNeeded(PlanCompilerPhase.Transformations)) { var projectionPrunningNeeded = ApplyTransformations(ref beforeTransformationRules1, TransformationRulesGroup.All); if (projectionPrunningNeeded) { beforeProjectionPruning3 = SwitchToPhase(PlanCompilerPhase.ProjectionPruning); ProjectionPruner.Process(this); ApplyTransformations(ref beforeTransformationRules2, TransformationRulesGroup.Project); } } // Join elimination if (IsPhaseNeeded(PlanCompilerPhase.JoinElimination)) { beforeJoinElimination1 = SwitchToPhase(PlanCompilerPhase.JoinElimination); var modified = JoinElimination.Process(this); if (modified) { ApplyTransformations(ref beforeTransformationRules3, TransformationRulesGroup.PostJoinElimination); beforeJoinElimination2 = SwitchToPhase(PlanCompilerPhase.JoinElimination); modified = JoinElimination.Process(this); if (modified) { ApplyTransformations(ref beforeTransformationRules4, TransformationRulesGroup.PostJoinElimination); } } } // Code generation beforeCodeGen = SwitchToPhase(PlanCompilerPhase.CodeGen); CodeGen.Process(this, out providerCommands, out resultColumnMap, out columnCount); #if DEBUG // GC.KeepAlive makes FxCop Grumpy. var size = beforePreProcessor.Length; size = beforeAggregatePushdown.Length; size = beforeNormalization.Length; size = beforeNTE.Length; size = beforeProjectionPruning1.Length; size = beforeNestPullup.Length; size = beforeProjectionPruning2.Length; size = beforeTransformationRules1.Length; size = beforeProjectionPruning3.Length; size = beforeTransformationRules2.Length; size = beforeJoinElimination1.Length; size = beforeTransformationRules3.Length; size = beforeJoinElimination2.Length; size = beforeTransformationRules4.Length; size = beforeCodeGen.Length; #endif // All done return; }
/// <summary> /// Another overload - with an additional discriminatorValue. /// Should this be a subtype instead? /// </summary> /// <param name="collectionVar">the collectionVar</param> /// <param name="columnMap">column map for the collection element</param> /// <param name="flattenedElementVars">elementVars with any nested collections pulled up</param> /// <param name="keys">keys specific to this collection</param> /// <param name="sortKeys">sort keys specific to this collecion</param> /// <param name="discriminatorValue">discriminator value for this collection (under the current nestOp)</param> /// <returns>a new CollectionInfo instance</returns> internal static CollectionInfo CreateCollectionInfo(Var collectionVar, ColumnMap columnMap, VarList flattenedElementVars, VarVec keys, List<InternalTrees.SortKey> sortKeys, object discriminatorValue) { return new CollectionInfo(collectionVar, columnMap, flattenedElementVars, keys, sortKeys, discriminatorValue); }
internal ConstantColumnMapGenerator(ColumnMap columnMap, int fieldsRequired) { _columnMap = columnMap; _fieldsRequired = fieldsRequired; }
/// <summary> /// For a given edmType, build an array of scalarColumnMaps that map to the columns /// in the store datareader provided. Note that we're hooking things up by name, not /// by ordinal position. /// </summary> /// <param name="storeDataReader"></param> /// <param name="edmType"></param> /// <returns></returns> private static ColumnMap[] GetColumnMapsForType(DbDataReader storeDataReader, EdmType edmType, Dictionary<string, FunctionImportReturnTypeStructuralTypeColumnRenameMapping> renameList) { // First get the list of properties; NOTE: we need to hook up the column by name, // not by position. IBaseList<EdmMember> members = TypeHelpers.GetAllStructuralMembers(edmType); ColumnMap[] propertyColumnMaps = new ColumnMap[members.Count]; int index = 0; foreach (EdmMember member in members) { if (!Helper.IsScalarType(member.TypeUsage.EdmType)) { throw EntityUtil.InvalidOperation(Strings.ADP_InvalidDataReaderUnableToMaterializeNonScalarType(member.Name, member.TypeUsage.EdmType.FullName)); } int ordinal = GetMemberOrdinalFromReader(storeDataReader, member, edmType, renameList); propertyColumnMaps[index] = new ScalarColumnMap(member.TypeUsage, member.Name, 0, ordinal); index++; } return propertyColumnMaps; }
/// <summary> /// Build the entityColumnMap from a store datareader, a type and an entitySet and /// a list ofproperties. /// </summary> /// <param name="storeDataReader"></param> /// <param name="edmType"></param> /// <param name="entitySet"></param> /// <param name="propertyColumnMaps"></param> /// <returns></returns> private static EntityColumnMap CreateEntityTypeElementColumnMap( DbDataReader storeDataReader, EdmType edmType, EntitySet entitySet, ColumnMap[] propertyColumnMaps, Dictionary<string, FunctionImportReturnTypeStructuralTypeColumnRenameMapping> renameList) { EntityType entityType = (EntityType)edmType; // The tricky part here is // that the KeyColumns list must point at the same ColumnMap(s) that // the properties list points to, so we build a quick array of // ColumnMap(s) that are indexed by their ordinal; then we can walk // the list of keyMembers, and find the ordinal in the reader, and // pick the same ColumnMap for it. // Build the ordinal -> ColumnMap index ColumnMap[] ordinalToColumnMap = new ColumnMap[storeDataReader.FieldCount]; foreach (ColumnMap propertyColumnMap in propertyColumnMaps) { int ordinal = ((ScalarColumnMap)propertyColumnMap).ColumnPos; ordinalToColumnMap[ordinal] = propertyColumnMap; } // Now build the list of KeyColumns; IList<EdmMember> keyMembers = entityType.KeyMembers; SimpleColumnMap[] keyColumns = new SimpleColumnMap[keyMembers.Count]; int keyMemberIndex = 0; foreach (EdmMember keyMember in keyMembers) { int keyOrdinal = GetMemberOrdinalFromReader(storeDataReader, keyMember, edmType, renameList); Debug.Assert(keyOrdinal >= 0, "keyMember for entity is not found by name in the data reader?"); ColumnMap keyColumnMap = ordinalToColumnMap[keyOrdinal]; Debug.Assert(null != keyColumnMap, "keyMember for entity isn't in properties collection for the entity?"); keyColumns[keyMemberIndex] = (SimpleColumnMap)keyColumnMap; keyMemberIndex++; } SimpleEntityIdentity entityIdentity = new SimpleEntityIdentity(entitySet, keyColumns); EntityColumnMap result = new EntityColumnMap(TypeUsage.Create(edmType), edmType.Name, propertyColumnMaps, entityIdentity); return result; }
/// <summary> /// Requires: a public type with a public, default constructor. Returns a column map initializing the type /// and all properties of the type with a public setter taking a primitive type and having a corresponding /// column in the reader. /// </summary> internal static CollectionColumnMap CreateColumnMapFromReaderAndClrType(DbDataReader reader, Type type, MetadataWorkspace workspace) { Debug.Assert(null != reader); Debug.Assert(null != type); Debug.Assert(null != workspace); // we require a default constructor ConstructorInfo constructor = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null); if (type.IsAbstract || (null == constructor && !type.IsValueType)) { throw EntityUtil.InvalidOperation( Strings.ObjectContext_InvalidTypeForStoreQuery(type)); } // build a LINQ expression used by result assembly to create results var memberInfo = new List<Tuple<MemberAssignment, int, EdmProperty>>(); foreach (PropertyInfo prop in type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)) { // for enums unwrap the type if nullable var propertyUnderlyingType = Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType; Type propType = propertyUnderlyingType.IsEnum ? propertyUnderlyingType.GetEnumUnderlyingType() : prop.PropertyType; EdmType modelType; int ordinal; if (TryGetColumnOrdinalFromReader(reader, prop.Name, out ordinal) && MetadataHelper.TryDetermineCSpaceModelType(propType, workspace, out modelType) && (Helper.IsScalarType(modelType)) && prop.CanWrite && prop.GetIndexParameters().Length == 0 && null != prop.GetSetMethod(/* nonPublic */true)) { memberInfo.Add(Tuple.Create( Expression.Bind(prop, Expression.Parameter(prop.PropertyType, "placeholder")), ordinal, new EdmProperty(prop.Name, TypeUsage.Create(modelType)))); } } // initialize members in the order in which they appear in the reader MemberInfo[] members = new MemberInfo[memberInfo.Count]; MemberBinding[] memberBindings = new MemberBinding[memberInfo.Count]; ColumnMap[] propertyMaps = new ColumnMap[memberInfo.Count]; EdmProperty[] modelProperties = new EdmProperty[memberInfo.Count]; int i = 0; foreach (var memberGroup in memberInfo.GroupBy(tuple => tuple.Item2).OrderBy(tuple => tuple.Key)) { // make sure that a single column isn't contributing to multiple properties if (memberGroup.Count() != 1) { throw EntityUtil.InvalidOperation(Strings.ObjectContext_TwoPropertiesMappedToSameColumn( reader.GetName(memberGroup.Key), String.Join(", ", memberGroup.Select(tuple => tuple.Item3.Name).ToArray()))); } var member = memberGroup.Single(); MemberAssignment assignment = member.Item1; int ordinal = member.Item2; EdmProperty modelProp = member.Item3; members[i] = assignment.Member; memberBindings[i] = assignment; propertyMaps[i] = new ScalarColumnMap(modelProp.TypeUsage, modelProp.Name, 0, ordinal); modelProperties[i] = modelProp; i++; } NewExpression newExpr = null == constructor ? Expression.New(type) : Expression.New(constructor); MemberInitExpression init = Expression.MemberInit(newExpr, memberBindings); InitializerMetadata initMetadata = InitializerMetadata.CreateProjectionInitializer( (EdmItemCollection)workspace.GetItemCollection(DataSpace.CSpace), init, members); // column map (a collection of rows with InitializerMetadata markup) RowType rowType = new RowType(modelProperties, initMetadata); RecordColumnMap rowMap = new RecordColumnMap(TypeUsage.Create(rowType), "DefaultTypeProjection", propertyMaps, null); CollectionColumnMap collectionMap = new SimpleCollectionColumnMap(rowType.GetCollectionType().TypeUsage, rowType.Name, rowMap, null, null); return collectionMap; }
/// <summary> /// This involves /// * Converting the ITree into a set of ProviderCommandInfo objects /// * Creating a column map to enable result assembly /// Currently, we only produce a single ITree, and correspondingly, the /// following steps are trivial /// </summary> /// <param name="compilerState">current compiler state</param> /// <param name="childCommands">CQTs for each store command</param> /// <param name="resultColumnMap">column map to help in result assembly</param> internal static void Process( PlanCompiler compilerState, out List<ProviderCommandInfo> childCommands, out ColumnMap resultColumnMap, out int columnCount) { var codeGen = new CodeGen(compilerState); codeGen.Process(out childCommands, out resultColumnMap, out columnCount); }
private ColumnMap Copy(ColumnMap columnMap) { return ColumnMapCopier.Copy(columnMap, m_varMap); }
/// <summary> /// The primary factory method to produce the BridgeDataReader; given a store data /// reader and a column map, create the BridgeDataReader, hooking up the IteratorSources /// and ResultColumn Hierarchy. All construction of top level data readers go through /// this method. /// </summary> /// <param name="storeDataReader"></param> /// <param name="columnMap">column map of the first result set</param> /// <param name="nextResultColumnMaps">enumerable of the column maps for NextResult() calls.</param> /// <returns></returns> static internal DbDataReader Create(DbDataReader storeDataReader, ColumnMap columnMap, MetadataWorkspace workspace, IEnumerable<ColumnMap> nextResultColumnMaps) { Debug.Assert(storeDataReader != null, "null storeDataReaders?"); Debug.Assert(columnMap != null, "null columnMap?"); Debug.Assert(workspace != null, "null workspace?"); var shaperInfo = CreateShaperInfo(storeDataReader, columnMap, workspace); DbDataReader result = new BridgeDataReader(shaperInfo.Key, shaperInfo.Value, /*depth:*/ 0, GetNextResultShaperInfo(storeDataReader, workspace, nextResultColumnMaps).GetEnumerator()); return result; }
internal static void Compile( cqt.DbCommandTree ctree, out List<ProviderCommandInfo> providerCommands, out ColumnMap resultColumnMap, out int columnCount, out Set<md.EntitySet> entitySets) { Assert(ctree != null, "Expected a valid, non-null Command Tree input"); var pc = new PlanCompiler(ctree); pc.Compile(out providerCommands, out resultColumnMap, out columnCount, out entitySets); }