두 날짜 사이의 날짜 목록 가져오기

두 날짜 사이의 날짜 목록 가져오기

표준 mysql 함수를 사용하면 두 날짜 사이의 일 목록을 반환하는 쿼리를 작성할 수 있습니다.

예: 2009-01-01 및 2009-01-13이 지정되면 다음 값이 포함된 하나의 열 테이블을 반환합니다.

 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

편집: 잘 이해하지 못한 것 같습니다.이 목록을 생성하려고 합니다.데이터베이스에 저장된 값(날짜별)이 있지만 왼쪽 외부 조인에서 위와 같은 날짜 목록으로 집계해야 합니다(이 조인 중 오른쪽에서 null을 며칠간 예상하며 이 작업을 처리합니다).

이 스토어드 프로시저를 사용하여 time_intervals라는 이름의 임시 테이블에 필요한 인터벌을 생성하고 데이터 테이블을 temp time_intervals 테이블과 결합합니다.

이 절차에서는 지정된 모든 다른 유형의 간격을 생성할 수 있습니다.

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;

이 투고 하단의 유사한 데이터 시나리오 예에서는 SQL Server에 대해 유사한 기능을 구축했습니다.

MSQL의 경우 이를 사용할 수 있습니다.매우 빠르다.

이를 테이블 값 함수 또는 저장된 proc로 정리하여 시작일과 종료일을 변수로 해석할 수 있습니다.

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

2021/01 편집(Dr. V): 이 솔루션이 마음에 들어 MySQL V8에서 사용할 수 있게 되었습니다.코드는 다음과 같습니다.순서로 정리합니다.

DELIMITER //

CREATE PROCEDURE dates_between (IN from_date DATETIME,
                               IN to_date DATETIME) BEGIN
    WITH RECURSIVE dates(Date) AS
    (
        SELECT from_date as Date
        UNION ALL
        SELECT DATE_ADD(Date, INTERVAL 1 day) FROM dates WHERE Date < to_date
    )
    SELECT DATE(Date) FROM dates;
END//

DELIMITER ;

MySQL의 사용자 변수는 다음과 같이 사용할 수 있습니다.

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은 처음 사용할 때 추가되므로 -1 입니다.또한 HAVING date_sequence를 사용하면 각 행에 대해 사용자 변수가 두 배로 증가하므로 사용할 수 없습니다.

BIRT 보고서에서도 데이터가 없는 날을 보고하고 싶다는 점에서 비슷한 문제가 있었습니다.이러한 날짜에 대한 엔트리가 없었기 때문에 가장 쉬운 해결책은 모든 날짜를 저장하는 간단한 테이블을 만들고 이를 사용하여 범위를 가져오거나 조인하여 해당 날짜에 대한 값을 0으로 얻는 것이었습니다.

우리는 5년 후에 테이블이 채워질 수 있도록 매달 실행하는 일을 하고 있습니다.테이블은 다음과 같이 작성됩니다.

create table all_dates (
    dt date primary key
);

물론 다양한 DBMS를 사용하여 이 작업을 수행하는 데 매우 까다로운 방법이 있지만, 델은 항상 가장 간단한 솔루션을 선택합니다.테이블의 스토리지 요건은 최소이며 쿼리를 훨씬 단순하고 휴대할 수 있습니다.이러한 종류의 솔루션은 데이터를 행 단위로 계산할 필요가 없기 때문에 성능 측면에서 거의 항상 더 우수합니다.

다른 옵션(이전에도 사용했지만)은 모든 날짜에 대해 테이블에 항목이 있는지 확인하는 것입니다.테이블을 정기적으로 스위프하여 존재하지 않는 날짜 및/또는 시간에 대해 0의 엔트리를 추가했습니다.이 옵션은, 보존되어 있는 데이터에 의해서 다릅니다.

만약 당신이 정말로 그 물건을 보관하는 것이 번거롭다고 생각한다면all_dates테이블이 채워지고 스토어드 프로시저가 해당 날짜가 포함된 데이터 세트를 반환하는 방법입니다.테이블에서 미리 계산된 데이터만 가져오는 것이 아니라 호출할 때마다 범위를 계산해야 하므로 이 작업은 거의 더 느립니다.

그러나 솔직히 말해서, 365,000개의 16바이트 날짜(예:)와 날짜를 중복하는 인덱스, 안전을 위해 20%의 오버헤드 등 심각한 데이터 스토리지 문제 없이 1000년 동안 테이블을 채울 수 있습니다. 대략 1400만 개 정도로 추정됩니다[135,000 * 16 * 2 * 1.2 = 140,16,000 바이트].

이 답변에서 아이디어를 빌리면 0 ~9 의 테이블을 설정하고 그것을 사용하여 날짜 목록을 생성할 수 있습니다.

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';

