/// <summary> /// Gets the column members. /// </summary> /// <param name="entityType">Type of the entity.</param> /// <param name="metaModel">The meta model.</param> /// <returns></returns> protected virtual IEnumerable<MemberInfo> GetColumnMembers(Type entityType, MetaModel metaModel) { foreach (var dataMember in metaModel.GetTable(entityType).RowType.PersistentDataMembers) { yield return dataMember.Member; } }
public void SetUp () { _readerMock = MockRepository.GenerateMock<IDataReader>(); _reverseMappingResolverMock = MockRepository.GenerateMock<IReverseMappingResolver>(); _metaModel = new AttributeMappingSource().GetModel (typeof (DataContextTestClass)); }
/// <summary> /// Adds simple (value) properties of an object to a given dictionary /// and recurses if a property contains complex data /// </summary> /// <param name="entity"></param> /// <param name="rawData"></param> /// <param name="prefix"></param> /// <param name="metaModel"></param> protected void AddRawData(object entity, IDictionary<string, object> rawData, string prefix, MetaModel metaModel) { if (entity == null) return; foreach (var memberInfo in GetColumnMembers(entity.GetType(), metaModel)) { var propertyValue = memberInfo.GetMemberValue(entity); // if it is a value, it can be stored directly var memberType = memberInfo.GetMemberType(); if (IsPrimitiveType(memberType)) { rawData[prefix + memberInfo.Name] = propertyValue; } else if (memberType.NotQuerableEnumerable()) { if (propertyValue != null) { var arrayValue = (Array) propertyValue; for (int arrayIndex = 0; arrayIndex < arrayValue.Length; arrayIndex++) { rawData[string.Format("{0}[{1}]", memberInfo.Name, arrayIndex)] = arrayValue.GetValue(arrayIndex); } } } else // otherwise, we recurse, and prefix the current property name to sub properties to avoid conflicts { AddRawData(propertyValue, rawData, memberInfo.Name + ".", metaModel); } } }
public RepositoryMetaType(string workspace, MetaType original, MetaTable table, MetaModel metaModel) { this.Workspace = workspace; this.Original = original; this.RepositoryMetaTable = table; this.RepositoryMetaModel = metaModel; }
public RepositoryMetaTable(string workspace, MetaTable orig, MetaModel model) { this.Workspace = workspace; this.Original = orig; this.RepositoryMetaModel = model; this.RepositoryMetaType = new RepositoryMetaType(workspace, orig.RowType, this, model); }
public DatabaseMappedSamples(string connectionString, MetaModel mapping, TextWriter log) { this.db = new NorthwindDatabase(connectionString, mapping) { Configuration = { Log = log } }; }
public CustomMetaTable(MetaTable table, MetaModel model) { _table = table; _model = model; _tableName = (_table.TableName.Contains(".") ? "" : "dbo.") + _table.TableName; var tableNameField = table.GetType().GetField("tableName", BindingFlags.NonPublic | BindingFlags.Instance); tableNameField.SetValue(_table, _tableName); }
private object locktarget = new object(); // Hold locks on private object rather than public MetaType. #endregion internal MappedType(MetaModel model, MetaTable table, TypeMapping typeMapping, Type type, MetaType inheritanceRoot) { this.model = model; this.table = table; this.typeMapping = typeMapping; this.type = type; this.inheritanceRoot = inheritanceRoot != null ? inheritanceRoot : this; this.InitDataMembers(); this.identities = this.dataMembers.Where(m => m.IsPrimaryKey).ToList().AsReadOnly(); this.persistentDataMembers = this.dataMembers.Where(m => m.IsPersistent).ToList().AsReadOnly(); }
object locktarget = new object(); // Hold locks on private object rather than public MetaType. internal AttributedMetaType(MetaModel model, MetaTable table, Type type, MetaType inheritanceRoot) { this.model = model; this.table = table; this.type = type; this.inheritanceRoot = (inheritanceRoot != null) ? inheritanceRoot : this; // Not lazy-loading to simplify locking and enhance performance // (because no lock will be required for the common read scenario). this.InitDataMembers(); this.identities = this.dataMembers.Where(m => m.IsPrimaryKey).ToList().AsReadOnly(); this.persistentMembers = this.dataMembers.Where(m => m.IsPersistent).ToList().AsReadOnly(); }
internal MemberAccessBinder(SqlBinder binder, Translator translator, SqlColumnizer columnizer, NodeFactory sqlFactory, MetaModel model, DataLoadOptions shape, bool canUseOuterApply) { this.binder = binder; this.translator = translator; this.columnizer = columnizer; this.sql = sqlFactory; this.typeProvider = sqlFactory.TypeProvider; this.expander = new SqlExpander(this.sql); this.aggregateChecker = new SqlAggregateChecker(); this.linkMap = new LinkOptimizationScope(null); this.outerAliasMap = new Dictionary<SqlAlias, SqlAlias>(); this.model = model; this.shape = shape; this.canUseOuterApply = canUseOuterApply; }
public AttributedMetaTable(TableAttribute attribute, MetaType type, MetaModel model) { _tableAttribute = attribute; _metaType = type; _containingModel = model; //If the attribute doesn't specify a table name the name of the table class is used if(!string.IsNullOrEmpty(attribute.Name)) { _tableName = attribute.Name; } else { _tableName = type.Name; } }
public DLinqDataModelProvider (Func<object> factory) { this.factory = factory; Type type = CreateContext ().GetType (); if (!typeof (DataContext).IsAssignableFrom (type)) throw new ArgumentException (String.Format ("Type '{0}' is not supported as data context factory", type)); this.factory = factory; model = new AttributeMappingSource ().GetModel (type); ContextType = model.ContextType; var l = new List<TableProvider> (); foreach (var m in model.GetTables ()) l.Add (new DLinqTableProvider (this, m)); tables = new ReadOnlyCollection<TableProvider> (l); }
/// <summary> /// Adds simple (value) properties of an object to a given dictionary /// and recurses if a property contains complex data /// </summary> /// <param name="entity"></param> /// <param name="rawData"></param> /// <param name="prefix"></param> /// <param name="metaModel"></param> protected void AddRawData(object entity, IDictionary<string, object> rawData, string prefix, MetaModel metaModel) { if (entity == null) return; foreach (var memberInfo in GetColumnMembers(entity.GetType(), metaModel)) { object propertyValue = memberInfo.GetMemberValue(entity); // if it is a value, it can be stored directly if (IsPrimitiveType(memberInfo.GetMemberType())) { rawData[prefix + memberInfo.Name] = propertyValue; } else // otherwise, we recurse, and prefix the current property name to sub properties to avoid conflicts { AddRawData(propertyValue, rawData, memberInfo.Name + ".", metaModel); } } }
public DLinqDataModelProvider(Func <object> factory) { this.factory = factory; Type type = CreateContext().GetType(); if (!typeof(DataContext).IsAssignableFrom(type)) { throw new ArgumentException(String.Format("Type '{0}' is not supported as data context factory", type)); } this.factory = factory; model = new AttributeMappingSource().GetModel(type); ContextType = model.ContextType; var l = new List <TableProvider> (); foreach (var m in model.GetTables()) { l.Add(new DLinqTableProvider(this, m)); } tables = new ReadOnlyCollection <TableProvider> (l); }
/// <summary> /// Constructor that creates a metadata context for the specified LINQ To SQL domain service type /// </summary> /// <param name="dataContextType">The DataContext type</param> public LinqToSqlTypeDescriptionContext(Type dataContextType) { if (dataContextType == null) { throw new ArgumentNullException("dataContextType"); } System.Data.Linq.DataContext dataContext = null; try { dataContext = (System.Data.Linq.DataContext)Activator.CreateInstance(dataContextType, String.Empty); } catch (TargetInvocationException tie) { if (tie.InnerException != null) { throw tie.InnerException; } throw; } this._model = dataContext.Mapping; }
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine)] // FindType method call. internal MappedFunction(MappedMetaModel model, FunctionMapping map, MethodInfo method) { this.model = model; this.map = map; this.method = method; this.rowTypes = _emptyTypes; if(map.Types.Count == 0 && this.method.ReturnType == typeof(IMultipleResults)) { throw Error.NoResultTypesDeclaredForFunction(method.Name); } else if(map.Types.Count > 1 && this.method.ReturnType != typeof(IMultipleResults)) { throw Error.TooManyResultTypesDeclaredForFunction(method.Name); } else if(map.Types.Count == 1 && this.method.ReturnType != typeof(IMultipleResults)) { Type elementType = TypeSystem.GetElementType(method.ReturnType); this.rowTypes = new List<MetaType>(1) { this.GetMetaType(map.Types[0], elementType) }.AsReadOnly(); } else if(map.Types.Count > 0) { List<MetaType> rowTypes = new List<MetaType>(); foreach(TypeMapping rtm in map.Types) { Type elementType = model.FindType(rtm.Name); if(elementType == null) { throw Error.CouldNotFindElementTypeInModel(rtm.Name); } MetaType mt = this.GetMetaType(rtm, elementType); // Only add unique meta types if(!rowTypes.Contains(mt)) { rowTypes.Add(mt); } } this.rowTypes = rowTypes.AsReadOnly(); } else if(map.FunReturn != null) { this.returnParameter = new MappedReturnParameter(method.ReturnParameter, map.FunReturn); } // Parameters. ParameterInfo[] pis = this.method.GetParameters(); if(pis.Length > 0) { List<MetaParameter> mps = new List<MetaParameter>(pis.Length); if(this.map.Parameters.Count != pis.Length) { throw Error.IncorrectNumberOfParametersMappedForMethod(this.map.MethodName); } for(int i = 0; i < pis.Length; i++) { mps.Add(new MappedParameter(pis[i], this.map.Parameters[i])); } this.parameters = mps.AsReadOnly(); } else { this.parameters = _emptyParameters; } }
/// <summary> /// Gets modified properties for entity, by using raw compare method. /// </summary> /// <param name="entity">The entity.</param> /// <param name="metaModel">The meta model.</param> /// <returns></returns> protected IList<MemberInfo> GetRawModifiedProperties(object entity, MetaModel metaModel) { var properties = new List<MemberInfo>(); IDictionary<string, object> originalData; // if we don't have this entity we consider all its properties as having been modified if (!rawDataEntities.TryGetValue(entity, out originalData)) return GetAllColumnProperties(entity, metaModel); var currentData = GetEntityRawData(entity, metaModel); // otherwise, we iterate and find what's changed foreach (string key in currentData.Keys) { var currentValue = currentData[key]; var originalValue = originalData[key]; if (IsPropertyModified(originalValue, currentValue)) properties.Add(GetProperty(entity, key)); } return properties; }
/// <summary> /// Get a MetaType that represents the dynamic type of the given node. /// </summary> internal static MetaType GetSourceMetaType(SqlNode node, MetaModel model) { Visitor v = new Visitor(); v.Visit(node); Type type = v.sourceType; type = TypeSystem.GetNonNullableType(type); // Emulate CLR's behavior: strip nullability from type. return model.GetMetaType(type); }
/// <summary> /// Gets the MetaModel representing a DataContext and all it's /// accessible tables, functions and entities. /// </summary> public MetaModel GetModel(Type dataContextType) { if (dataContextType == null) { throw Error.ArgumentNull("dataContextType"); } MetaModel model = null; if (primaryModel == null) { model = CreateModel(dataContextType); Interlocked.CompareExchange(ref primaryModel, model, null); } // if the primary one matches, use it! if (primaryModel.ContextType == dataContextType) { return(primaryModel); } // the rest of this only happens if you are using the mapping source for // more than one context type // build a map if one is not already defined if (secondaryModels == null) { Interlocked.CompareExchange(ref secondaryModels, new Dictionary <Type, MetaModel>(), null); } // if we haven't created a read/writer lock, make one now if (rwlock == null) { Interlocked.CompareExchange(ref rwlock, new ReaderWriterLock(), null); } // lock the map and look inside MetaModel foundModel; rwlock.AcquireReaderLock(Timeout.Infinite); try { if (secondaryModels.TryGetValue(dataContextType, out foundModel)) { return(foundModel); } } finally { rwlock.ReleaseReaderLock(); } // if it wasn't found, lock for write and try again rwlock.AcquireWriterLock(Timeout.Infinite); try { if (secondaryModels.TryGetValue(dataContextType, out foundModel)) { return(foundModel); } if (model == null) { model = CreateModel(dataContextType); } secondaryModels.Add(dataContextType, model); } finally { rwlock.ReleaseWriterLock(); } return(model); }
internal UnmappedType(MetaModel model, Type type) { this.model = model; this.type = type; }
internal SqlBinder(Translator translator, SqlFactory sqlFactory, MetaModel model, DataLoadOptions shape, SqlColumnizer columnizer, bool canUseOuterApply) { this.sql = sqlFactory; this.columnizer = columnizer; this.visitor = new Visitor(this, translator, this.columnizer, this.sql, model, shape, canUseOuterApply); }
private string DeleteDatabaseSQL( MetaModel model) { StringBuilder commandBuilder = new StringBuilder(); // Append the SQL for deleting the tables foreach (MetaTable table in model.GetTables()) { commandBuilder.Append(m_builder.DeleteTableSQL(table)); commandBuilder.Append("\r\n"); } return commandBuilder.ToString(); }
/// <summary> /// Returns a list of all modified properties since last Register/ClearModified /// </summary> /// <param name="entity"></param> /// <param name="metaModel"></param> /// <returns></returns> public IList<MemberInfo> GetModifiedProperties(object entity, MetaModel metaModel) { if (IsNotifying(entity)) return GetNotifyingModifiedProperties(entity, metaModel); return GetRawModifiedProperties(entity, metaModel); }
internal SqlFactory(TypeSystemProvider typeProvider, MetaModel model) { this.typeProvider = typeProvider; this.model = model; }
public DataBossTable(MetaModel model, Type rowType) { this.model = model; this.rowType = rowType; }
/// <summary> /// Gets all column properties. /// </summary> /// <param name="entity">The entity.</param> /// <param name="metaModel">The meta model.</param> /// <returns></returns> protected IList<MemberInfo> GetAllColumnProperties(object entity, MetaModel metaModel) { if (entity == null) throw new ArgumentNullException("entity"); var properties = new List<MemberInfo>(GetColumnMembers(entity.GetType(), metaModel)); return properties; }
/// <summary> /// Gets the self declaring entity modified properties. /// </summary> /// <param name="entity">The entity.</param> /// <param name="metaModel">The meta model.</param> /// <returns></returns> protected IList<MemberInfo> GetSelfDeclaringModifiedProperties(object entity, MetaModel metaModel) { return GetAllColumnProperties(entity, metaModel); }
/// <summary> /// Sets the raw entity as unmodified. /// </summary> /// <param name="entity">The entity.</param> /// <param name="metaModel">The meta model.</param> private void ClearRawModified(object entity, MetaModel metaModel) { rawDataEntities[entity] = GetEntityRawData(entity, metaModel); }
/// <summary> /// Gets the notifying entity modified properties. /// </summary> /// <param name="entity">The entity.</param> /// <param name="metaModel">The meta model.</param> /// <returns></returns> protected IList<MemberInfo> GetNotifyingModifiedProperties(object entity, MetaModel metaModel) { IDictionary<string, MemberInfo> properties; // if we don't have it, it is fully dirty if (!modifiedProperties.TryGetValue(entity, out properties) || ReferenceEquals(propertyChangingSentinal, modifiedProperties[entity])) return GetAllColumnProperties(entity, metaModel); return new List<MemberInfo>(properties.Values); }
internal Visitor(TypeSystemProvider typeProvider, MetaModel model) { this.sql = new SqlFactory(typeProvider, model); this.typeProvider = typeProvider; }
internal SqlRetyper(TypeSystemProvider typeProvider, MetaModel model) { this.visitor = new Visitor(typeProvider, model); }
/// <summary> /// Marks the entity as not dirty. /// </summary> /// <param name="entity"></param> /// <param name="metaModel"></param> public void ClearModified(object entity, MetaModel metaModel) { if (IsNotifying(entity)) ClearNotifyingModified(entity); else ClearRawModified(entity, metaModel); }