Holen Sie sich eine Liste der Daten zwischen zwei Daten

Mit den Standardfunktionen von MySQL können Sie eine Abfrage schreiben, die eine Liste von Tagen zwischen zwei Daten zurückgibt.

Beispiel: Wenn 2009-01-01 und 2009-01-13 angegeben werden, wird eine einspaltige Tabelle mit den folgenden Werten zurückgegeben:

 2009-01-01 
 2009-01-02 
 2009-01-03
 2009-01-04 
 2009-01-05
 2009-01-06
 2009-01-07
 2009-01-08 
 2009-01-09
 2009-01-10
 2009-01-11
 2009-01-12
 2009-01-13

Bearbeiten: Es scheint, ich war nicht klar. Ich möchte diese Liste generieren. Ich habe Werte in der Datenbank gespeichert (nach Datum / Uhrzeit), möchte aber, dass sie auf einem linken äußeren Join zu einer Liste von Daten wie oben zusammengefasst werden (ich erwarte für einige Tage Null von der rechten Seite einiger dieser Joins und werde dies behandeln ).

Ich würde diese gespeicherte Prozedur verwenden, um die Intervalle, die Sie benötigen, in die temporäre Tabelle mit dem Namen time_intervals zu generieren , dann JOIN und Ihre Datentabelle mit der temporären Tabelle time_intervals zu aggregieren .

Die Prozedur kann Intervalle aller verschiedenen Typen generieren, die darin angegeben sind:

call make_intervals('2009-01-01 00:00:00','2009-01-10 00:00:00',1,'DAY')
.
select * from time_intervals  
.
interval_start      interval_end        
------------------- ------------------- 
2009-01-01 00:00:00 2009-01-01 23:59:59 
2009-01-02 00:00:00 2009-01-02 23:59:59 
2009-01-03 00:00:00 2009-01-03 23:59:59 
2009-01-04 00:00:00 2009-01-04 23:59:59 
2009-01-05 00:00:00 2009-01-05 23:59:59 
2009-01-06 00:00:00 2009-01-06 23:59:59 
2009-01-07 00:00:00 2009-01-07 23:59:59 
2009-01-08 00:00:00 2009-01-08 23:59:59 
2009-01-09 00:00:00 2009-01-09 23:59:59 
.
call make_intervals('2009-01-01 00:00:00','2009-01-01 02:00:00',10,'MINUTE')
. 
select * from time_intervals
.  
interval_start      interval_end        
------------------- ------------------- 
2009-01-01 00:00:00 2009-01-01 00:09:59 
2009-01-01 00:10:00 2009-01-01 00:19:59 
2009-01-01 00:20:00 2009-01-01 00:29:59 
2009-01-01 00:30:00 2009-01-01 00:39:59 
2009-01-01 00:40:00 2009-01-01 00:49:59 
2009-01-01 00:50:00 2009-01-01 00:59:59 
2009-01-01 01:00:00 2009-01-01 01:09:59 
2009-01-01 01:10:00 2009-01-01 01:19:59 
2009-01-01 01:20:00 2009-01-01 01:29:59 
2009-01-01 01:30:00 2009-01-01 01:39:59 
2009-01-01 01:40:00 2009-01-01 01:49:59 
2009-01-01 01:50:00 2009-01-01 01:59:59 
.
I specified an interval_start and interval_end so you can aggregate the 
data timestamps with a "between interval_start and interval_end" type of JOIN.
.
Code for the proc:
.
-- drop procedure make_intervals
.
CREATE PROCEDURE make_intervals(startdate timestamp, enddate timestamp, intval integer, unitval varchar(10))
BEGIN
-- *************************************************************************
-- Procedure: make_intervals()
--    Author: Ron Savage
--      Date: 02/03/2009
--
-- Description:
-- This procedure creates a temporary table named time_intervals with the
-- interval_start and interval_end fields specifed from the startdate and
-- enddate arguments, at intervals of intval (unitval) size.
-- *************************************************************************
   declare thisDate timestamp;
   declare nextDate timestamp;
   set thisDate = startdate;

   -- *************************************************************************
   -- Drop / create the temp table
   -- *************************************************************************
   drop temporary table if exists time_intervals;
   create temporary table if not exists time_intervals
      (
      interval_start timestamp,
      interval_end timestamp
      );

   -- *************************************************************************
   -- Loop through the startdate adding each intval interval until enddate
   -- *************************************************************************
   repeat
      select
         case unitval
            when 'MICROSECOND' then timestampadd(MICROSECOND, intval, thisDate)
            when 'SECOND'      then timestampadd(SECOND, intval, thisDate)
            when 'MINUTE'      then timestampadd(MINUTE, intval, thisDate)
            when 'HOUR'        then timestampadd(HOUR, intval, thisDate)
            when 'DAY'         then timestampadd(DAY, intval, thisDate)
            when 'WEEK'        then timestampadd(WEEK, intval, thisDate)
            when 'MONTH'       then timestampadd(MONTH, intval, thisDate)
            when 'QUARTER'     then timestampadd(QUARTER, intval, thisDate)
            when 'YEAR'        then timestampadd(YEAR, intval, thisDate)
         end into nextDate;

      insert into time_intervals select thisDate, timestampadd(MICROSECOND, -1, nextDate);
      set thisDate = nextDate;
   until thisDate >= enddate
   end repeat;

 END;