이를 통해 최대 1000개의 날짜 목록을 생성할 수 있습니다.더 크게 해야 할 경우 내부 조회에 다른 교차 결합을 추가할 수 있습니다.

MariaDB > = 10.3 및 MySQL > = 8.0의 새로운 재귀(Common Table Expressions) 기능을 사용한 우아한 솔루션.

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;

위는 '2019-01-01'과 '2019-04-30' 사이의 날짜 표를 반환합니다.

액세스(또는 임의의 SQL 언어)

1. 필드로 를 하나 이 표라고 .이 테이블을 이 테이블이라고 부릅니다.tempRunDates
   -- 드드fromDate ★★★★★★★★★★★★★★★★★」toDate
   있는 합니다.---------------------------------------------------------------------------------------------------------------------------------------------------------------

2. 표를 만듭니다.Time_Day_Ref
   -- 이 테이블로 날짜 목록 가져오기(엑셀 목록 만들기 쉬움)
   은 -- 우경경 -- -- -- -- -- -- 。Greg_Dt
   부터 2020년했습니다.

3. 쿼리를 실행합니다.

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

진정해요!

통상, 이 목적을 위해서 보관하고 있는 보조 번호표를 사용합니다.다만, 다음과 같이 몇개의 변경이 있습니다.

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

테이블 값 함수 등의 변형을 본 적이 있습니다.

또한 영구적인 날짜 목록을 유지할 수도 있습니다.데이터 웨어하우스와 하루 중 시간 목록이 있습니다.

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

HRMS 시스템에서 이 기능을 사용했습니다.

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

이 솔루션은 MySQL 5.0에서 작동합니다.
테이블 만들기 -mytable.
스키마는 중요하지 않습니다.중요한 것은 그 안에 있는 줄의 수이다.
따라서 INT 유형의 열에는 행이 10개이고 값이 1 ~ 10개입니다.

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';

제한:위 쿼리에서 반환되는 최대 날짜 수는 다음과 같습니다.
(rows in mytable)*(rows in mytable) = 10*10 = 100.

sql에서 폼 부분을 변경하여 이 범위를 늘릴 수 있습니다.
mytable x, mytable y, mytable z에서
그래서 범위는10*10*10 =1000기타 등등.

이거 써도 돼

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;

임시 테이블 없음 | 절차 없음 | 기능 없음

다음 예에서는 1개월 날짜의 범위를 1일부터 같은 달의 마지막 날까지로 보여 줍니다.날짜 범위를 변경하려면 @e 'INTERVAL' 값을 사용합니다.

SET @s := CAST('2021-12-01' AS DATE); -- start at 2021-12-01
SET @e := @s + INTERVAL 1 MONTH - INTERVAL 1 DAY; -- ends at 2021-12-31

WITH RECURSIVE d_range AS
(
       SELECT @s AS gdate -- generated dates
       UNION ALL
       SELECT gdate + INTERVAL 1 day
       FROM   d_range
       WHERE  gdate < @e
)
SELECT *
FROM   d_range;

결과:

| gdate       |
+------------+
| 2021-12-01 |
| 2021-12-02 |
| 2021-12-03 |
| 2021-12-04 |
| 2021-12-05 |
| 2021-12-06 |
| 2021-12-07 |
| 2021-12-08 |
| 2021-12-09 |
| 2021-12-10 |
| 2021-12-11 |
| 2021-12-12 |
| 2021-12-13 |
| 2021-12-14 |
| 2021-12-15 |
| 2021-12-16 |
| 2021-12-17 |
| 2021-12-18 |
| 2021-12-19 |
| 2021-12-20 |
| 2021-12-21 |
| 2021-12-22 |
| 2021-12-23 |
| 2021-12-24 |
| 2021-12-25 |
| 2021-12-26 |
| 2021-12-27 |
| 2021-12-28 |
| 2021-12-29 |
| 2021-12-30 |
| 2021-12-31 |
+------------+
-> 31 rows in set (0.037 sec)

참고. 이 쿼리는 속도가 느리기 때문에 RECURSION을 사용합니다.31 rows in set (0.037 sec)더 긴 날짜 범위를 선택하면 더 느려집니다.

a_begin과 a_end의 두 가지 매개 변수를 사용하는 저장 프로시저를 만듭니다.t라는 이름의 임시 테이블을 만들고 변수 d를 선언한 후 a_begin을 d에 할당하고 실행한다.WHILE고리INSERTd를 t에 입력하여 호출하다ADDDATEd 값을 증가시키는 함수입니다.마침내.SELECT * FROM t.

다음과 같은 것을 사용합니다.

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

그 다음에@HOLDER변수 테이블에는 두 날짜 사이의 일별 증가된 모든 날짜가 포함되어 있습니다.마음의 콘텐츠에 참여할 준비가 되어 있습니다.

나는 꽤 오랫동안 이것과 싸워왔다.제가 솔루션을 검색했을 때 구글에서 처음 히트를 쳤기 때문에, 지금까지의 상황을 투고하겠습니다.

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';

