This is a session that is constructed around a given user and a transaction, to the given database. More...

Inheritance diagram for Deveel.Data.Session:

Public Member Functions
	Session (ITransaction transaction, User user)
	Constructs the session for the given user and transaction to the given database. More...

void	Dispose ()

void	Access (IEnumerable< IDbObject > objects, AccessType accessType)

void	Exit (IEnumerable< IDbObject > objects, AccessType accessType)

void	Lock (IEnumerable< IDbObject > objects, AccessType accessType, LockingMode mode)

void	Commit ()
	Commits the latest changes made by the user in the session. More...

void	Rollback ()
	Rolls-back all the modifications made by the user in this session More...

IQuery	CreateQuery ()

Properties
string	CurrentSchema `[get]`

DateTimeOffset	LastCommandTime `[get, private set]`

DateTimeOffset	StartedOn `[get, private set]`

ISessionContext	Context `[get, private set]`

User	User `[get, private set]`

IEventSource IEventSource.	ParentSource `[get]`

IContext IEventSource.	Context `[get]`

IEnumerable< KeyValuePair< string, object > > IEventSource.	Metadata `[get]`

ITransaction	Transaction `[get, private set]`

IDatabase	Database `[get]`

Properties inherited from Deveel.Data.ISession
string	CurrentSchema `[get]`
	Gets the name of the current schema of this session. More...

DateTimeOffset	StartedOn `[get]`

DateTimeOffset	LastCommandTime `[get]`

User	User `[get]`

ITransaction	Transaction `[get]`
	Gets the instance of ITransaction that handles the transactional operations of this session. More...

new ISessionContext	Context `[get]`

Properties inherited from Deveel.Data.Diagnostics.IEventSource
IContext	Context `[get]`

IEventSource	ParentSource `[get]`
	Gets an optional parent source. More...

IEnumerable< KeyValuePair< string, object > >	Metadata `[get]`
	Gets the list of metadata associated to the source. More...

Private Member Functions
	~Session ()

IEnumerable< KeyValuePair< string, object > >	GetMetadata ()

void	AssertNotDisposed ()

void	CheckAccess (ILockable[] lockables, AccessType accessType)

void	ReleaseLocks ()

void	OnCommand ()

void	DisposeTransaction ()

void	Dispose (bool disposing)

Private Attributes
List< LockHandle >	lockHandles

bool	disposed

Detailed Description

This is a session that is constructed around a given user and a transaction, to the given database.

Definition at line 32 of file Session.cs.

Constructor & Destructor Documentation

Deveel.Data.Session.Session	(	ITransaction	transaction,
		User	user
	)

inline

Constructs the session for the given user and transaction to the given database.

Parameters

transaction	A transaction that handles the commands issued by the user during the session.
user

See also: ITransaction

Definition at line 44 of file Session.cs.

                                                             {
             if (transaction == null)
                 throw new ArgumentNullException("transaction");
             
             if (user == null)
                 throw new ArgumentNullException("user");
 
             if (user.IsSystem || user.IsPublic)
                 throw new ArgumentException(String.Format("Cannot open a session for user '{0}'.", user.Name));
 
             Transaction = transaction;
             Context = transaction.Context.CreateSessionContext();
 
             transaction.Database.Sessions.Add(this);
 
             User = user;
             StartedOn = DateTimeOffset.UtcNow;
         }

Deveel.Data.Session.~Session ( )

inlineprivate

Definition at line 63 of file Session.cs.

                    {
             Dispose(false);
         }

Member Function Documentation

void Deveel.Data.Session.Access	(	IEnumerable< IDbObject >	objects,
		AccessType	accessType
	)

inline

Implements Deveel.Data.ISession.

Definition at line 111 of file Session.cs.

                                                                                   {
             if (Database == null)
                 return;
 
             lock (Database) {
                 var lockables = objects.OfType<ILockable>().ToArray();
                 if (lockables.Length == 0)
                     return;
 
                 CheckAccess(lockables, accessType);
 
                 var isolation = Transaction.Isolation;
 
                 LockHandle handle;
 
                 if (isolation == IsolationLevel.Serializable) {
                     handle = Database.Locker.Lock(lockables, AccessType.ReadWrite, LockingMode.Exclusive);
                 } else {
                     throw new NotImplementedException(string.Format("The locking for isolation '{0}' is not implemented yet.", isolation));
                 }
 
                 if (handle != null) {
                     if (lockHandles == null)
                         lockHandles = new List<LockHandle>();
 
                     lockHandles.Add(handle);
                 }
             }
         }

void Deveel.Data.Session.AssertNotDisposed ( )

inlineprivate

Definition at line 106 of file Session.cs.

                                          {
             if (disposed)
                 throw new ObjectDisposedException("Session");
         }

void Deveel.Data.Session.CheckAccess	(	ILockable[]	lockables,
		AccessType	accessType
	)

inlineprivate

Definition at line 166 of file Session.cs.

                                                                                {
             if (lockHandles == null || lockables == null)
                 return;
 
             foreach (var handle in lockHandles) {
                 foreach (var lockable in lockables) {
                     if (handle.IsHandled(lockable))
                         handle.CheckAccess(lockable, accessType);
                 }
             }
         }

void Deveel.Data.Session.Commit ( )

inline

Commits the latest changes made by the user in the session.

See also: ITransaction

Implements Deveel.Data.ISession.