Ähnliches Beispieldatenszenario am Ende dieses Beitrags , in dem ich eine ähnliche Funktion für SQL Server erstellt habe.

Für MSSQL können Sie dies verwenden. Es ist sehr schnell.

Sie können dies in eine Tabellenwertfunktion einschließen oder proc speichern und im Start- und Enddatum als Variablen analysieren.

DECLARE @startDate DATETIME
DECLARE @endDate DATETIME

SET @startDate = '2011-01-01'
SET @endDate = '2011-01-31';

WITH dates(Date) AS 
(
    SELECT @startdate as Date
    UNION ALL
    SELECT DATEADD(d,1,[Date])
    FROM dates 
    WHERE DATE < @enddate
)

SELECT Date
FROM dates
OPTION (MAXRECURSION 0)
GO

Wir hatten ein ähnliches Problem mit BIRT-Berichten, da wir an jenen Tagen berichten wollten, an denen keine Daten vorhanden waren. Da es für diese Daten keine Einträge gab, bestand die einfachste Lösung für uns darin, eine einfache Tabelle zu erstellen, in der alle Daten gespeichert wurden, und diese zum Abrufen von Bereichen oder zum Verknüpfen zu Nullwerten für dieses Datum zu verwenden.

Wir haben einen Job, der jeden Monat ausgeführt wird, um sicherzustellen, dass die Tabelle 5 Jahre in der Zukunft gefüllt ist. Die Tabelle wird folgendermaßen erstellt:

create table all_dates (
    dt date primary key
);

Zweifellos gibt es magisch knifflige Möglichkeiten, dies mit verschiedenen DBMS zu tun, aber wir entscheiden uns immer für die einfachste Lösung. Die Speicheranforderungen für die Tabelle sind minimal und machen die Abfragen so viel einfacher und portabler. Diese Art von Lösung ist aus Sicht der Leistung fast immer besser, da keine zeilenweisen Berechnungen für die Daten erforderlich sind.

Die andere Option (und wir haben dies bereits verwendet) besteht darin, sicherzustellen, dass für jedes Datum ein Eintrag in der Tabelle vorhanden ist. Wir haben die Tabelle regelmäßig gekehrt und keine Einträge für Daten und / oder Zeiten hinzugefügt, die nicht vorhanden waren. Dies ist in Ihrem Fall möglicherweise keine Option, sondern hängt von den gespeicherten Daten ab.

Wenn Sie wirklich denken, dass es ein Ärger ist, das zu behaltenall_dates Tabelle , ist eine gespeicherte Prozedur der richtige Weg, um einen Datensatz mit diesen Daten zurückzugeben. Dies ist mit ziemlicher Sicherheit langsamer, da Sie den Bereich bei jedem Aufruf berechnen müssen, anstatt nur vorberechnete Daten aus einer Tabelle abzurufen.

Um ehrlich zu sein, können Sie die Tabelle 1000 Jahre lang ohne ernsthafte Probleme bei der Datenspeicherung ausfüllen - 365.000 16-Byte-Daten (zum Beispiel) plus einen Index, der das Datum dupliziert, plus 20% Overhead für die Sicherheit, würde ich ungefähr schätzen ungefähr 14M [365.000 * 16 * 2 * 1,2 = 14.016.000 Bytes]), eine winzige Tabelle im Schema der Dinge.

Sie können die Benutzervariablen von MySQL folgendermaßen verwenden :

