🚀 go-pugleaf

>Pytanie: jakie rozwiązanie wdrożyć, aby rekordy utworzone przed 2015-10-01 
>wskazywały na wartość “A”, a te od 2015-10-01 na wartość “B”?

Jednym ze sposobów jaki przychodzi mi na myśl to rozszerzenie klucza w 
tabeli ZalezneWartosci:
  PK Id int
  PK Wersja int
  Wartosc string
o wersję:
{ Id: 1, Wersja: 1, Wartosc: “A” }
{ Id: 1, Wersja: 2, Wartosc: “B” }
i zapisywanie informacji w takiej rozszerzonej formie:
Dane
  PK Id int
  FK ZaleznaWartoscId int
  FK ZaleznaWartoscWersja int
  Utworzono date
rekord wyglądał by tak:
{ Id: 1, ZaleznaWartoscId: 1, ZaleznaWartoscWersja: 1, Utworzono: 
2015-09-01 }
{ Id: 1, ZaleznaWartoscId: 1, ZaleznaWartoscWersja: 2, Utworzono: 
2015-10-01 }

M.

Kolejny sposób, w którym można kontrolować moment wdrożenia nowych wartości:

ZalezneWartosci:
  PK Id int
  PK DataOd date
  DataDo date null
  Wartosc string

{ Id: 1, DataOd: 2015-09-01, DataDo: 2015-09-30, Wartosc: “A” }
{ Id: 2, DataOd: 2015-09-01, DataDo: 2015-09-30, Wartosc: “A1” }
{ Id: 3, DataOd: 2015-09-01, DataDo: 2015-09-30, Wartosc: “A2” }
{ Id: 1, DataOd: 2015-10-01, DataDo: null, Wartosc: “B” }
{ Id: 2, DataOd: 2015-10-01, DataDo: null, Wartosc: “A1” }
{ Id: 3, DataOd: 2015-10-01, DataDo: null, Wartosc: “B2” }

Dane
  PK Id int
  FK ZaleznaWartoscId int
  FK ZaleznaWartoscDataOd date
  Utworzono date

{ Id: 1, ZaleznaWartoscId: 1, ZaleznaWartoscDataOd: 2015-09-01, Utworzono: 
2015-09-01 }
{ Id: 2, ZaleznaWartoscId: 2, ZaleznaWartoscDataOd: 2015-09-01, Utworzono: 
2015-09-01 }
{ Id: 3, ZaleznaWartoscId: 1, ZaleznaWartoscDataOd: 2015-09-01, Utworzono: 
2015-09-01 }
{ Id: 4, ZaleznaWartoscId: 1, ZaleznaWartoscDataOd: 2015-09-01, Utworzono: 
2015-09-01 }
{ Id: 5, ZaleznaWartoscId: 2, ZaleznaWartoscDataOd: 2015-10-01, Utworzono: 
2015-10-01 }
{ Id: 6, ZaleznaWartoscId: 1, ZaleznaWartoscDataOd: 2015-10-01, Utworzono: 
2015-10-01 }
{ Id: 7, ZaleznaWartoscId: 1, ZaleznaWartoscDataOd: 2015-10-01, Utworzono: 
2015-10-01 }

Skomplikowane to jest, ale powinno zadziałać.
Obowiązującym zestawem będzie ten, którego DataDo będzie null.
Dodatkowo mogę powielać ZależneWartosciId na czym mi zależy...
Może jeszcze jakiś sposób jest?
Przy okazji dziękuję GDN za pomoc :)

M. 

I jeszcze jeden wariant (aby lepiej zobrazować dodałem pole 
JakasStalaWartosc):

ZalezneWartosci:
  PK Id int
  JakasStalaWartosc string

  { Id: 1,  JakasStalaWartosc: "X"}
  { Id: 2,  JakasStalaWartosc: "Y"}
  { Id: 3,  JakasStalaWartosc: "Z"}

HistoriaWartosci
  FK ZalezneWartosciId int
  PK DataOd date
  DataDo null
  Wartosc string

{ ZalezneWartosciId: 1, DataOd: 2015-09-01, DataDo: 2015-09-30, Wartosc: 
“A” }
{ ZalezneWartosciId: 2, DataOd: 2015-09-01, DataDo: 2015-09-30, Wartosc: 
 “A1” }
{ ZalezneWartosciId: 3, DataOd: 2015-09-01, DataDo: 2015-09-30, Wartosc: 
 “A2” }
{ ZalezneWartosciId: 1, DataOd: 2015-10-01, DataDo: null, Wartosc: “B” }
{ ZalezneWartosciId: 2, DataOd: 2015-10-01, DataDo: null, Wartosc: “A1” }
{ ZalezneWartosciId: 3, DataOd: 2015-10-01, DataDo: null, Wartosc: “B2” }

Dane
  PK Id int
  FK ZaleznaWartoscId int
  Utworzono date

