private void ThrowIfTargetNotLoadable(ILoadable target) { if (target == null) { throw new InterceptionTypeNotLoadableException(); } }
public InstructionBlockChain CallMethodWithReturn(MethodReference method, ILoadable instance, IPersistable returnValue, params ILoadable[] arguments) { var type = FixTypeReference(method.DeclaringType); method = FixMethodReference(type, method); InstructionBlock block; if (method.Resolve().IsStatic) { block = _creator.CallStaticMethod(method, returnValue, arguments); } else { block = _creator.CallInstanceMethod(method, instance, returnValue, arguments); } var chain = new InstructionBlockChain(); chain.Add(block); return(chain); }
protected void InitProjection(SqlString projectionString, SqlString whereString, SqlString orderByString, string groupByString, SqlString havingString, LockMode lockMode) { WalkEntityTree(persister, Alias); Persisters = new ILoadable[0]; InitStatementString(projectionString, whereString, orderByString, groupByString, havingString, lockMode); }
} // For the Ok btn that in the error panel public LogInViewModel(ILoadable loadable) { this.loadable = loadable; LoginCommand = new DelegateCommand(x => UserName.Length > 0, x => { BussinesLogic bl = new BussinesLogic(); p = bl.GetPersonByEmail(UserName); IsLogInActive = false; Notify("MutexIndex", "ErrorTitle"); if (p != null && Password.Equals(p.Password)) { BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += (s, e) => { while (progress < 1) { Thread.Sleep(50); progress += 0.01; Notify("Progress"); } }; worker.RunWorkerCompleted += (s, e) => loadable.Loaded(p.PersonType); worker.RunWorkerAsync(); } }); ErrorOkCommand = new DelegateCommand(x => IsLogInActive = true); CancelCommand = new DelegateCommand(x => { loadable.Cancel(); }); }
public void OnModsLoad() { IEnumerable <Assembly> asses = ModLoader.Mods .SafeSelect(mod => mod.GetType().Assembly); foreach (Assembly ass in asses) { foreach (Type classType in ass.GetTypes()) { try { Type iloadableType = classType.GetInterface("ILoadable"); if (iloadableType == null) { continue; } ILoadable loadable = this.LoadLoadableSingleton(classType); if (loadable == null) { continue; } this.Loadables.Add(loadable); } catch { } } } foreach (ILoadable loadable in this.Loadables) { loadable.OnModsLoad(); } }
protected void InitProjection(SqlString projectionString, SqlString whereString, string orderByString, string groupByString, LockMode lockMode) { WalkEntityTree(persister, Alias); Persisters = new ILoadable[0]; InitStatementString(projectionString, whereString, orderByString, groupByString, lockMode); }
private void ThrowIfTargetNotLoadable(ILoadable target) { if(target == null) { throw new InterceptionTypeNotLoadableException(); } }
/// <summary> /// Calculate and cache select-clause suffixes. /// </summary> public DefaultEntityAliases(IDictionary<string, string[]> userProvidedAliases, ILoadable persister, string suffix) { this.suffix = suffix; this.userProvidedAliases = userProvidedAliases; string[] keyColumnsCandidates = GetUserProvidedAliases(persister.IdentifierPropertyName, null); if (keyColumnsCandidates == null) { suffixedKeyColumns = GetUserProvidedAliases(EntityPersister.EntityID, GetIdentifierAliases(persister, suffix)); } else { suffixedKeyColumns = keyColumnsCandidates; } Intern(suffixedKeyColumns); suffixedPropertyColumns = GetSuffixedPropertyAliases(persister); suffixedDiscriminatorColumn = GetUserProvidedAlias(AbstractEntityPersister.EntityClass, GetDiscriminatorAlias(persister, suffix)); if (persister.IsVersioned) { suffixedVersionColumn = suffixedPropertyColumns[persister.VersionProperty]; } else { suffixedVersionColumn = null; } rowIdAlias = Loadable.RowIdAlias + suffix; // TODO: not visible to the user! }
public static void AddLoadable(ILoadable loadable) { lock (loadables) if (!loadables.Contains(loadable)) { loadables.Add(loadable); } }
/// <summary> /// Method that save the repository type of the object passed as argument inside the RavenDB embedded document. /// </summary> /// <param name="data">Object to store</param> /// <returns>Always RepositoryResponse.RepositorySuccess</returns> public override RepositoryResponse Save(ILoadable data) { /*try * {*/ lock (_store) { /*using (TransactionScope tx = new TransactionScope()) * {*/ using (IDocumentSession _session = _store.OpenSession()) { dynamic entity = data.GetAsDatabaseType(); _session.Store(entity); try { _session.SaveChanges(); } catch (COMException comE) { log.Warn("Cannot save cause to interop error", comE); } // tx.Complete(); log.Debug("Data saved with id " + entity.Id); } //} } /*} * catch (TransactionAbortedException tae) * { * log.Error("Transaction aborted", tae); * return RepositoryResponse.RepositoryTransactionAbort; * }*/ return(RepositoryResponse.RepositorySuccess); }
/// <summary> /// Retrieve property values from one row of a result set /// </summary> //6.0 TODO: Merge into ILoadable public static Task <object[]> HydrateAsync( this ILoadable loadable, DbDataReader rs, object id, object obj, string[][] suffixedPropertyColumns, ISet <string> fetchedLazyProperties, bool allProperties, ISessionImplementor session, CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(Task.FromCanceled <object[]>(cancellationToken)); } try { if (loadable is AbstractEntityPersister abstractEntityPersister) { return(abstractEntityPersister.HydrateAsync( rs, id, obj, suffixedPropertyColumns, fetchedLazyProperties, allProperties, session, cancellationToken)); } var rootLoadable = loadable.RootEntityName == loadable.EntityName ? loadable : (ILoadable)loadable.Factory.GetEntityPersister(loadable.RootEntityName); #pragma warning disable 618 // Fallback to the old behavior return(loadable.HydrateAsync(rs, id, obj, rootLoadable, suffixedPropertyColumns, allProperties, session, cancellationToken)); #pragma warning restore 618 } catch (Exception ex) { return(Task.FromException <object[]>(ex)); } }
public LogInViewModel(ILoadable loadable) { this.loadable = loadable; LoginCommand = new DelegateCommand(x => UserName.Length > 0, x => { IsLogInActive = false; Notify("MutexIndex", "ErrorTitle"); if (UserName == "Setec") { BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += (s, e) => { while (progress < 1) { Thread.Sleep(50); progress += 0.01; Notify("Progress"); } }; worker.RunWorkerCompleted += (s, e) => loadable.Loaded(); worker.RunWorkerAsync(); } }); ErrorOkCommand = new DelegateCommand(x => IsLogInActive = true); }
public static bool Draw(ILoadable loadable, IUndoable undoable, ICopyable copyable) { EditorGUILayout.BeginHorizontal(); if (GUILayout.Button("File", EditorStyles.toolbarButton, GUILayout.Width(35))) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("New: Ctrl+Atl+N "), false, OnNew, loadable); menu.AddItem(new GUIContent("Load: Ctrl+Atl+L"), false, OnLoad, loadable); menu.AddItem(new GUIContent("Save: Ctrl+Atl+S"), false, OnSave, loadable); menu.ShowAsContext(); return(true); } if (GUILayout.Button("Edit", EditorStyles.toolbarButton, GUILayout.Width(35))) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Undo: Ctrl+Atl+Z"), false, OnUndo, undoable); menu.AddItem(new GUIContent("Redo: Ctrl+Atl+Y"), false, OnRedo, undoable); menu.AddItem(new GUIContent("Copy: Ctrl+Atl+C"), false, Copy, copyable); menu.AddItem(new GUIContent("Past: Ctrl+Atl+V"), false, Paste, copyable); menu.ShowAsContext(); return(true); } if (GUILayout.Button("View", EditorStyles.toolbarButton, GUILayout.Width(35))) { GenericMenu menu = new GenericMenu(); menu.ShowAsContext(); return(true); } GUILayout.Label("", EditorStyles.toolbarButton); EditorGUILayout.EndHorizontal(); return(false); }
public static void AddContent(Mod mod, ILoadable instance) { instance.Load(mod); content.Add(instance); //ContentInstance.Register(instance); //Normally, we would have this line, but 1.3 already calls it, so having it everywhere would cause clashes. }
/// <summary> /// Gets element of the given type and identified by the string passed as arguments. /// </summary> /// <typeparam name="DBType">Type of the element stored in the database. This is used to identify the collection</typeparam> /// <param name="id">Identifier of the element to retrieve</param> /// <param name="elem">Reference where the object will be loaded</param> /// <returns>RepositoryResponse.RepositoryLoad if the element has been successfully loaded, /// RepositoryResponse.RepositoryMissingKey if the element is not contained in the repository, /// RepositoryResponse.RepositoryGenericError otherwise.</returns> public override RepositoryResponse GetByKey <DBType>(string id, ILoadable elem) { DBType entity; using (IDocumentSession _session = _store.OpenSession()) { entity = _session.Load <DBType>(id); } if (entity != null) { if (elem.LoadFromDatabaseType(entity)) { log.Debug("Data with key " + id + " loaded"); return(RepositoryResponse.RepositoryLoad); } else { return(RepositoryResponse.RepositoryGenericError); } } else { return(RepositoryResponse.RepositoryMissingKey); } }
private void FillEntityPersisterProperties(int i, OuterJoinableAssociation oj, ILoadable persister) { persisters[i] = persister; aliases[i] = oj.RHSAlias; EagerPropertyFetches[i] = oj.SelectMode == SelectMode.FetchLazyProperties; ChildFetchEntities[i] = oj.SelectMode == SelectMode.ChildFetch; }
public SimpleEntityLoader(ILoadable persister, SqlString sql, LockMode lockMode) { this.persister = new ILoadable[] { persister }; this.idType = persister.IdentifierType; this.sql = sql; this.lockMode = new LockMode[] { lockMode }; PostInstantiate(); }
//destroy the handle public void destroy() { if (resource != null) { resource.unload(); resource = null; } }
public void LoadSetLoaded() { ILoadable loadable = Sut; loadable.Load(); Assert.IsTrue(loadable.IsLoaded); }
//load layout public void Loadlayout(ILoadable employeeService) { if (!(Employees is null)) { Employees.Clear(); } Employees = employeeService.LoadAdvanced(); }
public SimpleEntityLoader( ILoadable persister, SqlString sql, LockMode lockMode ) { this.persister = new ILoadable[ ] {persister}; this.idType = persister.IdentifierType; this.sql = sql; this.lockMode = new LockMode[ ] {lockMode}; PostInstantiate(); }
private static List <Instruction> CreateInstanceMethodCallInstructions( MethodReference methodReference, ILoadable callerInstance, IPersistable returnValue, params ILoadable[] arguments) { return(CreateMethodCallInstructions(methodReference, callerInstance, returnValue, arguments)); }
/// <summary> /// Add a new loadable object to the savemanager for when the game is being loaded. /// </summary> /// <param name="saveable">Loadable to add.</param> public static void RegisterLoadable(ILoadable loadable) { if (_loadables.Contains(loadable)) { return; } _loadables.Add(loadable); }
/// <summary> /// Removes a new loadable object to the savemanager for when the game is being loaded. /// </summary> /// <param name="saveable">Loadable to remove.</param> public static void UnregisterLoadable(ILoadable loadable) { if (!_loadables.Contains(loadable)) { return; } _loadables.Remove(loadable); }
protected void InitClassPersisters(IList associations) { int joins = CountClassPersisters(associations); collectionOwner = -1; // if no collection found classPersisters = new ILoadable[joins + 1]; Owners = new int[joins + 1]; aliases = new string[joins + 1]; lockModeArray = CreateLockModeArray(joins + 1, LockMode.None); int i = 0; foreach (OuterJoinableAssociation oj in associations) { object subpersister = oj.Joinable; if (subpersister is ILoadable) { classPersisters[i] = ( ILoadable )subpersister; Owners[i] = ToOwner(oj, joins, oj.IsOneToOne); aliases[i] = oj.Subalias; if (oj.JoinType == JoinType.InnerJoin) { AddAllToPropertySpaces(classPersisters[i].PropertySpaces); } i++; } else { IQueryableCollection collPersister = ( IQueryableCollection )subpersister; // TODO: ?? suppress initialization of collections with a where condition if (oj.JoinType == JoinType.LeftOuterJoin) { collectionPersister = collPersister; collectionOwner = ToOwner(oj, joins, true); } else { AddToPropertySpaces(collPersister.CollectionSpace); } if (collPersister.IsOneToMany) { classPersisters[i] = ( ILoadable )collPersister.ElementPersister; aliases[i] = oj.Subalias; i++; } } } classPersisters[joins] = persister; Owners[joins] = -1; aliases[joins] = alias; if (ArrayHelper.IsAllNegative(Owners)) { Owners = null; } }
public void AddContent(ILoadable instance) { if (!loading) { throw new Exception(Language.GetTextValue("tModLoader.LoadErrorNotLoading")); } instance.Load(this); content.Add(instance); ContentInstance.Register(instance); }
private void RenderStatement( ILoadable[ ] persisters ) { int loadables = persisters.Length; Persisters = persisters; Suffixes = GenerateSuffixes( loadables ); lockModeArray = CreateLockModeArray( loadables, LockMode.None ); SqlString = SubstituteParams( SubstituteBrackets() ); }
public SubselectFetch(string alias, ILoadable loadable, QueryParameters queryParameters, ISet<EntityKey> resultingEntityKeys) { this.resultingEntityKeys = resultingEntityKeys; this.queryParameters = queryParameters; this.loadable = loadable; this.alias = alias; queryString = queryParameters.ProcessedSql.GetSubselectString(); }
public SubselectFetch(string alias, ILoadable loadable, QueryParameters queryParameters, ISet <EntityKey> resultingEntityKeys) { this.resultingEntityKeys = resultingEntityKeys; this.queryParameters = queryParameters; this.loadable = loadable; this.alias = alias; queryString = queryParameters.ProcessedSql.GetSubselectString(); }
/// <summary> /// Register given handler to given event as a weak reference. /// </summary> /// <param name="sender">Object to register.</param> /// <param name="handler">Handler to register.</param> public static void RegisterLoadable(ILoadable sender, EventHandler handler) { var listener = new WeakEventListener <ILoadable, object, EventArgs>(sender) { OnEventAction = (instance, source, eventArgs) => { handler.Invoke(source, eventArgs); }, OnDetachAction = (instance, weakEventListener) => instance.Loaded -= weakEventListener.OnEvent }; sender.Loaded += listener.OnEvent; }
protected void InitClassPersisters( IList associations ) { int joins = CountClassPersisters( associations ); collectionOwner = -1; // if no collection found classPersisters = new ILoadable[ joins + 1 ]; Owners = new int[ joins + 1 ]; aliases = new string[ joins + 1 ]; lockModeArray = CreateLockModeArray( joins + 1, LockMode.None ); int i = 0; foreach( OuterJoinableAssociation oj in associations ) { object subpersister = oj.Joinable; if( subpersister is ILoadable ) { classPersisters[ i ] = ( ILoadable ) subpersister; Owners[ i ] = ToOwner( oj, joins, oj.IsOneToOne ); aliases[ i ] = oj.Subalias; if( oj.JoinType == JoinType.InnerJoin ) { AddAllToPropertySpaces( classPersisters[ i ].PropertySpaces ); } i++; } else { IQueryableCollection collPersister = ( IQueryableCollection ) subpersister; // TODO: ?? suppress initialization of collections with a where condition if( oj.JoinType == JoinType.LeftOuterJoin ) { collectionPersister = collPersister; collectionOwner = ToOwner( oj, joins, true ); } else { AddToPropertySpaces( collPersister.CollectionSpace ); } if( collPersister.IsOneToMany ) { classPersisters[ i ] = ( ILoadable ) collPersister.ElementPersister; aliases[ i ] = oj.Subalias; i++; } } } classPersisters[ joins ] = persister; Owners[ joins ] = -1; aliases[ joins ] = alias; if( ArrayHelper.IsAllNegative( Owners ) ) { Owners = null; } }
public SubselectFetch(string alias, ILoadable loadable, QueryParameters queryParameters, ISet <EntityKey> resultingEntityKeys, IDictionary <string, int[]> namedParameterLocMap) { this.resultingEntityKeys = resultingEntityKeys; this.queryParameters = queryParameters; this.namedParameterLocMap = namedParameterLocMap; this.loadable = loadable; this.alias = alias; queryString = queryParameters.FilteredSQL.GetSubselectString(); }
public InstructionBlock CallInstanceMethod( MethodReference methodReference, ILoadable callerInstance, IPersistable returnValue, params ILoadable[] arguments) { var instructions = CreateInstanceMethodCallInstructions(methodReference, callerInstance, returnValue, arguments); return(new InstructionBlock("CallInstanceMethod: " + methodReference.Name, instructions)); }
public SubselectFetch(string alias, ILoadable loadable, QueryParameters queryParameters, ISet<EntityKey> resultingEntityKeys, IDictionary<string, int[]> namedParameterLocMap) { this.resultingEntityKeys = resultingEntityKeys; this.queryParameters = queryParameters; this.namedParameterLocMap = namedParameterLocMap; this.loadable = loadable; this.alias = alias; queryString = queryParameters.FilteredSQL.GetSubselectString(); }
public string[][] GetSuffixedPropertyAliases(ILoadable persister) { int size = persister.PropertyNames.Length; string[][] suffixedPropertyAliases = new string[size][]; for (int j = 0; j < size; j++) { suffixedPropertyAliases[j] = GetUserProvidedAliases(persister.PropertyNames[j], GetPropertyAliases(persister, j)); Intern(suffixedPropertyAliases[j]); } return(suffixedPropertyAliases); }
/// <summary> /// Returns default aliases for all the properties /// </summary> private string[][] GetAllPropertyAliases(ILoadable persister) { var propertyNames = persister.PropertyNames; var suffixedPropertyAliases = new string[propertyNames.Length][]; for (var i = 0; i < propertyNames.Length; i++) { suffixedPropertyAliases[i] = GetPropertyAliases(persister, i); } return(suffixedPropertyAliases); }
public void Intercept(IInvocation invocation) { ILoadable target = invocation.InvocationTarget as ILoadable; ThrowIfTargetNotLoadable(target); if (!target.IsLoaded) { target.Load(); } invocation.Proceed(); }
private string DetermineDiscriminatorAlias(ILoadable persister) { if (_userProvidedAliases != null) { var columns = GetUserProvidedAliases(AbstractEntityPersister.EntityClass); if (columns != null) { return(columns[0]); } } return(GetDiscriminatorAlias(persister, _suffix)); }
protected void InitProjection(CriteriaQueryTranslator translator, IDictionary<string, IFilter> enabledFilters, LockMode lockMode) { // the order of the calls here is important, as the join clauses can contain parameter bindings SqlString projectionString = translator.GetSelect(enabledFilters); WalkEntityTree(persister, Alias); SqlString whereString = translator.GetWhereCondition(enabledFilters); SqlString orderByString = translator.GetOrderBy(); SqlString groupByString = translator.GetGroupBy(); SqlString havingString = translator.GetHavingCondition(enabledFilters); Persisters = new ILoadable[0]; InitStatementString(projectionString, whereString, orderByString, groupByString.ToString(), havingString, lockMode); }
private void InitClassPersisters( IOuterJoinLoadable persister, IList associations ) { int joins = associations.Count; lockModeArray = CreateLockModeArray( joins + 1, LockMode.None ); classPersisters = new ILoadable[joins + 1]; Owners = new int[ joins + 1 ]; for( int i = 0; i < joins; i++ ) { OuterJoinableAssociation oj = ( OuterJoinableAssociation ) associations[ i ]; Persisters[ i ] = (ILoadable) oj.Joinable; Owners[ i ] = ToOwner( oj, joins, oj.IsOneToOne ); } classPersisters[ joins ] = persister; Owners[ joins ] = -1; if ( ArrayHelper.IsAllNegative( Owners ) ) { Owners = null; } }
private void InitClassPersisters( IList associations ) { int joins = associations.Count; lockModeArray = CreateLockModeArray( joins, LockMode.None ); classPersisters = new ILoadable[joins]; Owners = new int[joins]; int i = 0; foreach( OuterJoinableAssociation oj in associations ) { classPersisters[ i ] = ( ILoadable ) oj.Joinable; Owners[ i ] = ToOwner( oj, joins, oj.IsOneToOne ); i++; } if( ArrayHelper.IsAllNegative( Owners ) ) { Owners = null; } }
public ColumnEntityAliases(IDictionary<string, string[]> returnProperties, ILoadable persister) : base(returnProperties, persister, null) {}
private SqlString GenerateSequentialSelect(ILoadable persister) { //note that this method could easily be moved up to BasicEntityPersister, //if we ever needed to reuse it from other subclasses //figure out which tables need to be fetched AbstractEntityPersister subclassPersister = (AbstractEntityPersister)persister; HashedSet<int> tableNumbers = new HashedSet<int>(); string[] props = subclassPersister.PropertyNames; string[] classes = subclassPersister.PropertySubclassNames; for (int i = 0; i < props.Length; i++) { int propTableNumber = GetSubclassPropertyTableNumber(props[i], classes[i]); if (IsSubclassTableSequentialSelect(propTableNumber) && !IsSubclassTableLazy(propTableNumber)) { tableNumbers.Add(propTableNumber); } } if ((tableNumbers.Count == 0)) return null; //figure out which columns are needed List<int> columnNumbers = new List<int>(); int[] columnTableNumbers = SubclassColumnTableNumberClosure; for (int i = 0; i < SubclassColumnClosure.Length; i++) { if (tableNumbers.Contains(columnTableNumbers[i])) columnNumbers.Add(i); } //figure out which formulas are needed List<int> formulaNumbers = new List<int>(); int[] formulaTableNumbers = SubclassColumnTableNumberClosure; for (int i = 0; i < SubclassFormulaTemplateClosure.Length; i++) { if (tableNumbers.Contains(formulaTableNumbers[i])) formulaNumbers.Add(i); } //render the SQL return RenderSelect(ArrayHelper.ToIntArray(tableNumbers), columnNumbers.ToArray(), formulaNumbers.ToArray()); }
public string[][] GetSuffixedPropertyAliases(ILoadable persister) { int size = persister.PropertyNames.Length; string[][] suffixedPropertyAliases = new string[size][]; for (int j = 0; j < size; j++) { suffixedPropertyAliases[j] = GetUserProvidedAliases(persister.PropertyNames[j], GetPropertyAliases(persister, j)); Intern(suffixedPropertyAliases[j]); } return suffixedPropertyAliases; }
public DefaultEntityAliases(ILoadable persister, string suffix) : this(new CollectionHelper.EmptyMapClass<string, string[]>(), persister, suffix) {}
protected virtual string[] GetPropertyAliases(ILoadable persister, int j) { return persister.GetPropertyAliases(suffix, j); }
/// <summary> /// Determine the concrete class of an instance for the <c>IDataReader</c> /// </summary> private string GetInstanceClass(IDataReader rs, int i, ILoadable persister, object id, ISessionImplementor session) { if (persister.HasSubclasses) { // code to handle subclasses of topClass object discriminatorValue = persister.DiscriminatorType.NullSafeGet(rs, EntityAliases[i].SuffixedDiscriminatorAlias, session, null); string result = persister.GetSubclassForDiscriminatorValue(discriminatorValue); if (result == null) { // woops we got an instance of another class hierarchy branch. throw new WrongClassException(string.Format("Discriminator was: '{0}'", discriminatorValue), id, persister.EntityName); } return result; } else { return persister.EntityName; } }
protected override string[] GetPropertyAliases(ILoadable persister, int j) { return persister.GetPropertyColumnNames(j); }
protected override string GetDiscriminatorAlias(ILoadable persister, string suffix) { return persister.DiscriminatorColumnName; }
protected override string[] GetIdentifierAliases(ILoadable persister, string suffix) { return persister.IdentifierColumnNames; }
public ColumnEntityAliases(IDictionary returnProperties, ILoadable persister, string suffix) : base(returnProperties, persister, suffix) { }
public static void AddLoadable(ILoadable loadable) { lock (loadables) if (!loadables.Contains(loadable)) loadables.Add(loadable); }
public LoadWaiter(ILoadable[] loadables, Loader.LoadedCallbackMethod loadedCallback) { this.loadables = loadables; LoadedCallback = loadedCallback; Loader.AddLoadable(this); }
/// <summary> /// Unmarshall the fields of a persistent instance from a result set, /// without resolving associations or collections /// </summary> public object[] Hydrate(IDataReader rs, object id, object obj, ILoadable rootLoadable, string[][] suffixedPropertyColumns, bool allProperties, ISessionImplementor session) { if (log.IsDebugEnabled) { log.Debug("Hydrating entity: " + MessageHelper.InfoString(this, id, Factory)); } AbstractEntityPersister rootPersister = (AbstractEntityPersister)rootLoadable; bool hasDeferred = rootPersister.HasSequentialSelect; IDbCommand sequentialSelect = null; IDataReader sequentialResultSet = null; bool sequentialSelectEmpty = false; using (new SessionIdLoggingContext(session.SessionId)) try { if (hasDeferred) { SqlString sql = rootPersister.GetSequentialSelect(EntityName); if (sql != null) { //TODO: I am not so sure about the exception handling in this bit! sequentialSelect = session.Batcher.PrepareCommand(CommandType.Text, sql, IdentifierType.SqlTypes(factory)); rootPersister.IdentifierType.NullSafeSet(sequentialSelect, id, 0, session); sequentialResultSet = session.Batcher.ExecuteReader(sequentialSelect); if (!sequentialResultSet.Read()) { // TODO: Deal with the "optional" attribute in the <join> mapping; // this code assumes that optional defaults to "true" because it // doesn't actually seem to work in the fetch="join" code // // Note that actual proper handling of optional-ality here is actually // more involved than this patch assumes. Remember that we might have // multiple <join/> mappings associated with a single entity. Really // a couple of things need to happen to properly handle optional here: // 1) First and foremost, when handling multiple <join/>s, we really // should be using the entity root table as the driving table; // another option here would be to choose some non-optional joined // table to use as the driving table. In all likelihood, just using // the root table is much simplier // 2) Need to add the FK columns corresponding to each joined table // to the generated select list; these would then be used when // iterating the result set to determine whether all non-optional // data is present // My initial thoughts on the best way to deal with this would be // to introduce a new SequentialSelect abstraction that actually gets // generated in the persisters (ok, SingleTable...) and utilized here. // It would encapsulated all this required optional-ality checking... sequentialSelectEmpty = true; } } } string[] propNames = PropertyNames; IType[] types = PropertyTypes; object[] values = new object[types.Length]; bool[] laziness = PropertyLaziness; string[] propSubclassNames = SubclassPropertySubclassNameClosure; for (int i = 0; i < types.Length; i++) { if (!propertySelectable[i]) { values[i] = BackrefPropertyAccessor.Unknown; } else if (allProperties || !laziness[i]) { //decide which ResultSet to get the property value from: bool propertyIsDeferred = hasDeferred && rootPersister.IsSubclassPropertyDeferred(propNames[i], propSubclassNames[i]); if (propertyIsDeferred && sequentialSelectEmpty) { values[i] = null; } else { IDataReader propertyResultSet = propertyIsDeferred ? sequentialResultSet : rs; string[] cols = propertyIsDeferred ? propertyColumnAliases[i] : suffixedPropertyColumns[i]; values[i] = types[i].Hydrate(propertyResultSet, cols, session, obj); } } else { values[i] = LazyPropertyInitializer.UnfetchedProperty; } } if (sequentialResultSet != null) { sequentialResultSet.Close(); } return values; } finally { if (sequentialSelect != null) { session.Batcher.CloseCommand(sequentialSelect, sequentialResultSet); } } }
protected virtual string[] GetIdentifierAliases(ILoadable persister, string suffix) { return persister.GetIdentifierAliases(suffix); }
/// <summary> /// The entity instance is not in the session cache /// </summary> private object InstanceNotYetLoaded(IDataReader dr, int i, ILoadable persister, EntityKey key, LockMode lockMode, string rowIdAlias, EntityKey optionalObjectKey, object optionalObject, IList hydratedObjects, ISessionImplementor session) { object obj; string instanceClass = GetInstanceClass(dr, i, persister, key.Identifier, session); if (optionalObjectKey != null && key.Equals(optionalObjectKey)) { // its the given optional object obj = optionalObject; } else { obj = session.Instantiate(instanceClass, key.Identifier); } // need to hydrate it // grab its state from the DataReader and keep it in the Session // (but don't yet initialize the object itself) // note that we acquired LockMode.READ even if it was not requested LockMode acquiredLockMode = lockMode == LockMode.None ? LockMode.Read : lockMode; LoadFromResultSet(dr, i, obj, instanceClass, key, rowIdAlias, acquiredLockMode, persister, session); // materialize associations (and initialize the object) later hydratedObjects.Add(obj); return obj; }
/// <summary> /// Resolve any ids for currently loaded objects, duplications within the <c>IDataReader</c>, /// etc. Instanciate empty objects to be initialized from the <c>IDataReader</c>. Return an /// array of objects (a row of results) and an array of booleans (by side-effect) that determine /// wheter the corresponding object should be initialized /// </summary> private object[] GetRow(IDataReader rs, ILoadable[] persisters, EntityKey[] keys, object optionalObject, EntityKey optionalObjectKey, LockMode[] lockModes, IList hydratedObjects, ISessionImplementor session) { int cols = persisters.Length; IEntityAliases[] descriptors = EntityAliases; if (log.IsDebugEnabled) { log.Debug("result row: " + StringHelper.ToString(keys)); } object[] rowResults = new object[cols]; for (int i = 0; i < cols; i++) { object obj = null; EntityKey key = keys[i]; if (keys[i] == null) { // do nothing /* TODO NH-1001 : if (persisters[i]...EntityType) is an OneToMany or a ManyToOne and * the keys.length > 1 and the relation IsIgnoreNotFound probably we are in presence of * an load with "outer join" the relation can be considerer loaded even if the key is null (mean not found) */ } else { //If the object is already loaded, return the loaded one obj = session.GetEntityUsingInterceptor(key); if (obj != null) { //its already loaded so dont need to hydrate it InstanceAlreadyLoaded(rs, i, persisters[i], key, obj, lockModes[i], session); } else { obj = InstanceNotYetLoaded(rs, i, persisters[i], key, lockModes[i], descriptors[i].RowIdAlias, optionalObjectKey, optionalObject, hydratedObjects, session); } } rowResults[i] = obj; } return rowResults; }
protected void InitProjection(SqlString projectionString, SqlString whereString, SqlString orderByString, SqlString groupByString, SqlString havingString, IDictionary<string, IFilter> enabledFilters, LockMode lockMode) { WalkEntityTree(persister, Alias); Persisters = new ILoadable[0]; InitStatementString(projectionString, whereString, orderByString, groupByString.ToString(), havingString, lockMode); }
/// <summary> /// Hydrate the state of an object from the SQL <c>IDataReader</c>, into /// an array of "hydrated" values (do not resolve associations yet), /// and pass the hydrated state to the session. /// </summary> private void LoadFromResultSet(IDataReader rs, int i, object obj, string instanceClass, EntityKey key, string rowIdAlias, LockMode lockMode, ILoadable rootPersister, ISessionImplementor session) { object id = key.Identifier; // Get the persister for the _subclass_ ILoadable persister = (ILoadable) Factory.GetEntityPersister(instanceClass); if (log.IsDebugEnabled) { log.Debug("Initializing object from DataReader: " + MessageHelper.InfoString(persister, id)); } bool eagerPropertyFetch = IsEagerPropertyFetchEnabled(i); // add temp entry so that the next step is circular-reference // safe - only needed because some types don't take proper // advantage of two-phase-load (esp. components) TwoPhaseLoad.AddUninitializedEntity(key, obj, persister, lockMode, !eagerPropertyFetch, session); // This is not very nice (and quite slow): string[][] cols = persister == rootPersister ? EntityAliases[i].SuffixedPropertyAliases : EntityAliases[i].GetSuffixedPropertyAliases(persister); object[] values = persister.Hydrate(rs, id, obj, rootPersister, cols, eagerPropertyFetch, session); object rowId = persister.HasRowId ? rs[rowIdAlias] : null; IAssociationType[] ownerAssociationTypes = OwnerAssociationTypes; if (ownerAssociationTypes != null && ownerAssociationTypes[i] != null) { string ukName = ownerAssociationTypes[i].RHSUniqueKeyPropertyName; if (ukName != null) { int index = ((IUniqueKeyLoadable) persister).GetPropertyIndex(ukName); IType type = persister.PropertyTypes[index]; // polymorphism not really handled completely correctly, // perhaps...well, actually its ok, assuming that the // entity name used in the lookup is the same as the // the one used here, which it will be EntityUniqueKey euk = new EntityUniqueKey(rootPersister.EntityName, ukName, type.SemiResolve(values[index], session, obj), type, session.EntityMode, session.Factory); session.PersistenceContext.AddEntity(euk, obj); } } TwoPhaseLoad.PostHydrate(persister, id, values, rowId, obj, lockMode, !eagerPropertyFetch, session); }
protected virtual string GetDiscriminatorAlias(ILoadable persister, string suffix) { return persister.GetDiscriminatorAlias(suffix); }