Example #1
0
    public EntityError Resolve(EntityManager em) {
      IsServerError = true;
      try {
        EntityType entityType = null;
        if (EntityTypeName != null) {
          var stName = TypeNameInfo.FromClrTypeName(EntityTypeName).ToClient(em.MetadataStore).StructuralTypeName;
          entityType = em.MetadataStore.GetEntityType(stName);
          var ek = new EntityKey(entityType, KeyValues);
          Entity = em.GetEntityByKey(ek);
        }

        
        if (entityType != null) {
          if (PropertyName != null) {
            Property = entityType.Properties.FirstOrDefault(p => p.NameOnServer == PropertyName);
            if (Property != null) {
              PropertyName = Property.Name;
            }
          }
          
          var vc = new ValidationContext(this.Entity);
          vc.Property = Property;
          var veKey = (ErrorName ?? ErrorMessage) + (PropertyName ?? "");
          var ve = new ValidationError(null, vc, ErrorMessage, veKey);
          ve.IsServerError = true;
          this.Entity.EntityAspect.ValidationErrors.Add(ve);
        }
      } catch (Exception e) {
        ErrorMessage = ( ErrorMessage ?? "") + ":  Unable to Resolve this error: " + e.Message;
      }
      return this;
    }
Example #2
0
        /// <summary>
        /// Envia correo de usuario nuevo.
        /// </summary>
        /// <param name="USR_USERNAME"></param>
        /// <param name="USR_PASSWORD"></param>
        /// <param name="Configuracion"></param>
        public static void EnviarCorreoUsuarioNuevo(string USR_USERNAME, string USR_PASSWORD, XmlDocument Configuracion)
        {
            try
            {
                UsuarioLogic usuariologica = new UsuarioLogic();
                usuario user = usuariologica.GetUsuario(USR_USERNAME);

                string mailto = user.USR_CORREO;
                string nombre = user.USR_NOMBRE + " " + user.USR_APELLIDO;

                string subject = "";
                string message = "";

                using (var db = new colinasEntities())
                {
                    EntityKey k = new EntityKey("colinasEntities.plantillas_notificaciones", "PLANTILLAS_LLAVE", "USUARIONUEVO");
                    var pl = db.GetObjectByKey(k);
                    plantilla_notificacion plantilla = (plantilla_notificacion)pl;

                    subject = plantilla.PLANTILLAS_ASUNTO;
                    message = plantilla.PLANTILLAS_MENSAJE;
                }

                message = message.Replace("{NOMBRE}", nombre);
                message = message.Replace("{USUARIO}", USR_USERNAME);
                message = message.Replace("{CONTRASEÑA}", USR_PASSWORD);

                EnviarCorreo(mailto, subject, message, Configuracion);
            }
            catch (Exception ex)
            {
                log.Fatal("Error fatal al enviar correo de usuario nuevo.", ex);
                throw;
            }
        }
        public void ApplyChanges(MappingSet mappingSet, EntityKey key)
        {
            // Create new Component
            var component = existingSpecToUse.CreateImplementedComponentFor(key.Parent, newComponentName);

            // Set mapped column on the new Component's properties.
            foreach(var pair in propertyMappings)
            {
                var newProperty = component.GetProperty(pair.Key);
                var oldProperty = key.Properties.FirstOrDefault(p => p.Name == pair.Value);

                if(oldProperty == null)
                {
                    // Something went horribly wrong. We have a Property that has been mapped,
                    // but it doesn't actually exist. I am chosing to ignore this here, but log it.
                    log.ErrorFormat("Property {0} was mapped in the ConvertKeyToComponent wizard, but doesn't actually exist in the model.", pair.Value);
                    continue;
                }

                newProperty.SetMappedColumn(oldProperty.MappedColumn());
            }

            // Delete existing properties if needed.
            if(deleteExistingProperties)
            {
                foreach(var property in key.Properties.ToList())
                {
                    property.DeleteSelf();
                }
            }

            key.Component = component;
        }
Example #4
0
 public EntityRecord LookupByPrimaryKey(EntityKey primaryKey)
 {
     EntityRecord rec;
       if (RecordsByPrimaryKey.TryGetValue(primaryKey, out rec))
     return rec;
       return null;
 }
        public void AddOrUpdate(System.Globalization.CultureInfo culture, EntityKey key, IEnumerable<PropertyTranslation> propertyTranslations)
        {
            using (var db = new MultilingualDbContext(InstanceName))
            {
                var entry = db.Translations.Find(GetUnderlyingEntityKey(culture.Name, key));
                if (entry == null)
                {
                    entry = new EntityTranslationDbEntry
                    {
                        Culture = culture.Name,
                        EntityType = key.EntityType.Name,
                        EntityKey = key.Value.ToString()
                    };

                    entry.Properties = JsonConvert.SerializeObject(propertyTranslations);
                    db.Translations.Add(entry);
                }
                else
                {
                    entry.Properties = JsonConvert.SerializeObject(propertyTranslations);
                    entry.IsOutOfDate = false;
                }

                db.SaveChanges();

                Event.Raise(new TranslationUpdated(key, propertyTranslations, culture), GetInstance());
            }
        }
Example #6
0
        static void Main(string[] args)
        {
            using (VS2010Entities ie = new VS2010Entities())
            {
                EntityKey ek = new EntityKey("VS2010Entities.PESSOA", "COD_PESSOA", 8);

                PESSOA p = (PESSOA)ie.GetObjectByKey(ek);

                if (p != null)
                    p.NOME_PESSOA = "EMA FROST";

                foreach (var item in ie.PESSOA)
                {
                    Console.WriteLine(item.NOME_PESSOA);
                }

                Console.WriteLine("------------------------");

                ie.SaveChanges();

                foreach (var item in ie.PESSOA)
                {
                    Console.WriteLine(item.NOME_PESSOA);
                }

                Console.ReadKey();
            }
        }
 public BriefView(int id, bool w)
 {
     obj = new TravelDAL.Tour();
     using (var context = new TravelDBEntities())
     {
         EntityKey key = new EntityKey("TravelDBEntities.Tour", "IDTour", id);
         obj = (TravelDAL.Tour)context.GetObjectByKey(key);
         if (obj != null)
         {
             tourname = obj.Name;
             addinfo = obj.AdditionalInfo;
             if (addinfo.Length > 120) addinfo = addinfo.Substring(0, 120);
             addinfo += "...";
             minprice = obj.MinimalPrice.ToString();
             avgprice = obj.AveragePrice.ToString();
             rating = obj.AverageMark.ToString();
             wide = w;
             foreach (TravelDAL.Country m in obj.Country)
             {
                 countrynames += m.Name;
                 countrynames += " ";
             }
         }
     }
 }
