Table de plage de réglage automatique

Question

J'ai une table avec une plage de dates de début, une plage de dates de fin et quelques autres colonnes supplémentaires. Lors de la saisie d'un nouvel enregistrement, je souhaite ajuster automatiquement toutes les plages de dates qui se chevauchent (les réduire, les diviser ou les supprimer pour tenir compte de la nouvelle entrée - voir l'algorithme ci-dessous). Je veux également m'assurer qu'aucun enregistrement qui se chevauche ne peut être accidentellement inséré dans cette table. J'utilise Oracle et Java pour mon code d'application. Comment devrais-je appliquer la prévention des plages de dates qui se chevauchent et permettre également d'ajuster automatiquement les plages de chevauchement? Dois-je créer un déclencheur AFTER INSERT, avec un dbms_lock pour sérialiser l'accès, pour empêcher le chevauchement des données. Puis en Java, appliquer la logique pour tout ajuster automatiquement? Ou cette partie doit-elle être en PL/SQL dans l'appel de procédure stockée? C'est quelque chose dont nous avons besoin pour quelques autres tables, donc ce serait bien de faire abstraction.

Si quelqu'un a quelque chose comme cela déjà écrit, s'il vous plaît partager :)

Je ne trouve cette référence: http://asktom.oracle.com/pls/asktom/f?p=100:11:0::::P11_QUESTION_ID:474221407101

Voici un exemple de savoir comment traiter chacun des 4 cas de chevauchement pour le réglage à l'insertion :

= Example 1 = 
In DB (Start, End, Value): 
(0, 10, 'X') 
**(30, 100, 'Z') 
(200, 500, 'Y') 

Input 
(20, 50, 'A') 
Gives 
(0, 10, 'X') 
**(20, 50, 'A') 
**(51, 100, 'Z') 
(200, 500, 'Y') 


= Example 2 = 
In DB (Start, End, Value): 
(0, 10, 'X') 
**(30, 100, 'Z') 
(200, 500, 'Y') 

Input 
(40, 80, 'A') 
Gives 
(0, 10, 'X') 
**(30, 39, 'Z') 
**(40, 80, 'A') 
**(81, 100, 'Z') 
(200, 500, 'Y') 


= Example 3 = 
In DB (Start, End, Value): 
(0, 10, 'X') 
**(30, 100, 'Z') 
(200, 500, 'Y') 

Input 
(50, 120, 'A') 
Gives 
(0, 10, 'X') 
**(30, 49, 'Z') 
**(50, 120, 'A') 
(200, 500, 'Y') 


= Example 4 = 
In DB (Start, End, Value): 
(0, 10, 'X') 
**(30, 100, 'Z') 
(200, 500, 'Y') 

Input 
(20, 120, 'A') 
Gives 
(0, 10, 'X') 
**(20, 120, 'A') 
(200, 500, 'Y') 

L'algorithme est la suivante:

given range = g; input range = i; output range set = o 

if i.start <= g.start 
    if i.end >= g.end 
    o_1 = i 
    else 
    o_1 = i 
    o_2 = (i.end + 1, g.end) 
else 
    if i.end >= g.end 
    o_1 = (g.start, i.start - 1) 
    o_2 = i 
    else 
    o_1 = (g.start, i.start - 1) 
    o_2 = i 
    o_3 = (i.end + 1, g.end) 

Answer 1

J'ai généralement vu des modèles de données comme celui ayant le point de départ de la gamme étant le seul à être suivi, où le point de fin est alors implicite. Donc, ce serait

CREATE TABLE MY_TABLE 
(START_AT NUMBER, 
VALUE  NUMBER, 
CONSTRAINT MY_TABLE_PK (START_AT) 
); 

Si vous devez présenter des valeurs dans le format existant, vous pouvez utiliser l'analyse et une vue matérialisée, en utilisant LEAD(START_AT) OVER (ORDER BY START_AT) (je pense qu'il a raison, mais non testé) pour obtenir la valeur finale interprétée.

Answer 2

L'article d'AskTom donne un bon exemple de comment cela peut être fait, mais notez que cet exemple verrouille toute la table qui aura un impact sévère sur la concurrence de votre application.

Si la concurrence est une question pour vous, vous devez simplement ajouter une colonne de séquence (avec ORDER option si vous utilisez RAC) et d'écrire une requête comme ceci:

SELECT * 
FROM (
     SELECT *, rownum AS rn 
     FROM mytable 
     WHERE start_date <= :date 
       AND end_date >= :date 
     ORDER BY 
       seq DESC 
     ) 
WHERE rn = 1 

pour connaître la portée effective (et d'autres données) pour une date donnée.

Ceci renverra la dernière plage insérée contenant la date donnée.

Vous pouvez faire cette requête un peu plus efficace en exécutant une procédure de maintenance qui permettrait de se débarrasser des gammes qui se chevauchent en temps opportun (comme décrit dans le poste) et la réécriture de la requête comme ceci:

SELECT * 
FROM (
     SELECT *, rownum AS rn2 
     FROM (
       SELECT * 
       FROM (
         SELECT *, rownum AS rn 
         FROM mytable 
         WHERE seq <= :lseq 
           AND start_date <= :date 
           AND end_date >= :date 
         ORDER BY 
           start_date DESC 
         ) 
       WHERE rn = 1 
       UNION ALL 
       SELECT * 
       FROM (
         SELECT *, rownum AS rn 
         FROM mytable 
         WHERE seq > :lseq 
           AND start_date <= :date 
           AND end_date >= :date 
         ORDER BY 
           seq DESC 
         ) 
       WHERE rn = 1 
       ) 
     ORDER BY 
       seq DESC 
     ) 
WHERE rn2 = 1 

Créez les index sur start_date et seq pour que cela fonctionne rapidement. Cette dernière requête sélectionnera la première plage de correspondance parmi les plages traitées (qui sont connues pour ne pas se chevaucher), la première plage de correspondance parmi les plages non traitées (qui sont peu nombreuses) et des deux enregistrements sélectionnera la plage un avec le plus haut seq.