교체하다[yourTable]데이터베이스 테이블과 함께 사용합니다.요점은 선택한 테이블의 행 수가 반환할 날짜 수 = 이상이어야 한다는 것입니다.테이블 플레이스 홀더 DUAL을 사용하려고 했지만 1열만 반환됩니다.

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

여기서 먼저 현재 endDate에 하루를 더하면 2011-02-28 00:00:00가 되고 1초를 빼서 2011-02-27 23:59:59가 됩니다.이렇게 하면 지정된 간격 사이의 모든 날짜를 얻을 수 있습니다.

출력:
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 $$

이 절차에서는 연도의 시작부터 지금까지의 모든 날짜를 삽입하고 "시작"과 "종료"의 날짜만 대체하면 준비가 완료됩니다.

통계를 위해 두 달 사이에 있는 목록이 필요했어요.두 날짜는 구독 시작 날짜와 종료 날짜입니다.이 목록에는 모든 달과 월별 구독 금액이 표시됩니다.

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

기능 없음, 절차 없음

SET @s := '2020-01-01';
SET @e := @s + INTERVAL 1 YEAR - INTERVAL 1 DAY; -- set end date to select

SELECT CAST((DATE(@s)+INTERVAL (H+T+U) DAY) AS DATE) d -- generate a list of 400 days starting from @s date so @e can not be more then @s + 
FROM ( SELECT 0 H
    UNION ALL SELECT 100 UNION ALL SELECT 200 UNION ALL SELECT 300
  ) H CROSS JOIN ( SELECT 0 T
    UNION ALL SELECT  10 UNION ALL SELECT  20 UNION ALL SELECT  30
    UNION ALL SELECT  40 UNION ALL SELECT  50 UNION ALL SELECT  60
    UNION ALL SELECT  70 UNION ALL SELECT  80 UNION ALL SELECT  90
  ) T CROSS JOIN ( SELECT 0 U
    UNION ALL SELECT   1 UNION ALL SELECT   2 UNION ALL SELECT   3
    UNION ALL SELECT   4 UNION ALL SELECT   5 UNION ALL SELECT   6
    UNION ALL SELECT   7 UNION ALL SELECT   8 UNION ALL SELECT   9
  ) U
 -- generated lenght of date list can be calculated as fallow 1 * H(3 + 1) * T(9 + 1) * U(9 + 1) = 400
 -- it is crucial to preserve the numbering convention as 1, 2 ... 20, 30..., 100, 200, ... to retrieve chronological date selection
 -- add more UNION 400, 500, 600, ... H(6 + 1) if you want to select from more than 700 days!
WHERE
  (DATE(@s+INTERVAL (H+T+U) DAY)) <= DATE((@e))
ORDER BY d;

UNIONS는 선택 가능한 날짜의 길이와 범위를 정의합니다.그래서 항상 충분히 기록하도록 하세요.

SELECT 1 * (3 + 1) * (9 + 1) * (9 + 1); -- 400 days starting from from @s

이 기사를 바탕으로
( 완료 및 예상대로 동작)

@brad answer를 개선하여 커서가 있는 CTE를 사용했습니다.

DECLARE cursorPeriod CURSOR FOR SELECT * FROM (
   WITH RECURSIVE period as
        (
             SELECT '2019-01-01' as dt
             UNION
             SELECT DATE_ADD(period.dt, INTERVAL 1 DAY) FROM period WHERE DATE_ADD(period.dt, INTERVAL 1 DAY) <= '2019-04-30'
        )
   SELECT DATE(dt) FROM period ORDER BY dt ) AS derived_table;

DECLARE CONTINUE HANDLER FOR NOT FOUND SET exit_loop = TRUE;

휴대용 솔루션

-- Generate 
WITH 
tdates AS (
  WITH   t19 AS (
          SELECT  0 i union select 1 union select 2 union select 3 union select 4 union select 5 union select 6 union 
          select 7     union select 8 union select 9 )    
   SELECT  adddate('1970-01-01',t4.i*10000 + t3.i*1000 + t2.i*100 + t1.i*10 + t0.i) datei 
   FROM  t19 AS t0, t19 AS t1, t19 AS t2, t19 AS t3,  t19 AS t4 
)

select * from tdates
where datei between '2012-02-10' and '2012-02-15'

사용하고 있다

이번에는 간단하게 해결하겠습니다.

datable이라는 이름의 테이블을 만들었습니다.

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)

이제 Wee는 삽입된 레코드를 볼 수 있습니다.

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)

그리고 여기에서는 그 날짜들이 아닌 두 날짜 안에 레코드를 가져오기 위한 쿼리입니다.

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)

이게 많은 도움이 됐으면 좋겠어요.

언급URL : https://stackoverflow.com/questions/510012/get-a-list-of-dates-between-two-dates