{ Id: 1, ZaleznaWartoscId: 1, Utworzono: 2015-09-01 }
{ Id: 2, ZaleznaWartoscId: 2, Utworzono: 2015-09-01 }
{ Id: 3, ZaleznaWartoscId: 1, Utworzono: 2015-09-01 }
{ Id: 4, ZaleznaWartoscId: 1, Utworzono: 2015-09-01 }
{ Id: 5, ZaleznaWartoscId: 2, Utworzono: 2015-10-01 }
{ Id: 6, ZaleznaWartoscId: 1, Utworzono: 2015-10-01 }
{ Id: 7, ZaleznaWartoscId: 1, Utworzono: 2015-10-01 }

Chyba najbardziej elastyczne :)

M. 

Drobna korekta:

HistoriaWartosci
>PK ZalezneWartosciId int
  PK DataOd date
  DataDo date null
  Wartosc string

M.

Maciej Tokarz wrote at Do 17.09.2015 05:56:

Cześć Maciek,

trochę kombinujesz z tą relacją 1:n ;) Jeśli zaprojektowałeś model danych
z taką relacją to niestety konsekwencją jej jest, że po zmianie strony 1 
relacji, wszystkie zależne rekordy otrzymają aktualną wartość. Jeśli 
potrzebne są dwie różne zależne wartości, to dlaczego nie utwożysz w tabeli
"ZależneWartosci" nowego rekordu z wartościa "B" i używasz go od dnia 
2015-10-01 dla nowych rekordów w tabeli "Dane" ?

Ale jeśli już musiałbym kombinować, wybrałbym chyba wariant:

> Dane
>   PK Id int
>   FK ZaleznaWartoscId int
>   Utworzono date
> 
> ZalezneWartosci
>     PK Id int
> 

WartosciZalezneOdCzasu
   PK Id int
   FK ZalezneWartosciId int
   Od data
   Do data
   Wartosc string

albo bez redundancji

WartosciZalezneOdCzasu
   ZalezneWartosciId int
   Od data
   Do data
   Wartosc string
   PK(ZalezneWartosciId, Od, Do)

Czy musi byc "Od" i "Do", czy wystarczy jeden attrubut zdecyduj sam.

W ten sposób możesz w kwerendzie przez parametr, powiedzmy "kiedy" wpływać 
na to jaka wartość zostanie pokazana dla rekordów z tabeli Dane.

Ciao, Smyk

Witaj!

Tak to jest jak się kombinuje przed poranną kawką ;-)
Wybrałem wariant jak poniżej (przepraszam, że zaśmiecę grupę inną składnią).
Generalnie co ważne, a również podkreśliłeś, mam możliwość kontrolowania momentu wdrożenia określonej wartości:

public sealed class Shift
    {
        [DatabaseGenerated(DatabaseGeneratedOption.None)]
        public int Id { get; set; }

        public int Alias { get; set; }

        [StringLength(5)]
        public string Sign { get; set; }
        
        public bool IsValid { get; set; }
    }


public sealed class ShiftValue
    {
        [Key]
        [Column(Order = 0)]
        [DatabaseGenerated(DatabaseGeneratedOption.None)]
        public int ShiftId { get; set; }

        [Key]
        [Column(Order = 1, TypeName = "date")]
        public DateTime ValidFrom { get; set; }

        [Column(TypeName = "date")]
        public DateTime? ValidTo { get; set; }

        public TimeSpan Start { get; set; }

        public TimeSpan Finish { get; set; }

        public Guid CreatedBy { get; set; }

        [Column(TypeName = "smalldatetime")]
        public DateTime Created { get; set; }

        public Shift Shift { get; set; }
    }

i przykład wykorzystania:

var shiftValue = ShiftValuesSource.First(x => x.ShiftId == id && D >= x.ValidFrom && D <= (x.ValidTo ?? DateTime.MaxValue));
var s = shiftValue.Start;
var f = shiftValue.Finish;

Dane wyglądają tak:

context.Shifts.AddOrUpdate(x => x.Id,
                new Shift()
                {
                    Id = 1,
                    Alias = 76,
                    Sign = "I",
                    IsValid = true
                },
                new Shift()
                {
                    Id = 2,
                    Alias = 77,
                    Sign = "II",
                    IsValid = true
                },

            context.ShiftValues.AddOrUpdate(x => x.ValidFrom,
                new ShiftValue()
                {
                    ShiftId = 1,
                    ValidFrom = new DateTime(2013,1,1),
                    ValidTo = null,
                    Start = new TimeSpan(6, 0, 0),
                    Finish = new TimeSpan(14, 0, 0),
                    CreatedBy = new Guid("87ef9940-af60-4002-9944-012a930148b5"),
                    Created = new DateTime(2015, 3, 21)
                },
                new ShiftValue()
                {
                    ShiftId = 2,
                    ValidFrom = new DateTime(2013, 1, 1),
                    ValidTo = null,
                    Start = new TimeSpan(14, 0, 0),
                    Finish = new TimeSpan(22, 0, 0),
                    CreatedBy = new Guid("87ef9940-af60-4002-9944-012a930148b5"),
                    Created = new DateTime(2015, 3, 21)
                },

Widzę, że nie tylko ja śledzę grupę :)
Serdecznie pozdrawiam,
Maciej