Ignore:
Timestamp:
09/21/15 16:28:38 (7 years ago)
Author:
ascheibe
Message:

#2388 merged r12878, r12879, r12883, r12885, r12913, r12914, r12925, r12932, r12961 into stable

Location:
stable
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • stable

  • stable/HeuristicLab.Services.Hive.DataAccess

  • stable/HeuristicLab.Services.Hive.DataAccess/3.3/HiveDataContext.designer.cs

    r11920 r12962  
    33// <auto-generated>
    44//     This code was generated by a tool.
    5 //     Runtime Version:4.0.30319.34014
     5//     Runtime Version:4.0.30319.34209
    66//
    77//     Changes to this file may cause incorrect behavior and will be lost if
     
    6767    partial void UpdateLifecycle(Lifecycle instance);
    6868    partial void DeleteLifecycle(Lifecycle instance);
    69     partial void InsertDeletedJobStatistics(DeletedJobStatistics instance);
    70     partial void UpdateDeletedJobStatistics(DeletedJobStatistics instance);
    71     partial void DeleteDeletedJobStatistics(DeletedJobStatistics instance);
    72     partial void InsertUserStatistics(UserStatistics instance);
    73     partial void UpdateUserStatistics(UserStatistics instance);
    74     partial void DeleteUserStatistics(UserStatistics instance);
    75     partial void InsertSlaveStatistics(SlaveStatistics instance);
    76     partial void UpdateSlaveStatistics(SlaveStatistics instance);
    77     partial void DeleteSlaveStatistics(SlaveStatistics instance);
    78     partial void InsertStatistics(Statistics instance);
    79     partial void UpdateStatistics(Statistics instance);
    80     partial void DeleteStatistics(Statistics instance);
    8169    partial void InsertResourcePermission(ResourcePermission instance);
    8270    partial void UpdateResourcePermission(ResourcePermission instance);
     
    8573    partial void UpdateUserPriority(UserPriority instance);
    8674    partial void DeleteUserPriority(UserPriority instance);
     75    partial void InsertDimClient(DimClient instance);
     76    partial void UpdateDimClient(DimClient instance);
     77    partial void DeleteDimClient(DimClient instance);
     78    partial void InsertFactTask(FactTask instance);
     79    partial void UpdateFactTask(FactTask instance);
     80    partial void DeleteFactTask(FactTask instance);
     81    partial void InsertDimJob(DimJob instance);
     82    partial void UpdateDimJob(DimJob instance);
     83    partial void DeleteDimJob(DimJob instance);
     84    partial void InsertDimTime(DimTime instance);
     85    partial void UpdateDimTime(DimTime instance);
     86    partial void DeleteDimTime(DimTime instance);
     87    partial void InsertDimUser(DimUser instance);
     88    partial void UpdateDimUser(DimUser instance);
     89    partial void DeleteDimUser(DimUser instance);
     90    partial void InsertFactClientInfo(FactClientInfo instance);
     91    partial void UpdateFactClientInfo(FactClientInfo instance);
     92    partial void DeleteFactClientInfo(FactClientInfo instance);
    8793    #endregion
    8894   
     
    213219    }
    214220   
    215     public System.Data.Linq.Table<DeletedJobStatistics> DeletedJobStatistics
    216     {
    217       get
    218       {
    219         return this.GetTable<DeletedJobStatistics>();
    220       }
    221     }
    222    
    223     public System.Data.Linq.Table<UserStatistics> UserStatistics
    224     {
    225       get
    226       {
    227         return this.GetTable<UserStatistics>();
    228       }
    229     }
    230    
    231     public System.Data.Linq.Table<SlaveStatistics> SlaveStatistics
    232     {
    233       get
    234       {
    235         return this.GetTable<SlaveStatistics>();
    236       }
    237     }
    238    
    239     public System.Data.Linq.Table<Statistics> Statistics
    240     {
    241       get
    242       {
    243         return this.GetTable<Statistics>();
    244       }
    245     }
    246    
    247221    public System.Data.Linq.Table<ResourcePermission> ResourcePermissions
    248222    {
     
    258232      {
    259233        return this.GetTable<UserPriority>();
     234      }
     235    }
     236   
     237    public System.Data.Linq.Table<DimClient> DimClients
     238    {
     239      get
     240      {
     241        return this.GetTable<DimClient>();
     242      }
     243    }
     244   
     245    public System.Data.Linq.Table<FactTask> FactTasks
     246    {
     247      get
     248      {
     249        return this.GetTable<FactTask>();
     250      }
     251    }
     252   
     253    public System.Data.Linq.Table<DimJob> DimJobs
     254    {
     255      get
     256      {
     257        return this.GetTable<DimJob>();
     258      }
     259    }
     260   
     261    public System.Data.Linq.Table<DimTime> DimTimes
     262    {
     263      get
     264      {
     265        return this.GetTable<DimTime>();
     266      }
     267    }
     268   
     269    public System.Data.Linq.Table<DimUser> DimUsers
     270    {
     271      get
     272      {
     273        return this.GetTable<DimUser>();
     274      }
     275    }
     276   
     277    public System.Data.Linq.Table<FactClientInfo> FactClientInfos
     278    {
     279      get
     280      {
     281        return this.GetTable<FactClientInfo>();
    260282      }
    261283    }
     
    35283550  }
    35293551 
    3530   [global::System.Data.Linq.Mapping.TableAttribute(Name="")]
    3531   public partial class DeletedJobStatistics : INotifyPropertyChanging, INotifyPropertyChanged
    3532   {
    3533    
    3534     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    3535    
    3536     private System.Guid _UserId;
    3537    
    3538     private double _ExecutionTime;
    3539    
    3540     private double _ExecutionTimeFinishedJobs;
    3541    
    3542     private double _StartToEndTime;
    3543    
    3544     private System.Guid _DeletedJobStatisticsId;
    3545    
    3546     #region Extensibility Method Definitions
    3547     partial void OnLoaded();
    3548     partial void OnValidate(System.Data.Linq.ChangeAction action);
    3549     partial void OnCreated();
    3550     partial void OnUserIdChanging(System.Guid value);
    3551     partial void OnUserIdChanged();
    3552     partial void OnExecutionTimeSChanging(double value);
    3553     partial void OnExecutionTimeSChanged();
    3554     partial void OnExecutionTimeSFinishedJobsChanging(double value);
    3555     partial void OnExecutionTimeSFinishedJobsChanged();
    3556     partial void OnStartToEndTimeSChanging(double value);
    3557     partial void OnStartToEndTimeSChanged();
    3558     partial void OnDeletedJobStatisticsIdChanging(System.Guid value);
    3559     partial void OnDeletedJobStatisticsIdChanged();
    3560     #endregion
    3561    
    3562     public DeletedJobStatistics()
    3563     {
    3564       OnCreated();
    3565     }
    3566    
    3567     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL")]
    3568     public System.Guid UserId
    3569     {
    3570       get
    3571       {
    3572         return this._UserId;
    3573       }
    3574       set
    3575       {
    3576         if ((this._UserId != value))
    3577         {
    3578           this.OnUserIdChanging(value);
    3579           this.SendPropertyChanging();
    3580           this._UserId = value;
    3581           this.SendPropertyChanged("UserId");
    3582           this.OnUserIdChanged();
    3583         }
    3584       }
    3585     }
    3586    
    3587     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExecutionTime", DbType="float NOT NULL")]
    3588     public double ExecutionTimeS
    3589     {
    3590       get
    3591       {
    3592         return this._ExecutionTime;
    3593       }
    3594       set
    3595       {
    3596         if ((this._ExecutionTime != value))
    3597         {
    3598           this.OnExecutionTimeSChanging(value);
    3599           this.SendPropertyChanging();
    3600           this._ExecutionTime = value;
    3601           this.SendPropertyChanged("ExecutionTimeS");
    3602           this.OnExecutionTimeSChanged();
    3603         }
    3604       }
    3605     }
    3606    
    3607     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExecutionTimeFinishedJobs", DbType="float NOT NULL")]
    3608     public double ExecutionTimeSFinishedJobs
    3609     {
    3610       get
    3611       {
    3612         return this._ExecutionTimeFinishedJobs;
    3613       }
    3614       set
    3615       {
    3616         if ((this._ExecutionTimeFinishedJobs != value))
    3617         {
    3618           this.OnExecutionTimeSFinishedJobsChanging(value);
    3619           this.SendPropertyChanging();
    3620           this._ExecutionTimeFinishedJobs = value;
    3621           this.SendPropertyChanged("ExecutionTimeSFinishedJobs");
    3622           this.OnExecutionTimeSFinishedJobsChanged();
    3623         }
    3624       }
    3625     }
    3626    
    3627     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartToEndTime", DbType="float NOT NULL")]
    3628     public double StartToEndTimeS
    3629     {
    3630       get
    3631       {
    3632         return this._StartToEndTime;
    3633       }
    3634       set
    3635       {
    3636         if ((this._StartToEndTime != value))
    3637         {
    3638           this.OnStartToEndTimeSChanging(value);
    3639           this.SendPropertyChanging();
    3640           this._StartToEndTime = value;
    3641           this.SendPropertyChanged("StartToEndTimeS");
    3642           this.OnStartToEndTimeSChanged();
    3643         }
    3644       }
    3645     }
    3646    
    3647     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DeletedJobStatisticsId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
    3648     public System.Guid DeletedJobStatisticsId
    3649     {
    3650       get
    3651       {
    3652         return this._DeletedJobStatisticsId;
    3653       }
    3654       set
    3655       {
    3656         if ((this._DeletedJobStatisticsId != value))
    3657         {
    3658           this.OnDeletedJobStatisticsIdChanging(value);
    3659           this.SendPropertyChanging();
    3660           this._DeletedJobStatisticsId = value;
    3661           this.SendPropertyChanged("DeletedJobStatisticsId");
    3662           this.OnDeletedJobStatisticsIdChanged();
    3663         }
    3664       }
    3665     }
    3666    
    3667     public event PropertyChangingEventHandler PropertyChanging;
    3668    
    3669     public event PropertyChangedEventHandler PropertyChanged;
    3670    
    3671     protected virtual void SendPropertyChanging()
    3672     {
    3673       if ((this.PropertyChanging != null))
    3674       {
    3675         this.PropertyChanging(this, emptyChangingEventArgs);
    3676       }
    3677     }
    3678    
    3679     protected virtual void SendPropertyChanged(String propertyName)
    3680     {
    3681       if ((this.PropertyChanged != null))
    3682       {
    3683         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    3684       }
    3685     }
    3686   }
    3687  
    3688   [global::System.Data.Linq.Mapping.TableAttribute(Name="")]
    3689   public partial class UserStatistics : INotifyPropertyChanging, INotifyPropertyChanged
    3690   {
    3691    
    3692     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    3693    
    3694     private System.Guid _StatisticsId;
    3695    
    3696     private System.Guid _UserId;
    3697    
    3698     private double _ExecutionTime;
    3699    
    3700     private int _CoresUsed;
    3701    
    3702     private double _ExecutionTimeFinishedJobs;
    3703    
    3704     private double _StartToEndTime;
    3705    
    3706     private EntityRef<Statistics> _Statistics;
    3707    
    3708     #region Extensibility Method Definitions
    3709     partial void OnLoaded();
    3710     partial void OnValidate(System.Data.Linq.ChangeAction action);
    3711     partial void OnCreated();
    3712     partial void OnStatisticsIdChanging(System.Guid value);
    3713     partial void OnStatisticsIdChanged();
    3714     partial void OnUserIdChanging(System.Guid value);
    3715     partial void OnUserIdChanged();
    3716     partial void OnExecutionTimeMsChanging(double value);
    3717     partial void OnExecutionTimeMsChanged();
    3718     partial void OnUsedCoresChanging(int value);
    3719     partial void OnUsedCoresChanged();
    3720     partial void OnExecutionTimeMsFinishedJobsChanging(double value);
    3721     partial void OnExecutionTimeMsFinishedJobsChanged();
    3722     partial void OnStartToEndTimeMsChanging(double value);
    3723     partial void OnStartToEndTimeMsChanged();
    3724     #endregion
    3725    
    3726     public UserStatistics()
    3727     {
    3728       this._Statistics = default(EntityRef<Statistics>);
    3729       OnCreated();
    3730     }
    3731    
    3732     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StatisticsId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
    3733     public System.Guid StatisticsId
    3734     {
    3735       get
    3736       {
    3737         return this._StatisticsId;
    3738       }
    3739       set
    3740       {
    3741         if ((this._StatisticsId != value))
    3742         {
    3743           if (this._Statistics.HasLoadedOrAssignedValue)
    3744           {
    3745             throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
    3746           }
    3747           this.OnStatisticsIdChanging(value);
    3748           this.SendPropertyChanging();
    3749           this._StatisticsId = value;
    3750           this.SendPropertyChanged("StatisticsId");
    3751           this.OnStatisticsIdChanged();
    3752         }
    3753       }
    3754     }
    3755    
    3756     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
    3757     public System.Guid UserId
    3758     {
    3759       get
    3760       {
    3761         return this._UserId;
    3762       }
    3763       set
    3764       {
    3765         if ((this._UserId != value))
    3766         {
    3767           this.OnUserIdChanging(value);
    3768           this.SendPropertyChanging();
    3769           this._UserId = value;
    3770           this.SendPropertyChanged("UserId");
    3771           this.OnUserIdChanged();
    3772         }
    3773       }
    3774     }
    3775    
    3776     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExecutionTime", DbType="float NOT NULL")]
    3777     public double ExecutionTimeMs
    3778     {
    3779       get
    3780       {
    3781         return this._ExecutionTime;
    3782       }
    3783       set
    3784       {
    3785         if ((this._ExecutionTime != value))
    3786         {
    3787           this.OnExecutionTimeMsChanging(value);
    3788           this.SendPropertyChanging();
    3789           this._ExecutionTime = value;
    3790           this.SendPropertyChanged("ExecutionTimeMs");
    3791           this.OnExecutionTimeMsChanged();
    3792         }
    3793       }
    3794     }
    3795    
    3796     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CoresUsed", DbType="Int NOT NULL")]
    3797     public int UsedCores
    3798     {
    3799       get
    3800       {
    3801         return this._CoresUsed;
    3802       }
    3803       set
    3804       {
    3805         if ((this._CoresUsed != value))
    3806         {
    3807           this.OnUsedCoresChanging(value);
    3808           this.SendPropertyChanging();
    3809           this._CoresUsed = value;
    3810           this.SendPropertyChanged("UsedCores");
    3811           this.OnUsedCoresChanged();
    3812         }
    3813       }
    3814     }
    3815    
    3816     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExecutionTimeFinishedJobs", DbType="float NOT NULL")]
    3817     public double ExecutionTimeMsFinishedJobs
    3818     {
    3819       get
    3820       {
    3821         return this._ExecutionTimeFinishedJobs;
    3822       }
    3823       set
    3824       {
    3825         if ((this._ExecutionTimeFinishedJobs != value))
    3826         {
    3827           this.OnExecutionTimeMsFinishedJobsChanging(value);
    3828           this.SendPropertyChanging();
    3829           this._ExecutionTimeFinishedJobs = value;
    3830           this.SendPropertyChanged("ExecutionTimeMsFinishedJobs");
    3831           this.OnExecutionTimeMsFinishedJobsChanged();
    3832         }
    3833       }
    3834     }
    3835    
    3836     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartToEndTime", DbType="float NOT NULL")]
    3837     public double StartToEndTimeMs
    3838     {
    3839       get
    3840       {
    3841         return this._StartToEndTime;
    3842       }
    3843       set
    3844       {
    3845         if ((this._StartToEndTime != value))
    3846         {
    3847           this.OnStartToEndTimeMsChanging(value);
    3848           this.SendPropertyChanging();
    3849           this._StartToEndTime = value;
    3850           this.SendPropertyChanged("StartToEndTimeMs");
    3851           this.OnStartToEndTimeMsChanged();
    3852         }
    3853       }
    3854     }
    3855    
    3856     [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Statistics_UserStatistics", Storage="_Statistics", ThisKey="StatisticsId", OtherKey="StatisticsId", IsForeignKey=true)]
    3857     public Statistics Statistics
    3858     {
    3859       get
    3860       {
    3861         return this._Statistics.Entity;
    3862       }
    3863       set
    3864       {
    3865         Statistics previousValue = this._Statistics.Entity;
    3866         if (((previousValue != value)
    3867               || (this._Statistics.HasLoadedOrAssignedValue == false)))
    3868         {
    3869           this.SendPropertyChanging();
    3870           if ((previousValue != null))
    3871           {
    3872             this._Statistics.Entity = null;
    3873             previousValue.UserStatistics.Remove(this);
    3874           }
    3875           this._Statistics.Entity = value;
    3876           if ((value != null))
    3877           {
    3878             value.UserStatistics.Add(this);
    3879             this._StatisticsId = value.StatisticsId;
    3880           }
    3881           else
    3882           {
    3883             this._StatisticsId = default(System.Guid);
    3884           }
    3885           this.SendPropertyChanged("Statistics");
    3886         }
    3887       }
    3888     }
    3889    
    3890     public event PropertyChangingEventHandler PropertyChanging;
    3891    
    3892     public event PropertyChangedEventHandler PropertyChanged;
    3893    
    3894     protected virtual void SendPropertyChanging()
    3895     {
    3896       if ((this.PropertyChanging != null))
    3897       {
    3898         this.PropertyChanging(this, emptyChangingEventArgs);
    3899       }
    3900     }
    3901    
    3902     protected virtual void SendPropertyChanged(String propertyName)
    3903     {
    3904       if ((this.PropertyChanged != null))
    3905       {
    3906         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    3907       }
    3908     }
    3909   }
    3910  
    3911   [global::System.Data.Linq.Mapping.TableAttribute(Name="")]
    3912   public partial class SlaveStatistics : INotifyPropertyChanging, INotifyPropertyChanged
    3913   {
    3914    
    3915     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    3916    
    3917     private System.Guid _StatisticsId;
    3918    
    3919     private System.Guid _SlaveId;
    3920    
    3921     private int _Cores;
    3922    
    3923     private int _FreeCores;
    3924    
    3925     private double _CpuUtilization;
    3926    
    3927     private int _Memory;
    3928    
    3929     private int _FreeMemory;
    3930    
    3931     private EntityRef<Statistics> _Statistics;
    3932    
    3933     #region Extensibility Method Definitions
    3934     partial void OnLoaded();
    3935     partial void OnValidate(System.Data.Linq.ChangeAction action);
    3936     partial void OnCreated();
    3937     partial void OnStatisticsIdChanging(System.Guid value);
    3938     partial void OnStatisticsIdChanged();
    3939     partial void OnSlaveIdChanging(System.Guid value);
    3940     partial void OnSlaveIdChanged();
    3941     partial void OnCoresChanging(int value);
    3942     partial void OnCoresChanged();
    3943     partial void OnFreeCoresChanging(int value);
    3944     partial void OnFreeCoresChanged();
    3945     partial void OnCpuUtilizationChanging(double value);
    3946     partial void OnCpuUtilizationChanged();
    3947     partial void OnMemoryChanging(int value);
    3948     partial void OnMemoryChanged();
    3949     partial void OnFreeMemoryChanging(int value);
    3950     partial void OnFreeMemoryChanged();
    3951     #endregion
    3952    
    3953     public SlaveStatistics()
    3954     {
    3955       this._Statistics = default(EntityRef<Statistics>);
    3956       OnCreated();
    3957     }
    3958    
    3959     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StatisticsId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
    3960     public System.Guid StatisticsId
    3961     {
    3962       get
    3963       {
    3964         return this._StatisticsId;
    3965       }
    3966       set
    3967       {
    3968         if ((this._StatisticsId != value))
    3969         {
    3970           if (this._Statistics.HasLoadedOrAssignedValue)
    3971           {
    3972             throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
    3973           }
    3974           this.OnStatisticsIdChanging(value);
    3975           this.SendPropertyChanging();
    3976           this._StatisticsId = value;
    3977           this.SendPropertyChanged("StatisticsId");
    3978           this.OnStatisticsIdChanged();
    3979         }
    3980       }
    3981     }
    3982    
    3983     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SlaveId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
    3984     public System.Guid SlaveId
    3985     {
    3986       get
    3987       {
    3988         return this._SlaveId;
    3989       }
    3990       set
    3991       {
    3992         if ((this._SlaveId != value))
    3993         {
    3994           this.OnSlaveIdChanging(value);
    3995           this.SendPropertyChanging();
    3996           this._SlaveId = value;
    3997           this.SendPropertyChanged("SlaveId");
    3998           this.OnSlaveIdChanged();
    3999         }
    4000       }
    4001     }
    4002    
    4003     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Cores", DbType="Int NOT NULL")]
    4004     public int Cores
    4005     {
    4006       get
    4007       {
    4008         return this._Cores;
    4009       }
    4010       set
    4011       {
    4012         if ((this._Cores != value))
    4013         {
    4014           this.OnCoresChanging(value);
    4015           this.SendPropertyChanging();
    4016           this._Cores = value;
    4017           this.SendPropertyChanged("Cores");
    4018           this.OnCoresChanged();
    4019         }
    4020       }
    4021     }
    4022    
    4023     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FreeCores", DbType="Int NOT NULL")]
    4024     public int FreeCores
    4025     {
    4026       get
    4027       {
    4028         return this._FreeCores;
    4029       }
    4030       set
    4031       {
    4032         if ((this._FreeCores != value))
    4033         {
    4034           this.OnFreeCoresChanging(value);
    4035           this.SendPropertyChanging();
    4036           this._FreeCores = value;
    4037           this.SendPropertyChanged("FreeCores");
    4038           this.OnFreeCoresChanged();
    4039         }
    4040       }
    4041     }
    4042    
    4043     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CpuUtilization", DbType="float NOT NULL")]
    4044     public double CpuUtilization
    4045     {
    4046       get
    4047       {
    4048         return this._CpuUtilization;
    4049       }
    4050       set
    4051       {
    4052         if ((this._CpuUtilization != value))
    4053         {
    4054           this.OnCpuUtilizationChanging(value);
    4055           this.SendPropertyChanging();
    4056           this._CpuUtilization = value;
    4057           this.SendPropertyChanged("CpuUtilization");
    4058           this.OnCpuUtilizationChanged();
    4059         }
    4060       }
    4061     }
    4062    
    4063     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Memory", DbType="Int NOT NULL")]
    4064     public int Memory
    4065     {
    4066       get
    4067       {
    4068         return this._Memory;
    4069       }
    4070       set
    4071       {
    4072         if ((this._Memory != value))
    4073         {
    4074           this.OnMemoryChanging(value);
    4075           this.SendPropertyChanging();
    4076           this._Memory = value;
    4077           this.SendPropertyChanged("Memory");
    4078           this.OnMemoryChanged();
    4079         }
    4080       }
    4081     }
    4082    
    4083     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FreeMemory", DbType="Int NOT NULL")]
    4084     public int FreeMemory
    4085     {
    4086       get
    4087       {
    4088         return this._FreeMemory;
    4089       }
    4090       set
    4091       {
    4092         if ((this._FreeMemory != value))
    4093         {
    4094           this.OnFreeMemoryChanging(value);
    4095           this.SendPropertyChanging();
    4096           this._FreeMemory = value;
    4097           this.SendPropertyChanged("FreeMemory");
    4098           this.OnFreeMemoryChanged();
    4099         }
    4100       }
    4101     }
    4102    
    4103     [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Statistics_SlaveStatistics", Storage="_Statistics", ThisKey="StatisticsId", OtherKey="StatisticsId", IsForeignKey=true)]
    4104     public Statistics Statistics
    4105     {
    4106       get
    4107       {
    4108         return this._Statistics.Entity;
    4109       }
    4110       set
    4111       {
    4112         Statistics previousValue = this._Statistics.Entity;
    4113         if (((previousValue != value)
    4114               || (this._Statistics.HasLoadedOrAssignedValue == false)))
    4115         {
    4116           this.SendPropertyChanging();
    4117           if ((previousValue != null))
    4118           {
    4119             this._Statistics.Entity = null;
    4120             previousValue.SlaveStatistics.Remove(this);
    4121           }
    4122           this._Statistics.Entity = value;
    4123           if ((value != null))
    4124           {
    4125             value.SlaveStatistics.Add(this);
    4126             this._StatisticsId = value.StatisticsId;
    4127           }
    4128           else
    4129           {
    4130             this._StatisticsId = default(System.Guid);
    4131           }
    4132           this.SendPropertyChanged("Statistics");
    4133         }
    4134       }
    4135     }
    4136    
    4137     public event PropertyChangingEventHandler PropertyChanging;
    4138    
    4139     public event PropertyChangedEventHandler PropertyChanged;
    4140    
    4141     protected virtual void SendPropertyChanging()
    4142     {
    4143       if ((this.PropertyChanging != null))
    4144       {
    4145         this.PropertyChanging(this, emptyChangingEventArgs);
    4146       }
    4147     }
    4148    
    4149     protected virtual void SendPropertyChanged(String propertyName)
    4150     {
    4151       if ((this.PropertyChanged != null))
    4152       {
    4153         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    4154       }
    4155     }
    4156   }
    4157  
    4158   [global::System.Data.Linq.Mapping.TableAttribute(Name="")]
    4159   public partial class Statistics : INotifyPropertyChanging, INotifyPropertyChanged
    4160   {
    4161    
    4162     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    4163    
    4164     private System.Guid _StatisticsId;
    4165    
    4166     private System.DateTime _Timestamp;
    4167    
    4168     private EntitySet<UserStatistics> _UserStatistics;
    4169    
    4170     private EntitySet<SlaveStatistics> _SlaveStatistics;
    4171    
    4172     #region Extensibility Method Definitions
    4173     partial void OnLoaded();
    4174     partial void OnValidate(System.Data.Linq.ChangeAction action);
    4175     partial void OnCreated();
    4176     partial void OnStatisticsIdChanging(System.Guid value);
    4177     partial void OnStatisticsIdChanged();
    4178     partial void OnTimestampChanging(System.DateTime value);
    4179     partial void OnTimestampChanged();
    4180     #endregion
    4181    
    4182     public Statistics()
    4183     {
    4184       this._UserStatistics = new EntitySet<UserStatistics>(new Action<UserStatistics>(this.attach_UserStatistics), new Action<UserStatistics>(this.detach_UserStatistics));
    4185       this._SlaveStatistics = new EntitySet<SlaveStatistics>(new Action<SlaveStatistics>(this.attach_SlaveStatistics), new Action<SlaveStatistics>(this.detach_SlaveStatistics));
    4186       OnCreated();
    4187     }
    4188    
    4189     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StatisticsId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
    4190     public System.Guid StatisticsId
    4191     {
    4192       get
    4193       {
    4194         return this._StatisticsId;
    4195       }
    4196       set
    4197       {
    4198         if ((this._StatisticsId != value))
    4199         {
    4200           this.OnStatisticsIdChanging(value);
    4201           this.SendPropertyChanging();
    4202           this._StatisticsId = value;
    4203           this.SendPropertyChanged("StatisticsId");
    4204           this.OnStatisticsIdChanged();
    4205         }
    4206       }
    4207     }
    4208    
    4209     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Timestamp")]
    4210     public System.DateTime Timestamp
    4211     {
    4212       get
    4213       {
    4214         return this._Timestamp;
    4215       }
    4216       set
    4217       {
    4218         if ((this._Timestamp != value))
    4219         {
    4220           this.OnTimestampChanging(value);
    4221           this.SendPropertyChanging();
    4222           this._Timestamp = value;
    4223           this.SendPropertyChanged("Timestamp");
    4224           this.OnTimestampChanged();
    4225         }
    4226       }
    4227     }
    4228    
    4229     [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Statistics_UserStatistics", Storage="_UserStatistics", ThisKey="StatisticsId", OtherKey="StatisticsId")]
    4230     public EntitySet<UserStatistics> UserStatistics
    4231     {
    4232       get
    4233       {
    4234         return this._UserStatistics;
    4235       }
    4236       set
    4237       {
    4238         this._UserStatistics.Assign(value);
    4239       }
    4240     }
    4241    
    4242     [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Statistics_SlaveStatistics", Storage="_SlaveStatistics", ThisKey="StatisticsId", OtherKey="StatisticsId")]
    4243     public EntitySet<SlaveStatistics> SlaveStatistics
    4244     {
    4245       get
    4246       {
    4247         return this._SlaveStatistics;
    4248       }
    4249       set
    4250       {
    4251         this._SlaveStatistics.Assign(value);
    4252       }
    4253     }
    4254    
    4255     public event PropertyChangingEventHandler PropertyChanging;
    4256    
    4257     public event PropertyChangedEventHandler PropertyChanged;
    4258    
    4259     protected virtual void SendPropertyChanging()
    4260     {
    4261       if ((this.PropertyChanging != null))
    4262       {
    4263         this.PropertyChanging(this, emptyChangingEventArgs);
    4264       }
    4265     }
    4266    
    4267     protected virtual void SendPropertyChanged(String propertyName)
    4268     {
    4269       if ((this.PropertyChanged != null))
    4270       {
    4271         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    4272       }
    4273     }
    4274    
    4275     private void attach_UserStatistics(UserStatistics entity)
    4276     {
    4277       this.SendPropertyChanging();
    4278       entity.Statistics = this;
    4279     }
    4280    
    4281     private void detach_UserStatistics(UserStatistics entity)
    4282     {
    4283       this.SendPropertyChanging();
    4284       entity.Statistics = null;
    4285     }
    4286    
    4287     private void attach_SlaveStatistics(SlaveStatistics entity)
    4288     {
    4289       this.SendPropertyChanging();
    4290       entity.Statistics = this;
    4291     }
    4292    
    4293     private void detach_SlaveStatistics(SlaveStatistics entity)
    4294     {
    4295       this.SendPropertyChanging();
    4296       entity.Statistics = null;
    4297     }
    4298   }
    4299  
    43003552  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ResourcePermission")]
    43013553  public partial class ResourcePermission : INotifyPropertyChanging, INotifyPropertyChanged
     
    45343786    }
    45353787  }
     3788 
     3789  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimClient")]
     3790  public partial class DimClient : INotifyPropertyChanging, INotifyPropertyChanged
     3791  {
     3792   
     3793    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     3794   
     3795    private System.Guid _Id;
     3796   
     3797    private string _Name;
     3798   
     3799    private System.Guid _ResourceId;
     3800   
     3801    private System.Nullable<System.DateTime> _ExpirationTime;
     3802   
     3803    private System.Nullable<System.Guid> _ResourceGroupId;
     3804   
     3805    private System.Nullable<System.Guid> _ResourceGroup2Id;
     3806   
     3807    private string _GroupName;
     3808   
     3809    private string _GroupName2;
     3810   
     3811    private EntitySet<FactTask> _FactTasks;
     3812   
     3813    private EntitySet<FactClientInfo> _FactClientInfos;
     3814   
     3815    #region Extensibility Method Definitions
     3816    partial void OnLoaded();
     3817    partial void OnValidate(System.Data.Linq.ChangeAction action);
     3818    partial void OnCreated();
     3819    partial void OnIdChanging(System.Guid value);
     3820    partial void OnIdChanged();
     3821    partial void OnNameChanging(string value);
     3822    partial void OnNameChanged();
     3823    partial void OnResourceIdChanging(System.Guid value);
     3824    partial void OnResourceIdChanged();
     3825    partial void OnExpirationTimeChanging(System.Nullable<System.DateTime> value);
     3826    partial void OnExpirationTimeChanged();
     3827    partial void OnResourceGroupIdChanging(System.Nullable<System.Guid> value);
     3828    partial void OnResourceGroupIdChanged();
     3829    partial void OnResourceGroup2IdChanging(System.Nullable<System.Guid> value);
     3830    partial void OnResourceGroup2IdChanged();
     3831    partial void OnGroupNameChanging(string value);
     3832    partial void OnGroupNameChanged();
     3833    partial void OnGroupName2Changing(string value);
     3834    partial void OnGroupName2Changed();
     3835    #endregion
     3836   
     3837    public DimClient()
     3838    {
     3839      this._FactTasks = new EntitySet<FactTask>(new Action<FactTask>(this.attach_FactTasks), new Action<FactTask>(this.detach_FactTasks));
     3840      this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
     3841      OnCreated();
     3842    }
     3843   
     3844    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
     3845    public System.Guid Id
     3846    {
     3847      get
     3848      {
     3849        return this._Id;
     3850      }
     3851      set
     3852      {
     3853        if ((this._Id != value))
     3854        {
     3855          this.OnIdChanging(value);
     3856          this.SendPropertyChanging();
     3857          this._Id = value;
     3858          this.SendPropertyChanged("Id");
     3859          this.OnIdChanged();
     3860        }
     3861      }
     3862    }
     3863   
     3864    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
     3865    public string Name
     3866    {
     3867      get
     3868      {
     3869        return this._Name;
     3870      }
     3871      set
     3872      {
     3873        if ((this._Name != value))
     3874        {
     3875          this.OnNameChanging(value);
     3876          this.SendPropertyChanging();
     3877          this._Name = value;
     3878          this.SendPropertyChanged("Name");
     3879          this.OnNameChanged();
     3880        }
     3881      }
     3882    }
     3883   
     3884    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL")]
     3885    public System.Guid ResourceId
     3886    {
     3887      get
     3888      {
     3889        return this._ResourceId;
     3890      }
     3891      set
     3892      {
     3893        if ((this._ResourceId != value))
     3894        {
     3895          this.OnResourceIdChanging(value);
     3896          this.SendPropertyChanging();
     3897          this._ResourceId = value;
     3898          this.SendPropertyChanged("ResourceId");
     3899          this.OnResourceIdChanged();
     3900        }
     3901      }
     3902    }
     3903   
     3904    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExpirationTime", DbType="DateTime")]
     3905    public System.Nullable<System.DateTime> ExpirationTime
     3906    {
     3907      get
     3908      {
     3909        return this._ExpirationTime;
     3910      }
     3911      set
     3912      {
     3913        if ((this._ExpirationTime != value))
     3914        {
     3915          this.OnExpirationTimeChanging(value);
     3916          this.SendPropertyChanging();
     3917          this._ExpirationTime = value;
     3918          this.SendPropertyChanged("ExpirationTime");
     3919          this.OnExpirationTimeChanged();
     3920        }
     3921      }
     3922    }
     3923   
     3924    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceGroupId", DbType="UniqueIdentifier")]
     3925    public System.Nullable<System.Guid> ResourceGroupId
     3926    {
     3927      get
     3928      {
     3929        return this._ResourceGroupId;
     3930      }
     3931      set
     3932      {
     3933        if ((this._ResourceGroupId != value))
     3934        {
     3935          this.OnResourceGroupIdChanging(value);
     3936          this.SendPropertyChanging();
     3937          this._ResourceGroupId = value;
     3938          this.SendPropertyChanged("ResourceGroupId");
     3939          this.OnResourceGroupIdChanged();
     3940        }
     3941      }
     3942    }
     3943   
     3944    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceGroup2Id", DbType="UniqueIdentifier")]
     3945    public System.Nullable<System.Guid> ResourceGroup2Id
     3946    {
     3947      get
     3948      {
     3949        return this._ResourceGroup2Id;
     3950      }
     3951      set
     3952      {
     3953        if ((this._ResourceGroup2Id != value))
     3954        {
     3955          this.OnResourceGroup2IdChanging(value);
     3956          this.SendPropertyChanging();
     3957          this._ResourceGroup2Id = value;
     3958          this.SendPropertyChanged("ResourceGroup2Id");
     3959          this.OnResourceGroup2IdChanged();
     3960        }
     3961      }
     3962    }
     3963   
     3964    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GroupName")]
     3965    public string GroupName
     3966    {
     3967      get
     3968      {
     3969        return this._GroupName;
     3970      }
     3971      set
     3972      {
     3973        if ((this._GroupName != value))
     3974        {
     3975          this.OnGroupNameChanging(value);
     3976          this.SendPropertyChanging();
     3977          this._GroupName = value;
     3978          this.SendPropertyChanged("GroupName");
     3979          this.OnGroupNameChanged();
     3980        }
     3981      }
     3982    }
     3983   
     3984    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GroupName2")]
     3985    public string GroupName2
     3986    {
     3987      get
     3988      {
     3989        return this._GroupName2;
     3990      }
     3991      set
     3992      {
     3993        if ((this._GroupName2 != value))
     3994        {
     3995          this.OnGroupName2Changing(value);
     3996          this.SendPropertyChanging();
     3997          this._GroupName2 = value;
     3998          this.SendPropertyChanged("GroupName2");
     3999          this.OnGroupName2Changed();
     4000        }
     4001      }
     4002    }
     4003   
     4004    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactTask", Storage="_FactTasks", ThisKey="Id", OtherKey="LastClientId")]
     4005    public EntitySet<FactTask> FactTasks
     4006    {
     4007      get
     4008      {
     4009        return this._FactTasks;
     4010      }
     4011      set
     4012      {
     4013        this._FactTasks.Assign(value);
     4014      }
     4015    }
     4016   
     4017    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactClientInfo", Storage="_FactClientInfos", ThisKey="Id", OtherKey="ClientId")]
     4018    public EntitySet<FactClientInfo> FactClientInfos
     4019    {
     4020      get
     4021      {
     4022        return this._FactClientInfos;
     4023      }
     4024      set
     4025      {
     4026        this._FactClientInfos.Assign(value);
     4027      }
     4028    }
     4029   
     4030    public event PropertyChangingEventHandler PropertyChanging;
     4031   
     4032    public event PropertyChangedEventHandler PropertyChanged;
     4033   
     4034    protected virtual void SendPropertyChanging()
     4035    {
     4036      if ((this.PropertyChanging != null))
     4037      {
     4038        this.PropertyChanging(this, emptyChangingEventArgs);
     4039      }
     4040    }
     4041   
     4042    protected virtual void SendPropertyChanged(String propertyName)
     4043    {
     4044      if ((this.PropertyChanged != null))
     4045      {
     4046        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     4047      }
     4048    }
     4049   
     4050    private void attach_FactTasks(FactTask entity)
     4051    {
     4052      this.SendPropertyChanging();
     4053      entity.DimClient = this;
     4054    }
     4055   
     4056    private void detach_FactTasks(FactTask entity)
     4057    {
     4058      this.SendPropertyChanging();
     4059      entity.DimClient = null;
     4060    }
     4061   
     4062    private void attach_FactClientInfos(FactClientInfo entity)
     4063    {
     4064      this.SendPropertyChanging();
     4065      entity.DimClient = this;
     4066    }
     4067   
     4068    private void detach_FactClientInfos(FactClientInfo entity)
     4069    {
     4070      this.SendPropertyChanging();
     4071      entity.DimClient = null;
     4072    }
     4073  }
     4074 
     4075  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].FactTask")]
     4076  public partial class FactTask : INotifyPropertyChanging, INotifyPropertyChanged
     4077  {
     4078   
     4079    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     4080   
     4081    private System.Guid _TaskId;
     4082   
     4083    private long _TotalRuntime;
     4084   
     4085    private long _TotalWaitingTime;
     4086   
     4087    private long _TotalTransferTime;
     4088   
     4089    private int _NumCalculationRuns;
     4090   
     4091    private int _NumFails;
     4092   
     4093    private int _CoresRequired;
     4094   
     4095    private int _MemoryRequired;
     4096   
     4097    private int _Priority;
     4098   
     4099    private System.Nullable<System.Guid> _LastClientId;
     4100   
     4101    private System.Guid _JobId;
     4102   
     4103    private System.Nullable<System.DateTime> _EndTime;
     4104   
     4105    private global::HeuristicLab.Services.Hive.DataAccess.TaskState _TaskState;
     4106   
     4107    private string _Exception;
     4108   
     4109    private long _InitialWaitingTimeMs;
     4110   
     4111    private System.Nullable<System.DateTime> _StartTime;
     4112   
     4113    private EntityRef<DimClient> _DimClient;
     4114   
     4115    private EntityRef<DimJob> _DimJob;
     4116   
     4117    #region Extensibility Method Definitions
     4118    partial void OnLoaded();
     4119    partial void OnValidate(System.Data.Linq.ChangeAction action);
     4120    partial void OnCreated();
     4121    partial void OnTaskIdChanging(System.Guid value);
     4122    partial void OnTaskIdChanged();
     4123    partial void OnCalculatingTimeChanging(long value);
     4124    partial void OnCalculatingTimeChanged();
     4125    partial void OnWaitingTimeChanging(long value);
     4126    partial void OnWaitingTimeChanged();
     4127    partial void OnTransferTimeChanging(long value);
     4128    partial void OnTransferTimeChanged();
     4129    partial void OnNumCalculationRunsChanging(int value);
     4130    partial void OnNumCalculationRunsChanged();
     4131    partial void OnNumRetriesChanging(int value);
     4132    partial void OnNumRetriesChanged();
     4133    partial void OnCoresRequiredChanging(int value);
     4134    partial void OnCoresRequiredChanged();
     4135    partial void OnMemoryRequiredChanging(int value);
     4136    partial void OnMemoryRequiredChanged();
     4137    partial void OnPriorityChanging(int value);
     4138    partial void OnPriorityChanged();
     4139    partial void OnLastClientIdChanging(System.Nullable<System.Guid> value);
     4140    partial void OnLastClientIdChanged();
     4141    partial void OnJobIdChanging(System.Guid value);
     4142    partial void OnJobIdChanged();
     4143    partial void OnEndTimeChanging(System.Nullable<System.DateTime> value);
     4144    partial void OnEndTimeChanged();
     4145    partial void OnTaskStateChanging(global::HeuristicLab.Services.Hive.DataAccess.TaskState value);
     4146    partial void OnTaskStateChanged();
     4147    partial void OnExceptionChanging(string value);
     4148    partial void OnExceptionChanged();
     4149    partial void OnInitialWaitingTimeChanging(long value);
     4150    partial void OnInitialWaitingTimeChanged();
     4151    partial void OnStartTimeChanging(System.Nullable<System.DateTime> value);
     4152    partial void OnStartTimeChanged();
     4153    #endregion
     4154   
     4155    public FactTask()
     4156    {
     4157      this._DimClient = default(EntityRef<DimClient>);
     4158      this._DimJob = default(EntityRef<DimJob>);
     4159      OnCreated();
     4160    }
     4161   
     4162    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TaskId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
     4163    public System.Guid TaskId
     4164    {
     4165      get
     4166      {
     4167        return this._TaskId;
     4168      }
     4169      set
     4170      {
     4171        if ((this._TaskId != value))
     4172        {
     4173          this.OnTaskIdChanging(value);
     4174          this.SendPropertyChanging();
     4175          this._TaskId = value;
     4176          this.SendPropertyChanged("TaskId");
     4177          this.OnTaskIdChanged();
     4178        }
     4179      }
     4180    }
     4181   
     4182    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalRuntime", DbType="INT NOT NULL")]
     4183    public long CalculatingTime
     4184    {
     4185      get
     4186      {
     4187        return this._TotalRuntime;
     4188      }
     4189      set
     4190      {
     4191        if ((this._TotalRuntime != value))
     4192        {
     4193          this.OnCalculatingTimeChanging(value);
     4194          this.SendPropertyChanging();
     4195          this._TotalRuntime = value;
     4196          this.SendPropertyChanged("CalculatingTime");
     4197          this.OnCalculatingTimeChanged();
     4198        }
     4199      }
     4200    }
     4201   
     4202    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalWaitingTime", DbType="INT NOT NULL")]
     4203    public long WaitingTime
     4204    {
     4205      get
     4206      {
     4207        return this._TotalWaitingTime;
     4208      }
     4209      set
     4210      {
     4211        if ((this._TotalWaitingTime != value))
     4212        {
     4213          this.OnWaitingTimeChanging(value);
     4214          this.SendPropertyChanging();
     4215          this._TotalWaitingTime = value;
     4216          this.SendPropertyChanged("WaitingTime");
     4217          this.OnWaitingTimeChanged();
     4218        }
     4219      }
     4220    }
     4221   
     4222    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTransferTime", DbType="INT NOT NULL")]
     4223    public long TransferTime
     4224    {
     4225      get
     4226      {
     4227        return this._TotalTransferTime;
     4228      }
     4229      set
     4230      {
     4231        if ((this._TotalTransferTime != value))
     4232        {
     4233          this.OnTransferTimeChanging(value);
     4234          this.SendPropertyChanging();
     4235          this._TotalTransferTime = value;
     4236          this.SendPropertyChanged("TransferTime");
     4237          this.OnTransferTimeChanged();
     4238        }
     4239      }
     4240    }
     4241   
     4242    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumCalculationRuns", DbType="Int NOT NULL")]
     4243    public int NumCalculationRuns
     4244    {
     4245      get
     4246      {
     4247        return this._NumCalculationRuns;
     4248      }
     4249      set
     4250      {
     4251        if ((this._NumCalculationRuns != value))
     4252        {
     4253          this.OnNumCalculationRunsChanging(value);
     4254          this.SendPropertyChanging();
     4255          this._NumCalculationRuns = value;
     4256          this.SendPropertyChanged("NumCalculationRuns");
     4257          this.OnNumCalculationRunsChanged();
     4258        }
     4259      }
     4260    }
     4261   
     4262    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumFails", DbType="Int NOT NULL")]
     4263    public int NumRetries
     4264    {
     4265      get
     4266      {
     4267        return this._NumFails;
     4268      }
     4269      set
     4270      {
     4271        if ((this._NumFails != value))
     4272        {
     4273          this.OnNumRetriesChanging(value);
     4274          this.SendPropertyChanging();
     4275          this._NumFails = value;
     4276          this.SendPropertyChanged("NumRetries");
     4277          this.OnNumRetriesChanged();
     4278        }
     4279      }
     4280    }
     4281   
     4282    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CoresRequired", DbType="Int NOT NULL")]
     4283    public int CoresRequired
     4284    {
     4285      get
     4286      {
     4287        return this._CoresRequired;
     4288      }
     4289      set
     4290      {
     4291        if ((this._CoresRequired != value))
     4292        {
     4293          this.OnCoresRequiredChanging(value);
     4294          this.SendPropertyChanging();
     4295          this._CoresRequired = value;
     4296          this.SendPropertyChanged("CoresRequired");
     4297          this.OnCoresRequiredChanged();
     4298        }
     4299      }
     4300    }
     4301   
     4302    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_MemoryRequired", DbType="Int NOT NULL")]
     4303    public int MemoryRequired
     4304    {
     4305      get
     4306      {
     4307        return this._MemoryRequired;
     4308      }
     4309      set
     4310      {
     4311        if ((this._MemoryRequired != value))
     4312        {
     4313          this.OnMemoryRequiredChanging(value);
     4314          this.SendPropertyChanging();
     4315          this._MemoryRequired = value;
     4316          this.SendPropertyChanged("MemoryRequired");
     4317          this.OnMemoryRequiredChanged();
     4318        }
     4319      }
     4320    }
     4321   
     4322    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Priority", DbType="Int NOT NULL")]
     4323    public int Priority
     4324    {
     4325      get
     4326      {
     4327        return this._Priority;
     4328      }
     4329      set
     4330      {
     4331        if ((this._Priority != value))
     4332        {
     4333          this.OnPriorityChanging(value);
     4334          this.SendPropertyChanging();
     4335          this._Priority = value;
     4336          this.SendPropertyChanged("Priority");
     4337          this.OnPriorityChanged();
     4338        }
     4339      }
     4340    }
     4341   
     4342    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastClientId", DbType="UniqueIdentifier NOT NULL")]
     4343    public System.Nullable<System.Guid> LastClientId
     4344    {
     4345      get
     4346      {
     4347        return this._LastClientId;
     4348      }
     4349      set
     4350      {
     4351        if ((this._LastClientId != value))
     4352        {
     4353          if (this._DimClient.HasLoadedOrAssignedValue)
     4354          {
     4355            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
     4356          }
     4357          this.OnLastClientIdChanging(value);
     4358          this.SendPropertyChanging();
     4359          this._LastClientId = value;
     4360          this.SendPropertyChanged("LastClientId");
     4361          this.OnLastClientIdChanged();
     4362        }
     4363      }
     4364    }
     4365   
     4366    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL")]
     4367    public System.Guid JobId
     4368    {
     4369      get
     4370      {
     4371        return this._JobId;
     4372      }
     4373      set
     4374      {
     4375        if ((this._JobId != value))
     4376        {
     4377          if (this._DimJob.HasLoadedOrAssignedValue)
     4378          {
     4379            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
     4380          }
     4381          this.OnJobIdChanging(value);
     4382          this.SendPropertyChanging();
     4383          this._JobId = value;
     4384          this.SendPropertyChanged("JobId");
     4385          this.OnJobIdChanged();
     4386        }
     4387      }
     4388    }
     4389   
     4390    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_EndTime", DbType="DateTime NOT NULL")]
     4391    public System.Nullable<System.DateTime> EndTime
     4392    {
     4393      get
     4394      {
     4395        return this._EndTime;
     4396      }
     4397      set
     4398      {
     4399        if ((this._EndTime != value))
     4400        {
     4401          this.OnEndTimeChanging(value);
     4402          this.SendPropertyChanging();
     4403          this._EndTime = value;
     4404          this.SendPropertyChanged("EndTime");
     4405          this.OnEndTimeChanged();
     4406        }
     4407      }
     4408    }
     4409   
     4410    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TaskState", DbType="varchar(30)", CanBeNull=false)]
     4411    public global::HeuristicLab.Services.Hive.DataAccess.TaskState TaskState
     4412    {
     4413      get
     4414      {
     4415        return this._TaskState;
     4416      }
     4417      set
     4418      {
     4419        if ((this._TaskState != value))
     4420        {
     4421          this.OnTaskStateChanging(value);
     4422          this.SendPropertyChanging();
     4423          this._TaskState = value;
     4424          this.SendPropertyChanged("TaskState");
     4425          this.OnTaskStateChanged();
     4426        }
     4427      }
     4428    }
     4429   
     4430    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Exception", DbType="varchar(MAX)")]
     4431    public string Exception
     4432    {
     4433      get
     4434      {
     4435        return this._Exception;
     4436      }
     4437      set
     4438      {
     4439        if ((this._Exception != value))
     4440        {
     4441          this.OnExceptionChanging(value);
     4442          this.SendPropertyChanging();
     4443          this._Exception = value;
     4444          this.SendPropertyChanged("Exception");
     4445          this.OnExceptionChanged();
     4446        }
     4447      }
     4448    }
     4449   
     4450    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_InitialWaitingTimeMs", DbType="INT")]
     4451    public long InitialWaitingTime
     4452    {
     4453      get
     4454      {
     4455        return this._InitialWaitingTimeMs;
     4456      }
     4457      set
     4458      {
     4459        if ((this._InitialWaitingTimeMs != value))
     4460        {
     4461          this.OnInitialWaitingTimeChanging(value);
     4462          this.SendPropertyChanging();
     4463          this._InitialWaitingTimeMs = value;
     4464          this.SendPropertyChanged("InitialWaitingTime");
     4465          this.OnInitialWaitingTimeChanged();
     4466        }
     4467      }
     4468    }
     4469   
     4470    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartTime")]
     4471    public System.Nullable<System.DateTime> StartTime
     4472    {
     4473      get
     4474      {
     4475        return this._StartTime;
     4476      }
     4477      set
     4478      {
     4479        if ((this._StartTime != value))
     4480        {
     4481          this.OnStartTimeChanging(value);
     4482          this.SendPropertyChanging();
     4483          this._StartTime = value;
     4484          this.SendPropertyChanged("StartTime");
     4485          this.OnStartTimeChanged();
     4486        }
     4487      }
     4488    }
     4489   
     4490    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactTask", Storage="_DimClient", ThisKey="LastClientId", OtherKey="Id", IsForeignKey=true)]
     4491    public DimClient DimClient
     4492    {
     4493      get
     4494      {
     4495        return this._DimClient.Entity;
     4496      }
     4497      set
     4498      {
     4499        DimClient previousValue = this._DimClient.Entity;
     4500        if (((previousValue != value)
     4501              || (this._DimClient.HasLoadedOrAssignedValue == false)))
     4502        {
     4503          this.SendPropertyChanging();
     4504          if ((previousValue != null))
     4505          {
     4506            this._DimClient.Entity = null;
     4507            previousValue.FactTasks.Remove(this);
     4508          }
     4509          this._DimClient.Entity = value;
     4510          if ((value != null))
     4511          {
     4512            value.FactTasks.Add(this);
     4513            this._LastClientId = value.Id;
     4514          }
     4515          else
     4516          {
     4517            this._LastClientId = default(Nullable<System.Guid>);
     4518          }
     4519          this.SendPropertyChanged("DimClient");
     4520        }
     4521      }
     4522    }
     4523   
     4524    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimJob_FactTask", Storage="_DimJob", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true)]
     4525    public DimJob DimJob
     4526    {
     4527      get
     4528      {
     4529        return this._DimJob.Entity;
     4530      }
     4531      set
     4532      {
     4533        DimJob previousValue = this._DimJob.Entity;
     4534        if (((previousValue != value)
     4535              || (this._DimJob.HasLoadedOrAssignedValue == false)))
     4536        {
     4537          this.SendPropertyChanging();
     4538          if ((previousValue != null))
     4539          {
     4540            this._DimJob.Entity = null;
     4541            previousValue.FactTasks.Remove(this);
     4542          }
     4543          this._DimJob.Entity = value;
     4544          if ((value != null))
     4545          {
     4546            value.FactTasks.Add(this);
     4547            this._JobId = value.JobId;
     4548          }
     4549          else
     4550          {
     4551            this._JobId = default(System.Guid);
     4552          }
     4553          this.SendPropertyChanged("DimJob");
     4554        }
     4555      }
     4556    }
     4557   
     4558    public event PropertyChangingEventHandler PropertyChanging;
     4559   
     4560    public event PropertyChangedEventHandler PropertyChanged;
     4561   
     4562    protected virtual void SendPropertyChanging()
     4563    {
     4564      if ((this.PropertyChanging != null))
     4565      {
     4566        this.PropertyChanging(this, emptyChangingEventArgs);
     4567      }
     4568    }
     4569   
     4570    protected virtual void SendPropertyChanged(String propertyName)
     4571    {
     4572      if ((this.PropertyChanged != null))
     4573      {
     4574        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     4575      }
     4576    }
     4577  }
     4578 
     4579  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimJob")]
     4580  public partial class DimJob : INotifyPropertyChanging, INotifyPropertyChanged
     4581  {
     4582   
     4583    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     4584   
     4585    private System.Guid _JobId;
     4586   
     4587    private System.Guid _UserId;
     4588   
     4589    private string _JobName;
     4590   
     4591    private string _UserName;
     4592   
     4593    private System.DateTime _DateCreated;
     4594   
     4595    private int _TotalTasks;
     4596   
     4597    private int _CompletedTasks;
     4598   
     4599    private System.Nullable<System.DateTime> _DateCompleted;
     4600   
     4601    private EntitySet<FactTask> _FactTasks;
     4602   
     4603    #region Extensibility Method Definitions
     4604    partial void OnLoaded();
     4605    partial void OnValidate(System.Data.Linq.ChangeAction action);
     4606    partial void OnCreated();
     4607    partial void OnJobIdChanging(System.Guid value);
     4608    partial void OnJobIdChanged();
     4609    partial void OnUserIdChanging(System.Guid value);
     4610    partial void OnUserIdChanged();
     4611    partial void OnJobNameChanging(string value);
     4612    partial void OnJobNameChanged();
     4613    partial void OnUserNameChanging(string value);
     4614    partial void OnUserNameChanged();
     4615    partial void OnDateCreatedChanging(System.DateTime value);
     4616    partial void OnDateCreatedChanged();
     4617    partial void OnTotalTasksChanging(int value);
     4618    partial void OnTotalTasksChanged();
     4619    partial void OnCompletedTasksChanging(int value);
     4620    partial void OnCompletedTasksChanged();
     4621    partial void OnDateCompletedChanging(System.Nullable<System.DateTime> value);
     4622    partial void OnDateCompletedChanged();
     4623    #endregion
     4624   
     4625    public DimJob()
     4626    {
     4627      this._FactTasks = new EntitySet<FactTask>(new Action<FactTask>(this.attach_FactTasks), new Action<FactTask>(this.detach_FactTasks));
     4628      OnCreated();
     4629    }
     4630   
     4631    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
     4632    public System.Guid JobId
     4633    {
     4634      get
     4635      {
     4636        return this._JobId;
     4637      }
     4638      set
     4639      {
     4640        if ((this._JobId != value))
     4641        {
     4642          this.OnJobIdChanging(value);
     4643          this.SendPropertyChanging();
     4644          this._JobId = value;
     4645          this.SendPropertyChanged("JobId");
     4646          this.OnJobIdChanged();
     4647        }
     4648      }
     4649    }
     4650   
     4651    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL")]
     4652    public System.Guid UserId
     4653    {
     4654      get
     4655      {
     4656        return this._UserId;
     4657      }
     4658      set
     4659      {
     4660        if ((this._UserId != value))
     4661        {
     4662          this.OnUserIdChanging(value);
     4663          this.SendPropertyChanging();
     4664          this._UserId = value;
     4665          this.SendPropertyChanged("UserId");
     4666          this.OnUserIdChanged();
     4667        }
     4668      }
     4669    }
     4670   
     4671    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobName", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
     4672    public string JobName
     4673    {
     4674      get
     4675      {
     4676        return this._JobName;
     4677      }
     4678      set
     4679      {
     4680        if ((this._JobName != value))
     4681        {
     4682          this.OnJobNameChanging(value);
     4683          this.SendPropertyChanging();
     4684          this._JobName = value;
     4685          this.SendPropertyChanged("JobName");
     4686          this.OnJobNameChanged();
     4687        }
     4688      }
     4689    }
     4690   
     4691    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserName", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
     4692    public string UserName
     4693    {
     4694      get
     4695      {
     4696        return this._UserName;
     4697      }
     4698      set
     4699      {
     4700        if ((this._UserName != value))
     4701        {
     4702          this.OnUserNameChanging(value);
     4703          this.SendPropertyChanging();
     4704          this._UserName = value;
     4705          this.SendPropertyChanged("UserName");
     4706          this.OnUserNameChanged();
     4707        }
     4708      }
     4709    }
     4710   
     4711    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCreated", DbType="DateTime NOT NULL")]
     4712    public System.DateTime DateCreated
     4713    {
     4714      get
     4715      {
     4716        return this._DateCreated;
     4717      }
     4718      set
     4719      {
     4720        if ((this._DateCreated != value))
     4721        {
     4722          this.OnDateCreatedChanging(value);
     4723          this.SendPropertyChanging();
     4724          this._DateCreated = value;
     4725          this.SendPropertyChanged("DateCreated");
     4726          this.OnDateCreatedChanged();
     4727        }
     4728      }
     4729    }
     4730   
     4731    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTasks", DbType="INT NOT NULL")]
     4732    public int TotalTasks
     4733    {
     4734      get
     4735      {
     4736        return this._TotalTasks;
     4737      }
     4738      set
     4739      {
     4740        if ((this._TotalTasks != value))
     4741        {
     4742          this.OnTotalTasksChanging(value);
     4743          this.SendPropertyChanging();
     4744          this._TotalTasks = value;
     4745          this.SendPropertyChanged("TotalTasks");
     4746          this.OnTotalTasksChanged();
     4747        }
     4748      }
     4749    }
     4750   
     4751    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CompletedTasks", DbType="INT NOT NULL")]
     4752    public int CompletedTasks
     4753    {
     4754      get
     4755      {
     4756        return this._CompletedTasks;
     4757      }
     4758      set
     4759      {
     4760        if ((this._CompletedTasks != value))
     4761        {
     4762          this.OnCompletedTasksChanging(value);
     4763          this.SendPropertyChanging();
     4764          this._CompletedTasks = value;
     4765          this.SendPropertyChanged("CompletedTasks");
     4766          this.OnCompletedTasksChanged();
     4767        }
     4768      }
     4769    }
     4770   
     4771    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCompleted", DbType="DateTime NULL")]
     4772    public System.Nullable<System.DateTime> DateCompleted
     4773    {
     4774      get
     4775      {
     4776        return this._DateCompleted;
     4777      }
     4778      set
     4779      {
     4780        if ((this._DateCompleted != value))
     4781        {
     4782          this.OnDateCompletedChanging(value);
     4783          this.SendPropertyChanging();
     4784          this._DateCompleted = value;
     4785          this.SendPropertyChanged("DateCompleted");
     4786          this.OnDateCompletedChanged();
     4787        }
     4788      }
     4789    }
     4790   
     4791    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimJob_FactTask", Storage="_FactTasks", ThisKey="JobId", OtherKey="JobId")]
     4792    public EntitySet<FactTask> FactTasks
     4793    {
     4794      get
     4795      {
     4796        return this._FactTasks;
     4797      }
     4798      set
     4799      {
     4800        this._FactTasks.Assign(value);
     4801      }
     4802    }
     4803   
     4804    public event PropertyChangingEventHandler PropertyChanging;
     4805   
     4806    public event PropertyChangedEventHandler PropertyChanged;
     4807   
     4808    protected virtual void SendPropertyChanging()
     4809    {
     4810      if ((this.PropertyChanging != null))
     4811      {
     4812        this.PropertyChanging(this, emptyChangingEventArgs);
     4813      }
     4814    }
     4815   
     4816    protected virtual void SendPropertyChanged(String propertyName)
     4817    {
     4818      if ((this.PropertyChanged != null))
     4819      {
     4820        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     4821      }
     4822    }
     4823   
     4824    private void attach_FactTasks(FactTask entity)
     4825    {
     4826      this.SendPropertyChanging();
     4827      entity.DimJob = this;
     4828    }
     4829   
     4830    private void detach_FactTasks(FactTask entity)
     4831    {
     4832      this.SendPropertyChanging();
     4833      entity.DimJob = null;
     4834    }
     4835  }
     4836 
     4837  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimTime")]
     4838  public partial class DimTime : INotifyPropertyChanging, INotifyPropertyChanged
     4839  {
     4840   
     4841    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     4842   
     4843    private System.DateTime _Time;
     4844   
     4845    private System.DateTime _Hour;
     4846   
     4847    private System.DateTime _Day;
     4848   
     4849    private System.DateTime _Month;
     4850   
     4851    private System.DateTime _Year;
     4852   
     4853    private System.DateTime _Minute;
     4854   
     4855    private EntitySet<FactClientInfo> _FactClientInfos;
     4856   
     4857    #region Extensibility Method Definitions
     4858    partial void OnLoaded();
     4859    partial void OnValidate(System.Data.Linq.ChangeAction action);
     4860    partial void OnCreated();
     4861    partial void OnTimeChanging(System.DateTime value);
     4862    partial void OnTimeChanged();
     4863    partial void OnHourChanging(System.DateTime value);
     4864    partial void OnHourChanged();
     4865    partial void OnDayChanging(System.DateTime value);
     4866    partial void OnDayChanged();
     4867    partial void OnMonthChanging(System.DateTime value);
     4868    partial void OnMonthChanged();
     4869    partial void OnYearChanging(System.DateTime value);
     4870    partial void OnYearChanged();
     4871    partial void OnMinuteChanging(System.DateTime value);
     4872    partial void OnMinuteChanged();
     4873    #endregion
     4874   
     4875    public DimTime()
     4876    {
     4877      this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
     4878      OnCreated();
     4879    }
     4880   
     4881    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Time", DbType="DateTime NOT NULL", IsPrimaryKey=true)]
     4882    public System.DateTime Time
     4883    {
     4884      get
     4885      {
     4886        return this._Time;
     4887      }
     4888      set
     4889      {
     4890        if ((this._Time != value))
     4891        {
     4892          this.OnTimeChanging(value);
     4893          this.SendPropertyChanging();
     4894          this._Time = value;
     4895          this.SendPropertyChanged("Time");
     4896          this.OnTimeChanged();
     4897        }
     4898      }
     4899    }
     4900   
     4901    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Hour", DbType="DateTime NOT NULL")]
     4902    public System.DateTime Hour
     4903    {
     4904      get
     4905      {
     4906        return this._Hour;
     4907      }
     4908      set
     4909      {
     4910        if ((this._Hour != value))
     4911        {
     4912          this.OnHourChanging(value);
     4913          this.SendPropertyChanging();
     4914          this._Hour = value;
     4915          this.SendPropertyChanged("Hour");
     4916          this.OnHourChanged();
     4917        }
     4918      }
     4919    }
     4920   
     4921    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Day", DbType="Date NOT NULL")]
     4922    public System.DateTime Day
     4923    {
     4924      get
     4925      {
     4926        return this._Day;
     4927      }
     4928      set
     4929      {
     4930        if ((this._Day != value))
     4931        {
     4932          this.OnDayChanging(value);
     4933          this.SendPropertyChanging();
     4934          this._Day = value;
     4935          this.SendPropertyChanged("Day");
     4936          this.OnDayChanged();
     4937        }
     4938      }
     4939    }
     4940   
     4941    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Month", DbType="Date NOT NULL")]
     4942    public System.DateTime Month
     4943    {
     4944      get
     4945      {
     4946        return this._Month;
     4947      }
     4948      set
     4949      {
     4950        if ((this._Month != value))
     4951        {
     4952          this.OnMonthChanging(value);
     4953          this.SendPropertyChanging();
     4954          this._Month = value;
     4955          this.SendPropertyChanged("Month");
     4956          this.OnMonthChanged();
     4957        }
     4958      }
     4959    }
     4960   
     4961    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Year", DbType="Date NOT NULL")]
     4962    public System.DateTime Year
     4963    {
     4964      get
     4965      {
     4966        return this._Year;
     4967      }
     4968      set
     4969      {
     4970        if ((this._Year != value))
     4971        {
     4972          this.OnYearChanging(value);
     4973          this.SendPropertyChanging();
     4974          this._Year = value;
     4975          this.SendPropertyChanged("Year");
     4976          this.OnYearChanged();
     4977        }
     4978      }
     4979    }
     4980   
     4981    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Minute")]
     4982    public System.DateTime Minute
     4983    {
     4984      get
     4985      {
     4986        return this._Minute;
     4987      }
     4988      set
     4989      {
     4990        if ((this._Minute != value))
     4991        {
     4992          this.OnMinuteChanging(value);
     4993          this.SendPropertyChanging();
     4994          this._Minute = value;
     4995          this.SendPropertyChanged("Minute");
     4996          this.OnMinuteChanged();
     4997        }
     4998      }
     4999    }
     5000   
     5001    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactClientInfo", Storage="_FactClientInfos", ThisKey="Time", OtherKey="Time")]
     5002    public EntitySet<FactClientInfo> FactClientInfos
     5003    {
     5004      get
     5005      {
     5006        return this._FactClientInfos;
     5007      }
     5008      set
     5009      {
     5010        this._FactClientInfos.Assign(value);
     5011      }
     5012    }
     5013   
     5014    public event PropertyChangingEventHandler PropertyChanging;
     5015   
     5016    public event PropertyChangedEventHandler PropertyChanged;
     5017   
     5018    protected virtual void SendPropertyChanging()
     5019    {
     5020      if ((this.PropertyChanging != null))
     5021      {
     5022        this.PropertyChanging(this, emptyChangingEventArgs);
     5023      }
     5024    }
     5025   
     5026    protected virtual void SendPropertyChanged(String propertyName)
     5027    {
     5028      if ((this.PropertyChanged != null))
     5029      {
     5030        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     5031      }
     5032    }
     5033   
     5034    private void attach_FactClientInfos(FactClientInfo entity)
     5035    {
     5036      this.SendPropertyChanging();
     5037      entity.DimTime = this;
     5038    }
     5039   
     5040    private void detach_FactClientInfos(FactClientInfo entity)
     5041    {
     5042      this.SendPropertyChanging();
     5043      entity.DimTime = null;
     5044    }
     5045  }
     5046 
     5047  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimUser")]
     5048  public partial class DimUser : INotifyPropertyChanging, INotifyPropertyChanged
     5049  {
     5050   
     5051    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     5052   
     5053    private System.Guid _UserId;
     5054   
     5055    private string _Name;
     5056   
     5057    private EntitySet<FactClientInfo> _FactClientInfos;
     5058   
     5059    #region Extensibility Method Definitions
     5060    partial void OnLoaded();
     5061    partial void OnValidate(System.Data.Linq.ChangeAction action);
     5062    partial void OnCreated();
     5063    partial void OnUserIdChanging(System.Guid value);
     5064    partial void OnUserIdChanged();
     5065    partial void OnNameChanging(string value);
     5066    partial void OnNameChanged();
     5067    #endregion
     5068   
     5069    public DimUser()
     5070    {
     5071      this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
     5072      OnCreated();
     5073    }
     5074   
     5075    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
     5076    public System.Guid UserId
     5077    {
     5078      get
     5079      {
     5080        return this._UserId;
     5081      }
     5082      set
     5083      {
     5084        if ((this._UserId != value))
     5085        {
     5086          this.OnUserIdChanging(value);
     5087          this.SendPropertyChanging();
     5088          this._UserId = value;
     5089          this.SendPropertyChanged("UserId");
     5090          this.OnUserIdChanged();
     5091        }
     5092      }
     5093    }
     5094   
     5095    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
     5096    public string Name
     5097    {
     5098      get
     5099      {
     5100        return this._Name;
     5101      }
     5102      set
     5103      {
     5104        if ((this._Name != value))
     5105        {
     5106          this.OnNameChanging(value);
     5107          this.SendPropertyChanging();
     5108          this._Name = value;
     5109          this.SendPropertyChanged("Name");
     5110          this.OnNameChanged();
     5111        }
     5112      }
     5113    }
     5114   
     5115    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimUser_FactClientInfo", Storage="_FactClientInfos", ThisKey="UserId", OtherKey="UserId")]
     5116    public EntitySet<FactClientInfo> FactClientInfos
     5117    {
     5118      get
     5119      {
     5120        return this._FactClientInfos;
     5121      }
     5122      set
     5123      {
     5124        this._FactClientInfos.Assign(value);
     5125      }
     5126    }
     5127   
     5128    public event PropertyChangingEventHandler PropertyChanging;
     5129   
     5130    public event PropertyChangedEventHandler PropertyChanged;
     5131   
     5132    protected virtual void SendPropertyChanging()
     5133    {
     5134      if ((this.PropertyChanging != null))
     5135      {
     5136        this.PropertyChanging(this, emptyChangingEventArgs);
     5137      }
     5138    }
     5139   
     5140    protected virtual void SendPropertyChanged(String propertyName)
     5141    {
     5142      if ((this.PropertyChanged != null))
     5143      {
     5144        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     5145      }
     5146    }
     5147   
     5148    private void attach_FactClientInfos(FactClientInfo entity)
     5149    {
     5150      this.SendPropertyChanging();
     5151      entity.DimUser = this;
     5152    }
     5153   
     5154    private void detach_FactClientInfos(FactClientInfo entity)
     5155    {
     5156      this.SendPropertyChanging();
     5157      entity.DimUser = null;
     5158    }
     5159  }
     5160 
     5161  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].FactClientInfo")]
     5162  public partial class FactClientInfo : INotifyPropertyChanging, INotifyPropertyChanged
     5163  {
     5164   
     5165    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     5166   
     5167    private System.Guid _ClientId;
     5168   
     5169    private System.DateTime _Time;
     5170   
     5171    private System.Guid _UserId;
     5172   
     5173    private int _NumUsedCores;
     5174   
     5175    private int _NumTotalCores;
     5176   
     5177    private int _UsedMemory;
     5178   
     5179    private int _TotalMemory;
     5180   
     5181    private double _CpuUtilization;
     5182   
     5183    private long _TotalTimeIdle;
     5184   
     5185    private long _TotalTimeOffline;
     5186   
     5187    private long _TotalTimeUnavailable;
     5188   
     5189    private global::HeuristicLab.Services.Hive.DataAccess.SlaveState _SlaveState;
     5190   
     5191    private bool _IsAllowedToCalculate;
     5192   
     5193    private EntityRef<DimClient> _DimClient;
     5194   
     5195    private EntityRef<DimTime> _DimTime;
     5196   
     5197    private EntityRef<DimUser> _DimUser;
     5198   
     5199    #region Extensibility Method Definitions
     5200    partial void OnLoaded();
     5201    partial void OnValidate(System.Data.Linq.ChangeAction action);
     5202    partial void OnCreated();
     5203    partial void OnClientIdChanging(System.Guid value);
     5204    partial void OnClientIdChanged();
     5205    partial void OnTimeChanging(System.DateTime value);
     5206    partial void OnTimeChanged();
     5207    partial void OnUserIdChanging(System.Guid value);
     5208    partial void OnUserIdChanged();
     5209    partial void OnNumUsedCoresChanging(int value);
     5210    partial void OnNumUsedCoresChanged();
     5211    partial void OnNumTotalCoresChanging(int value);
     5212    partial void OnNumTotalCoresChanged();
     5213    partial void OnUsedMemoryChanging(int value);
     5214    partial void OnUsedMemoryChanged();
     5215    partial void OnTotalMemoryChanging(int value);
     5216    partial void OnTotalMemoryChanged();
     5217    partial void OnCpuUtilizationChanging(double value);
     5218    partial void OnCpuUtilizationChanged();
     5219    partial void OnIdleTimeChanging(long value);
     5220    partial void OnIdleTimeChanged();
     5221    partial void OnOfflineTimeChanging(long value);
     5222    partial void OnOfflineTimeChanged();
     5223    partial void OnUnavailableTimeChanging(long value);
     5224    partial void OnUnavailableTimeChanged();
     5225    partial void OnSlaveStateChanging(global::HeuristicLab.Services.Hive.DataAccess.SlaveState value);
     5226    partial void OnSlaveStateChanged();
     5227    partial void OnIsAllowedToCalculateChanging(bool value);
     5228    partial void OnIsAllowedToCalculateChanged();
     5229    #endregion
     5230   
     5231    public FactClientInfo()
     5232    {
     5233      this._DimClient = default(EntityRef<DimClient>);
     5234      this._DimTime = default(EntityRef<DimTime>);
     5235      this._DimUser = default(EntityRef<DimUser>);
     5236      OnCreated();
     5237    }
     5238   
     5239    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ClientId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
     5240    public System.Guid ClientId
     5241    {
     5242      get
     5243      {
     5244        return this._ClientId;
     5245      }
     5246      set
     5247      {
     5248        if ((this._ClientId != value))
     5249        {
     5250          if (this._DimClient.HasLoadedOrAssignedValue)
     5251          {
     5252            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
     5253          }
     5254          this.OnClientIdChanging(value);
     5255          this.SendPropertyChanging();
     5256          this._ClientId = value;
     5257          this.SendPropertyChanged("ClientId");
     5258          this.OnClientIdChanged();
     5259        }
     5260      }
     5261    }
     5262   
     5263    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Time", DbType="DateTime NOT NULL", IsPrimaryKey=true)]
     5264    public System.DateTime Time
     5265    {
     5266      get
     5267      {
     5268        return this._Time;
     5269      }
     5270      set
     5271      {
     5272        if ((this._Time != value))
     5273        {
     5274          if (this._DimTime.HasLoadedOrAssignedValue)
     5275          {
     5276            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
     5277          }
     5278          this.OnTimeChanging(value);
     5279          this.SendPropertyChanging();
     5280          this._Time = value;
     5281          this.SendPropertyChanged("Time");
     5282          this.OnTimeChanged();
     5283        }
     5284      }
     5285    }
     5286   
     5287    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NULL", IsPrimaryKey=true)]
     5288    public System.Guid UserId
     5289    {
     5290      get
     5291      {
     5292        return this._UserId;
     5293      }
     5294      set
     5295      {
     5296        if ((this._UserId != value))
     5297        {
     5298          if (this._DimUser.HasLoadedOrAssignedValue)
     5299          {
     5300            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
     5301          }
     5302          this.OnUserIdChanging(value);
     5303          this.SendPropertyChanging();
     5304          this._UserId = value;
     5305          this.SendPropertyChanged("UserId");
     5306          this.OnUserIdChanged();
     5307        }
     5308      }
     5309    }
     5310   
     5311    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumUsedCores", DbType="Int NOT NULL")]
     5312    public int NumUsedCores
     5313    {
     5314      get
     5315      {
     5316        return this._NumUsedCores;
     5317      }
     5318      set
     5319      {
     5320        if ((this._NumUsedCores != value))
     5321        {
     5322          this.OnNumUsedCoresChanging(value);
     5323          this.SendPropertyChanging();
     5324          this._NumUsedCores = value;
     5325          this.SendPropertyChanged("NumUsedCores");
     5326          this.OnNumUsedCoresChanged();
     5327        }
     5328      }
     5329    }
     5330   
     5331    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumTotalCores", DbType="Int NOT NULL")]
     5332    public int NumTotalCores
     5333    {
     5334      get
     5335      {
     5336        return this._NumTotalCores;
     5337      }
     5338      set
     5339      {
     5340        if ((this._NumTotalCores != value))
     5341        {
     5342          this.OnNumTotalCoresChanging(value);
     5343          this.SendPropertyChanging();
     5344          this._NumTotalCores = value;
     5345          this.SendPropertyChanged("NumTotalCores");
     5346          this.OnNumTotalCoresChanged();
     5347        }
     5348      }
     5349    }
     5350   
     5351    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UsedMemory", DbType="Int NOT NULL")]
     5352    public int UsedMemory
     5353    {
     5354      get
     5355      {
     5356        return this._UsedMemory;
     5357      }
     5358      set
     5359      {
     5360        if ((this._UsedMemory != value))
     5361        {
     5362          this.OnUsedMemoryChanging(value);
     5363          this.SendPropertyChanging();
     5364          this._UsedMemory = value;
     5365          this.SendPropertyChanged("UsedMemory");
     5366          this.OnUsedMemoryChanged();
     5367        }
     5368      }
     5369    }
     5370   
     5371    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalMemory", DbType="Int NOT NULL")]
     5372    public int TotalMemory
     5373    {
     5374      get
     5375      {
     5376        return this._TotalMemory;
     5377      }
     5378      set
     5379      {
     5380        if ((this._TotalMemory != value))
     5381        {
     5382          this.OnTotalMemoryChanging(value);
     5383          this.SendPropertyChanging();
     5384          this._TotalMemory = value;
     5385          this.SendPropertyChanged("TotalMemory");
     5386          this.OnTotalMemoryChanged();
     5387        }
     5388      }
     5389    }
     5390   
     5391    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CpuUtilization", DbType="Float NOT NULL")]
     5392    public double CpuUtilization
     5393    {
     5394      get
     5395      {
     5396        return this._CpuUtilization;
     5397      }
     5398      set
     5399      {
     5400        if ((this._CpuUtilization != value))
     5401        {
     5402          this.OnCpuUtilizationChanging(value);
     5403          this.SendPropertyChanging();
     5404          this._CpuUtilization = value;
     5405          this.SendPropertyChanged("CpuUtilization");
     5406          this.OnCpuUtilizationChanged();
     5407        }
     5408      }
     5409    }
     5410   
     5411    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeIdle", DbType="INT NOT NULL")]
     5412    public long IdleTime
     5413    {
     5414      get
     5415      {
     5416        return this._TotalTimeIdle;
     5417      }
     5418      set
     5419      {
     5420        if ((this._TotalTimeIdle != value))
     5421        {
     5422          this.OnIdleTimeChanging(value);
     5423          this.SendPropertyChanging();
     5424          this._TotalTimeIdle = value;
     5425          this.SendPropertyChanged("IdleTime");
     5426          this.OnIdleTimeChanged();
     5427        }
     5428      }
     5429    }
     5430   
     5431    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeOffline", DbType="INT NOT NULL")]
     5432    public long OfflineTime
     5433    {
     5434      get
     5435      {
     5436        return this._TotalTimeOffline;
     5437      }
     5438      set
     5439      {
     5440        if ((this._TotalTimeOffline != value))
     5441        {
     5442          this.OnOfflineTimeChanging(value);
     5443          this.SendPropertyChanging();
     5444          this._TotalTimeOffline = value;
     5445          this.SendPropertyChanged("OfflineTime");
     5446          this.OnOfflineTimeChanged();
     5447        }
     5448      }
     5449    }
     5450   
     5451    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeUnavailable", DbType="INT NOT NULL")]
     5452    public long UnavailableTime
     5453    {
     5454      get
     5455      {
     5456        return this._TotalTimeUnavailable;
     5457      }
     5458      set
     5459      {
     5460        if ((this._TotalTimeUnavailable != value))
     5461        {
     5462          this.OnUnavailableTimeChanging(value);
     5463          this.SendPropertyChanging();
     5464          this._TotalTimeUnavailable = value;
     5465          this.SendPropertyChanged("UnavailableTime");
     5466          this.OnUnavailableTimeChanged();
     5467        }
     5468      }
     5469    }
     5470   
     5471    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SlaveState", DbType="VarChar(15)", CanBeNull=false)]
     5472    public global::HeuristicLab.Services.Hive.DataAccess.SlaveState SlaveState
     5473    {
     5474      get
     5475      {
     5476        return this._SlaveState;
     5477      }
     5478      set
     5479      {
     5480        if ((this._SlaveState != value))
     5481        {
     5482          this.OnSlaveStateChanging(value);
     5483          this.SendPropertyChanging();
     5484          this._SlaveState = value;
     5485          this.SendPropertyChanged("SlaveState");
     5486          this.OnSlaveStateChanged();
     5487        }
     5488      }
     5489    }
     5490   
     5491    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsAllowedToCalculate", DbType="BIT")]
     5492    public bool IsAllowedToCalculate
     5493    {
     5494      get
     5495      {
     5496        return this._IsAllowedToCalculate;
     5497      }
     5498      set
     5499      {
     5500        if ((this._IsAllowedToCalculate != value))
     5501        {
     5502          this.OnIsAllowedToCalculateChanging(value);
     5503          this.SendPropertyChanging();
     5504          this._IsAllowedToCalculate = value;
     5505          this.SendPropertyChanged("IsAllowedToCalculate");
     5506          this.OnIsAllowedToCalculateChanged();
     5507        }
     5508      }
     5509    }
     5510   
     5511    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactClientInfo", Storage="_DimClient", ThisKey="ClientId", OtherKey="Id", IsForeignKey=true)]
     5512    public DimClient DimClient
     5513    {
     5514      get
     5515      {
     5516        return this._DimClient.Entity;
     5517      }
     5518      set
     5519      {
     5520        DimClient previousValue = this._DimClient.Entity;
     5521        if (((previousValue != value)
     5522              || (this._DimClient.HasLoadedOrAssignedValue == false)))
     5523        {
     5524          this.SendPropertyChanging();
     5525          if ((previousValue != null))
     5526          {
     5527            this._DimClient.Entity = null;
     5528            previousValue.FactClientInfos.Remove(this);
     5529          }
     5530          this._DimClient.Entity = value;
     5531          if ((value != null))
     5532          {
     5533            value.FactClientInfos.Add(this);
     5534            this._ClientId = value.Id;
     5535          }
     5536          else
     5537          {
     5538            this._ClientId = default(System.Guid);
     5539          }
     5540          this.SendPropertyChanged("DimClient");
     5541        }
     5542      }
     5543    }
     5544   
     5545    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactClientInfo", Storage="_DimTime", ThisKey="Time", OtherKey="Time", IsForeignKey=true)]
     5546    public DimTime DimTime
     5547    {
     5548      get
     5549      {
     5550        return this._DimTime.Entity;
     5551      }
     5552      set
     5553      {
     5554        DimTime previousValue = this._DimTime.Entity;
     5555        if (((previousValue != value)
     5556              || (this._DimTime.HasLoadedOrAssignedValue == false)))
     5557        {
     5558          this.SendPropertyChanging();
     5559          if ((previousValue != null))
     5560          {
     5561            this._DimTime.Entity = null;
     5562            previousValue.FactClientInfos.Remove(this);
     5563          }
     5564          this._DimTime.Entity = value;
     5565          if ((value != null))
     5566          {
     5567            value.FactClientInfos.Add(this);
     5568            this._Time = value.Time;
     5569          }
     5570          else
     5571          {
     5572            this._Time = default(System.DateTime);
     5573          }
     5574          this.SendPropertyChanged("DimTime");
     5575        }
     5576      }
     5577    }
     5578   
     5579    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimUser_FactClientInfo", Storage="_DimUser", ThisKey="UserId", OtherKey="UserId", IsForeignKey=true)]
     5580    public DimUser DimUser
     5581    {
     5582      get
     5583      {
     5584        return this._DimUser.Entity;
     5585      }
     5586      set
     5587      {
     5588        DimUser previousValue = this._DimUser.Entity;
     5589        if (((previousValue != value)
     5590              || (this._DimUser.HasLoadedOrAssignedValue == false)))
     5591        {
     5592          this.SendPropertyChanging();
     5593          if ((previousValue != null))
     5594          {
     5595            this._DimUser.Entity = null;
     5596            previousValue.FactClientInfos.Remove(this);
     5597          }
     5598          this._DimUser.Entity = value;
     5599          if ((value != null))
     5600          {
     5601            value.FactClientInfos.Add(this);
     5602            this._UserId = value.UserId;
     5603          }
     5604          else
     5605          {
     5606            this._UserId = default(System.Guid);
     5607          }
     5608          this.SendPropertyChanged("DimUser");
     5609        }
     5610      }
     5611    }
     5612   
     5613    public event PropertyChangingEventHandler PropertyChanging;
     5614   
     5615    public event PropertyChangedEventHandler PropertyChanged;
     5616   
     5617    protected virtual void SendPropertyChanging()
     5618    {
     5619      if ((this.PropertyChanging != null))
     5620      {
     5621        this.PropertyChanging(this, emptyChangingEventArgs);
     5622      }
     5623    }
     5624   
     5625    protected virtual void SendPropertyChanged(String propertyName)
     5626    {
     5627      if ((this.PropertyChanged != null))
     5628      {
     5629        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     5630      }
     5631    }
     5632  }
    45365633}
    45375634#pragma warning restore 1591
Note: See TracChangeset for help on using the changeset viewer.