Vérifier le chevauchement de plages de date dans MySQL

Cette table est utilisée pour stocker les sessions (événements):

CREATE TABLE session (
  id int(11) NOT NULL AUTO_INCREMENT
, start_date date
, end_date date
);

INSERT INTO session
  (start_date, end_date)
VALUES
  ("2010-01-01", "2010-01-10")
, ("2010-01-20", "2010-01-30")
, ("2010-02-01", "2010-02-15")
;

Nous ne voulons pas avoir de conflit entre les plages.

Disons que nous avons besoin d'insérer une nouvelle session à partir de 2010-01-05 à 2010-01-25.

Nous voudrions savoir le conflit session(s).

Voici ma requête:

SELECT *
FROM session
WHERE "2010-01-05" BETWEEN start_date AND end_date
   OR "2010-01-25" BETWEEN start_date AND end_date
   OR "2010-01-05" >= start_date AND "2010-01-25" <= end_date
;

Voici le résultat:

+----+------------+------------+
| id | start_date | end_date   |
+----+------------+------------+
|  1 | 2010-01-01 | 2010-01-10 |
|  2 | 2010-01-20 | 2010-01-30 |
+----+------------+------------+

Est-il un meilleur moyen d'obtenir cela?

violon

Votre troisième condition est fausse. Il est censé être "2010-01-05" <= start_date AND "2010-01-25" >= end_date. Voir stackoverflow.com/a/28802972/632951 pour la visualisation. Votre troisième condition ne sera jamais à évaluer, car la première (et deuxième) condition déjà le couvre.

InformationsquelleAutor Pierre de LESPINAY | 2010-03-30

132

J'ai eu comme une requête avec une application de calendrier je l'ai déjà écrit. Je crois que j'ai utilisé quelque chose comme ceci:
```
... WHERE new_start < existing_end
      AND new_end   > existing_start;
```
Mise à JOUR Cela devrait fonctionner ((ns, ne, es, ee) = (new_start, new_end, existing_start, existing_end)):
1. ns - ne - es - ee: ne se chevauchent pas et ne correspond pas (car ne < es)
2. ns - es - ne - ee: les chevauchements et les matchs
3. es - ns - ee - ne: les chevauchements et les matchs
4. es - ee - ns - ne: ne se chevauchent pas et ne correspond pas (parce que ns > ee)
5. es - ns - ne - ee: les chevauchements et les matchs
6. ns - es - ee - ne: les chevauchements et les matchs
Ici est un violon
- Je pense que cela devrait fonctionner, mis à jour répondre
- Fonctionne très bien!, mais je pense que @Pierre de LESPINAY est à la recherche pour l'inclusion des plages dans sa question: OÙ new_start <= existing_end ET new_end >= existing_start;
- Si il était vraiment, il aurait plaint il y a 2 ans ...
- J'ai un événement d'aujourd'hui et une autre commence aujourd'hui, ils ne se chevauchent ? À mon avis, ils vont se chevaucher. Mais la requête SQL ne pas le dire: sqlfiddle.com/#!2/0a6fd/1/0
- En fait, il aurait juste ajouté le = dans son code au lieu de prendre la peine de s'en plaindre.
InformationsquelleAutor soulmerge
24
```
SELECT * FROM tbl WHERE
existing_start BETWEEN $newStart AND $newEnd OR 
existing_end BETWEEN $newStart AND $newEnd OR
$newStart BETWEEN existing_start AND existing_end

if (!empty($result))
throw new Exception('We have overlapping')
```
Ces 3 lignes de code sql clauses de couvrir les 4 cas de chevauchement nécessaire.
- Même si l'OP n'a pas été apparemment à la recherche de ce qui se chevauchent définition, cette réponse est la meilleure solution pour le problème décrit par la question du nom. J'étais à la recherche de ce chevauchement, qui est le véritable chevauchement.
InformationsquelleAutor Lamy
13

Lamy réponse est bonne, mais vous pouvez l'optimiser un peu plus.
```
SELECT * FROM tbl WHERE
existing_start BETWEEN $newSTart AND $newEnd OR
$newStart BETWEEN existing_start AND existing_end
```
Cela va attraper tous les quatre scénarios où les plages se superposent et d'exclure les deux où ils ne sont pas.
- Il existe d'autres solutions en plus de cela, et les deux autres ci-dessus?
InformationsquelleAutor LordJavac
4

J'ai dû faire face le problème similaire. Mon problème était de cesser de réservation entre une gamme de bloqué les dates. Par exemple la réservation est bloquée pour une propriété entre le 2 mai au 7 mai. J'avais besoin de trouver toute sorte de chevauchement de date de détecter et d'arrêter la réservation. Ma solution est similaire à LordJavac.
```
SELECT * FROM ib_master_blocked_dates WHERE venue_id=$venue_id AND 
(
    (mbd_from_date BETWEEN '$from_date' AND '$to_date') 
    OR
    (mbd_to_date BETWEEN  '$from_date' AND '$to_date')
    OR
    ('$from_date' BETWEEN mbd_from_date AND mbd_to_date)
    OR      
    ('$to_date' BETWEEN mbd_from_date AND mbd_to_date)      
)
*mbd=master_blocked_dates
```
Laissez-moi savoir si cela ne fonctionne pas.

InformationsquelleAutor Niraj Kumar

Donné deux intervalles comme (s1, e1) et (s2, e2) avec s1<e1 et s2<e2

Vous pouvez calculer le chevauchement comme ceci:

SELECT 
     s1, e1, s2, e2,
     ABS(e1-s1) as len1,
     ABS(e2-s2) as len2,
     GREATEST(LEAST(e1, e2) - GREATEST(s1, s2), 0)>0 as overlaps,
     GREATEST(LEAST(e1, e2) - GREATEST(s1, s2), 0) as overlap_length
FROM test_intervals

Fonctionnera aussi si un intervalle est à l'intérieur de l'autre.

InformationsquelleAutor Mackraken

0

Récemment, j'ai été aux prises avec le même problème et est arrivé à la fin avec cette une seule étape facile (Cela peut ne pas être une bonne approche ou la consommation de mémoire)-
```
SELECT * FROM duty_register WHERE employee = '2' AND (
(
duty_start_date BETWEEN {$start_date} AND {$end_date}
OR
duty_end_date BETWEEN {$start_date} AND {$end_date}
)
OR
(
{$start_date} BETWEEN duty_start_date AND duty_end_date
OR
{$end_date} BETWEEN duty_start_date AND duty_end_date)
);
```
Cela m'a aidé à trouver des entrées avec chevauchement des plages de dates.

Espère que cela aide quelqu'un.

InformationsquelleAutor Vishal Kumar Sahu

Vous devez vous connecter pour publier un commentaire.