SET @num = -1;
SELECT DATE_ADD( '2009-01-01', interval @num := @num+1 day) AS date_sequence, 
your_table.* FROM your_table
WHERE your_table.other_column IS NOT NULL
HAVING DATE_ADD('2009-01-01', interval @num day) <= '2009-01-13'

@num ist -1, weil Sie es bei der ersten Verwendung hinzufügen. Außerdem können Sie "HAVING date_sequence" nicht verwenden, da dadurch die Benutzervariable für jede Zeile zweimal inkrementiert wird.

Wenn Sie eine Idee aus dieser Antwort entlehnen, können Sie eine Tabelle mit 0 bis 9 erstellen und daraus Ihre Datumsliste erstellen.

CREATE TABLE num (i int);
INSERT INTO num (i) VALUES (0), (1), (2), (3), (4), (5), (6), (7), (8), (9);

select adddate('2009-01-01', numlist.id) as `date` from
(SELECT n1.i + n10.i*10 + n100.i*100 AS id
   FROM num n1 cross join num as n10 cross join num as n100) as numlist
where adddate('2009-01-01', numlist.id) <= '2009-01-13';

Auf diese Weise können Sie eine Liste mit bis zu 1000 Daten erstellen. Wenn Sie größer werden müssen, können Sie der inneren Abfrage einen weiteren Cross-Join hinzufügen.

Für den Zugriff (oder eine beliebige SQL-Sprache)

1. Erstellen Sie eine Tabelle mit 2 Feldern. Wir nennen diese Tabelle tempRunDates:
   --Felder fromDateund - toDate
   Dann fügen Sie nur 1 Datensatz ein, der das Start- und das Enddatum hat.

2. Erstellen Sie eine weitere Tabelle: Time_Day_Ref
   --Importieren Sie eine Liste mit Daten (Liste in Excel erstellen ist einfach) in diese Tabelle.
   - Der Feldname in meinem Fall ist Greg_Dtfür Gregorianisches Datum. -
   Ich habe meine Liste vom 1. Januar 2009 bis zum 1. Januar 2020 erstellt.

3. Führen Sie die Abfrage aus:

   SELECT Time_Day_Ref.GREG_DT
   FROM tempRunDates, Time_Day_Ref
   WHERE Time_Day_Ref.greg_dt>=tempRunDates.fromDate And greg_dt<=tempRunDates.toDate;

Einfach!

Normalerweise verwendet man eine Hilfszahlentabelle, die Sie normalerweise nur für diesen Zweck aufbewahren, mit einigen Variationen davon:

SELECT *
FROM (
    SELECT DATEADD(d, number - 1, '2009-01-01') AS dt
    FROM Numbers
    WHERE number BETWEEN 1 AND DATEDIFF(d, '2009-01-01', '2009-01-13') + 1
) AS DateRange
LEFT JOIN YourStuff
    ON DateRange.dt = YourStuff.DateColumn

Ich habe Variationen mit Tabellenwertfunktionen usw. gesehen.

Sie können auch eine permanente Liste von Daten führen. Wir haben das in unserem Data Warehouse sowie eine Liste der Tageszeiten.

Wie Sie Daten zwischen zwei angegebenen Daten in SQL Server finden, erfahren Sie unter http://ektaraval.blogspot.com/2010/09/writing-recursive-query-to-find-out-all.html

CREATE FUNCTION [dbo].[_DATES]
(
    @startDate DATETIME,
    @endDate DATETIME
)
RETURNS 
@DATES TABLE(
    DATE1 DATETIME
)
AS
BEGIN
    WHILE @startDate <= @endDate
    BEGIN 
        INSERT INTO @DATES (DATE1)
            SELECT @startDate   
    SELECT @startDate = DATEADD(d,1,@startDate) 
    END
RETURN
END

Elegante Lösung mit neuen rekursiven Funktionen (Common Table Expressions) in MariaDB> = 10.3 und MySQL> = 8.0.

WITH RECURSIVE t as (
    select '2019-01-01' as dt
  UNION
    SELECT DATE_ADD(t.dt, INTERVAL 1 DAY) FROM t WHERE DATE_ADD(t.dt, INTERVAL 1 DAY) <= '2019-04-30'
)
select * FROM t;

Das Obige gibt eine Tabelle mit Daten zwischen '2019-01-01' und '2019-04-30' zurück.

