none
Kombinationen selektieren RRS feed

  • Frage

  • Hallo allerseits!
     
    Ich habe eine Tabelle "OKM", die so aussieht:
     
       PersonID A N V W
       -------- - - - -
       1040     N J J N
       1041     N J N N
       1042     J N N N
       1043     N J N J
     
    PersonID ist dabei der Primary Key, die übrigen Felder sind J/N-Flags. Aus
    dieser Tabelle soll ich nun Personen für eine statistische Auswertung nach
    verschiedenen Kriterien selektieren. Diese sind in einer Tabelle "Basis"
    definiert:
     
       BasisID Beschreibung
       ------- -----------------
       1       Alle
       2       Mit N
       3       Ausschließlich A
     
    Das gewünschte Ergebnis sieht dann so aus:
     
       BasisID PersonID
       ------- --------
       1       1040
       1       1041
       1       1042
       1       1043
       2       1040
       2       1041
       2       1043
       3       1042
     
    Um das Ganze in einem SELECT-Statement erledigen zu können, habe ich eine
    Tabelle "Flags" definiert, die zu jeder BasisID alle erlaubten Kombinationen von
    A, N, V und W enthalten. Das SELECT-Statement sieht dann so aus:
     
       SELECT
             B.BasisID,
             O.PersonID
          FROM
             OKM O
             INNER JOIN Flags F
                ON F.A = O.A
                   AND F.N = O.N
                   AND F.V = O.V
                   AND F.W = O.W
             INNER JOIN Basis B
                ON B.BasisID = F.BasisID;
     
    Das funktioniert zwar, bei steigender Anzahl Zeilen in Basis (derzeit 18) wird
    das Ganze recht unübersichtlich. Hat irgendjemand eine Idee für einen
    wartungsfreundlicheren Lösungsansatz?
     
    TIA
     
     
    Grüße
    Thomas
     
    --
    Any problem in computer science can be solved with another layer
    of indirection. But that usually will create another problem.
                                       David Wheeler
     
    Mittwoch, 16. November 2011 15:14

Antworten

  • Nur mal ein unausgegorener Gedanke:

    wie wäre es, wenn Du die J/N-Werte als Bitmask umdefinierst:

    NJJN = 4*8
    NJNN = 4
    JJJJ = 2*4*8*16

    Damit hättest Du jede Kombination als Wert vorliegen und könntest entsprechend selektieren.

    Mittwoch, 16. November 2011 19:28
  • Hallo Thomas, hier ist noch mal Christa's Ansatz etwas verfeinert!

    Declare @Personen as Table(PersonID integer, A char(1), N char(1), V char(1), W char(1), Mask integer);
    Declare @Basis as Table(BasisID integer, Beschreibung varchar(100), Mask integer);
    
    Insert into @Personen(PersonID, A, N, V, W, Mask) values(1040, 'N', 'J', 'J', 'N', 6);
    Insert into @Personen(PersonID, A, N, V, W, Mask) values(1041, 'N', 'J', 'N', 'N', 2);
    Insert into @Personen(PersonID, A, N, V, W, Mask) values(1042, 'J', 'N', 'J', 'N', 1);
    Insert into @Personen(PersonID, A, N, V, W, Mask) values(1043, 'N', 'J', 'N', 'J', 10);
    
    Insert into @Basis(BasisID, Beschreibung, Mask) values(1, 'Alle', 15);
    Insert into @Basis(BasisID, Beschreibung, Mask) values(2, 'Mit N', 2);
    Insert into @Basis(BasisID, Beschreibung, Mask) values(3, 'Ausschließlich A', 1);
    
    Select *
    from @Personen where Mask &2 = 2;
    
    Select b.BasisID, b.Beschreibung, p.PersonID
    from @Personen p
    , @Basis b
    where p.Mask & b.Mask <> 0;

     

     

    Einen schönen Tag noch,
    Christoph
    --
    Microsoft SQL Server MVP
    www.insidesql.org/blogs/cmu


    Donnerstag, 17. November 2011 07:07

Alle Antworten

  • Nur mal ein unausgegorener Gedanke:

    wie wäre es, wenn Du die J/N-Werte als Bitmask umdefinierst:

    NJJN = 4*8
    NJNN = 4
    JJJJ = 2*4*8*16

    Damit hättest Du jede Kombination als Wert vorliegen und könntest entsprechend selektieren.

    Mittwoch, 16. November 2011 19:28
  • Hallo Thomas, hier ist noch mal Christa's Ansatz etwas verfeinert!

    Declare @Personen as Table(PersonID integer, A char(1), N char(1), V char(1), W char(1), Mask integer);
    Declare @Basis as Table(BasisID integer, Beschreibung varchar(100), Mask integer);
    
    Insert into @Personen(PersonID, A, N, V, W, Mask) values(1040, 'N', 'J', 'J', 'N', 6);
    Insert into @Personen(PersonID, A, N, V, W, Mask) values(1041, 'N', 'J', 'N', 'N', 2);
    Insert into @Personen(PersonID, A, N, V, W, Mask) values(1042, 'J', 'N', 'J', 'N', 1);
    Insert into @Personen(PersonID, A, N, V, W, Mask) values(1043, 'N', 'J', 'N', 'J', 10);
    
    Insert into @Basis(BasisID, Beschreibung, Mask) values(1, 'Alle', 15);
    Insert into @Basis(BasisID, Beschreibung, Mask) values(2, 'Mit N', 2);
    Insert into @Basis(BasisID, Beschreibung, Mask) values(3, 'Ausschließlich A', 1);
    
    Select *
    from @Personen where Mask &2 = 2;
    
    Select b.BasisID, b.Beschreibung, p.PersonID
    from @Personen p
    , @Basis b
    where p.Mask & b.Mask <> 0;

     

     

    Einen schönen Tag noch,
    Christoph
    --
    Microsoft SQL Server MVP
    www.insidesql.org/blogs/cmu


    Donnerstag, 17. November 2011 07:07
  • Da war noch ein kleiner Fehler im dritten Insert:

    Insert into @Personen(PersonID, A, N, V, W, Mask) values(1042, 'J', 'N',
    'J', 'N', 5);

    Einen schönen Tag noch,
    Christoph
    --
    Microsoft SQL Server MVP
    www.insidesql.org/blogs/cmu

    Donnerstag, 17. November 2011 07:15
  • Hallo Christa & Christoph!
     
    Vielen Dank! Das funktioniert perfekt.
     
     
    Grüße
    Thomas
     
    --
    Any problem in computer science can be solved with another layer
    of indirection. But that usually will create another problem.
                                       David Wheeler
     
    Freitag, 18. November 2011 11:35