MySQL seleziona le righe in cui la data non è compresa tra la data

Question

Ho un sistema di prenotazione in cui ho bisogno di selezionare qualsiasi stanza disponibile dal database. La configurazione di base è:

table: room 
columns: id, maxGuests 

table: roombooking 
columns: id, startDate, endDate 

table: roombooking_room: 
columns: id, room_id, roombooking_id 

Ho bisogno di selezionare stanze che può andare bene gli ospiti richiesti, o selezionare due (o più) camere per soddisfare gli ospiti in (come definito da maxGuests, ovviamente utilizzando il più basso/armadio maxGuests prima)

potevo ciclo attraverso il mio intervallo di date e utilizzare questo sql:. ​​

SELECT `id` 
FROM `room` 
WHERE `id` NOT IN 
(
    SELECT `roombooking_room`.`room_id` 
    FROM `roombooking_room`, `roombooking` 
    WHERE `roombooking`.`confirmed` =1 
    AND DATE(%s) BETWEEN `roombooking`.`startDate` AND `roombooking`.`endDate` 
) 
AND `room`.`maxGuests`>=%d 

Dove% $ 1 è la data e l'% in loop 2d è il numero di ospiti per essere prenotato in Ma questo solo sarà restituisce false se ci sono più ospiti di quanti ne possa prendere una e ci deve essere un quic modo per farlo, piuttosto che fare un ciclo con php ed eseguire la query?

Questo è simile a una parte del SQL pensavo: Getting Dates between a range of dates ma con Mysql

---

soluzione, in base alla risposta del ircmaxwell:

$query = sprintf(
     "SELECT `id`, `maxGuests` 
     FROM `room` 
     WHERE `id` NOT IN 
     (
      SELECT `roombooking_room`.`room_id` 
      FROM `roombooking_room` 
      JOIN `roombooking` ON `roombooking_room`.`roombooking_id` = `roombooking`.`id` 
      WHERE `roombooking`.`confirmed` =1 
      AND (`roomBooking`.`startDate` > DATE(%s) OR `roomBooking`.`endDate` < DATE(%s)) 
     ) 
     AND `maxGuests` <= %d ORDER BY `maxGuests` DESC", 
     $endDate->toString('yyyy-MM-dd'), $startDate->toString('yyyy-MM-dd'), $noGuests); 
     $result = $db->query($query); 
     $result = $result->fetchAll(); 

     $rooms = array(); 
     $guests = 0; 
     foreach($result as $res) { 
      if($guests >= $noGuests) break; 
      $guests += (int)$res['maxGuests']; 
      $rooms[] = $res['id']; 
     } 

Answer 1

Supponendo che siete interessati a mettere @Guests da @StartDate a @EndDate

SELECT DISTINCT r.id, 
FROM room r 
    LEFT JOIN roombooking_room rbr ON r.id = rbr.room_id 
    LEFT JOIN roombooking ON rbr.roombooking_id = rb.id 
WHERE COALESCE(@StartDate NOT BETWEEN rb.startDate AND rb.endDate, TRUE) 
     AND COALESCE(@EndDate NOT BETWEEN rb.startDate AND rb.endDate, TRUE) 
     AND @Guests < r.maxGuests 

dovrebbe dare un elenco di tutte le camere che sono liberi e possono ospitare dato numero di ospiti per il periodo specificato.

NOTE
Questa query funziona solo per le camere singole, se si vuole guardare più sale che sarà necessario applicare gli stessi criteri a una combinazione di sale. Per questo è necessario avere query ricorsive o alcune tabelle di supporto. Inoltre, COALESCE è lì per occuparsi dei NULL: se una stanza non è stata prenotata, non avrebbe alcun record con date da confrontare, quindi non restituirebbe stanze completamente libere. La data tra data1 e data2 restituirà NULL se data1 o date2 sono nulle e la coalesce la trasformerà in vera (alternativa è fare un UNION di stanze completamente libere, che potrebbe essere più veloce).

Con più stanze le cose diventano davvero interessanti. Questo scenario è una parte importante del tuo problema? E quale database stai usando, hai accesso a richieste ricorsive?

EDIT

