Changeset 12441 for branches/HiveStatistics/sources/HeuristicLab.Services.Hive.DataAccess/3.3/HiveDataContext.designer.cs

Timestamp:

06/12/15 17:04:39 (9 years ago)

Author:

dglaser

Message:

#2388: Restored files/settings from old HiveStatistics branch

File:

• branches/HiveStatistics/sources/HeuristicLab.Services.Hive.DataAccess/3.3/HiveDataContext.designer.cs (modified) (4 diffs)

branches/HiveStatistics/sources/HeuristicLab.Services.Hive.DataAccess/3.3/HiveDataContext.designer.cs

@@ -23 +23 @@
   
   
-  [global::System.Data.Linq.Mapping.DatabaseAttribute(Name="HeuristicLab.Hive")]
+  [global::System.Data.Linq.Mapping.DatabaseAttribute(Name="HeuristicLab.Hive-3.3")]
   public partial class HiveDataContext : System.Data.Linq.DataContext
   {
@@ -85 +85 @@
     partial void UpdateUserPriority(UserPriority instance);
     partial void DeleteUserPriority(UserPriority instance);
+    partial void InsertDimClient(DimClient instance);
+    partial void UpdateDimClient(DimClient instance);
+    partial void DeleteDimClient(DimClient instance);
+    partial void InsertFactTask(FactTask instance);
+    partial void UpdateFactTask(FactTask instance);
+    partial void DeleteFactTask(FactTask instance);
+    partial void InsertDimJob(DimJob instance);
+    partial void UpdateDimJob(DimJob instance);
+    partial void DeleteDimJob(DimJob instance);
+    partial void InsertDimTime(DimTime instance);
+    partial void UpdateDimTime(DimTime instance);
+    partial void DeleteDimTime(DimTime instance);
+    partial void InsertDimUser(DimUser instance);
+    partial void UpdateDimUser(DimUser instance);
+    partial void DeleteDimUser(DimUser instance);
+    partial void InsertFactClientInfo(FactClientInfo instance);
+    partial void UpdateFactClientInfo(FactClientInfo instance);
+    partial void DeleteFactClientInfo(FactClientInfo instance);
     #endregion
     
@@ -258 +276 @@
       {
         return this.GetTable<UserPriority>();
+      }
+    }
+    
+    public System.Data.Linq.Table<DimClient> DimClients
+    {
+      get
+      {
+        return this.GetTable<DimClient>();
+      }
+    }
+    
+    public System.Data.Linq.Table<FactTask> FactTasks
+    {
+      get
+      {
+        return this.GetTable<FactTask>();
+      }
+    }
+    
+    public System.Data.Linq.Table<DimJob> DimJobs
+    {
+      get
+      {
+        return this.GetTable<DimJob>();
+      }
+    }
+    
+    public System.Data.Linq.Table<DimTime> DimTimes
+    {
+      get
+      {
+        return this.GetTable<DimTime>();
+      }
+    }
+    
+    public System.Data.Linq.Table<DimUser> DimUsers
+    {
+      get
+      {
+        return this.GetTable<DimUser>();
+      }
+    }
+    
+    public System.Data.Linq.Table<FactClientInfo> FactClientInfos
+    {
+      get
+      {
+        return this.GetTable<FactClientInfo>();
       }
     }
@@ -4534 +4600 @@
     }
   }
