🚀 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