Come ho detto più volte in passato, il tuo modo di cercare una soluzione (algoritmo greedy che guarda più grandi camere libere prima) non è ottimale, se si vuole ottenere il miglior adattamento tra numero richiesto di ospiti e camere.

Quindi, se si sostituisce il tuo foreach con

$bestCapacity = 0; 
$bestSolution = array(); 

for ($i = 1; $i <= pow(2,sizeof($result))-1; $i++) { 
    $solutionIdx = $i; 
    $solutionGuests = 0; 
    $solution = array(); 
    $j = 0; 
    while ($solutionIdx > 0) : 
     if ($solutionIdx % 2 == 1) { 
      $solution[] = $result[$j]['id']; 
      $solutionGuests += $result[$j]['maxGuests']; 
     } 
     $solutionIdx = intval($solutionIdx/2); 
     $j++; 
    endwhile;  
    if (($solutionGuests <= $bestCapacity || $bestCapacity == 0) && $solutionGuests >= $noGuests) { 
     $bestCapacity = $solutionGuests; 
     $bestSolution = $solution; 
    } 
} 

print_r($bestSolution); 
print_r($bestCapacity); 

passerà attraverso tutte le possibili combinazioni e trovare la soluzione che spreca il minor numero di spazi.

Answer 2

Ok, prima di tutto, la query interna stai usando è un join cartesiano e sarà MOLTO costoso. È necessario specificare i criteri di join (roombooking_room.booking_id = roombooking.id per esempio).

In secondo luogo, supponendo di avere un intervallo di date, cosa possiamo dire a riguardo? Bene, chiamiamo l'inizio del range rangeStartDate e rangeEndDate.

Ora, che cosa possiamo dire su qualsiasi altro intervallo di date che non ha alcuna forma di sovrapposizione con questa gamma? Bene, lo endDate non deve essere compreso tra rangeStartDate e rangeEndDate. Lo stesso con lo startDate. E il rangeStartDate (e rangeEndDate, ma non abbiamo bisogno di check it) non può essere compreso tra startDate e endDate ...

Quindi, ipotizzando %1$s è rangeStartDate e %2$s è rangeEndDate, una vasta dove la clausola potrebbe essere:

WHERE `roomBooking`.`startDate` NOT BETWEEN %1$s AND %2s 
    AND `roomBooking`.`endDate` NOT BETWEEN %1$s AND %2$$s 
    AND %1s NOT BETWEEN `roomBooking`.`startDate` AND `roomBooking`.`endDate` 

Ma, c'è un modo più semplice per dirlo. L'unico modo per un campo di essere al di fuori di un altro è per il data_iniziale sia dopo l'end_date, o l'end_date essere prima della START_ID

Quindi, supponendo %1$s è rangeStartDate e %2$s è rangeEndDate, un altro completo dove la clausola potrebbe essere:

WHERE `roomBooking`.`startDate` > %2$s 
    OR `roomBooking`.`endDate` < %1$s 

quindi, che porta la query complessiva:

SELECT `id` 
FROM `room` 
WHERE `id` NOT IN 
(
    SELECT `roombooking_room`.`room_id` 
    FROM `roombooking_room` 
    JOIN `roombooking` ON `roombooking_room`.`roombooking_id` = `roombooking`.`id` 
    WHERE `roombooking`.`confirmed` =1 
    AND (`roomBooking`.`startDate` > %2$s 
     OR `roomBooking`.`endDate` < %1$s) 
) 
AND `room`.`maxGuests`>=%d 

ci sono altri modi per farlo, così, in modo da tenere in cerca ...

Answer 3

SELECT rooms.id 
FROM rooms LEFT JOIN bookings 
ON booking.room_id = rooms.id 
WHERE <booking overlaps date range of interest> AND <wherever else> 
GROUP BY rooms.id 
HAVING booking.id IS NULL 

Potrei perdere il ricordo di come funziona l'unione sinistra, quindi potrebbe essere necessario utilizzare una condizione leggermente diversa sull'avere, forse un conteggio o una somma.

Nel peggiore dei casi, con gli indici adatti, che dovrebbero scansionare metà delle prenotazioni.