Wir haben dies in unserem HRMS-System verwendet. Sie werden es nützlich finden

SELECT CAST(DAYNAME(daydate) as CHAR) as dayname,daydate
    FROM
    (select CAST((date_add('20110101', interval H.i*100 + T.i*10 + U.i day) )as DATE) as daydate
      from erp_integers as H
    cross
      join erp_integers as T
    cross
      join erp_integers as U
     where date_add('20110101', interval H.i*100 + T.i*10 + U.i day ) <= '20110228'
    order
        by daydate ASC
        )Days

Diese Lösung funktioniert mit MySQL 5.0.
Erstellen Sie eine Tabelle - mytable.
Das Schema ist nicht wesentlich. Was zählt, ist die Anzahl der Zeilen darin.
Sie können also nur eine Spalte vom Typ INT mit 10 Zeilen und Werten von 1 bis 10 behalten.

SQL:

set @tempDate=date('2011-07-01') - interval 1 day;
select
date(@tempDate := (date(@tempDate) + interval 1 day)) as theDate
from mytable x,mytable y
group by theDate
having theDate <= '2011-07-31';

Einschränkung: Die maximale Anzahl von Daten, die von der obigen Abfrage zurückgegeben werden, beträgt
(rows in mytable)*(rows in mytable) = 10*10 = 100.

Sie können diesen Bereich erhöhen, indem Sie den Formularteil in SQL ändern:
von mytable x, mytable y, mytable z
Also, der Bereich sei 10*10*10 =1000und so weiter.

Erstellen Sie eine gespeicherte Prozedur, die zwei Parameter a_begin und a_end verwendet. Erstellen Sie eine temporäre Tabelle mit dem Namen t, deklarieren Sie eine Variable d, weisen Sie d a_begin zu und führen Sie eine WHILESchleife INSERTd in t aus und rufen Sie die ADDDATEFunktion auf, um den Wert d zu erhöhen . Endlich SELECT * FROM t.

Ich würde etwas Ähnliches verwenden:

DECLARE @DATEFROM AS DATETIME
DECLARE @DATETO AS DATETIME
DECLARE @HOLDER TABLE(DATE DATETIME)

SET @DATEFROM = '2010-08-10'
SET @DATETO = '2010-09-11'

INSERT INTO
    @HOLDER
        (DATE)
VALUES
    (@DATEFROM)

WHILE @DATEFROM < @DATETO
BEGIN

    SELECT @DATEFROM = DATEADD(D, 1, @DATEFROM)
    INSERT 
    INTO
        @HOLDER
            (DATE)
    VALUES
        (@DATEFROM)
END

SELECT 
    DATE
FROM
    @HOLDER

Dann enthält die @HOLDERVariablentabelle alle Daten, die zwischen diesen beiden Daten um einen Tag erhöht wurden, und kann nach Herzenslust hinzugefügt werden.

Ich habe eine ganze Weile damit gekämpft. Da dies der erste Treffer bei Google ist, als ich nach der Lösung gesucht habe, möchte ich posten, wo ich bisher angekommen bin.

SET @d := '2011-09-01';
SELECT @d AS d, cast( @d := DATE_ADD( @d , INTERVAL 1 DAY ) AS DATE ) AS new_d
  FROM [yourTable]
  WHERE @d <= '2012-05-01';

Ersetzen Sie [yourTable]durch eine Tabelle aus Ihrer Datenbank. Der Trick besteht darin, dass die Anzahl der Zeilen in der von Ihnen ausgewählten Tabelle> = die Anzahl der Daten sein muss, die zurückgegeben werden sollen. Ich habe versucht, den Tabellenplatzhalter DUAL zu verwenden, aber er hat nur eine einzelne Zeile zurückgegeben.

select * from table_name where col_Date between '2011/02/25' AND DATEADD(s,-1,DATEADD(d,1,'2011/02/27'))

Fügen Sie hier zuerst einen Tag zum aktuellen Enddatum hinzu, es ist 2011-02-28 00:00:00, dann subtrahieren Sie eine Sekunde, um das Enddatum 2011-02-27 23:59:59 festzulegen. Auf diese Weise können Sie alle Daten zwischen den angegebenen Intervallen abrufen.

Ausgabe:
2011/02/25
2011/02/26
2011/02/27

DELIMITER $$  
CREATE PROCEDURE popula_calendario_controle()
   BEGIN
      DECLARE a INT Default 0;
      DECLARE first_day_of_year DATE;
      set first_day_of_year = CONCAT(DATE_FORMAT(curdate(),'%Y'),'-01-01');
      one_by_one: LOOP
         IF dayofweek(adddate(first_day_of_year,a)) <> 1 THEN
            INSERT INTO calendario.controle VALUES(null,150,adddate(first_day_of_year,a),adddate(first_day_of_year,a),1);
         END IF;
         SET a=a+1;
         IF a=365 THEN
            LEAVE one_by_one;
         END IF;
      END LOOP one_by_one;
END $$

Bei diesem Verfahren werden alle Daten vom Anfang des Jahres bis jetzt eingefügt. Ersetzen Sie einfach die Tage "Start" und "Ende", und schon kann es losgehen!

Ich brauchte eine Liste mit allen Monaten zwischen zwei Daten für Statistiken. Die 2 Daten sind das Start- und Enddatum eines Abonnements. Die Liste zeigt also alle Monate und die Anzahl der Abonnements pro Monat.

MYSQL

CREATE PROCEDURE `get_amount_subscription_per_month`()
BEGIN
   -- Select the ultimate start and enddate from subscribers
   select @startdate := min(DATE_FORMAT(a.startdate, "%Y-%m-01")), 
          @enddate := max(DATE_FORMAT(a.enddate, "%Y-%m-01")) + interval 1 MONTH
   from subscription a;

   -- Tmp table with all months (dates), you can always format them with DATE_FORMAT) 
   DROP TABLE IF EXISTS tmp_months;
   create temporary table tmp_months (
      year_month date,
      PRIMARY KEY (year_month)
   );


   set @tempDate=@startdate;  #- interval 1 MONTH;

   -- Insert every month in tmp table
   WHILE @tempDate <= @enddate DO
     insert into tmp_months (year_month) values (@tempDate);
     set @tempDate = (date(@tempDate) + interval 1 MONTH);
   END WHILE;

   -- All months
   select year_month from tmp_months;

   -- If you want the amount of subscription per month else leave it out
   select mnd.year_month, sum(subscription.amount) as subscription_amount
   from tmp_months mnd
   LEFT JOIN subscription ON mnd.year_month >= DATE_FORMAT(subscription.startdate, "%Y-%m-01") and mnd.year_month <= DATE_FORMAT(subscription.enddate, "%Y-%m-01")
   GROUP BY mnd.year_month;

 END

Sie können dies verwenden

SELECT CAST(cal.date_list AS DATE) day_year
FROM (
  SELECT SUBDATE('2019-01-01', INTERVAL 1 YEAR) + INTERVAL xc DAY AS date_list
  FROM (
        SELECT @xi:=@xi+1 as xc from
        (SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4) xc1,
        (SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4) xc2,
        (SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4) xc3,
        (SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4) xc4,
        (SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4) xc5,
        (SELECT @xi:=-1) xc0
    ) xxc1
) cal
WHERE cal.date_list BETWEEN '2019-01-01' AND '2019-12-31'
ORDER BY cal.date_list DESC;

ich benutze Server version: 5.7.11-log MySQL Community Server (GPL)

Jetzt werden wir dies auf einfache Weise lösen.

Ich habe eine Tabelle mit dem Namen "Datentabelle" erstellt.

mysql> describe datetable;
+---------+---------+------+-----+---------+-------+
| Field   | Type    | Null | Key | Default | Extra |
+---------+---------+------+-----+---------+-------+
| colid   | int(11) | NO   | PRI | NULL    |       |
| coldate | date    | YES  |     | NULL    |       |
+---------+---------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Jetzt sehen wir die eingefügten Datensätze darin.

mysql> select * from datetable;
+-------+------------+
| colid | coldate    |
+-------+------------+
|   101 | 2015-01-01 |
|   102 | 2015-05-01 |
|   103 | 2016-01-01 |
+-------+------------+
3 rows in set (0.00 sec)

und hier unsere Abfrage, Datensätze innerhalb von zwei Daten anstatt dieser Daten abzurufen.

mysql> select * from datetable where coldate > '2015-01-01' and coldate < '2016-01-01';
+-------+------------+
| colid | coldate    |
+-------+------------+
|   102 | 2015-05-01 |
+-------+------------+
1 row in set (0.00 sec)

hoffe, das würde vielen helfen.