Ignore:
Timestamp:
07/16/15 15:09:12 (6 years ago)
Author:
dglaser
Message:

#2388:

HeuristicLab.Services.Hive.DataAccess-3.3:

  • Removed old statistics tables
  • Updated SQL Scripts

HeuristicLab.Services.WebApp-3.3:
HeuristicLab.Services.WebApp.Status-3.3:
HeuristicLab.Services.WebApp.Statistics-3.3:

  • Minor changes
File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/HiveStatistics/sources/HeuristicLab.Services.Hive.DataAccess/3.3/HiveDataContext.designer.cs

    r12551 r12768  
    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);
     
    228216      {
    229217        return this.GetTable<Lifecycle>();
    230       }
    231     }
    232    
    233     public System.Data.Linq.Table<DeletedJobStatistics> DeletedJobStatistics
    234     {
    235       get
    236       {
    237         return this.GetTable<DeletedJobStatistics>();
    238       }
    239     }
    240    
    241     public System.Data.Linq.Table<UserStatistics> UserStatistics
    242     {
    243       get
    244       {
    245         return this.GetTable<UserStatistics>();
    246       }
    247     }
    248    
    249     public System.Data.Linq.Table<SlaveStatistics> SlaveStatistics
    250     {
    251       get
    252       {
    253         return this.GetTable<SlaveStatistics>();
    254       }
    255     }
    256    
    257     public System.Data.Linq.Table<Statistics> Statistics
    258     {
    259       get
    260       {
    261         return this.GetTable<Statistics>();
    262218      }
    263219    }
     
    35913547        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    35923548      }
    3593     }
    3594   }
    3595  
    3596   [global::System.Data.Linq.Mapping.TableAttribute(Name="")]
    3597   public partial class DeletedJobStatistics : INotifyPropertyChanging, INotifyPropertyChanged
    3598   {
    3599    
    3600     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    3601    
    3602     private System.Guid _UserId;
    3603    
    3604     private double _ExecutionTime;
    3605    
    3606     private double _ExecutionTimeFinishedJobs;
    3607    
    3608     private double _StartToEndTime;
    3609    
    3610     private System.Guid _DeletedJobStatisticsId;
    3611    
    3612     #region Extensibility Method Definitions
    3613     partial void OnLoaded();
    3614     partial void OnValidate(System.Data.Linq.ChangeAction action);
    3615     partial void OnCreated();
    3616     partial void OnUserIdChanging(System.Guid value);
    3617     partial void OnUserIdChanged();
    3618     partial void OnExecutionTimeSChanging(double value);
    3619     partial void OnExecutionTimeSChanged();
    3620     partial void OnExecutionTimeSFinishedJobsChanging(double value);
    3621     partial void OnExecutionTimeSFinishedJobsChanged();
    3622     partial void OnStartToEndTimeSChanging(double value);
    3623     partial void OnStartToEndTimeSChanged();
    3624     partial void OnDeletedJobStatisticsIdChanging(System.Guid value);
    3625     partial void OnDeletedJobStatisticsIdChanged();
    3626     #endregion
    3627    
    3628     public DeletedJobStatistics()
    3629     {
    3630       OnCreated();
    3631     }
    3632    
    3633     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL")]
    3634     public System.Guid UserId
    3635     {
    3636       get
    3637       {
    3638         return this._UserId;
    3639       }
    3640       set
    3641       {
    3642         if ((this._UserId != value))
    3643         {
    3644           this.OnUserIdChanging(value);
    3645           this.SendPropertyChanging();
    3646           this._UserId = value;
    3647           this.SendPropertyChanged("UserId");
    3648           this.OnUserIdChanged();
    3649         }
    3650       }
    3651     }
    3652    
    3653     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExecutionTime", DbType="float NOT NULL")]
    3654     public double ExecutionTimeS
    3655     {
    3656       get
    3657       {
    3658         return this._ExecutionTime;
    3659       }
    3660       set
    3661       {
    3662         if ((this._ExecutionTime != value))
    3663         {
    3664           this.OnExecutionTimeSChanging(value);
    3665           this.SendPropertyChanging();
    3666           this._ExecutionTime = value;
    3667           this.SendPropertyChanged("ExecutionTimeS");
    3668           this.OnExecutionTimeSChanged();
    3669         }
    3670       }
    3671     }
    3672    
    3673     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExecutionTimeFinishedJobs", DbType="float NOT NULL")]
    3674     public double ExecutionTimeSFinishedJobs
    3675     {
    3676       get
    3677       {
    3678         return this._ExecutionTimeFinishedJobs;
    3679       }
    3680       set
    3681       {
    3682         if ((this._ExecutionTimeFinishedJobs != value))
    3683         {
    3684           this.OnExecutionTimeSFinishedJobsChanging(value);
    3685           this.SendPropertyChanging();
    3686           this._ExecutionTimeFinishedJobs = value;
    3687           this.SendPropertyChanged("ExecutionTimeSFinishedJobs");
    3688           this.OnExecutionTimeSFinishedJobsChanged();
    3689         }
    3690       }
    3691     }
    3692    
    3693     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartToEndTime", DbType="float NOT NULL")]
    3694     public double StartToEndTimeS
    3695     {
    3696       get
    3697       {
    3698         return this._StartToEndTime;
    3699       }
    3700       set
    3701       {
    3702         if ((this._StartToEndTime != value))
    3703         {
    3704           this.OnStartToEndTimeSChanging(value);
    3705           this.SendPropertyChanging();
    3706           this._StartToEndTime = value;
    3707           this.SendPropertyChanged("StartToEndTimeS");
    3708           this.OnStartToEndTimeSChanged();
    3709         }
    3710       }
    3711     }
    3712    
    3713     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DeletedJobStatisticsId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
    3714     public System.Guid DeletedJobStatisticsId
    3715     {
    3716       get
    3717       {
    3718         return this._DeletedJobStatisticsId;
    3719       }
    3720       set
    3721       {
    3722         if ((this._DeletedJobStatisticsId != value))
    3723         {
    3724           this.OnDeletedJobStatisticsIdChanging(value);
    3725           this.SendPropertyChanging();
    3726           this._DeletedJobStatisticsId = value;
    3727           this.SendPropertyChanged("DeletedJobStatisticsId");
    3728           this.OnDeletedJobStatisticsIdChanged();
    3729         }
    3730       }
    3731     }
    3732    
    3733     public event PropertyChangingEventHandler PropertyChanging;
    3734    
    3735     public event PropertyChangedEventHandler PropertyChanged;
    3736    
    3737     protected virtual void SendPropertyChanging()
    3738     {
    3739       if ((this.PropertyChanging != null))
    3740       {
    3741         this.PropertyChanging(this, emptyChangingEventArgs);
    3742       }
    3743     }
    3744    
    3745     protected virtual void SendPropertyChanged(String propertyName)
    3746     {
    3747       if ((this.PropertyChanged != null))
    3748       {
    3749         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    3750       }
    3751     }
    3752   }
    3753  
    3754   [global::System.Data.Linq.Mapping.TableAttribute(Name="")]
    3755   public partial class UserStatistics : INotifyPropertyChanging, INotifyPropertyChanged
    3756   {
    3757    
    3758     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    3759    
    3760     private System.Guid _StatisticsId;
    3761    
    3762     private System.Guid _UserId;
    3763    
    3764     private double _ExecutionTime;
    3765    
    3766     private int _CoresUsed;
    3767    
    3768     private double _ExecutionTimeFinishedJobs;
    3769    
    3770     private double _StartToEndTime;
    3771    
    3772     private EntityRef<Statistics> _Statistics;
    3773    
    3774     #region Extensibility Method Definitions
    3775     partial void OnLoaded();
    3776     partial void OnValidate(System.Data.Linq.ChangeAction action);
    3777     partial void OnCreated();
    3778     partial void OnStatisticsIdChanging(System.Guid value);
    3779     partial void OnStatisticsIdChanged();
    3780     partial void OnUserIdChanging(System.Guid value);
    3781     partial void OnUserIdChanged();
    3782     partial void OnExecutionTimeMsChanging(double value);
    3783     partial void OnExecutionTimeMsChanged();
    3784     partial void OnUsedCoresChanging(int value);
    3785     partial void OnUsedCoresChanged();
    3786     partial void OnExecutionTimeMsFinishedJobsChanging(double value);
    3787     partial void OnExecutionTimeMsFinishedJobsChanged();
    3788     partial void OnStartToEndTimeMsChanging(double value);
    3789     partial void OnStartToEndTimeMsChanged();
    3790     #endregion
    3791    
    3792     public UserStatistics()
    3793     {
    3794       this._Statistics = default(EntityRef<Statistics>);
    3795       OnCreated();
    3796     }
    3797    
    3798     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StatisticsId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
    3799     public System.Guid StatisticsId
    3800     {
    3801       get
    3802       {
    3803         return this._StatisticsId;
    3804       }
    3805       set
    3806       {
    3807         if ((this._StatisticsId != value))
    3808         {
    3809           if (this._Statistics.HasLoadedOrAssignedValue)
    3810           {
    3811             throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
    3812           }
    3813           this.OnStatisticsIdChanging(value);
    3814           this.SendPropertyChanging();
    3815           this._StatisticsId = value;
    3816           this.SendPropertyChanged("StatisticsId");
    3817           this.OnStatisticsIdChanged();
    3818         }
    3819       }
    3820     }
    3821    
    3822     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
    3823     public System.Guid UserId
    3824     {
    3825       get
    3826       {
    3827         return this._UserId;
    3828       }
    3829       set
    3830       {
    3831         if ((this._UserId != value))
    3832         {
    3833           this.OnUserIdChanging(value);
    3834           this.SendPropertyChanging();
    3835           this._UserId = value;
    3836           this.SendPropertyChanged("UserId");
    3837           this.OnUserIdChanged();
    3838         }
    3839       }
    3840     }
    3841    
    3842     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExecutionTime", DbType="float NOT NULL")]
    3843     public double ExecutionTimeMs
    3844     {
    3845       get
    3846       {
    3847         return this._ExecutionTime;
    3848       }
    3849       set
    3850       {
    3851         if ((this._ExecutionTime != value))
    3852         {
    3853           this.OnExecutionTimeMsChanging(value);
    3854           this.SendPropertyChanging();
    3855           this._ExecutionTime = value;
    3856           this.SendPropertyChanged("ExecutionTimeMs");
    3857           this.OnExecutionTimeMsChanged();
    3858         }
    3859       }
    3860     }
    3861    
    3862     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CoresUsed", DbType="Int NOT NULL")]
    3863     public int UsedCores
    3864     {
    3865       get
    3866       {
    3867         return this._CoresUsed;
    3868       }
    3869       set
    3870       {
    3871         if ((this._CoresUsed != value))
    3872         {
    3873           this.OnUsedCoresChanging(value);
    3874           this.SendPropertyChanging();
    3875           this._CoresUsed = value;
    3876           this.SendPropertyChanged("UsedCores");
    3877           this.OnUsedCoresChanged();
    3878         }
    3879       }
    3880     }
    3881    
    3882     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExecutionTimeFinishedJobs", DbType="float NOT NULL")]
    3883     public double ExecutionTimeMsFinishedJobs
    3884     {
    3885       get
    3886       {
    3887         return this._ExecutionTimeFinishedJobs;
    3888       }
    3889       set
    3890       {
    3891         if ((this._ExecutionTimeFinishedJobs != value))
    3892         {
    3893           this.OnExecutionTimeMsFinishedJobsChanging(value);
    3894           this.SendPropertyChanging();
    3895           this._ExecutionTimeFinishedJobs = value;
    3896           this.SendPropertyChanged("ExecutionTimeMsFinishedJobs");
    3897           this.OnExecutionTimeMsFinishedJobsChanged();
    3898         }
    3899       }
    3900     }
    3901    
    3902     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartToEndTime", DbType="float NOT NULL")]
    3903     public double StartToEndTimeMs
    3904     {
    3905       get
    3906       {
    3907         return this._StartToEndTime;
    3908       }
    3909       set
    3910       {
    3911         if ((this._StartToEndTime != value))
    3912         {
    3913           this.OnStartToEndTimeMsChanging(value);
    3914           this.SendPropertyChanging();
    3915           this._StartToEndTime = value;
    3916           this.SendPropertyChanged("StartToEndTimeMs");
    3917           this.OnStartToEndTimeMsChanged();
    3918         }
    3919       }
    3920     }
    3921    
    3922     [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Statistics_UserStatistics", Storage="_Statistics", ThisKey="StatisticsId", OtherKey="StatisticsId", IsForeignKey=true)]
    3923     public Statistics Statistics
    3924     {
    3925       get
    3926       {
    3927         return this._Statistics.Entity;
    3928       }
    3929       set
    3930       {
    3931         Statistics previousValue = this._Statistics.Entity;
    3932         if (((previousValue != value)
    3933               || (this._Statistics.HasLoadedOrAssignedValue == false)))
    3934         {
    3935           this.SendPropertyChanging();
    3936           if ((previousValue != null))
    3937           {
    3938             this._Statistics.Entity = null;
    3939             previousValue.UserStatistics.Remove(this);
    3940           }
    3941           this._Statistics.Entity = value;
    3942           if ((value != null))
    3943           {
    3944             value.UserStatistics.Add(this);
    3945             this._StatisticsId = value.StatisticsId;
    3946           }
    3947           else
    3948           {
    3949             this._StatisticsId = default(System.Guid);
    3950           }
    3951           this.SendPropertyChanged("Statistics");
    3952         }
    3953       }
    3954     }
    3955    
    3956     public event PropertyChangingEventHandler PropertyChanging;
    3957    
    3958     public event PropertyChangedEventHandler PropertyChanged;
    3959    
    3960     protected virtual void SendPropertyChanging()
    3961     {
    3962       if ((this.PropertyChanging != null))
    3963       {
    3964         this.PropertyChanging(this, emptyChangingEventArgs);
    3965       }
    3966     }
    3967    
    3968     protected virtual void SendPropertyChanged(String propertyName)
    3969     {
    3970       if ((this.PropertyChanged != null))
    3971       {
    3972         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    3973       }
    3974     }
    3975   }
    3976  
    3977   [global::System.Data.Linq.Mapping.TableAttribute(Name="")]
    3978   public partial class SlaveStatistics : INotifyPropertyChanging, INotifyPropertyChanged
    3979   {
    3980    
    3981     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    3982    
    3983     private System.Guid _StatisticsId;
    3984    
    3985     private System.Guid _SlaveId;
    3986    
    3987     private int _Cores;
    3988    
    3989     private int _FreeCores;
    3990    
    3991     private double _CpuUtilization;
    3992    
    3993     private int _Memory;
    3994    
    3995     private int _FreeMemory;
    3996    
    3997     private EntityRef<Statistics> _Statistics;
    3998    
    3999     #region Extensibility Method Definitions
    4000     partial void OnLoaded();
    4001     partial void OnValidate(System.Data.Linq.ChangeAction action);
    4002     partial void OnCreated();
    4003     partial void OnStatisticsIdChanging(System.Guid value);
    4004     partial void OnStatisticsIdChanged();
    4005     partial void OnSlaveIdChanging(System.Guid value);
    4006     partial void OnSlaveIdChanged();
    4007     partial void OnCoresChanging(int value);
    4008     partial void OnCoresChanged();
    4009     partial void OnFreeCoresChanging(int value);
    4010     partial void OnFreeCoresChanged();
    4011     partial void OnCpuUtilizationChanging(double value);
    4012     partial void OnCpuUtilizationChanged();
    4013     partial void OnMemoryChanging(int value);
    4014     partial void OnMemoryChanged();
    4015     partial void OnFreeMemoryChanging(int value);
    4016     partial void OnFreeMemoryChanged();
    4017     #endregion
    4018    
    4019     public SlaveStatistics()
    4020     {
    4021       this._Statistics = default(EntityRef<Statistics>);
    4022       OnCreated();
    4023     }
    4024    
    4025     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StatisticsId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
    4026     public System.Guid StatisticsId
    4027     {
    4028       get
    4029       {
    4030         return this._StatisticsId;
    4031       }
    4032       set
    4033       {
    4034         if ((this._StatisticsId != value))
    4035         {
    4036           if (this._Statistics.HasLoadedOrAssignedValue)
    4037           {
    4038             throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
    4039           }
    4040           this.OnStatisticsIdChanging(value);
    4041           this.SendPropertyChanging();
    4042           this._StatisticsId = value;
    4043           this.SendPropertyChanged("StatisticsId");
    4044           this.OnStatisticsIdChanged();
    4045         }
    4046       }
    4047     }
    4048    
    4049     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SlaveId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
    4050     public System.Guid SlaveId
    4051     {
    4052       get
    4053       {
    4054         return this._SlaveId;
    4055       }
    4056       set
    4057       {
    4058         if ((this._SlaveId != value))
    4059         {
    4060           this.OnSlaveIdChanging(value);
    4061           this.SendPropertyChanging();
    4062           this._SlaveId = value;
    4063           this.SendPropertyChanged("SlaveId");
    4064           this.OnSlaveIdChanged();
    4065         }
    4066       }
    4067     }
    4068    
    4069     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Cores", DbType="Int NOT NULL")]
    4070     public int Cores
    4071     {
    4072       get
    4073       {
    4074         return this._Cores;
    4075       }
    4076       set
    4077       {
    4078         if ((this._Cores != value))
    4079         {
    4080           this.OnCoresChanging(value);
    4081           this.SendPropertyChanging();
    4082           this._Cores = value;
    4083           this.SendPropertyChanged("Cores");
    4084           this.OnCoresChanged();
    4085         }
    4086       }
    4087     }
    4088    
    4089     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FreeCores", DbType="Int NOT NULL")]
    4090     public int FreeCores
    4091     {
    4092       get
    4093       {
    4094         return this._FreeCores;
    4095       }
    4096       set
    4097       {
    4098         if ((this._FreeCores != value))
    4099         {
    4100           this.OnFreeCoresChanging(value);
    4101           this.SendPropertyChanging();
    4102           this._FreeCores = value;
    4103           this.SendPropertyChanged("FreeCores");
    4104           this.OnFreeCoresChanged();
    4105         }
    4106       }
    4107     }
    4108    
    4109     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CpuUtilization", DbType="float NOT NULL")]
    4110     public double CpuUtilization
    4111     {
    4112       get
    4113       {
    4114         return this._CpuUtilization;
    4115       }
    4116       set
    4117       {
    4118         if ((this._CpuUtilization != value))
    4119         {
    4120           this.OnCpuUtilizationChanging(value);
    4121           this.SendPropertyChanging();
    4122           this._CpuUtilization = value;
    4123           this.SendPropertyChanged("CpuUtilization");
    4124           this.OnCpuUtilizationChanged();
    4125         }
    4126       }
    4127     }
    4128    
    4129     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Memory", DbType="Int NOT NULL")]
    4130     public int Memory
    4131     {
    4132       get
    4133       {
    4134         return this._Memory;
    4135       }
    4136       set
    4137       {
    4138         if ((this._Memory != value))
    4139         {
    4140           this.OnMemoryChanging(value);
    4141           this.SendPropertyChanging();
    4142           this._Memory = value;
    4143           this.SendPropertyChanged("Memory");
    4144           this.OnMemoryChanged();
    4145         }
    4146       }
    4147     }
    4148    
    4149     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FreeMemory", DbType="Int NOT NULL")]
    4150     public int FreeMemory
    4151     {
    4152       get
    4153       {
    4154         return this._FreeMemory;
    4155       }
    4156       set
    4157       {
    4158         if ((this._FreeMemory != value))
    4159         {
    4160           this.OnFreeMemoryChanging(value);
    4161           this.SendPropertyChanging();
    4162           this._FreeMemory = value;
    4163           this.SendPropertyChanged("FreeMemory");
    4164           this.OnFreeMemoryChanged();
    4165         }
    4166       }
    4167     }
    4168    
    4169     [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Statistics_SlaveStatistics", Storage="_Statistics", ThisKey="StatisticsId", OtherKey="StatisticsId", IsForeignKey=true)]
    4170     public Statistics Statistics
    4171     {
    4172       get
    4173       {
    4174         return this._Statistics.Entity;
    4175       }
    4176       set
    4177       {
    4178         Statistics previousValue = this._Statistics.Entity;
    4179         if (((previousValue != value)
    4180               || (this._Statistics.HasLoadedOrAssignedValue == false)))
    4181         {
    4182           this.SendPropertyChanging();
    4183           if ((previousValue != null))
    4184           {
    4185             this._Statistics.Entity = null;
    4186             previousValue.SlaveStatistics.Remove(this);
    4187           }
    4188           this._Statistics.Entity = value;
    4189           if ((value != null))
    4190           {
    4191             value.SlaveStatistics.Add(this);
    4192             this._StatisticsId = value.StatisticsId;
    4193           }
    4194           else
    4195           {
    4196             this._StatisticsId = default(System.Guid);
    4197           }
    4198           this.SendPropertyChanged("Statistics");
    4199         }
    4200       }
    4201     }
    4202    
    4203     public event PropertyChangingEventHandler PropertyChanging;
    4204    
    4205     public event PropertyChangedEventHandler PropertyChanged;
    4206    
    4207     protected virtual void SendPropertyChanging()
    4208     {
    4209       if ((this.PropertyChanging != null))
    4210       {
    4211         this.PropertyChanging(this, emptyChangingEventArgs);
    4212       }
    4213     }
    4214    
    4215     protected virtual void SendPropertyChanged(String propertyName)
    4216     {
    4217       if ((this.PropertyChanged != null))
    4218       {
    4219         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    4220       }
    4221     }
    4222   }
    4223  
    4224   [global::System.Data.Linq.Mapping.TableAttribute(Name="")]
    4225   public partial class Statistics : INotifyPropertyChanging, INotifyPropertyChanged
    4226   {
    4227    
    4228     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    4229    
    4230     private System.Guid _StatisticsId;
    4231    
    4232     private System.DateTime _Timestamp;
    4233    
    4234     private EntitySet<UserStatistics> _UserStatistics;
    4235    
    4236     private EntitySet<SlaveStatistics> _SlaveStatistics;
    4237    
    4238     #region Extensibility Method Definitions
    4239     partial void OnLoaded();
    4240     partial void OnValidate(System.Data.Linq.ChangeAction action);
    4241     partial void OnCreated();
    4242     partial void OnStatisticsIdChanging(System.Guid value);
    4243     partial void OnStatisticsIdChanged();
    4244     partial void OnTimestampChanging(System.DateTime value);
    4245     partial void OnTimestampChanged();
    4246     #endregion
    4247    
    4248     public Statistics()
    4249     {
    4250       this._UserStatistics = new EntitySet<UserStatistics>(new Action<UserStatistics>(this.attach_UserStatistics), new Action<UserStatistics>(this.detach_UserStatistics));
    4251       this._SlaveStatistics = new EntitySet<SlaveStatistics>(new Action<SlaveStatistics>(this.attach_SlaveStatistics), new Action<SlaveStatistics>(this.detach_SlaveStatistics));
    4252       OnCreated();
    4253     }
    4254    
    4255     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StatisticsId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
    4256     public System.Guid StatisticsId
    4257     {
    4258       get
    4259       {
    4260         return this._StatisticsId;
    4261       }
    4262       set
    4263       {
    4264         if ((this._StatisticsId != value))
    4265         {
    4266           this.OnStatisticsIdChanging(value);
    4267           this.SendPropertyChanging();
    4268           this._StatisticsId = value;
    4269           this.SendPropertyChanged("StatisticsId");
    4270           this.OnStatisticsIdChanged();
    4271         }
    4272       }
    4273     }
    4274    
    4275     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Timestamp")]
    4276     public System.DateTime Timestamp
    4277     {
    4278       get
    4279       {
    4280         return this._Timestamp;
    4281       }
    4282       set
    4283       {
    4284         if ((this._Timestamp != value))
    4285         {
    4286           this.OnTimestampChanging(value);
    4287           this.SendPropertyChanging();
    4288           this._Timestamp = value;
    4289           this.SendPropertyChanged("Timestamp");
    4290           this.OnTimestampChanged();
    4291         }
    4292       }
    4293     }
    4294    
    4295     [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Statistics_UserStatistics", Storage="_UserStatistics", ThisKey="StatisticsId", OtherKey="StatisticsId")]
    4296     public EntitySet<UserStatistics> UserStatistics
    4297     {
    4298       get
    4299       {
    4300         return this._UserStatistics;
    4301       }
    4302       set
    4303       {
    4304         this._UserStatistics.Assign(value);
    4305       }
    4306     }
    4307    
    4308     [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Statistics_SlaveStatistics", Storage="_SlaveStatistics", ThisKey="StatisticsId", OtherKey="StatisticsId")]
    4309     public EntitySet<SlaveStatistics> SlaveStatistics
    4310     {
    4311       get
    4312       {
    4313         return this._SlaveStatistics;
    4314       }
    4315       set
    4316       {
    4317         this._SlaveStatistics.Assign(value);
    4318       }
    4319     }
    4320    
    4321     public event PropertyChangingEventHandler PropertyChanging;
    4322    
    4323     public event PropertyChangedEventHandler PropertyChanged;
    4324    
    4325     protected virtual void SendPropertyChanging()
    4326     {
    4327       if ((this.PropertyChanging != null))
    4328       {
    4329         this.PropertyChanging(this, emptyChangingEventArgs);
    4330       }
    4331     }
    4332    
    4333     protected virtual void SendPropertyChanged(String propertyName)
    4334     {
    4335       if ((this.PropertyChanged != null))
    4336       {
    4337         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    4338       }
    4339     }
    4340    
    4341     private void attach_UserStatistics(UserStatistics entity)
    4342     {
    4343       this.SendPropertyChanging();
    4344       entity.Statistics = this;
    4345     }
    4346    
    4347     private void detach_UserStatistics(UserStatistics entity)
    4348     {
    4349       this.SendPropertyChanging();
    4350       entity.Statistics = null;
    4351     }
    4352    
    4353     private void attach_SlaveStatistics(SlaveStatistics entity)
    4354     {
    4355       this.SendPropertyChanging();
    4356       entity.Statistics = this;
    4357     }
    4358    
    4359     private void detach_SlaveStatistics(SlaveStatistics entity)
    4360     {
    4361       this.SendPropertyChanging();
    4362       entity.Statistics = null;
    43633549    }
    43643550  }
Note: See TracChangeset for help on using the changeset viewer.