Definition at line 200 of file Session.cs.

                              {
             AssertNotDisposed();
 
             if (Transaction != null) {
                 try {
                     Transaction.Commit();
                 } finally {
                     OnCommand();
                     DisposeTransaction();
                 }
             }
         }

IQuery Deveel.Data.Session.CreateQuery ( )

inline

Implements Deveel.Data.ISession.

Definition at line 235 of file Session.cs.

                                     {
             return new Query(this);
         }

void Deveel.Data.Session.Dispose ( )

inline

Definition at line 67 of file Session.cs.

                               {
             Dispose(true);
             GC.SuppressFinalize(this);
         }

void Deveel.Data.Session.Dispose ( bool disposing )

inlineprivate

Definition at line 239 of file Session.cs.

                                              {
             if (!disposed) {
                 if (disposing) {
                     try {
                         Rollback();
                     } catch (Exception) {
                         // TODO: Notify the underlying system
                     }
                 }
 
                 lockHandles = null;
                 disposed = true;
             }
         }

void Deveel.Data.Session.DisposeTransaction ( )

inlineprivate

Definition at line 226 of file Session.cs.

                                           {
             ReleaseLocks();
 
             if (Database != null)
                 Database.Sessions.Remove(this);
 
             Transaction = null;
         }

void Deveel.Data.Session.Exit	(	IEnumerable< IDbObject >	objects,
		AccessType	accessType
	)

inline

Implements Deveel.Data.ISession.

Definition at line 141 of file Session.cs.

                                                                                 {
             // Only SERIALIZABLE isolation is supported, that means locks for read and write
             //    are acquired on access and released only at the end of the session/transaction
             throw new NotImplementedException("The Exit mechanism is not implemented");
         }

IEnumerable<KeyValuePair<string, object> > Deveel.Data.Session.GetMetadata ( )

inlineprivate

Definition at line 96 of file Session.cs.

                                                                         {
             return new Dictionary<string, object> {
                 { KnownEventMetadata.UserName, User.Name },
                 { KnownEventMetadata.LastCommandTime, LastCommandTime },
                 { KnownEventMetadata.SessionStartTime, StartedOn },
             };
         }

void Deveel.Data.Session.Lock	(	IEnumerable< IDbObject >	objects,
		AccessType	accessType,
		LockingMode	mode
	)

inline

Implements Deveel.Data.ISession.

Definition at line 147 of file Session.cs.

                                                                                                   {
             lock (Database) {
                 var lockables = objects.OfType<ILockable>().ToArray();
                 if (lockables.Length == 0)
                     return;
 
                 // Before we can lock the objects, we must wait for them
                 //  to be available...
                 CheckAccess(lockables, accessType);
 
                 var handle = Database.Locker.Lock(lockables, accessType, mode);
 
                 if (lockHandles == null)
                     lockHandles = new List<LockHandle>();
 
                 lockHandles.Add(handle);
             }
         }

void Deveel.Data.Session.OnCommand ( )

inlineprivate

Definition at line 196 of file Session.cs.

                                  {
             LastCommandTime = DateTimeOffset.UtcNow;
         }

void Deveel.Data.Session.ReleaseLocks ( )

inlineprivate

Definition at line 178 of file Session.cs.

                                     {
             if (Database == null)
                 return;
 
             lock (Database) {
                 if (lockHandles != null) {
                     foreach (var handle in lockHandles) {
                         if (handle != null)
                             handle.Release();
                     }
                 }
             }
         }

void Deveel.Data.Session.Rollback ( )

inline

Rolls-back all the modifications made by the user in this session

Implements Deveel.Data.ISession.

Definition at line 213 of file Session.cs.

                                {
             AssertNotDisposed();
 
             if (Transaction != null) {
                 try {
                     Transaction.Rollback();
                 } finally {
                     OnCommand();
                     DisposeTransaction();
                 }
             }
         }

Member Data Documentation

bool Deveel.Data.Session.disposed

private

Definition at line 34 of file Session.cs.

List<LockHandle> Deveel.Data.Session.lockHandles

private

Definition at line 33 of file Session.cs.

Property Documentation

ISessionContext Deveel.Data.Session.Context

getprivate set

Definition at line 80 of file Session.cs.

IContext IEventSource. Deveel.Data.Session.Context

getprivate

Definition at line 88 of file Session.cs.

string Deveel.Data.Session.CurrentSchema

get

Definition at line 72 of file Session.cs.

IDatabase Deveel.Data.Session.Database

get

Definition at line 192 of file Session.cs.

DateTimeOffset Deveel.Data.Session.LastCommandTime

getprivate set

Definition at line 76 of file Session.cs.

IEnumerable<KeyValuePair<string, object> > IEventSource. Deveel.Data.Session.Metadata

getprivate

Definition at line 92 of file Session.cs.

IEventSource IEventSource. Deveel.Data.Session.ParentSource

getprivate

Definition at line 84 of file Session.cs.

DateTimeOffset Deveel.Data.Session.StartedOn

getprivate set

Definition at line 78 of file Session.cs.

ITransaction Deveel.Data.Session.Transaction

getprivate set

Definition at line 104 of file Session.cs.

User Deveel.Data.Session.User

getprivate set

Definition at line 82 of file Session.cs.

The documentation for this class was generated from the following file:

/var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb/Deveel.Data/Session.cs

Public Member Functions

Properties

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation