예제 #1
0
        private ITypeFieldValueList ExtractCurrentRowValues(IReadOnlyEntity entity, Type type, ITransaction tx)
        {
            ITypeFieldValueList fieldValueList = null;

            ITypeFieldValueList keyFieldValueList = OperationUtils.ExtractEntityTypeKeyValues(entity, type);
            IDbCommand          cmd    = null;
            IDataReader         reader = null;

            try
            {
                cmd    = CreateRetrievalPreparedStatement(keyFieldValueList, tx);
                reader = cmd.ExecuteReader();
                if (reader.Read())
                {
                    fieldValueList = ReadValues(type, reader);
                }
            }
            catch (Exception ex)
            {
                string message = String.Format("SQL Exception while trying retrieve current data row from {0}"
                                               , entity.GetType().FullName);
                throw new StatementExecutionException(message, ex);
            }
            finally
            {
                DbMgtUtility.Close(reader);
                DbMgtUtility.Close(cmd);
            }
            return(fieldValueList);
        }
예제 #2
0
        private Object ExtractCurrentVersionValue(IReadOnlyEntity entity, IColumn versionColumn, Type type
                                                  , ITransaction tx)
        {
            Object versionValue = null;

            ITypeFieldValueList keyFieldValueList = OperationUtils.ExtractEntityTypeKeyValues(entity, type);
            IDbCommand          cmd    = null;
            IDataReader         reader = null;

            try
            {
                cmd    = CreateRetrievalPreparedStatement(keyFieldValueList, tx);
                reader = cmd.ExecuteReader();
                if (reader.Read())
                {
                    versionValue = DbLayer.DataManipulate().ReadFromResultSet(reader, versionColumn);
                }
            }
            catch (Exception ex)
            {
                String message = String.Format("SQL Exception while trying retrieve version information from {0}"
                                               , entity.GetType().FullName);
                throw new StatementExecutionException(message, ex);
            }
            finally
            {
                DbMgtUtility.Close(reader);
                DbMgtUtility.Close(cmd);
            }
            return(versionValue);
        }
예제 #3
0
        private void LoadFromDb(IReadOnlyEntity roEntity, IDataReader reader, ITransaction tx)
        {
            EntityInfo entityInfo = CacheManager.GetEntityInfo(roEntity);

            while (entityInfo != null)
            {
                string tableName = entityInfo.TableInfo.TableName;
                if (entityInfo.EntityType == roEntity.GetType() || tableName == null) //if i==0 that means it's base class and can use existing result set
                {
                    LoadForType(roEntity, entityInfo.EntityType, reader, tx);
                }
                else
                {
                    IDbCommand  superCmd    = null;
                    IDataReader superReader = null;
                    try
                    {
                        ITypeFieldValueList keyValueList = OperationUtils.ExtractEntityTypeKeyValues(roEntity, entityInfo.EntityType);
                        superCmd    = CreateRetrievalPreparedStatement(keyValueList, tx);
                        superReader = superCmd.ExecuteReader();
                        if (superReader.Read())
                        {
                            LoadForType(roEntity, entityInfo.EntityType, superReader, tx);
                        }
                        else
                        {
                            string message =
                                String.Format(
                                    "Super class {0} does not contains a matching record for the base class {1}",
                                    entityInfo.EntityType.FullName, roEntity.GetType().FullName);
                            throw new NoMatchingRecordFoundForSuperClassException(message);
                        }
                    }
                    catch (Exception ex)
                    {
                        String message = String.Format("SQL Exception while trying to read from table {0}", tableName);
                        throw new ReadFromResultSetException(message, ex);
                    }
                    finally
                    {
                        DbMgtUtility.Close(superReader);
                        DbMgtUtility.Close(superCmd);
                    }
                }
                entityInfo = entityInfo.SuperEntityInfo;
            }
        }
예제 #4
0
        /// <summary>
        /// Compare equality through ID
        /// </summary>
        /// <param name="other">Entity to compare.</param>
        /// <returns>true if are equals</returns>
        /// <remarks>
        /// Two entities are equals if they are of the same hierarchy tree/sub-tree
        /// and has same id.
        /// </remarks>
        public virtual bool Equals(IReadOnlyEntity <IdT> other)
        {
            if (null == other || (!GetType().IsInstanceOfType(other) && !other.GetType().IsInstanceOfType(this)))
            {
                return(false);
            }
            if (ReferenceEquals(this, other))
            {
                return(true);
            }

            bool otherIsTransient = Equals(other.ID, default(IdT));
            bool thisIsTransient  = IsTransient();

            if (otherIsTransient && thisIsTransient)
            {
                return(ReferenceEquals(other, this));
            }

            return(other.ID.Equals(ID));
        }
