public object Assemble(object cached, ISessionImplementor session, object owner)
        {
            IList     srcList = (IList)cached;
            ArrayList result  = new ArrayList();

            for (int i = 0; i < assemblersList.Count; i++)
            {
                ICacheAssembler[] assemblers     = (ICacheAssembler[])assemblersList[i];
                IList             queryFromCache = (IList)srcList[i];
                ArrayList         queryResults   = new ArrayList();
                foreach (object fromCache in queryFromCache)
                {
                    if (assemblers.Length == 1)
                    {
                        queryResults.Add(assemblers[0].Assemble(fromCache, session, owner));
                    }
                    else
                    {
                        queryResults.Add(TypeFactory.Assemble((object[])fromCache, assemblers, session, owner));
                    }
                }
                result.Add(queryResults);
            }
            return(result);
        }
Beispiel #2
0
        private static object[] Assemble(object[] values, object result, object id, IEntityPersister persister,
                                         IInterceptor interceptor, ISessionImplementor session)
        {
            //assembled state gets put in a new array (we read from cache by value!)
            object[] assembledProps = TypeFactory.Assemble(values, persister.PropertyTypes, session, result);

            //from h3.2 TODO: reuse the PreLoadEvent
            PreLoadEvent preLoadEvent = new PreLoadEvent((IEventSource)session);

            preLoadEvent.Entity    = result;
            preLoadEvent.State     = assembledProps;
            preLoadEvent.Id        = id;
            preLoadEvent.Persister = persister;

            IPreLoadEventListener[] listeners = session.Listeners.PreLoadEventListeners;
            for (int i = 0; i < listeners.Length; i++)
            {
                listeners[i].OnPreLoad(preLoadEvent);
            }

            persister.SetPropertyValues(result, assembledProps, session.EntityMode);

            return(assembledProps);
        }
Beispiel #3
0
        public IList Get(QueryKey key, IType[] returnTypes, ISet spaces, ISessionImplementor session)
        {
            if (log.IsDebugEnabled)
            {
                log.Debug("checking cached query results in region: " + regionName);
            }
            IList cacheable = ( IList )queryCache.Get(key);

            if (cacheable == null)
            {
                log.Debug("query results were not found in cache");
                return(null);
            }
            IList result    = new ArrayList(cacheable.Count - 1);
            long  timestamp = ( long )cacheable[0];

            log.Debug("Checking query spaces for up-to-dateness [" + spaces + "]");
            if (!IsUpToDate(spaces, timestamp))
            {
                log.Debug("cached query results were not up to date");
                return(null);
            }
            log.Debug("returning cached query results");
            for (int i = 1; i < cacheable.Count; i++)
            {
                if (returnTypes.Length == 1)
                {
                    result.Add(returnTypes[0].Assemble(cacheable[i], session, null));
                }
                else
                {
                    result.Add(TypeFactory.Assemble(( object[] )cacheable[i], returnTypes, session, null));
                }
            }
            return(result);
        }
        public IList Get(QueryKey key, ICacheAssembler[] returnTypes, bool isNaturalKeyLookup, ISet <string> spaces,
                         ISessionImplementor session)
        {
            if (log.IsDebugEnabled)
            {
                log.DebugFormat("checking cached query results in region: '{0}'; {1}", regionName, key);
            }
            var cacheable = (IList)queryCache.Get(key);

            if (cacheable == null)
            {
                log.DebugFormat("query results were not found in cache: {0}", key);
                return(null);
            }
            var timestamp = (long)cacheable[0];

            if (log.IsDebugEnabled)
            {
                log.DebugFormat("Checking query spaces for up-to-dateness [{0}]", StringHelper.CollectionToString((ICollection)spaces));
            }
            if (!isNaturalKeyLookup && !IsUpToDate(spaces, timestamp))
            {
                log.DebugFormat("cached query results were not up to date for: {0}", key);
                return(null);
            }

            log.DebugFormat("returning cached query results for: {0}", key);
            for (int i = 1; i < cacheable.Count; i++)
            {
                if (returnTypes.Length == 1)
                {
                    returnTypes[0].BeforeAssemble(cacheable[i], session);
                }
                else
                {
                    TypeFactory.BeforeAssemble((object[])cacheable[i], returnTypes, session);
                }
            }
            IList result = new List <object>(cacheable.Count - 1);

            for (int i = 1; i < cacheable.Count; i++)
            {
                try
                {
                    if (returnTypes.Length == 1)
                    {
                        result.Add(returnTypes[0].Assemble(cacheable[i], session, null));
                    }
                    else
                    {
                        result.Add(TypeFactory.Assemble((object[])cacheable[i], returnTypes, session, null));
                    }
                }
                catch (UnresolvableObjectException)
                {
                    if (isNaturalKeyLookup)
                    {
                        //TODO: not really completely correct, since
                        //      the UnresolvableObjectException could occur while resolving
                        //      associations, leaving the PC in an inconsistent state
                        log.Debug("could not reassemble cached result set");
                        queryCache.Remove(key);
                        return(null);
                    }

                    throw;
                }
            }
            return(result);
        }