+  
+  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimClient")]
+  public partial class DimClient : INotifyPropertyChanging, INotifyPropertyChanged
+  {
+    
+    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
+    
+    private System.Guid _Id;
+    
+    private string _Name;
+    
+    private System.Guid _ResourceId;
+    
+    private System.Nullable<System.DateTime> _ExpirationTime;
+    
+    private System.Nullable<System.Guid> _ResourceGroupId;
+    
+    private System.Nullable<System.Guid> _ResourceGroup2Id;
+    
+    private EntitySet<FactTask> _FactTasks;
+    
+    private EntitySet<FactClientInfo> _FactClientInfos;
+    
+    #region Extensibility Method Definitions
+    partial void OnLoaded();
+    partial void OnValidate(System.Data.Linq.ChangeAction action);
+    partial void OnCreated();
+    partial void OnIdChanging(System.Guid value);
+    partial void OnIdChanged();
+    partial void OnNameChanging(string value);
+    partial void OnNameChanged();
+    partial void OnResourceIdChanging(System.Guid value);
+    partial void OnResourceIdChanged();
+    partial void OnExpirationTimeChanging(System.Nullable<System.DateTime> value);
+    partial void OnExpirationTimeChanged();
+    partial void OnResourceGroupIdChanging(System.Nullable<System.Guid> value);
+    partial void OnResourceGroupIdChanged();
+    partial void OnResourceGroup2IdChanging(System.Nullable<System.Guid> value);
+    partial void OnResourceGroup2IdChanged();
+    #endregion
+    
+    public DimClient()
+    {
+      this._FactTasks = new EntitySet<FactTask>(new Action<FactTask>(this.attach_FactTasks), new Action<FactTask>(this.detach_FactTasks));
+      this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
+      OnCreated();
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
+    public System.Guid Id
+    {
+      get
+      {
+        return this._Id;
+      }
+      set
+      {
+        if ((this._Id != value))
+        {
+          this.OnIdChanging(value);
+          this.SendPropertyChanging();
+          this._Id = value;
+          this.SendPropertyChanged("Id");
+          this.OnIdChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
+    public string Name
+    {
+      get
+      {
+        return this._Name;
+      }
+      set
+      {
+        if ((this._Name != value))
+        {
+          this.OnNameChanging(value);
+          this.SendPropertyChanging();
+          this._Name = value;
+          this.SendPropertyChanged("Name");
+          this.OnNameChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL")]
+    public System.Guid ResourceId
+    {
+      get
+      {
+        return this._ResourceId;
+      }
+      set
+      {
+        if ((this._ResourceId != value))
+        {
+          this.OnResourceIdChanging(value);
+          this.SendPropertyChanging();
+          this._ResourceId = value;
+          this.SendPropertyChanged("ResourceId");
+          this.OnResourceIdChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExpirationTime", DbType="DateTime")]
+    public System.Nullable<System.DateTime> ExpirationTime
+    {
+      get
+      {
+        return this._ExpirationTime;
+      }
+      set
+      {
+        if ((this._ExpirationTime != value))
+        {
+          this.OnExpirationTimeChanging(value);
+          this.SendPropertyChanging();
+          this._ExpirationTime = value;
+          this.SendPropertyChanged("ExpirationTime");
+          this.OnExpirationTimeChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceGroupId", DbType="UniqueIdentifier")]
+    public System.Nullable<System.Guid> ResourceGroupId
+    {
+      get
+      {
+        return this._ResourceGroupId;
+      }
+      set
+      {
+        if ((this._ResourceGroupId != value))
+        {
+          this.OnResourceGroupIdChanging(value);
+          this.SendPropertyChanging();
+          this._ResourceGroupId = value;
+          this.SendPropertyChanged("ResourceGroupId");
+          this.OnResourceGroupIdChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceGroup2Id", DbType="UniqueIdentifier")]
+    public System.Nullable<System.Guid> ResourceGroup2Id
+    {
+      get
+      {
+        return this._ResourceGroup2Id;
+      }
+      set
+      {
+        if ((this._ResourceGroup2Id != value))
+        {
+          this.OnResourceGroup2IdChanging(value);
+          this.SendPropertyChanging();
+          this._ResourceGroup2Id = value;
+          this.SendPropertyChanged("ResourceGroup2Id");
+          this.OnResourceGroup2IdChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactTask", Storage="_FactTasks", ThisKey="Id", OtherKey="LastClientId")]
+    public EntitySet<FactTask> FactTasks
+    {
+      get
+      {
+        return this._FactTasks;
+      }
+      set
+      {
+        this._FactTasks.Assign(value);
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactClientInfo", Storage="_FactClientInfos", ThisKey="Id", OtherKey="ClientId")]
+    public EntitySet<FactClientInfo> FactClientInfos
+    {
+      get
+      {
+        return this._FactClientInfos;
+      }
+      set
+      {
+        this._FactClientInfos.Assign(value);
+      }
+    }
+    
+    public event PropertyChangingEventHandler PropertyChanging;
+    
+    public event PropertyChangedEventHandler PropertyChanged;
+    
+    protected virtual void SendPropertyChanging()
+    {
+      if ((this.PropertyChanging != null))
+      {
+        this.PropertyChanging(this, emptyChangingEventArgs);
+      }
+    }
+    
+    protected virtual void SendPropertyChanged(String propertyName)
+    {
+      if ((this.PropertyChanged != null))
+      {
+        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
+      }
+    }
+    
+    private void attach_FactTasks(FactTask entity)
+    {
+      this.SendPropertyChanging();
+      entity.DimClient = this;
+    }
+    
+    private void detach_FactTasks(FactTask entity)
+    {
+      this.SendPropertyChanging();
+      entity.DimClient = null;
+    }
+    
+    private void attach_FactClientInfos(FactClientInfo entity)
+    {
+      this.SendPropertyChanging();
+      entity.DimClient = this;
+    }
+    
+    private void detach_FactClientInfos(FactClientInfo entity)
+    {
+      this.SendPropertyChanging();
+      entity.DimClient = null;
+    }
+  }
+  
+  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].FactTask")]
+  public partial class FactTask : INotifyPropertyChanging, INotifyPropertyChanged
+  {
+    
+    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
+    
+    private System.Guid _TaskId;
+    
+    private double _TotalRuntime;
+    
+    private double _TotalWaitingTime;
+    
+    private double _TotalTransferTime;
+    
+    private int _NumCalculationRuns;
+    
+    private int _NumFails;
+    
+    private int _CoresRequired;
+    
+    private int _MemoryRequired;
+    
+    private int _Priority;
+    
+    private System.Guid _LastClientId;
+    
+    private System.Guid _JobId;
+    
+    private System.DateTime _StartTime;
+    
+    private System.Nullable<System.DateTime> _EndTime;
+    
+    private global::HeuristicLab.Services.Hive.DataAccess.TaskState _TaskState;
+    
+    private string _Exception;
+    
+    private EntityRef<DimClient> _DimClient;
+    
+    private EntityRef<DimJob> _DimJob;
+    
+    private EntityRef<DimTime> _DimTime;
+    
+    private EntityRef<DimTime> _DimTime1;
+    
+    #region Extensibility Method Definitions
+    partial void OnLoaded();
+    partial void OnValidate(System.Data.Linq.ChangeAction action);
+    partial void OnCreated();
+    partial void OnTaskIdChanging(System.Guid value);
+    partial void OnTaskIdChanged();
+    partial void OnTotalRuntimeChanging(double value);
+    partial void OnTotalRuntimeChanged();
+    partial void OnTotalWaitingTimeChanging(double value);
+    partial void OnTotalWaitingTimeChanged();
+    partial void OnTotalTransferTimeChanging(double value);
+    partial void OnTotalTransferTimeChanged();
+    partial void OnNumCalculationRunsChanging(int value);
+    partial void OnNumCalculationRunsChanged();
+    partial void OnNumRetriesChanging(int value);
+    partial void OnNumRetriesChanged();
+    partial void OnCoresRequiredChanging(int value);
+    partial void OnCoresRequiredChanged();
+    partial void OnMemoryRequiredChanging(int value);
+    partial void OnMemoryRequiredChanged();
+    partial void OnPriorityChanging(int value);
+    partial void OnPriorityChanged();
+    partial void OnLastClientIdChanging(System.Guid value);
+    partial void OnLastClientIdChanged();
+    partial void OnJobIdChanging(System.Guid value);
+    partial void OnJobIdChanged();
+    partial void OnStartTimeChanging(System.DateTime value);
+    partial void OnStartTimeChanged();
+    partial void OnEndTimeChanging(System.Nullable<System.DateTime> value);
+    partial void OnEndTimeChanged();
+    partial void OnTaskStateChanging(global::HeuristicLab.Services.Hive.DataAccess.TaskState value);
+    partial void OnTaskStateChanged();
+    partial void OnExceptionChanging(string value);
+    partial void OnExceptionChanged();
+    #endregion
+    
+    public FactTask()
+    {
+      this._DimClient = default(EntityRef<DimClient>);
+      this._DimJob = default(EntityRef<DimJob>);
+      this._DimTime = default(EntityRef<DimTime>);
+      this._DimTime1 = default(EntityRef<DimTime>);
+      OnCreated();
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TaskId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
+    public System.Guid TaskId
+    {
+      get
+      {
+        return this._TaskId;
+      }
+      set
+      {
+        if ((this._TaskId != value))
+        {
+          this.OnTaskIdChanging(value);
+          this.SendPropertyChanging();
+          this._TaskId = value;
+          this.SendPropertyChanged("TaskId");
+          this.OnTaskIdChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalRuntime", DbType="Float NOT NULL")]
+    public double TotalRuntime
+    {
+      get
+      {
+        return this._TotalRuntime;
+      }
+      set
+      {
+        if ((this._TotalRuntime != value))
+        {
+          this.OnTotalRuntimeChanging(value);
+          this.SendPropertyChanging();
+          this._TotalRuntime = value;
+          this.SendPropertyChanged("TotalRuntime");
+          this.OnTotalRuntimeChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalWaitingTime", DbType="Float NOT NULL")]
+    public double TotalWaitingTime
+    {
+      get
+      {
+        return this._TotalWaitingTime;
+      }
+      set
+      {
+        if ((this._TotalWaitingTime != value))
+        {
+          this.OnTotalWaitingTimeChanging(value);
+          this.SendPropertyChanging();
+          this._TotalWaitingTime = value;
+          this.SendPropertyChanged("TotalWaitingTime");
+          this.OnTotalWaitingTimeChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTransferTime", DbType="Float NOT NULL")]
+    public double TotalTransferTime
+    {
+      get
+      {
+        return this._TotalTransferTime;
+      }
+      set
+      {
+        if ((this._TotalTransferTime != value))
+        {
+          this.OnTotalTransferTimeChanging(value);
+          this.SendPropertyChanging();
+          this._TotalTransferTime = value;
+          this.SendPropertyChanged("TotalTransferTime");
+          this.OnTotalTransferTimeChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumCalculationRuns", DbType="Int NOT NULL")]
+    public int NumCalculationRuns
+    {
+      get
+      {
+        return this._NumCalculationRuns;
+      }
+      set
+      {
+        if ((this._NumCalculationRuns != value))
+        {
+          this.OnNumCalculationRunsChanging(value);
+          this.SendPropertyChanging();
+          this._NumCalculationRuns = value;
+          this.SendPropertyChanged("NumCalculationRuns");
+          this.OnNumCalculationRunsChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumFails", DbType="Int NOT NULL")]
+    public int NumRetries
+    {
+      get
+      {
+        return this._NumFails;
+      }
+      set
+      {
+        if ((this._NumFails != value))
+        {
+          this.OnNumRetriesChanging(value);
+          this.SendPropertyChanging();
+          this._NumFails = value;
+          this.SendPropertyChanged("NumRetries");
+          this.OnNumRetriesChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CoresRequired", DbType="Int NOT NULL")]
+    public int CoresRequired
+    {
+      get
+      {
+        return this._CoresRequired;
+      }
+      set
+      {
+        if ((this._CoresRequired != value))
+        {
+          this.OnCoresRequiredChanging(value);
+          this.SendPropertyChanging();
+          this._CoresRequired = value;
+          this.SendPropertyChanged("CoresRequired");
+          this.OnCoresRequiredChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_MemoryRequired", DbType="Int NOT NULL")]
+    public int MemoryRequired
+    {
+      get
+      {
+        return this._MemoryRequired;
+      }
+      set
+      {
+        if ((this._MemoryRequired != value))
+        {
+          this.OnMemoryRequiredChanging(value);
+          this.SendPropertyChanging();
+          this._MemoryRequired = value;
+          this.SendPropertyChanged("MemoryRequired");
+          this.OnMemoryRequiredChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Priority", DbType="Int NOT NULL")]
+    public int Priority
+    {
+      get
+      {
+        return this._Priority;
+      }
+      set
+      {
+        if ((this._Priority != value))
+        {
+          this.OnPriorityChanging(value);
+          this.SendPropertyChanging();
+          this._Priority = value;
+          this.SendPropertyChanged("Priority");
+          this.OnPriorityChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastClientId", DbType="UniqueIdentifier NOT NULL")]
+    public System.Guid LastClientId
+    {
+      get
+      {
+        return this._LastClientId;
+      }
+      set
+      {
+        if ((this._LastClientId != value))
+        {
+          if (this._DimClient.HasLoadedOrAssignedValue)
+          {
+            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
+          }
+          this.OnLastClientIdChanging(value);
+          this.SendPropertyChanging();
+          this._LastClientId = value;
+          this.SendPropertyChanged("LastClientId");
+          this.OnLastClientIdChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL")]
+    public System.Guid JobId
+    {
+      get
+      {
+        return this._JobId;
+      }
+      set
+      {
+        if ((this._JobId != value))
+        {
+          if (this._DimJob.HasLoadedOrAssignedValue)
+          {
+            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
+          }
+          this.OnJobIdChanging(value);
+          this.SendPropertyChanging();
+          this._JobId = value;
+          this.SendPropertyChanged("JobId");
+          this.OnJobIdChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartTime", DbType="DateTime NOT NULL")]
+    public System.DateTime StartTime
+    {
+      get
+      {
+        return this._StartTime;
+      }
+      set
+      {
+        if ((this._StartTime != value))
+        {
+          if (this._DimTime1.HasLoadedOrAssignedValue)
+          {
+            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
+          }
+          this.OnStartTimeChanging(value);
+          this.SendPropertyChanging();
+          this._StartTime = value;
+          this.SendPropertyChanged("StartTime");
+          this.OnStartTimeChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_EndTime", DbType="DateTime NOT NULL")]
+    public System.Nullable<System.DateTime> EndTime
+    {
+      get
+      {
+        return this._EndTime;
+      }
+      set
+      {
+        if ((this._EndTime != value))
+        {
+          if (this._DimTime.HasLoadedOrAssignedValue)
+          {
+            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
+          }
+          this.OnEndTimeChanging(value);
+          this.SendPropertyChanging();
+          this._EndTime = value;
+          this.SendPropertyChanged("EndTime");
+          this.OnEndTimeChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TaskState", DbType="varchar(30)", CanBeNull=false)]
+    public global::HeuristicLab.Services.Hive.DataAccess.TaskState TaskState
+    {
+      get
+      {
+        return this._TaskState;
+      }
+      set
+      {
+        if ((this._TaskState != value))
+        {
+          this.OnTaskStateChanging(value);
+          this.SendPropertyChanging();
+          this._TaskState = value;
+          this.SendPropertyChanged("TaskState");
+          this.OnTaskStateChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Exception", DbType="varchar(MAX)")]
+    public string Exception
+    {
+      get
+      {
+        return this._Exception;
+      }
+      set
+      {
+        if ((this._Exception != value))
+        {
+          this.OnExceptionChanging(value);
+          this.SendPropertyChanging();
+          this._Exception = value;
+          this.SendPropertyChanged("Exception");
+          this.OnExceptionChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactTask", Storage="_DimClient", ThisKey="LastClientId", OtherKey="Id", IsForeignKey=true)]
+    public DimClient DimClient
+    {
+      get
+      {
+        return this._DimClient.Entity;
+      }
+      set
+      {
+        DimClient previousValue = this._DimClient.Entity;
+        if (((previousValue != value) 
+              || (this._DimClient.HasLoadedOrAssignedValue == false)))
+        {
+          this.SendPropertyChanging();
+          if ((previousValue != null))
+          {
+            this._DimClient.Entity = null;
+            previousValue.FactTasks.Remove(this);
+          }
+          this._DimClient.Entity = value;
+          if ((value != null))
+          {
+            value.FactTasks.Add(this);
+            this._LastClientId = value.Id;
+          }
+          else
+          {
+            this._LastClientId = default(System.Guid);
+          }
+          this.SendPropertyChanged("DimClient");
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimJob_FactTask", Storage="_DimJob", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true)]
+    public DimJob DimJob
+    {
+      get
+      {
+        return this._DimJob.Entity;
+      }
+      set
+      {
+        DimJob previousValue = this._DimJob.Entity;
+        if (((previousValue != value) 
+              || (this._DimJob.HasLoadedOrAssignedValue == false)))
+        {
+          this.SendPropertyChanging();
+          if ((previousValue != null))
+          {
+            this._DimJob.Entity = null;
+            previousValue.FactTasks.Remove(this);
+          }
+          this._DimJob.Entity = value;
+          if ((value != null))
+          {
+            value.FactTasks.Add(this);
+            this._JobId = value.JobId;
+          }
+          else
+          {
+            this._JobId = default(System.Guid);
+          }
+          this.SendPropertyChanged("DimJob");
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactTask", Storage="_DimTime", ThisKey="EndTime", OtherKey="Time", IsForeignKey=true)]
+    public DimTime DimTimeEnd
+    {
+      get
+      {
+        return this._DimTime.Entity;
+      }
+      set
+      {
+        DimTime previousValue = this._DimTime.Entity;
+        if (((previousValue != value) 
+              || (this._DimTime.HasLoadedOrAssignedValue == false)))
+        {
+          this.SendPropertyChanging();
+          if ((previousValue != null))
+          {
+            this._DimTime.Entity = null;
+            previousValue.FactTasks.Remove(this);
+          }
+          this._DimTime.Entity = value;
+          if ((value != null))
+          {
+            value.FactTasks.Add(this);
+            this._EndTime = value.Time;
+          }
+          else
+          {
+            this._EndTime = default(Nullable<System.DateTime>);
+          }
+          this.SendPropertyChanged("DimTimeEnd");
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactTask1", Storage="_DimTime1", ThisKey="StartTime", OtherKey="Time", IsForeignKey=true)]
+    public DimTime DimTimeStart
+    {
+      get
+      {
+        return this._DimTime1.Entity;
+      }
+      set
+      {
+        DimTime previousValue = this._DimTime1.Entity;
+        if (((previousValue != value) 
+              || (this._DimTime1.HasLoadedOrAssignedValue == false)))
+        {
+          this.SendPropertyChanging();
+          if ((previousValue != null))
+          {
+            this._DimTime1.Entity = null;
+            previousValue.FactTasks1.Remove(this);
+          }
+          this._DimTime1.Entity = value;
+          if ((value != null))
+          {
+            value.FactTasks1.Add(this);
+            this._StartTime = value.Time;
+          }
+          else
+          {
+            this._StartTime = default(System.DateTime);
+          }
+          this.SendPropertyChanged("DimTimeStart");
+        }
+      }
+    }
+    
+    public event PropertyChangingEventHandler PropertyChanging;
+    
+    public event PropertyChangedEventHandler PropertyChanged;
+    
+    protected virtual void SendPropertyChanging()
+    {
+      if ((this.PropertyChanging != null))
+      {
+        this.PropertyChanging(this, emptyChangingEventArgs);
+      }
+    }
+    
+    protected virtual void SendPropertyChanged(String propertyName)
+    {
+      if ((this.PropertyChanged != null))
+      {
+        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
+      }
+    }
+  }
+  
+  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimJob")]
+  public partial class DimJob : INotifyPropertyChanging, INotifyPropertyChanged
+  {
+    
+    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
+    
+    private System.Guid _JobId;
+    
+    private System.Guid _UserId;
+    
+    private string _JobName;
+    
+    private string _UserName;
+    
+    private EntitySet<FactTask> _FactTasks;
+    
+    #region Extensibility Method Definitions
+    partial void OnLoaded();
+    partial void OnValidate(System.Data.Linq.ChangeAction action);
+    partial void OnCreated();
+    partial void OnJobIdChanging(System.Guid value);
+    partial void OnJobIdChanged();
+    partial void OnUserIdChanging(System.Guid value);
+    partial void OnUserIdChanged();
+    partial void OnJobNameChanging(string value);
+    partial void OnJobNameChanged();
+    partial void OnUserNameChanging(string value);
+    partial void OnUserNameChanged();
+    #endregion
+    
+    public DimJob()
+    {
+      this._FactTasks = new EntitySet<FactTask>(new Action<FactTask>(this.attach_FactTasks), new Action<FactTask>(this.detach_FactTasks));
+      OnCreated();
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
+    public System.Guid JobId
+    {
+      get
+      {
+        return this._JobId;
+      }
+      set
+      {
+        if ((this._JobId != value))
+        {
+          this.OnJobIdChanging(value);
+          this.SendPropertyChanging();
+          this._JobId = value;
+          this.SendPropertyChanged("JobId");
+          this.OnJobIdChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL")]
+    public System.Guid UserId
+    {
+      get
+      {
+        return this._UserId;
+      }
+      set
+      {
+        if ((this._UserId != value))
+        {
+          this.OnUserIdChanging(value);
+          this.SendPropertyChanging();
+          this._UserId = value;
+          this.SendPropertyChanged("UserId");
+          this.OnUserIdChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobName", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
+    public string JobName
+    {
+      get
+      {
+        return this._JobName;
+      }
+      set
+      {
+        if ((this._JobName != value))
+        {
+          this.OnJobNameChanging(value);
+          this.SendPropertyChanging();
+          this._JobName = value;
+          this.SendPropertyChanged("JobName");
+          this.OnJobNameChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserName", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
+    public string UserName
+    {
+      get
+      {
+        return this._UserName;
+      }
+      set
+      {
+        if ((this._UserName != value))
+        {
+          this.OnUserNameChanging(value);
+          this.SendPropertyChanging();
+          this._UserName = value;
+          this.SendPropertyChanged("UserName");
+          this.OnUserNameChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimJob_FactTask", Storage="_FactTasks", ThisKey="JobId", OtherKey="JobId")]
+    public EntitySet<FactTask> FactTasks
+    {
+      get
+      {
+        return this._FactTasks;
+      }
+      set
+      {
+        this._FactTasks.Assign(value);
+      }
+    }
+    
+    public event PropertyChangingEventHandler PropertyChanging;
+    
+    public event PropertyChangedEventHandler PropertyChanged;
+    
+    protected virtual void SendPropertyChanging()
+    {
+      if ((this.PropertyChanging != null))
+      {
+        this.PropertyChanging(this, emptyChangingEventArgs);
+      }
+    }
+    
+    protected virtual void SendPropertyChanged(String propertyName)
+    {
+      if ((this.PropertyChanged != null))
+      {
+        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
+      }
+    }
+    
+    private void attach_FactTasks(FactTask entity)
+    {
+      this.SendPropertyChanging();
+      entity.DimJob = this;
+    }
+    
+    private void detach_FactTasks(FactTask entity)
+    {
+      this.SendPropertyChanging();
+      entity.DimJob = null;
+    }
+  }
+  
+  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimTime")]
+  public partial class DimTime : INotifyPropertyChanging, INotifyPropertyChanged
+  {
+    
+    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
+    
+    private System.DateTime _Time;
+    
+    private System.DateTime _Hour;
+    
+    private System.DateTime _Day;
+    
+    private System.DateTime _Month;
+    
+    private System.DateTime _Year;
+    
+    private EntitySet<FactTask> _FactTasks;
+    
+    private EntitySet<FactTask> _FactTasks1;
+    
+    private EntitySet<FactClientInfo> _FactClientInfos;
+    
+    #region Extensibility Method Definitions
+    partial void OnLoaded();
+    partial void OnValidate(System.Data.Linq.ChangeAction action);
+    partial void OnCreated();
+    partial void OnTimeChanging(System.DateTime value);
+    partial void OnTimeChanged();
+    partial void OnHourChanging(System.DateTime value);
+    partial void OnHourChanged();
+    partial void OnDayChanging(System.DateTime value);
+    partial void OnDayChanged();
+    partial void OnMonthChanging(System.DateTime value);
+    partial void OnMonthChanged();
+    partial void OnYearChanging(System.DateTime value);
+    partial void OnYearChanged();
+    #endregion
+    
+    public DimTime()
+    {
+      this._FactTasks = new EntitySet<FactTask>(new Action<FactTask>(this.attach_FactTasks), new Action<FactTask>(this.detach_FactTasks));
+      this._FactTasks1 = new EntitySet<FactTask>(new Action<FactTask>(this.attach_FactTasks1), new Action<FactTask>(this.detach_FactTasks1));
+      this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
+      OnCreated();
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Time", DbType="DateTime NOT NULL", IsPrimaryKey=true)]
+    public System.DateTime Time
+    {
+      get
+      {
+        return this._Time;
+      }
+      set
+      {
+        if ((this._Time != value))
+        {
+          this.OnTimeChanging(value);
+          this.SendPropertyChanging();
+          this._Time = value;
+          this.SendPropertyChanged("Time");
+          this.OnTimeChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Hour", DbType="DateTime NOT NULL")]
+    public System.DateTime Hour
+    {
+      get
+      {
+        return this._Hour;
+      }
+      set
+      {
+        if ((this._Hour != value))
+        {
+          this.OnHourChanging(value);
+          this.SendPropertyChanging();
+          this._Hour = value;
+          this.SendPropertyChanged("Hour");
+          this.OnHourChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Day", DbType="Date NOT NULL")]
+    public System.DateTime Day
+    {
+      get
+      {
+        return this._Day;
+      }
+      set
+      {
+        if ((this._Day != value))
+        {
+          this.OnDayChanging(value);
+          this.SendPropertyChanging();
+          this._Day = value;
+          this.SendPropertyChanged("Day");
+          this.OnDayChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Month", DbType="Date NOT NULL")]
+    public System.DateTime Month
+    {
+      get
+      {
+        return this._Month;
+      }
+      set
+      {
+        if ((this._Month != value))
+        {
+          this.OnMonthChanging(value);
+          this.SendPropertyChanging();
+          this._Month = value;
+          this.SendPropertyChanged("Month");
+          this.OnMonthChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Year", DbType="Date NOT NULL")]
+    public System.DateTime Year
+    {
+      get
+      {
+        return this._Year;
+      }
+      set
+      {
+        if ((this._Year != value))
+        {
+          this.OnYearChanging(value);
+          this.SendPropertyChanging();
+          this._Year = value;
+          this.SendPropertyChanged("Year");
+          this.OnYearChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactTask", Storage="_FactTasks", ThisKey="Time", OtherKey="EndTime")]
+    public EntitySet<FactTask> FactTasks
+    {
+      get
+      {
+        return this._FactTasks;
+      }
+      set
+      {
+        this._FactTasks.Assign(value);
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactTask1", Storage="_FactTasks1", ThisKey="Time", OtherKey="StartTime")]
+    public EntitySet<FactTask> FactTasks1
+    {
+      get
+      {
+        return this._FactTasks1;
+      }
+      set
+      {
+        this._FactTasks1.Assign(value);
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactClientInfo", Storage="_FactClientInfos", ThisKey="Time", OtherKey="Time")]
+    public EntitySet<FactClientInfo> FactClientInfos
+    {
+      get
+      {
+        return this._FactClientInfos;
+      }
+      set
+      {
+        this._FactClientInfos.Assign(value);
+      }
+    }
+    
+    public event PropertyChangingEventHandler PropertyChanging;
+    
+    public event PropertyChangedEventHandler PropertyChanged;
+    
+    protected virtual void SendPropertyChanging()
+    {
+      if ((this.PropertyChanging != null))
+      {
+        this.PropertyChanging(this, emptyChangingEventArgs);
+      }
+    }
+    
+    protected virtual void SendPropertyChanged(String propertyName)
+    {
+      if ((this.PropertyChanged != null))
+      {
+        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
+      }
+    }
+    
+    private void attach_FactTasks(FactTask entity)
+    {
+      this.SendPropertyChanging();
+      entity.DimTimeEnd = this;
+    }
+    
+    private void detach_FactTasks(FactTask entity)
+    {
+      this.SendPropertyChanging();
+      entity.DimTimeEnd = null;
+    }
+    
+    private void attach_FactTasks1(FactTask entity)
+    {
+      this.SendPropertyChanging();
+      entity.DimTimeStart = this;
+    }
+    
+    private void detach_FactTasks1(FactTask entity)
+    {
+      this.SendPropertyChanging();
+      entity.DimTimeStart = null;
+    }
+    
+    private void attach_FactClientInfos(FactClientInfo entity)
+    {
+      this.SendPropertyChanging();
+      entity.DimTime = this;
+    }
+    
+    private void detach_FactClientInfos(FactClientInfo entity)
+    {
+      this.SendPropertyChanging();
+      entity.DimTime = null;
+    }
+  }
+  
+  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimUser")]
+  public partial class DimUser : INotifyPropertyChanging, INotifyPropertyChanged
+  {
+    
+    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
+    
+    private System.Guid _UserId;
+    
+    private string _Name;
+    
+    private EntitySet<FactClientInfo> _FactClientInfos;
+    
+    #region Extensibility Method Definitions
+    partial void OnLoaded();
+    partial void OnValidate(System.Data.Linq.ChangeAction action);
+    partial void OnCreated();
+    partial void OnUserIdChanging(System.Guid value);
+    partial void OnUserIdChanged();
+    partial void OnNameChanging(string value);
+    partial void OnNameChanged();
+    #endregion
+    
+    public DimUser()
+    {
+      this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
+      OnCreated();
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
+    public System.Guid UserId
+    {
+      get
+      {
+        return this._UserId;
+      }
+      set
+      {
+        if ((this._UserId != value))
+        {
+          this.OnUserIdChanging(value);
+          this.SendPropertyChanging();
+          this._UserId = value;
+          this.SendPropertyChanged("UserId");
+          this.OnUserIdChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
+    public string Name
+    {
+      get
+      {
+        return this._Name;
+      }
+      set
+      {
+        if ((this._Name != value))
+        {
+          this.OnNameChanging(value);
+          this.SendPropertyChanging();
+          this._Name = value;
+          this.SendPropertyChanged("Name");
+          this.OnNameChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimUser_FactClientInfo", Storage="_FactClientInfos", ThisKey="UserId", OtherKey="UserId")]
+    public EntitySet<FactClientInfo> FactClientInfos
+    {
+      get
+      {
+        return this._FactClientInfos;
+      }
+      set
+      {
+        this._FactClientInfos.Assign(value);
+      }
+    }
+    
+    public event PropertyChangingEventHandler PropertyChanging;
+    
+    public event PropertyChangedEventHandler PropertyChanged;
+    
+    protected virtual void SendPropertyChanging()
+    {
+      if ((this.PropertyChanging != null))
+      {
+        this.PropertyChanging(this, emptyChangingEventArgs);
+      }
+    }
+    
+    protected virtual void SendPropertyChanged(String propertyName)
+    {
+      if ((this.PropertyChanged != null))
+      {
+        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
+      }
+    }
+    
+    private void attach_FactClientInfos(FactClientInfo entity)
+    {
+      this.SendPropertyChanging();
+      entity.DimUser = this;
+    }
+    
+    private void detach_FactClientInfos(FactClientInfo entity)
+    {
+      this.SendPropertyChanging();
+      entity.DimUser = null;
+    }
+  }
+  
+  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].FactClientInfo")]
+  public partial class FactClientInfo : INotifyPropertyChanging, INotifyPropertyChanged
+  {
+    
+    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
+    
+    private System.Guid _ClientId;
+    
+    private System.DateTime _Time;
+    
+    private System.Guid _UserId;
+    
+    private int _NumUsedCores;
+    
+    private int _NumTotalCores;
+    
+    private int _UsedMemory;
+    
+    private int _TotalMemory;
+    
+    private double _CpuUtilization;
+    
+    private double _TotalTimeIdle;
+    
+    private double _TotalTimeCalculating;
+    
+    private double _TotalTimeTransferring;
+    
+    private double _TotalTimeOffline;
+    
+    private double _TotalTimeUnavailable;
+    
+    private global::HeuristicLab.Services.Hive.DataAccess.SlaveState _SlaveState;
+    
+    private EntityRef<DimClient> _DimClient;
+    
+    private EntityRef<DimTime> _DimTime;
+    
+    private EntityRef<DimUser> _DimUser;
+    
+    #region Extensibility Method Definitions
+    partial void OnLoaded();
+    partial void OnValidate(System.Data.Linq.ChangeAction action);
+    partial void OnCreated();
+    partial void OnClientIdChanging(System.Guid value);
+    partial void OnClientIdChanged();
+    partial void OnTimeChanging(System.DateTime value);
+    partial void OnTimeChanged();
+    partial void OnUserIdChanging(System.Guid value);
+    partial void OnUserIdChanged();
+    partial void OnNumUsedCoresChanging(int value);
+    partial void OnNumUsedCoresChanged();
+    partial void OnNumTotalCoresChanging(int value);
+    partial void OnNumTotalCoresChanged();
+    partial void OnUsedMemoryChanging(int value);
+    partial void OnUsedMemoryChanged();
+    partial void OnTotalMemoryChanging(int value);
+    partial void OnTotalMemoryChanged();
+    partial void OnCpuUtilizationChanging(double value);
+    partial void OnCpuUtilizationChanged();
+    partial void OnTotalTimeIdleChanging(double value);
+    partial void OnTotalTimeIdleChanged();
+    partial void OnTotalTimeCalculatingChanging(double value);
+    partial void OnTotalTimeCalculatingChanged();
+    partial void OnTotalTimeTransferringChanging(double value);
+    partial void OnTotalTimeTransferringChanged();
+    partial void OnTotalTimeOfflineChanging(double value);
+    partial void OnTotalTimeOfflineChanged();
+    partial void OnTotalTimeUnavailableChanging(double value);
+    partial void OnTotalTimeUnavailableChanged();
+    partial void OnSlaveStateChanging(global::HeuristicLab.Services.Hive.DataAccess.SlaveState value);
+    partial void OnSlaveStateChanged();
+    #endregion
+    
+    public FactClientInfo()
+    {
+      this._DimClient = default(EntityRef<DimClient>);
+      this._DimTime = default(EntityRef<DimTime>);
+      this._DimUser = default(EntityRef<DimUser>);
+      OnCreated();
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ClientId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
+    public System.Guid ClientId
+    {
+      get
+      {
+        return this._ClientId;
+      }
+      set
+      {
+        if ((this._ClientId != value))
+        {
+          if (this._DimClient.HasLoadedOrAssignedValue)
+          {
+            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
+          }
+          this.OnClientIdChanging(value);
+          this.SendPropertyChanging();
+          this._ClientId = value;
+          this.SendPropertyChanged("ClientId");
+          this.OnClientIdChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Time", DbType="DateTime NOT NULL", IsPrimaryKey=true)]
+    public System.DateTime Time
+    {
+      get
+      {
+        return this._Time;
+      }
+      set
+      {
+        if ((this._Time != value))
+        {
+          if (this._DimTime.HasLoadedOrAssignedValue)
+          {
+            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
+          }
+          this.OnTimeChanging(value);
+          this.SendPropertyChanging();
+          this._Time = value;
+          this.SendPropertyChanged("Time");
+          this.OnTimeChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NULL", IsPrimaryKey=true)]
+    public System.Guid UserId
+    {
+      get
+      {
+        return this._UserId;
+      }
+      set
+      {
+        if ((this._UserId != value))
+        {
+          if (this._DimUser.HasLoadedOrAssignedValue)
+          {
+            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
+          }
+          this.OnUserIdChanging(value);
+          this.SendPropertyChanging();
+          this._UserId = value;
+          this.SendPropertyChanged("UserId");
+          this.OnUserIdChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumUsedCores", DbType="Int NOT NULL")]
+    public int NumUsedCores
+    {
+      get
+      {
+        return this._NumUsedCores;
+      }
+      set
+      {
+        if ((this._NumUsedCores != value))
+        {
+          this.OnNumUsedCoresChanging(value);
+          this.SendPropertyChanging();
+          this._NumUsedCores = value;
+          this.SendPropertyChanged("NumUsedCores");
+          this.OnNumUsedCoresChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumTotalCores", DbType="Int NOT NULL")]
+    public int NumTotalCores
+    {
+      get
+      {
+        return this._NumTotalCores;
+      }
+      set
+      {
+        if ((this._NumTotalCores != value))
+        {
+          this.OnNumTotalCoresChanging(value);
+          this.SendPropertyChanging();
+          this._NumTotalCores = value;
+          this.SendPropertyChanged("NumTotalCores");
+          this.OnNumTotalCoresChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UsedMemory", DbType="Int NOT NULL")]
+    public int UsedMemory
+    {
+      get
+      {
+        return this._UsedMemory;
+      }
+      set
+      {
+        if ((this._UsedMemory != value))
+        {
+          this.OnUsedMemoryChanging(value);
+          this.SendPropertyChanging();
+          this._UsedMemory = value;
+          this.SendPropertyChanged("UsedMemory");
+          this.OnUsedMemoryChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalMemory", DbType="Int NOT NULL")]
+    public int TotalMemory
+    {
+      get
+      {
+        return this._TotalMemory;
+      }
+      set
+      {
+        if ((this._TotalMemory != value))
+        {
+          this.OnTotalMemoryChanging(value);
+          this.SendPropertyChanging();
+          this._TotalMemory = value;
+          this.SendPropertyChanged("TotalMemory");
+          this.OnTotalMemoryChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CpuUtilization", DbType="Float NOT NULL")]
+    public double CpuUtilization
+    {
+      get
+      {
+        return this._CpuUtilization;
+      }
+      set
+      {
+        if ((this._CpuUtilization != value))
+        {
+          this.OnCpuUtilizationChanging(value);
+          this.SendPropertyChanging();
+          this._CpuUtilization = value;
+          this.SendPropertyChanged("CpuUtilization");
+          this.OnCpuUtilizationChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeIdle", DbType="Float NOT NULL")]
+    public double TotalTimeIdle
+    {
+      get
+      {
+        return this._TotalTimeIdle;
+      }
+      set
+      {
+        if ((this._TotalTimeIdle != value))
+        {
+          this.OnTotalTimeIdleChanging(value);
+          this.SendPropertyChanging();
+          this._TotalTimeIdle = value;
+          this.SendPropertyChanged("TotalTimeIdle");
+          this.OnTotalTimeIdleChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeCalculating", DbType="Float NOT NULL")]
+    public double TotalTimeCalculating
+    {
+      get
+      {
+        return this._TotalTimeCalculating;
+      }
+      set
+      {
+        if ((this._TotalTimeCalculating != value))
+        {
+          this.OnTotalTimeCalculatingChanging(value);
+          this.SendPropertyChanging();
+          this._TotalTimeCalculating = value;
+          this.SendPropertyChanged("TotalTimeCalculating");
+          this.OnTotalTimeCalculatingChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeTransferring", DbType="Float NOT NULL")]
+    public double TotalTimeTransferring
+    {
+      get
+      {
+        return this._TotalTimeTransferring;
+      }
+      set
+      {
+        if ((this._TotalTimeTransferring != value))
+        {
+          this.OnTotalTimeTransferringChanging(value);
+          this.SendPropertyChanging();
+          this._TotalTimeTransferring = value;
+          this.SendPropertyChanged("TotalTimeTransferring");
+          this.OnTotalTimeTransferringChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeOffline", DbType="Float NOT NULL")]
+    public double TotalTimeOffline
+    {
+      get
+      {
+        return this._TotalTimeOffline;
+      }
+      set
+      {
+        if ((this._TotalTimeOffline != value))
+        {
+          this.OnTotalTimeOfflineChanging(value);
+          this.SendPropertyChanging();
+          this._TotalTimeOffline = value;
+          this.SendPropertyChanged("TotalTimeOffline");
+          this.OnTotalTimeOfflineChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeUnavailable", DbType="Float NOT NULL")]
+    public double TotalTimeUnavailable
+    {
+      get
+      {
+        return this._TotalTimeUnavailable;
+      }
+      set
+      {
+        if ((this._TotalTimeUnavailable != value))
+        {
+          this.OnTotalTimeUnavailableChanging(value);
+          this.SendPropertyChanging();
+          this._TotalTimeUnavailable = value;
+          this.SendPropertyChanged("TotalTimeUnavailable");
+          this.OnTotalTimeUnavailableChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SlaveState", DbType="VarChar(15)", CanBeNull=false)]
+    public global::HeuristicLab.Services.Hive.DataAccess.SlaveState SlaveState
+    {
+      get
+      {
+        return this._SlaveState;
+      }
+      set
+      {
+        if ((this._SlaveState != value))
+        {
+          this.OnSlaveStateChanging(value);
+          this.SendPropertyChanging();
+          this._SlaveState = value;
+          this.SendPropertyChanged("SlaveState");
+          this.OnSlaveStateChanged();
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactClientInfo", Storage="_DimClient", ThisKey="ClientId", OtherKey="Id", IsForeignKey=true)]
+    public DimClient DimClient
+    {
+      get
+      {
+        return this._DimClient.Entity;
+      }
+      set
+      {
+        DimClient previousValue = this._DimClient.Entity;
+        if (((previousValue != value) 
+              || (this._DimClient.HasLoadedOrAssignedValue == false)))
+        {
+          this.SendPropertyChanging();
+          if ((previousValue != null))
+          {
+            this._DimClient.Entity = null;
+            previousValue.FactClientInfos.Remove(this);
+          }
+          this._DimClient.Entity = value;
+          if ((value != null))
+          {
+            value.FactClientInfos.Add(this);
+            this._ClientId = value.Id;
+          }
+          else
+          {
+            this._ClientId = default(System.Guid);
+          }
+          this.SendPropertyChanged("DimClient");
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactClientInfo", Storage="_DimTime", ThisKey="Time", OtherKey="Time", IsForeignKey=true)]
+    public DimTime DimTime
+    {
+      get
+      {
+        return this._DimTime.Entity;
+      }
+      set
+      {
+        DimTime previousValue = this._DimTime.Entity;
+        if (((previousValue != value) 
+              || (this._DimTime.HasLoadedOrAssignedValue == false)))
+        {
+          this.SendPropertyChanging();
+          if ((previousValue != null))
+          {
+            this._DimTime.Entity = null;
+            previousValue.FactClientInfos.Remove(this);
+          }
+          this._DimTime.Entity = value;
+          if ((value != null))
+          {
+            value.FactClientInfos.Add(this);
+            this._Time = value.Time;
+          }
+          else
+          {
+            this._Time = default(System.DateTime);
+          }
+          this.SendPropertyChanged("DimTime");
+        }
+      }
+    }
+    
+    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimUser_FactClientInfo", Storage="_DimUser", ThisKey="UserId", OtherKey="UserId", IsForeignKey=true)]
+    public DimUser DimUser
+    {
+      get
+      {
+        return this._DimUser.Entity;
+      }
+      set
+      {
+        DimUser previousValue = this._DimUser.Entity;
+        if (((previousValue != value) 
+              || (this._DimUser.HasLoadedOrAssignedValue == false)))
+        {
+          this.SendPropertyChanging();
+          if ((previousValue != null))
+          {
+            this._DimUser.Entity = null;
+            previousValue.FactClientInfos.Remove(this);
+          }
+          this._DimUser.Entity = value;
+          if ((value != null))
+          {
+            value.FactClientInfos.Add(this);
+            this._UserId = value.UserId;
+          }
+          else
+          {
+            this._UserId = default(System.Guid);
+          }
+          this.SendPropertyChanged("DimUser");
+        }
+      }
+    }
+    
+    public event PropertyChangingEventHandler PropertyChanging;
+    
+    public event PropertyChangedEventHandler PropertyChanged;
+    
+    protected virtual void SendPropertyChanging()
+    {
+      if ((this.PropertyChanging != null))
+      {
+        this.PropertyChanging(this, emptyChangingEventArgs);
+      }
+    }
+    
+    protected virtual void SendPropertyChanged(String propertyName)
+    {
+      if ((this.PropertyChanged != null))
+      {
+        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
+      }
+    }
+  }
 }
 #pragma warning restore 1591