예제 #5
0
        public void LoadChildrenFromRelation(IReadOnlyEntity parentRoEntity, Type entityType, ITransaction tx
                                             , IRelation relation, bool lazy)
        {
            EntityInfo     entityInfo    = CacheManager.GetEntityInfo(entityType);
            IEntityContext entityContext = parentRoEntity.Context;

            PropertyInfo property = entityInfo.GetProperty(relation.AttributeName);
            Object       value    = ReflectionUtils.GetValue(property, parentRoEntity);

            if (!lazy && relation.FetchStrategy == FetchStrategy.Lazy)
            {
                CreateProxy(parentRoEntity, entityType, tx, relation, value, property);
                return;
            }

            ICollection <IReadOnlyEntity> children = ReadRelationChildrenFromDb(parentRoEntity, entityType, tx, relation);

            if (entityContext != null &&
                !relation.ReverseRelationship)
            {
                foreach (IReadOnlyEntity childEntity in children)
                {
                    ITypeFieldValueList valueTypeList = OperationUtils.ExtractRelationKeyValues(childEntity, relation);
                    if (valueTypeList != null)
                    {
                        entityContext.ChangeTracker.AddChildEntityKey(valueTypeList);
                    }
                }
            }

            if ((value == null || ProxyUtil.IsProxyType(value.GetType())) &&
                ReflectionUtils.IsImplementInterface(property.PropertyType, typeof(ICollection <>)))
            {
                Type propertyType = property.PropertyType;
                if (propertyType.IsInterface)
                {
                    Type generic = propertyType.GetGenericArguments()[0];
                    propertyType = typeof(List <>).MakeGenericType(new Type[] { generic });
                }
                value = Activator.CreateInstance(propertyType);

                IList genCollection = (IList)value;
                foreach (IReadOnlyEntity serverRoDbClass in children)
                {
                    genCollection.Add(serverRoDbClass);
                }
                ReflectionUtils.SetValue(property, parentRoEntity, genCollection);
            }
            else if (value != null &&
                     ReflectionUtils.IsImplementInterface(property.PropertyType, typeof(ICollection <>)))
            {
                IList genCollection = (IList)value;
                foreach (IReadOnlyEntity serverRoDbClass in children)
                {
                    genCollection.Add(serverRoDbClass);
                }
            }
            else
            {
                IEnumerator <IReadOnlyEntity> childEnumarator = children.GetEnumerator();
                if (childEnumarator.MoveNext())
                {
                    IReadOnlyEntity singleRoDbClass = childEnumarator.Current;
                    if (property.PropertyType.IsAssignableFrom(singleRoDbClass.GetType()))
                    {
                        ReflectionUtils.SetValue(property, parentRoEntity, singleRoDbClass);
                    }
                    else
                    {
                        string message = singleRoDbClass.GetType().FullName + " is not matching the getter " + property.Name;
                        Logger.GetLogger(Config.LoggerName).Fatal(message);
                        throw new NoSetterFoundToSetChildObjectListException(message);
                    }
                }
            }
        }
예제 #6
0
 public EntityFieldValueList(IReadOnlyEntity entity) : base(entity.GetType())
 {
     _entity = entity;
 }
예제 #7
0
        private static void SetParentRelationFieldsForNonIdentifyingRelations(IEntity parentEntity
                                                                              , IEnumerable <IEntity> childObjects, RelationColumnMapping mapping)
        {
            IReadOnlyEntity       firstObject     = null;
            IEnumerator <IEntity> childEnumerator = childObjects.GetEnumerator();

            if (childEnumerator.MoveNext())
            {
                firstObject = childEnumerator.Current;
            }
            if (firstObject == null)
            {
                return;
            }
            EntityInfo parentInfo = CacheManager.GetEntityInfo(parentEntity);
            EntityInfo childInfo  = CacheManager.GetEntityInfo(firstObject);

            PropertyInfo setter    = null;
            bool         foundOnce = false;

            while (parentInfo != null)
            {
                IColumn parentMatchedColumn = parentInfo.FindColumnByAttribute(mapping.FromField);
                if (parentMatchedColumn != null)
                {
                    foundOnce = true;
                    setter    = parentInfo.GetProperty(parentMatchedColumn);
                }
                parentInfo = parentInfo.SuperEntityInfo;
            }
            if (!foundOnce)
            {
                string message = String.Format("The field {0} does not have a matching field in the object {1}", mapping.ToField, firstObject.GetType().FullName);
                throw new NoMatchingColumnFoundException(message);
            }

            foundOnce = false;
            while (childInfo != null)
            {
                IColumn childMatchedColumn = childInfo.FindColumnByAttribute(mapping.ToField);

                if (childMatchedColumn != null)
                {
                    foundOnce = true;
                    foreach (IReadOnlyEntity dbObject in childObjects)
                    {
                        ITypeFieldValueList fieldValueList  = OperationUtils.ExtractEntityTypeFieldValues(dbObject, childInfo.EntityType);
                        EntityFieldValue    childFieldValue = fieldValueList.GetFieldValue(childMatchedColumn.AttributeName);
                        setter.SetValue(parentEntity, childFieldValue.Value, null);
                    }
                }
                childInfo = childInfo.SuperEntityInfo;
            }
            if (!foundOnce)
            {
                string message = String.Format("The field {0} does not have a matching field in the object {1}", mapping.ToField, firstObject.GetType().FullName);
                throw new NoMatchingColumnFoundException(message);
            }
        }