Example #8
0
        /// <summary>
        /// Removes the Category by ID.
        /// </summary>
        /// <param name="categoryID">The category ID.</param>
        public static void RemoveByID(int categoryID)
        {
            object categoryForDeletion;

            EntityKey categoryKey = new EntityKey("WebCalendarEntities.Categories", "ID", categoryID);

            if (db.TryGetObjectByKey(categoryKey, out categoryForDeletion))
            {
                try
                {
                    db.DeleteObject(categoryForDeletion);
                    db.SaveChanges();
                }
                catch (OptimisticConcurrencyException ex)
                {
                    throw new InvalidOperationException(string.Format(
                                                                      "The Category with an ID of '{0}' could not be deleted.\n" +
                                                                      "Make sure that any related objects are already deleted.\n",
                        categoryKey.EntityKeyValues[0].Value), ex);
                }
            }
            else
            {
                throw new InvalidOperationException(string.Format(
                                                                  "The Category with an ID of '{0}' could not be found.\n" +
                                                                  "Make sure that Category exists.\n",
                    categoryKey.EntityKeyValues[0].Value));
            }
        }
        /// <summary>
        /// Creates an EntityKey that represents a Conceptual Null
        /// </summary>
        /// <param name="originalKey">An EntityKey representing the existing FK values that could not be nulled</param>
        /// <returns>EntityKey marked as a conceptual null with the FK values from the original key</returns>
        public static EntityKey CreateConceptualNullKey(EntityKey originalKey)
        {
            Debug.Assert(originalKey != null, "Original key can not be null");

            //Conceptual nulls have special entity set name and a copy of the previous values
            EntityKey nullKey = new EntityKey(s_NullForeignKey, originalKey.EntityKeyValues);
            return nullKey;
        }
        /// <summary>
        ///     Creates an EntityKey that represents a Conceptual Null
        /// </summary>
        /// <param name="originalKey"> An EntityKey representing the existing FK values that could not be nulled </param>
        /// <returns> EntityKey marked as a conceptual null with the FK values from the original key </returns>
        public static EntityKey CreateConceptualNullKey(EntityKey originalKey)
        {
            DebugCheck.NotNull(originalKey);

            //Conceptual nulls have special entity set name and a copy of the previous values
            var nullKey = new EntityKey(s_NullForeignKey, originalKey.EntityKeyValues);
            return nullKey;
        }
            public void AddEntityToIndex(EntityKey entityKey, Document doc)
            {
                // when creating a projection index, the entity key should not be passed
                Debug.Assert(entityKey == null);

                // adding document to index
                this._index.AddEntity(doc);
            }
        /// <summary>
        /// Private extension method for ObjectStateManager class
        /// Dump all tracking info to a string 
        /// </summary>
        /// <param name="manager">ObjectStateManager</param>
        /// <param name="objectStateEntries">Collection of ObjectStateEntries. If null, then all entities will be displayed</param>
        /// <param name="entityKey">EntityKey of given entity. If null, then all entities will be displayed</param>
        /// <param name="asHtml">Output string as HTML</param>
        /// <returns>String with tracking info about entries</returns>
        private static string Dump(
          ObjectStateManager manager,
          IEnumerable<ObjectStateEntry> objectStateEntries,
          EntityKey entityKey,
          bool asHtml)
        {
            StringBuilder dump = new StringBuilder();

            if (entityKey != null)
            {
                objectStateEntries = new List<ObjectStateEntry>();
                (objectStateEntries as List<ObjectStateEntry>).Add(manager.GetObjectStateEntry(entityKey));
            }
            else if (objectStateEntries == null)
            {
                objectStateEntries = manager.GetObjectStateEntries(~EntityState.Detached);
            }

            dump.AppendFormat("ObjectStateManager entries : # {0}\n", objectStateEntries.Count());

            foreach (var entry in objectStateEntries)
            {
                dump.Append(ObjectStateEntryToString(entry));

                if (entry.State == EntityState.Added)
                {
                    for (int i = 0; i < entry.CurrentValues.FieldCount; i++)
                    {
                        dump.AppendFormat("\n\t- {0} = {1}",
                          entry.CurrentValues.GetName(i),
                          ObjectToString(entry.CurrentValues[i]));
                    }
                }
                else if (entry.State == EntityState.Modified)
                {
                    foreach (string prop in entry.GetModifiedProperties())
                    {
                        dump.AppendFormat("\n\t- {0} : {1} -> {2}",
                            prop,
                            ObjectToString(entry.OriginalValues[prop]),
                            ObjectToString(entry.CurrentValues[prop]));
                    }
                }
            }

            if (asHtml)
            {
                dump.Replace("\n", "<br />");
                dump.Replace("\t", "&nbsp;&nbsp;&nbsp;&nbsp;");
            }
            else
            {
                dump.Replace("<b>", "");
                dump.Replace("</b>", "");
            }

            return dump.ToString();
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="metadata"></param>
        /// <param name="memberInfo"></param>
        /// <param name="entityKey"></param>
        public EntityRecordInfo(EntityType metadata, IEnumerable<EdmMember> memberInfo, EntityKey entityKey, EntitySet entitySet)
            : base(TypeUsage.Create(metadata), memberInfo) {
            EntityUtil.CheckArgumentNull<EntityKey>(entityKey, "entityKey");
            EntityUtil.CheckArgumentNull(entitySet, "entitySet");

            _entityKey = entityKey;
            _entitySet = entitySet;
            ValidateEntityType(entitySet);
        }
 public RelationshipChange(EntityKey sourceKey, EntityKey targetKey, object source, object target, EntitySetBase entitySet, EntityState state)
 {
     _sourceKey = sourceKey;
     _targetKey = targetKey;
     _source = source;
     _target = target;
     _entitySet = entitySet;
     _state = state;
 }
 public ManagementObjectsViewModel()
 {
     using (var context = new MCDatabaseModelContainer())
     {
         var key = new EntityKey();
         context.ObjectStateManager.GetObjectStateEntry(key);
         Buildings = context.Buildings.ToList();
     }
 }
        public EntityRecordInfo(EntityType metadata, IEnumerable<EdmMember> memberInfo, EntityKey entityKey, EntitySet entitySet)
            : base(TypeUsage.Create(metadata), memberInfo)
        {
            Contract.Requires(entityKey != null);
            Contract.Requires(entitySet != null);

            _entityKey = entityKey;
            ValidateEntityType(entitySet);
        }
        public EntityRecordInfo(EntityType metadata, IEnumerable<EdmMember> memberInfo, EntityKey entityKey, EntitySet entitySet)
            : base(TypeUsage.Create(metadata), memberInfo)
        {
            Check.NotNull(entityKey, "entityKey");
            Check.NotNull(entitySet, "entitySet");

            _entityKey = entityKey;
            ValidateEntityType(entitySet);
        }
        public override void DetachFromModel()
        {
            if (Detached) return;

            key.PropertyChanged -= key_PropertyChanged;
            key.PropertiesChanged -= key_PropertiesChanged;
            key.Parent.PropertyChanged -= Entity_PropertyChanged;
            key = null;
            Detached = true;
        }
    public async Task EntityKeyNoMetadata() {

      try {
        var ek = new EntityKey(typeof(FooEntity), MetadataStore.Detached, 7);
        Assert.Fail("should not get here");
      } catch (Exception e) {
        Assert.IsTrue(e.Message.Contains("FooEntity") && e.Message.Contains("FetchMetadata"));
      }

    }
Example #20
0
 public static HotSpot GetHotSpot(String BssidToGet)
 {
     HotSpot obj = new HotSpot();
     using (var context = new HotSpotsDBEntities())
     {
         EntityKey key = new EntityKey("HotSpotsDBEntities.HotSpot", "bssid", BssidToGet);
         obj = (HotSpot)context.GetObjectByKey(key);
     }
     return obj;
 }
        /// <summary>
        ///     Returns true if the supplied key represents a Conceptual Null
        /// </summary>
        /// <param name="key"> The key to be checked </param>
        public static bool IsConceptualNullKey(EntityKey key)
        {
            if (key == null)
            {
                return false;
            }

            return string.Equals(key.EntityContainerName, s_NullPart) &&
                   string.Equals(key.EntitySetName, s_NullPart);
        }
 public void RemoveChildren(EntityKey parentEntityKey, NavigationProperty navProp) {
   var navChildrenList = GetNavChildrenList(parentEntityKey, false);
   if (navChildrenList == null) return;
   var ix = navChildrenList.IndexOf(nc => nc.NavigationProperty == navProp);
   if (ix != -1) return;
   navChildrenList.RemoveAt(ix);
   if (navChildrenList.Count == 0) {
     _map.Remove(parentEntityKey);
   }
 }
        /// <summary>
        ///     Checks if the Real Key represents different FK values
        ///     than those present when the Conceptual Null was created
        /// </summary>
        /// <param name="conceptualNullKey"> The key representing the Conceptual Null </param>
        /// <param name="realKey"> The key to be checked </param>
        /// <returns> True if the values are different, false otherwise </returns>
        public static bool IsConceptualNullKeyChanged(EntityKey conceptualNullKey, EntityKey realKey)
        {
            Debug.Assert(IsConceptualNullKey(conceptualNullKey), "The key supplied is not a null key");

            if (realKey == null)
            {
                return true;
            }

            return !EntityKey.InternalEquals(conceptualNullKey, realKey, compareEntitySets: false);
        }
Example #24
0
            public virtual void AddEntityToIndex(EntityKey entityKey, Document doc)
            {
                string key = _parent.GetEntityKeyInCache(entityKey);

                // adding key to index (it's essential to do this _before_ checking the key length - the index should fail to be read next time)
                _index.Index.Add(entityKey);

                // Putting the entity to cache, but only if it doesn't exist there.
                // That's because when loading from DynamoDb whe should never overwrite local updates.
                _parent._cacheClient.SetValue(key, new CacheDocumentWrapper(doc));
            }
        internal static Mock<IEntityWrapper> CreateMockEntityWrapper()
        {
            var mockEntityWrapper = new Mock<IEntityWrapper>(MockBehavior.Strict);

            var entityWithRelationshipsMock = new Mock<IEntityWithRelationships>(MockBehavior.Strict);
            mockEntityWrapper.Setup(m => m.Entity).Returns(entityWithRelationshipsMock.Object);

            var entityKey = new EntityKey(qualifiedEntitySetName: "entityContainerName.entitySetName");
            mockEntityWrapper.Setup(m => m.EntityKey).Returns(entityKey);

            return mockEntityWrapper;
        }
Example #26
0
 public void Delete(CultureInfo culture, EntityKey key)
 {
     using (var db = new MultilingualDbContext(InstanceName))
     {
         var entry = db.Translations.Find(GetUnderlyingEntityKey(culture.Name, key));
         if (entry != null)
         {
             db.Translations.Remove(entry);
             db.SaveChanges();
         }
     }
 }
 public async Task FetchByKey() {
   var em1 = await TestFns.NewEm(_serviceName);
   var q = new EntityQuery<Fruit>().From("Fruits");
   var r0 = await em1.ExecuteQuery(q);
   Assert.IsTrue(r0.Count() > 0);
   var fruit1 = r0.First();
   var id = fruit1.Id;
   var ek = new EntityKey(typeof(Fruit), em1.MetadataStore, id);
   var r1 = await em1.ExecuteQuery(ek.ToQuery());
   var fruits = r1.Cast<Fruit>();
   Assert.IsTrue(fruits.First() == fruit1);
   
 }
    public List<NavChildren> GetNavChildrenList(EntityKey entityKey, bool createIfNotFound) {
      List<NavChildren> navChildrenList = null;

      if (_map.TryGetValue(entityKey, out navChildrenList)) {
        return navChildrenList;
      } else {
        if (createIfNotFound) {
          navChildrenList = new List<NavChildren>();
          _map.Add(entityKey, navChildrenList);
        }
      }
      return navChildrenList;
    }
Example #29
0
		private void UpdateResources() {
			Resources.Clear();
			if(!String.IsNullOrEmpty(resourceIds)) {
				XmlDocument xmlDocument = new XmlDocument();
				xmlDocument.LoadXml(resourceIds);
				foreach(XmlNode xmlNode in xmlDocument.DocumentElement.ChildNodes) {
					EntityKey entityKey = new EntityKey(objectContext.DefaultContainerName + ".Resources", "Key", Int32.Parse(xmlNode.Attributes["Value"].Value));
					Object obj = null;
					if(objectContext.TryGetObjectByKey(entityKey, out obj)) {
						Resources.Add((Resource)obj);
					}
				}
			}
		}
Example #30
0
 public static void DeleteHotSpot(String BssidToDelete)
 {
     HotSpot obj = new HotSpot();
     using (var context = new HotSpotsDBEntities())
     {
         EntityKey key = new EntityKey("HotSpotsDBEntities.HotSpot", "bssid", BssidToDelete);
         obj = (HotSpot)context.GetObjectByKey(key);
         if (obj != null)
         {
             context.DeleteObject(obj);
         }
         context.SaveChanges();
     }
 }
Example #31
0
 public static bool Equals(EntityKey a, EntityKey b)
 {
     return(EntityKeyComparer.Instance.Compare(a, b) == 0);
 }
        public virtual async Task OnMergeAsync(MergeEvent @event, IDictionary copiedAlready, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
            EventCache   copyCache = (EventCache)copiedAlready;
            IEventSource source    = @event.Session;
            object       original  = @event.Original;

            if (original != null)
            {
                object entity;
                if (original.IsProxy())
                {
                    ILazyInitializer li = ((INHibernateProxy)original).HibernateLazyInitializer;
                    if (li.IsUninitialized)
                    {
                        log.Debug("ignoring uninitialized proxy");
                        @event.Result = await(source.LoadAsync(li.EntityName, li.Identifier, cancellationToken)).ConfigureAwait(false);
                        return;                         //EARLY EXIT!
                    }
                    else
                    {
                        entity = await(li.GetImplementationAsync(cancellationToken)).ConfigureAwait(false);
                    }
                }
                else
                {
                    entity = original;
                }

                if (copyCache.Contains(entity) && copyCache.IsOperatedOn(entity))
                {
                    log.Debug("already in merge process");
                    @event.Result = entity;
                }
                else
                {
                    if (copyCache.Contains(entity))
                    {
                        log.Info("already in copyCache; setting in merge process");
                        copyCache.SetOperatedOn(entity, true);
                    }

                    @event.Entity = entity;
                    EntityState entityState = EntityState.Undefined;
                    if (ReferenceEquals(null, @event.EntityName))
                    {
                        @event.EntityName = source.BestGuessEntityName(entity);
                    }

                    // Check the persistence context for an entry relating to this
                    // entity to be merged...
                    EntityEntry entry = source.PersistenceContext.GetEntry(entity);
                    if (entry == null)
                    {
                        IEntityPersister persister = source.GetEntityPersister(@event.EntityName, entity);
                        object           id        = persister.GetIdentifier(entity);
                        if (id != null)
                        {
                            EntityKey key           = source.GenerateEntityKey(id, persister);
                            object    managedEntity = source.PersistenceContext.GetEntity(key);
                            entry = source.PersistenceContext.GetEntry(managedEntity);
                            if (entry != null)
                            {
                                // we have specialized case of a detached entity from the
                                // perspective of the merge operation.  Specifically, we
                                // have an incoming entity instance which has a corresponding
                                // entry in the current persistence context, but registered
                                // under a different entity instance
                                entityState = EntityState.Detached;
                            }
                        }
                    }

                    if (entityState == EntityState.Undefined)
                    {
                        entityState = await(GetEntityStateAsync(entity, @event.EntityName, entry, source, cancellationToken)).ConfigureAwait(false);
                    }

                    switch (entityState)
                    {
                    case EntityState.Persistent:
                        await(EntityIsPersistentAsync(@event, copyCache, cancellationToken)).ConfigureAwait(false);
                        break;

                    case EntityState.Transient:
                        await(EntityIsTransientAsync(@event, copyCache, cancellationToken)).ConfigureAwait(false);
                        break;

                    case EntityState.Detached:
                        await(EntityIsDetachedAsync(@event, copyCache, cancellationToken)).ConfigureAwait(false);
                        break;

                    default:
                        throw new ObjectDeletedException("deleted instance passed to merge", null, GetLoggableName(@event.EntityName, entity));
                    }
                }
            }
        }
Example #33
0
 public EntityKey ForgetEdgeFromNode(EntityKey fromNode)
 {
     return(new EntityKey(_setName, _inboundEdges.Where(e => e != fromNode._setName)));
 }
Example #34
0
        /// <summary>
        /// Applies to join a group
        /// </summary>
        /// <param name="AutoAcceptOutstandingInvite">Optional, default true. Automatically accept an outstanding invitation if one exists instead of creating an application (Optional)</param>
        /// <param name="Entity">The entity to perform this action on. (Optional)</param>
        /// <param name="Group">The identifier of the group (Required)</param>
        public static Task <ApplyToGroupResponse> ApplyToGroup(EntityKey Group, bool?AutoAcceptOutstandingInvite = default, EntityKey Entity = default,
                                                               PlayFabAuthenticationContext customAuthContext    = null, object customData   = null, Dictionary <string, string> extraHeaders = null)
        {
            ApplyToGroupRequest request = new ApplyToGroupRequest()
            {
                Group = Group,
                AutoAcceptOutstandingInvite = AutoAcceptOutstandingInvite,
                Entity = Entity,
            };

            var context = GetContext(customAuthContext);

            return(PlayFabHttp.MakeApiCallAsync <ApplyToGroupResponse>("/Group/ApplyToGroup", request,
                                                                       AuthType.EntityToken,
                                                                       customData, extraHeaders, context));
        }
        /// <inheritdoc />
        public async Task <int> ProcessResultsSetAsync(DbDataReader reader, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
            ThrowIfNotInitialized();

            var dialect         = Session.Factory.Dialect;
            var hydratedObjects = new List <object> [_queryInfos.Count];
            var isDebugLog      = Log.IsDebugEnabled();

            using (Session.SwitchCacheMode(_cacheMode))
            {
                var rowCount = 0;
                for (var i = 0; i < _queryInfos.Count; i++)
                {
                    var queryInfo       = _queryInfos[i];
                    var loader          = queryInfo.Loader;
                    var queryParameters = queryInfo.Parameters;

                    //Skip processing for items already loaded from cache
                    if (queryInfo.IsResultFromCache)
                    {
                        continue;
                    }

                    var entitySpan = loader.EntityPersisters.Length;
                    hydratedObjects[i] = entitySpan == 0 ? null : new List <object>(entitySpan);
                    var keys = new EntityKey[entitySpan];

                    var selection        = queryParameters.RowSelection;
                    var createSubselects = loader.IsSubselectLoadingEnabled;

                    _subselectResultKeys[i] = createSubselects ? new List <EntityKey[]>() : null;
                    var maxRows          = Loader.Loader.HasMaxRows(selection) ? selection.MaxRows : int.MaxValue;
                    var advanceSelection = !dialect.SupportsLimitOffset || !loader.UseLimit(selection, dialect);

                    if (advanceSelection)
                    {
                        await(Loader.Loader.AdvanceAsync(reader, selection, cancellationToken)).ConfigureAwait(false);
                    }

                    var forcedResultTransformer = queryInfo.CacheKey?.ResultTransformer;
                    if (queryParameters.HasAutoDiscoverScalarTypes)
                    {
                        loader.AutoDiscoverTypes(reader, queryParameters, forcedResultTransformer);
                    }

                    var lockModeArray     = loader.GetLockModes(queryParameters.LockModes);
                    var optionalObjectKey = Loader.Loader.GetOptionalObjectKey(queryParameters, Session);
                    var tmpResults        = new List <object>();
                    var queryCacheBuilder = queryInfo.IsCacheable ? new QueryCacheResultBuilder(loader) : null;
                    var cacheBatcher      = queryInfo.CacheBatcher;
                    var ownCacheBatcher   = cacheBatcher == null;
                    if (ownCacheBatcher)
                    {
                        cacheBatcher = new CacheBatcher(Session);
                    }

                    if (isDebugLog)
                    {
                        Log.Debug("processing result set");
                    }

                    int count;
                    for (count = 0; count < maxRows && await(reader.ReadAsync(cancellationToken)).ConfigureAwait(false); count++)
                    {
                        if (isDebugLog)
                        {
                            Log.Debug("result set row: {0}", count);
                        }

                        rowCount++;

                        var o =
                            await(loader.GetRowFromResultSetAsync(
                                      reader,
                                      Session,
                                      queryParameters,
                                      lockModeArray,
                                      optionalObjectKey,
                                      hydratedObjects[i],
                                      keys,
                                      true,
                                      forcedResultTransformer,
                                      queryCacheBuilder,
                                      (persister, data) => cacheBatcher.AddToBatch(persister, data)
                                      , cancellationToken)).ConfigureAwait(false);
                        if (loader.IsSubselectLoadingEnabled)
                        {
                            _subselectResultKeys[i].Add(keys);
                            keys = new EntityKey[entitySpan];                             //can't reuse in this case
                        }

                        tmpResults.Add(o);
                    }

                    if (isDebugLog)
                    {
                        Log.Debug("done processing result set ({0} rows)", count);
                    }

                    queryInfo.Result = tmpResults;
                    if (queryInfo.CanPutToCache)
                    {
                        queryInfo.ResultToCache = queryCacheBuilder.Result;
                    }

                    if (ownCacheBatcher)
                    {
                        await(cacheBatcher.ExecuteBatchAsync(cancellationToken)).ConfigureAwait(false);
                    }

                    await(reader.NextResultAsync(cancellationToken)).ConfigureAwait(false);
                }

                StopLoadingCollections(reader);
                _reader          = reader;
                _hydratedObjects = hydratedObjects;
                return(rowCount);
            }
        }
Example #36
0
 public Task <object> GetEntityUsingInterceptorAsync(EntityKey key, CancellationToken cancellationToken)
 {
     return(_session.GetEntityUsingInterceptorAsync(key, cancellationToken));
 }
Example #37
0
 public abstract WeaponEntity ReplaceWeapon(EntityKey Owner, WeaponScanStruct orient, ref WeaponPartsRefreshStruct refreshParams);
Example #38
0
        private void GetResultsFromDatabase(IList results)
        {
            bool statsEnabled = session.Factory.Statistics.IsStatisticsEnabled;
            var  stopWatch    = new Stopwatch();

            if (statsEnabled)
            {
                stopWatch.Start();
            }
            int rowCount = 0;

            try
            {
                using (var reader = resultSetsCommand.GetReader(parameters.ToArray(), null))
                {
                    ArrayList[]          hydratedObjects     = new ArrayList[loaders.Count];
                    List <EntityKey[]>[] subselectResultKeys = new List <EntityKey[]> [loaders.Count];
                    bool[] createSubselects = new bool[loaders.Count];
                    for (int i = 0; i < loaders.Count; i++)
                    {
                        CriteriaLoader loader     = loaders[i];
                        int            entitySpan = loader.EntityPersisters.Length;
                        hydratedObjects[i] = entitySpan == 0 ? null : new ArrayList(entitySpan);
                        EntityKey[]     keys            = new EntityKey[entitySpan];
                        QueryParameters queryParameters = parameters[i];
                        IList           tmpResults      = new ArrayList();

                        RowSelection selection = parameters[i].RowSelection;
                        createSubselects[i]    = loader.IsSubselectLoadingEnabled;
                        subselectResultKeys[i] = createSubselects[i] ? new List <EntityKey[]>() : null;
                        int maxRows = Loader.Loader.HasMaxRows(selection) ? selection.MaxRows : int.MaxValue;
                        if (!dialect.SupportsLimitOffset || !Loader.Loader.UseLimit(selection, dialect))
                        {
                            Loader.Loader.Advance(reader, selection);
                        }
                        int count;
                        for (count = 0; count < maxRows && reader.Read(); count++)
                        {
                            rowCount++;

                            object o =
                                loader.GetRowFromResultSet(reader, session, queryParameters, loader.GetLockModes(queryParameters.LockModes),
                                                           null, hydratedObjects[i], keys, true);
                            if (createSubselects[i])
                            {
                                subselectResultKeys[i].Add(keys);
                                keys = new EntityKey[entitySpan];                                 //can't reuse in this case
                            }
                            tmpResults.Add(o);
                        }

                        results.Add(tmpResults);
                        reader.NextResult();
                    }

                    for (int i = 0; i < loaders.Count; i++)
                    {
                        CriteriaLoader loader = loaders[i];
                        loader.InitializeEntitiesAndCollections(hydratedObjects[i], reader, session, false);

                        if (createSubselects[i])
                        {
                            loader.CreateSubselects(subselectResultKeys[i], parameters[i], session);
                        }
                    }
                }
            }
            catch (Exception sqle)
            {
                var message = string.Format("Failed to execute multi criteria: [{0}]", resultSetsCommand.Sql);
                log.Error(message, sqle);
                throw ADOExceptionHelper.Convert(session.Factory.SQLExceptionConverter, sqle, "Failed to execute multi criteria", resultSetsCommand.Sql);
            }
            if (statsEnabled)
            {
                stopWatch.Stop();
                session.Factory.StatisticsImplementor.QueryExecuted(string.Format("{0} queries (MultiCriteria)", loaders.Count), rowCount, stopWatch.Elapsed);
            }
        }
        public virtual async Task OnRefreshAsync(RefreshEvent @event, IDictionary refreshedAlready, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
            IEventSource source = @event.Session;

            bool isTransient = !source.Contains(@event.Entity);

            if (source.PersistenceContext.ReassociateIfUninitializedProxy(@event.Entity))
            {
                if (isTransient)
                {
                    source.SetReadOnly(@event.Entity, source.DefaultReadOnly);
                }
                return;
            }

            object obj = await(source.PersistenceContext.UnproxyAndReassociateAsync(@event.Entity, cancellationToken)).ConfigureAwait(false);

            if (refreshedAlready.Contains(obj))
            {
                log.Debug("already refreshed");
                return;
            }

            EntityEntry      e = source.PersistenceContext.GetEntry(obj);
            IEntityPersister persister;
            object           id;

            if (e == null)
            {
                persister = source.GetEntityPersister(source.BestGuessEntityName(obj), obj);                 //refresh() does not pass an entityName
                id        = persister.GetIdentifier(obj);
                if (log.IsDebugEnabled())
                {
                    log.Debug("refreshing transient {0}", MessageHelper.InfoString(persister, id, source.Factory));
                }
                EntityKey key = source.GenerateEntityKey(id, persister);
                if (source.PersistenceContext.GetEntry(key) != null)
                {
                    throw new PersistentObjectException("attempted to refresh transient instance when persistent instance was already associated with the Session: " +
                                                        MessageHelper.InfoString(persister, id, source.Factory));
                }
            }
            else
            {
                if (log.IsDebugEnabled())
                {
                    log.Debug("refreshing {0}", MessageHelper.InfoString(e.Persister, e.Id, source.Factory));
                }
                if (!e.ExistsInDatabase)
                {
                    throw new HibernateException("this instance does not yet exist as a row in the database");
                }

                persister = e.Persister;
                id        = e.Id;
            }

            // cascade the refresh prior to refreshing this entity
            refreshedAlready[obj] = obj;
            await(new Cascade(CascadingAction.Refresh, CascadePoint.BeforeRefresh, source).CascadeOnAsync(persister, obj, refreshedAlready, cancellationToken)).ConfigureAwait(false);

            if (e != null)
            {
                EntityKey key = source.GenerateEntityKey(id, persister);
                source.PersistenceContext.RemoveEntity(key);
                if (persister.HasCollections)
                {
                    await(new EvictVisitor(source).ProcessAsync(obj, persister, cancellationToken)).ConfigureAwait(false);
                }
            }

            if (persister.HasCache)
            {
                CacheKey ck = source.GenerateCacheKey(id, persister.IdentifierType, persister.RootEntityName);
                await(persister.Cache.RemoveAsync(ck, cancellationToken)).ConfigureAwait(false);
            }

            await(EvictCachedCollectionsAsync(persister, id, source.Factory, cancellationToken)).ConfigureAwait(false);

            // NH Different behavior : NH-1601
            // At this point the entity need the real refresh, all elementes of collections are Refreshed,
            // the collection state was evicted, but the PersistentCollection (in the entity state)
            // is associated with a possible previous session.
            await(new WrapVisitor(source).ProcessAsync(obj, persister, cancellationToken)).ConfigureAwait(false);

            string previousFetchProfile = source.FetchProfile;

            source.FetchProfile = "refresh";
            object result = await(persister.LoadAsync(id, obj, @event.LockMode, source, cancellationToken)).ConfigureAwait(false);

            if (result != null)
            {
                if (!persister.IsMutable)
                {
                    source.SetReadOnly(result, true);
                }
                else
                {
                    source.SetReadOnly(result, e == null ? source.DefaultReadOnly : !e.IsModifiableEntity());
                }
            }
            source.FetchProfile = previousFetchProfile;

            // NH Different behavior : we are ignoring transient entities without throw any kind of exception
            // because a transient entity is "self refreshed"
            if (!(await(ForeignKeys.IsTransientFastAsync(persister.EntityName, obj, @event.Session, cancellationToken)).ConfigureAwait(false)).GetValueOrDefault(result == null))
            {
                UnresolvableObjectException.ThrowIfNull(result, id, persister.EntityName);
            }
        }
Example #40
0
        // <summary>
        // Call to ensure a target entities key is added into the state manager
        // properly
        // </summary>
        public IEntityWrapper HandleRelationshipSpan(
            IEntityWrapper wrappedEntity, EntityKey targetKey, AssociationEndMember targetMember)
        {
            if (null == wrappedEntity.Entity)
            {
                return(wrappedEntity);
            }
            DebugCheck.NotNull(targetMember);
            Debug.Assert(
                targetMember.RelationshipMultiplicity == RelationshipMultiplicity.One ||
                targetMember.RelationshipMultiplicity == RelationshipMultiplicity.ZeroOrOne);

            var sourceKey    = wrappedEntity.EntityKey;
            var sourceMember = MetadataHelper.GetOtherAssociationEnd(targetMember);

            CheckClearedEntryOnSpan(targetKey, wrappedEntity, sourceKey, targetMember);

            if (null != (object)targetKey)
            {
                EntitySet targetEntitySet;

                var associationSet = Context.MetadataWorkspace.MetadataOptimization.FindCSpaceAssociationSet(
                    (AssociationType)targetMember.DeclaringType, targetMember.Name,
                    targetKey.EntitySetName, targetKey.EntityContainerName, out targetEntitySet);
                Debug.Assert(associationSet != null, "associationSet should not be null");

                var         manager = Context.ObjectStateManager;
                EntityState newEntryState;
                // If there is an existing relationship entry, update it based on its current state and the MergeOption, otherwise add a new one
                if (
                    !ObjectStateManager.TryUpdateExistingRelationships(
                        Context, MergeOption, associationSet, sourceMember, sourceKey, wrappedEntity, targetMember, targetKey,
                        /*setIsLoaded*/ true, out newEntryState))
                {
                    // Try to find a state entry for the target key
                    var targetEntry = manager.GetOrAddKeyEntry(targetKey, targetEntitySet);

                    // For 1-1 relationships we have to take care of the relationships of targetEntity
                    var needNewRelationship = true;
                    switch (sourceMember.RelationshipMultiplicity)
                    {
                    case RelationshipMultiplicity.ZeroOrOne:
                    case RelationshipMultiplicity.One:
                        // devnote: targetEntry can be a key entry (targetEntry.Entity == null),
                        // but it that case this parameter won't be used in TryUpdateExistingRelationships
                        needNewRelationship = !ObjectStateManager.TryUpdateExistingRelationships(
                            Context,
                            MergeOption,
                            associationSet,
                            targetMember,
                            targetKey,
                            targetEntry.WrappedEntity,
                            sourceMember,
                            sourceKey,
                            setIsLoaded: true,
                            newEntryState: out newEntryState);

                        // It is possible that as part of removing existing relationships, the key entry was deleted
                        // If that is the case, recreate the key entry
                        if (targetEntry.State
                            == EntityState.Detached)
                        {
                            targetEntry = manager.AddKeyEntry(targetKey, targetEntitySet);
                        }
                        break;

                    case RelationshipMultiplicity.Many:
                        // we always need a new relationship with Many-To-Many, if there was no exact match between these two entities, so do nothing
                        break;

                    default:
                        Debug.Assert(false, "Unexpected sourceMember.RelationshipMultiplicity");
                        break;
                    }

                    if (needNewRelationship)
                    {
                        // If the target entry is a key entry, then we need to add a relation
                        //   between the source and target entries
                        // If we are in a state where we just need to add a new Deleted relation, we
                        //   only need to do that and not touch the related ends
                        // If the target entry is a full entity entry, then we need to add
                        //   the target entity to the source collection or reference
                        if (targetEntry.IsKeyEntry ||
                            newEntryState == EntityState.Deleted)
                        {
                            // Add a relationship between the source entity and the target key entry
                            var wrapper = new RelationshipWrapper(
                                associationSet, sourceMember.Name, sourceKey, targetMember.Name, targetKey);
                            manager.AddNewRelation(wrapper, newEntryState);
                        }
                        else
                        {
                            Debug.Assert(!targetEntry.IsRelationship, "how IsRelationship?");
                            if (targetEntry.State
                                != EntityState.Deleted)
                            {
                                // The entry contains an entity, do collection or reference fixup
                                // This will also try to create a new relationship entry or will revert the delete on an existing deleted relationship
                                ObjectStateManager.AddEntityToCollectionOrReference(
                                    MergeOption, wrappedEntity, sourceMember,
                                    targetEntry.WrappedEntity,
                                    targetMember,
                                    setIsLoaded: true,
                                    relationshipAlreadyExists: false,
                                    inKeyEntryPromotion: false);
                            }
                            else
                            {
                                // if the target entry is deleted, then the materializer needs to create a deleted relationship
                                // between the entity and the target entry so that if the entity is deleted, the update
                                // pipeline can find the relationship (even though it is deleted)
                                var wrapper = new RelationshipWrapper(
                                    associationSet, sourceMember.Name, sourceKey, targetMember.Name, targetKey);
                                manager.AddNewRelation(wrapper, EntityState.Deleted);
                            }
                        }
                    }
                }
            }
            else
            {
                RelatedEnd relatedEnd;
                if (TryGetRelatedEnd(
                        wrappedEntity, (AssociationType)targetMember.DeclaringType, sourceMember.Name, targetMember.Name, out relatedEnd))
                {
                    SetIsLoadedForSpan(relatedEnd, false);
                }
            }

            // else there is nothing else for us to do, the relationship has been handled already
            return(wrappedEntity);
        }
Example #41
0
        // <summary>
        // REQUIRES:: entity exists; MergeOption is AppendOnly
        // Handles state management for an entity with the given key. When the entity already exists
        // in the state manager, it is returned directly. Otherwise, the entityDelegate is invoked and
        // the resulting entity is returned.
        // </summary>
        public IEntityWrapper HandleEntityAppendOnly <TEntity>(
            Func <Shaper, IEntityWrapper> constructEntityDelegate, EntityKey entityKey, EntitySet entitySet)
        {
            Debug.Assert(MergeOption == MergeOption.AppendOnly, "only use HandleEntityAppendOnly when MergeOption is AppendOnly");
            DebugCheck.NotNull(constructEntityDelegate);

            IEntityWrapper result;

            if (null == (object)entityKey)
            {
                // no entity set, so no tracking is required for this entity, just
                // call the delegate to "materialize" it.
                result = constructEntityDelegate(this);
                RegisterMaterializedEntityForEvent(result);
            }
            else
            {
                Debug.Assert(null != entitySet, "if there is an entity key, there must also be an entity set");

                // check for an existing entity with the same key
                var existingEntry = Context.ObjectStateManager.FindEntityEntry(entityKey);
                if (null != existingEntry &&
                    !existingEntry.IsKeyEntry)
                {
                    Debug.Assert(existingEntry.EntityKey.Equals(entityKey), "Found ObjectStateEntry with wrong EntityKey");
                    if (typeof(TEntity)
                        != existingEntry.WrappedEntity.IdentityType)
                    {
                        var key = existingEntry.EntityKey;
                        throw new NotSupportedException(
                                  Strings.Materializer_RecyclingEntity(
                                      TypeHelpers.GetFullName(key.EntityContainerName, key.EntitySetName), typeof(TEntity).FullName,
                                      existingEntry.WrappedEntity.IdentityType.FullName));
                    }

                    if (EntityState.Added
                        == existingEntry.State)
                    {
                        throw new InvalidOperationException(
                                  Strings.Materializer_AddedEntityAlreadyExists(typeof(TEntity).FullName));
                    }
                    result = existingEntry.WrappedEntity;
                }
                else
                {
                    // We don't already have the entity, so construct it
                    result = constructEntityDelegate(this);
                    RegisterMaterializedEntityForEvent(result);
                    if (null == existingEntry)
                    {
                        Context.ObjectStateManager.AddEntry(result, entityKey, entitySet, "HandleEntity", false);
                    }
                    else
                    {
                        Context.ObjectStateManager.PromoteKeyEntry(
                            existingEntry, result, false, /*setIsLoaded*/ true, /*keyEntryInitialized*/ false);
                    }
                }
            }
            return(result);
        }
        protected virtual async Task PerformUpdateAsync(SaveOrUpdateEvent @event, object entity, IEntityPersister persister, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
            if (!persister.IsMutable)
            {
                log.Debug("immutable instance passed to PerformUpdate(), locking");
            }

            if (log.IsDebugEnabled())
            {
                log.Debug("updating {0}", MessageHelper.InfoString(persister, @event.RequestedId, @event.Session.Factory));
            }

            IEventSource source = @event.Session;

            EntityKey key = source.GenerateEntityKey(@event.RequestedId, persister);

            source.PersistenceContext.CheckUniqueness(key, entity);

            if (InvokeUpdateLifecycle(entity, persister, source))
            {
                await(ReassociateAsync(@event, @event.Entity, @event.RequestedId, persister, cancellationToken)).ConfigureAwait(false);
                return;
            }

            // this is a transient object with existing persistent state not loaded by the session
            await(new OnUpdateVisitor(source, @event.RequestedId, entity).ProcessAsync(entity, persister, cancellationToken)).ConfigureAwait(false);

            //TODO: put this stuff back in to read snapshot from
            //      the second-level cache (needs some extra work)

            /*Object[] cachedState = null;
             *
             * if ( persister.hasCache() ) {
             * CacheEntry entry = (CacheEntry) persister.getCache()
             * .get( event.getRequestedId(), source.getTimestamp() );
             * cachedState = entry==null ?
             * null :
             * entry.getState(); //TODO: half-assemble this stuff
             * }*/

            source.PersistenceContext.AddEntity(
                entity,
                persister.IsMutable ? Status.Loaded : Status.ReadOnly,
                null,
                key,
                persister.GetVersion(entity),
                LockMode.None,
                true,
                persister,
                false);

            //persister.AfterReassociate(entity, source); TODO H3.2 not ported

            if (log.IsDebugEnabled())
            {
                log.Debug("updating {0}", MessageHelper.InfoString(persister, @event.RequestedId, source.Factory));
            }

            await(CascadeOnUpdateAsync(@event, persister, entity, cancellationToken)).ConfigureAwait(false);
        }
Example #43
0
 public static EntityKey Deserialize(EntityKey typeTag, BinaryReader reader)
 {
     return(_entityKeySerializer.Read(reader));
 }
        protected List <object> DoList()
        {
            bool statsEnabled = session.Factory.Statistics.IsStatisticsEnabled;
            var  stopWatch    = new Stopwatch();

            if (statsEnabled)
            {
                stopWatch.Start();
            }
            int rowCount = 0;

            var results = new List <object>();

            var hydratedObjects = new List <object> [Translators.Count];

            List <EntityKey[]>[] subselectResultKeys = new List <EntityKey[]> [Translators.Count];
            bool[] createSubselects = new bool[Translators.Count];

            try
            {
                using (var reader = resultSetsCommand.GetReader(_timeout))
                {
                    if (log.IsDebugEnabled())
                    {
                        log.Debug("Executing {0} queries", translators.Count);
                    }
                    for (int i = 0; i < translators.Count; i++)
                    {
                        ITranslator     translator = Translators[i];
                        QueryParameters parameter  = Parameters[i];

                        int entitySpan = translator.Loader.EntityPersisters.Length;
                        hydratedObjects[i] = entitySpan > 0 ? new List <object>() : null;
                        RowSelection selection = parameter.RowSelection;
                        int          maxRows   = Loader.Loader.HasMaxRows(selection) ? selection.MaxRows : int.MaxValue;
                        if (!dialect.SupportsLimitOffset || !translator.Loader.UseLimit(selection, dialect))
                        {
                            Loader.Loader.Advance(reader, selection);
                        }

                        if (parameter.HasAutoDiscoverScalarTypes)
                        {
                            translator.Loader.AutoDiscoverTypes(reader, parameter, null);
                        }

                        LockMode[] lockModeArray     = translator.Loader.GetLockModes(parameter.LockModes);
                        EntityKey  optionalObjectKey = Loader.Loader.GetOptionalObjectKey(parameter, session);

                        createSubselects[i]    = translator.Loader.IsSubselectLoadingEnabled;
                        subselectResultKeys[i] = createSubselects[i] ? new List <EntityKey[]>() : null;

                        translator.Loader.HandleEmptyCollections(parameter.CollectionKeys, reader, session);
                        EntityKey[] keys = new EntityKey[entitySpan];                         // we can reuse it each time

                        if (log.IsDebugEnabled())
                        {
                            log.Debug("processing result set");
                        }

                        IList tempResults = new List <object>();
                        int   count;
                        for (count = 0; count < maxRows && reader.Read(); count++)
                        {
                            if (log.IsDebugEnabled())
                            {
                                log.Debug("result set row: {0}", count);
                            }

                            rowCount++;
                            object result = translator.Loader.GetRowFromResultSet(
                                reader, session, parameter, lockModeArray, optionalObjectKey, hydratedObjects[i], keys, true);
                            tempResults.Add(result);

                            if (createSubselects[i])
                            {
                                subselectResultKeys[i].Add(keys);
                                keys = new EntityKey[entitySpan];                                 //can't reuse in this case
                            }
                        }

                        if (log.IsDebugEnabled())
                        {
                            log.Debug("done processing result set ({0} rows)", count);
                        }

                        results.Add(tempResults);

                        if (log.IsDebugEnabled())
                        {
                            log.Debug("Query {0} returned {1} results", i, tempResults.Count);
                        }

                        reader.NextResult();
                    }

                    for (int i = 0; i < translators.Count; i++)
                    {
                        ITranslator     translator = translators[i];
                        QueryParameters parameter  = parameters[i];

                        translator.Loader.InitializeEntitiesAndCollections(hydratedObjects[i], reader, session, false);

                        if (createSubselects[i])
                        {
                            translator.Loader.CreateSubselects(subselectResultKeys[i], parameter, session);
                        }
                    }
                }
            }
            catch (Exception sqle)
            {
                log.Error(sqle, "Failed to execute multi query: [{0}]", resultSetsCommand.Sql);
                throw ADOExceptionHelper.Convert(session.Factory.SQLExceptionConverter, sqle, "Failed to execute multi query", resultSetsCommand.Sql);
            }

            if (statsEnabled)
            {
                stopWatch.Stop();
                session.Factory.StatisticsImplementor.QueryExecuted(string.Format("{0} queries (MultiQuery)", translators.Count), rowCount, stopWatch.Elapsed);
            }
            return(results);
        }
Example #45
0
 public object GetEntityUsingInterceptor(EntityKey key)
 {
     return(_session.GetEntityUsingInterceptor(key));
 }
Example #46
0
 public static void Serialize(EntityKey data, Core.Utils.MyBinaryWriter writer,
                              EntityKey last = default(EntityKey), bool weiteAll = false)
 {
     _entityKeySerializer.Write(data, writer);
 }
        /// <summary>
        /// Performs all the actual work needed to save an entity (well to get the save moved to
        /// the execution queue).
        /// </summary>
        /// <param name="entity">The entity to be saved </param>
        /// <param name="key">The id to be used for saving the entity (or null, in the case of identity columns) </param>
        /// <param name="persister">The entity's persister instance. </param>
        /// <param name="useIdentityColumn">Should an identity column be used for id generation? </param>
        /// <param name="anything">Generally cascade-specific information. </param>
        /// <param name="source">The session which is the source of the current event. </param>
        /// <param name="requiresImmediateIdAccess">
        /// Is access to the identifier required immediately
        /// after the completion of the save?  persist(), for example, does not require this...
        /// </param>
        /// <returns>
        /// The id used to save the entity; may be null depending on the
        /// type of id generator used and the requiresImmediateIdAccess value
        /// </returns>
        protected virtual object PerformSaveOrReplicate(object entity, EntityKey key, IEntityPersister persister, bool useIdentityColumn, object anything, IEventSource source, bool requiresImmediateIdAccess)
        {
            Validate(entity, persister, source);

            object id = key == null ? null : key.Identifier;

            // NH Different behavior (shouldDelayIdentityInserts=false anyway)
            //bool inTxn = source.ConnectionManager.IsInActiveTransaction;
            //bool shouldDelayIdentityInserts = !inTxn && !requiresImmediateIdAccess;
            bool shouldDelayIdentityInserts = false;

            // Put a placeholder in entries, so we don't recurse back and try to save() the
            // same object again. QUESTION: should this be done before onSave() is called?
            // likewise, should it be done before onUpdate()?
            source.PersistenceContext.AddEntry(entity, Status.Saving, null, null, id, null, LockMode.Write, useIdentityColumn, persister, false, false);

            CascadeBeforeSave(source, persister, entity, anything);

            // NH-962: This was originally done before many-to-one cascades.
            if (useIdentityColumn && !shouldDelayIdentityInserts)
            {
                log.Debug("executing insertions");
                source.ActionQueue.ExecuteInserts();
            }

            object[] values = persister.GetPropertyValuesToInsert(entity, GetMergeMap(anything), source);
            IType[]  types  = persister.PropertyTypes;

            bool substitute = SubstituteValuesIfNecessary(entity, id, values, persister, source);

            if (persister.HasCollections)
            {
                substitute = substitute || VisitCollectionsBeforeSave(entity, id, values, types, source);
            }

            if (substitute)
            {
                persister.SetPropertyValues(entity, values, source.EntityMode);
            }

            TypeHelper.DeepCopy(values, types, persister.PropertyUpdateability, values, source);

            new ForeignKeys.Nullifier(entity, false, useIdentityColumn, source).NullifyTransientReferences(values, types);
            new Nullability(source).CheckNullability(values, persister, false);

            if (useIdentityColumn)
            {
                EntityIdentityInsertAction insert = new EntityIdentityInsertAction(values, entity, persister, source, shouldDelayIdentityInserts);
                if (!shouldDelayIdentityInserts)
                {
                    log.Debug("executing identity-insert immediately");
                    source.ActionQueue.Execute(insert);
                    id = insert.GeneratedId;
                    //now done in EntityIdentityInsertAction
                    //persister.setIdentifier( entity, id, source.getEntityMode() );
                    key = source.GenerateEntityKey(id, persister);
                    source.PersistenceContext.CheckUniqueness(key, entity);
                    //source.getBatcher().executeBatch(); //found another way to ensure that all batched joined inserts have been executed
                }
                else
                {
                    log.Debug("delaying identity-insert due to no transaction in progress");
                    source.ActionQueue.AddAction(insert);
                    key = insert.DelayedEntityKey;
                }
            }

            object version = Versioning.GetVersion(values, persister);

            source.PersistenceContext.AddEntity(
                entity,
                persister.IsMutable ? Status.Loaded : Status.ReadOnly,
                values, key,
                version,
                LockMode.Write,
                useIdentityColumn,
                persister,
                VersionIncrementDisabled,
                false);
            //source.getPersistenceContext().removeNonExist( new EntityKey( id, persister, source.getEntityMode() ) );

            if (!useIdentityColumn)
            {
                source.ActionQueue.AddAction(new EntityInsertAction(id, values, entity, version, persister, source));
            }

            CascadeAfterSave(source, persister, entity, anything);

            MarkInterceptorDirty(entity, persister, source);

            return(id);
        }
 public KeyValue([NotNull] IForeignKey foreignKey, EntityKey keyValue, ValueType valueType)
 {
     ForeignKey = foreignKey;
     Key        = keyValue;
     ValueType  = valueType;
 }
Example #49
0
        private async Task GetResultsFromDatabaseAsync(IList results, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
            bool statsEnabled = session.Factory.Statistics.IsStatisticsEnabled;
            var  stopWatch    = new Stopwatch();

            if (statsEnabled)
            {
                stopWatch.Start();
            }
            int rowCount = 0;

            try
            {
                using (var reader = await(resultSetsCommand.GetReaderAsync(_timeout, cancellationToken)).ConfigureAwait(false))
                {
                    var hydratedObjects = new List <object> [loaders.Count];
                    List <EntityKey[]>[] subselectResultKeys = new List <EntityKey[]> [loaders.Count];
                    bool[] createSubselects = new bool[loaders.Count];
                    for (int i = 0; i < loaders.Count; i++)
                    {
                        CriteriaLoader loader     = loaders[i];
                        int            entitySpan = loader.EntityPersisters.Length;
                        hydratedObjects[i] = entitySpan == 0 ? null : new List <object>(entitySpan);
                        EntityKey[]     keys            = new EntityKey[entitySpan];
                        QueryParameters queryParameters = parameters[i];
                        IList           tmpResults      = new List <object>();

                        RowSelection selection = parameters[i].RowSelection;
                        createSubselects[i]    = loader.IsSubselectLoadingEnabled;
                        subselectResultKeys[i] = createSubselects[i] ? new List <EntityKey[]>() : null;
                        int maxRows = Loader.Loader.HasMaxRows(selection) ? selection.MaxRows : int.MaxValue;
                        if (!dialect.SupportsLimitOffset || !loader.UseLimit(selection, dialect))
                        {
                            await(Loader.Loader.AdvanceAsync(reader, selection, cancellationToken)).ConfigureAwait(false);
                        }
                        int count;
                        for (count = 0; count < maxRows && await(reader.ReadAsync(cancellationToken)).ConfigureAwait(false); count++)
                        {
                            rowCount++;

                            object o =
                                await(loader.GetRowFromResultSetAsync(reader, session, queryParameters, loader.GetLockModes(queryParameters.LockModes),
                                                                      null, hydratedObjects[i], keys, true, cancellationToken)).ConfigureAwait(false);
                            if (createSubselects[i])
                            {
                                subselectResultKeys[i].Add(keys);
                                keys = new EntityKey[entitySpan];                                 //can't reuse in this case
                            }
                            tmpResults.Add(o);
                        }

                        results.Add(tmpResults);
                        await(reader.NextResultAsync(cancellationToken)).ConfigureAwait(false);
                    }

                    for (int i = 0; i < loaders.Count; i++)
                    {
                        CriteriaLoader loader = loaders[i];
                        await(loader.InitializeEntitiesAndCollectionsAsync(hydratedObjects[i], reader, session, session.DefaultReadOnly, cancellationToken: cancellationToken)).ConfigureAwait(false);

                        if (createSubselects[i])
                        {
                            loader.CreateSubselects(subselectResultKeys[i], parameters[i], session);
                        }
                    }
                }
            }
            catch (OperationCanceledException) { throw; }
            catch (Exception sqle)
            {
                log.Error(sqle, "Failed to execute multi criteria: [{0}]", resultSetsCommand.Sql);
                throw ADOExceptionHelper.Convert(session.Factory.SQLExceptionConverter, sqle, "Failed to execute multi criteria", resultSetsCommand.Sql);
            }
            if (statsEnabled)
            {
                stopWatch.Stop();
                session.Factory.StatisticsImplementor.QueryExecuted(string.Format("{0} queries (MultiCriteria)", loaders.Count), rowCount, stopWatch.Elapsed);
            }
        }
Example #50
0
 protected override PlayerEntity GetEntityWithEntityKey(EntityKey entitykey)
 {
     return(((PlayerContext)EntitasContext).GetEntityWithEntityKey(entitykey));
 }
Example #51
0
 protected override WeaponEntity GetEntityWithEntityKey(EntityKey entitykey)
 {
     return(((WeaponContext)EntitasContext).GetEntityWithEntityKey(entitykey));
 }
Example #52
0
 public object GetObjectByKey(EntityKey key)
 {
     return(null);
 }
Example #53
0
        /// <summary>
        /// Lists all outstanding invitations and group applications for an entity
        /// </summary>
        /// <param name="Entity">The entity to perform this action on. (Optional)</param>
        public static Task <ListMembershipOpportunitiesResponse> ListMembershipOpportunities(EntityKey Entity = default,
                                                                                             PlayFabAuthenticationContext customAuthContext = null, object customData = null, Dictionary <string, string> extraHeaders = null)
        {
            ListMembershipOpportunitiesRequest request = new ListMembershipOpportunitiesRequest()
            {
                Entity = Entity,
            };

            var context = GetContext(customAuthContext);

            return(PlayFabHttp.MakeApiCallAsync <ListMembershipOpportunitiesResponse>("/Group/ListMembershipOpportunities", request,
                                                                                      AuthType.EntityToken,
                                                                                      customData, extraHeaders, context));
        }
Example #54
0
 /// <summary>
 /// sync from event of playerEntiy.BagSet.WeaponSlot Component
 /// </summary>
 /// <param name="entityKey"></param>
 internal void Sync(EntityKey entityKey)
 {
     entity = WeaponEntityFactory.GetWeaponEntity(WeaponContext, entityKey);
 }
Example #55
0
 public override float DecreaseHp(VehiclePartIndex index, float amount, EUIDeadType damageType, EntityKey damageSource)
 {
     AssertUtility.Assert(amount >= 0);
     return(base.DecreaseHp(index, amount, damageType, damageSource));
 }
Example #56
0
 public bool HasIncomingEdgeFromNode(EntityKey node)
 {
     return(_inboundEdges.Contains(node._setName));
 }
Example #57
0
        private bool TryExecuteSelectImpl(EntitySession session, EntityCommand command, object[] args, out IList <EntityRecord> records)
        {
            records = _empty;
            var cacheType = command.TargetEntityInfo.CacheType;
            var entType   = command.TargetEntityInfo.EntityType;
            var fullSet   = GetFullyCachedSet(entType);

            if (fullSet == null)
            {
                return(false);
            }
            switch (command.Kind)
            {
            case EntityCommandKind.SelectAll:
            case EntityCommandKind.SelectAllPaged:
                if (cacheType != CacheType.FullSet)
                {
                    return(false);
                }
                if (command.Kind == EntityCommandKind.SelectAllPaged && args.Length == 2)
                {
                    records = fullSet.Records.Skip((int)args[0]).Take((int)args[1]).ToList();
                }
                else
                {
                    records = fullSet.Records;
                }
                return(true);

            case EntityCommandKind.SelectByKeyArray:
                if (cacheType != CacheType.FullSet)
                {
                    return(false);
                }
                //create hashset of values
                HashSet <object> idSet = new HashSet <object>();
                var iEnum = args[0] as IEnumerable;
                foreach (var v in iEnum)
                {
                    idSet.Add(v);
                }
                records = fullSet.Records.Where(r => idSet.Contains(r.PrimaryKey.Values[0])).ToList();
                return(true);

            case EntityCommandKind.SelectByKey:
                if (command.SelectKey.KeyType.IsSet(KeyType.PrimaryKey))
                {
                    var pk  = new EntityKey(command.SelectKey, args);
                    var rec = fullSet.LookupByPrimaryKey(pk);
                    if (rec != null)
                    {
                        records = new EntityRecord[] { rec };
                        return(true);
                    }
                    else
                    {
                        records = _empty;
                        return(false); // not found, records already set to empty array
                    }
                }//if PrimaryKey
                if (command.SelectKey.KeyType.IsSet(KeyType.ForeignKey))
                {
                    records = fullSet.Records.Where(rec => rec.KeyMatches(command.SelectKey, args)).ToList();
                    return(true);
                }
                return(false);

            default:
                return(false); //never happens
            }//switch
        }
        /// <summary>
        /// Return the Underlying Persistent Object in a given <see cref="ISession"/>, or null.
        /// </summary>
        /// <param name="s">The Session to get the object from.</param>
        /// <returns>The Persistent Object this proxy is Proxying, or <see langword="null" />.</returns>
        public object GetImplementation(ISessionImplementor s)
        {
            EntityKey key = s.GenerateEntityKey(Identifier, s.Factory.GetEntityPersister(EntityName));

            return(s.PersistenceContext.GetEntity(key));
        }
Example #59
0
 /// <summary>
 /// 是否赋值
 /// </summary>
 public WeaponBagSlotData()
 {
     WeaponKey = EntityKey.EmptyWeapon;
 }
Example #60
0
 protected override WeaponEntity GetEntityWithEntityKey(EntityKey entitykey)
 {
     return(null);
 }