예제 #8
0
        protected ICollection <IReadOnlyEntity> ReadRelationChildrenFromDb(IReadOnlyEntity entity, Type entityType
                                                                           , ITransaction tx, IRelation relation)
        {
            var retrievedEntities = new List <IReadOnlyEntity>();
            ICollection <Type> childTypesToProcess = GetChildTypesToProcess(relation);

            int index = 0;

            foreach (var childType in childTypesToProcess)
            {
                index++;
                IRelation effectiveRelation = relation.Clone();
                effectiveRelation.RelatedObjectType = childType;
                effectiveRelation.RelationShipName  = relation.RelationShipName + "_" + index;

                EntityInfo entityInfo = CacheManager.GetEntityInfo(entityType);
                var        logSb      = new StringBuilder();
                var        query      = entityInfo.GetRelationObjectLoad(DbLayer, effectiveRelation);

                IList <string> fields = new List <string>();
                foreach (RelationColumnMapping mapping in effectiveRelation.TableColumnMappings)
                {
                    fields.Add(mapping.FromField);
                }

                IDbCommand cmd = null;
                try
                {
                    cmd             = tx.CreateCommand();
                    cmd.CommandText = query;
                }
                catch (Exception ex)
                {
                    string message = String.Format("SQL Exception while trying create command for sql {0}", query);
                    throw new CommandCreationException(message, ex);
                }

                bool showQuery = Config.ShowQueries;
                if (showQuery)
                {
                    logSb.Append(query);
                }

                for (int i = 0; i < fields.Count; i++)
                {
                    string field      = fields[i];
                    object fieldValue = null;

                    IColumn matchColumn = entityInfo.FindColumnByAttribute(field);
                    EntityRelationColumnInfo entityRelationColumnInfo =
                        entityInfo.FindRelationColumnInfo(matchColumn != null ? matchColumn.AttributeName : "");
                    if (entityRelationColumnInfo != null)
                    {
                        EntityFieldValue entityFieldValue = entity.Context.ChangeTracker.GetFieldValue(matchColumn.AttributeName);
                        fieldValue = entityFieldValue.Value;
                    }
                    else if (matchColumn != null)
                    {
                        PropertyInfo getter = entityInfo.GetProperty(matchColumn.AttributeName);
                        fieldValue = ReflectionUtils.GetValue(getter, entity);
                    }
                    else
                    {
                        string message = String.Format("The field {0} does not have a matching field in the object {1}"
                                                       , field, entity.GetType().FullName);
                        throw new NoMatchingColumnFoundException(message);
                    }

                    if (showQuery)
                    {
                        logSb.Append(" ,").Append(matchColumn.ColumnName).Append("=").Append(fieldValue);
                    }
                    DbLayer.DataManipulate().SetToPreparedStatement(cmd, fieldValue, i + 1, matchColumn);
                }

                if (showQuery)
                {
                    Logger.GetLogger(Config.LoggerName).Debug(logSb.ToString());
                }
                if (Config.EnableStatistics)
                {
                    Statistics.RegisterSelect(childType);
                }

                ICollection <IReadOnlyEntity> retrievedEntitiesForType = ExecuteAndReadFromPreparedStatement(entity, tx, cmd, childType);
                retrievedEntities.AddRange(retrievedEntitiesForType);
            }
            return(retrievedEntities);
        }
예제 #9
0
        public static IEntityFieldValueList ExtractEntityKeyValues(IReadOnlyEntity entity)
        {
            EntityFieldValueList valueList = null;

            if (entity is IEntity)
            {
                valueList = new EntityFieldValueList(entity);
                IEntity entityDbClass = (IEntity)entity;
                ICollection <EntityFieldValue> extractedValues = ExtractValues(entityDbClass, true, entity.GetType());
                foreach (EntityFieldValue entityFieldValue in extractedValues)
                {
                    valueList.FieldValues.Add(entityFieldValue);
                }
            }
            return(valueList);
        }