获得两个连续两个日期，它们之间的时间间隔最长

Question

$a = 1950-05-01
$b = 1965-08-10
$c = 1990-12-30
$d = 1990-12-29
$e = 2012-09-03

从按日期升序排序的mysql数据库中检索日期。

我需要一个mysql或PHP脚本来获得具有最大天差的两个CONSECUTIVE日期。

解释：脚本应该计算$ a和$ b，$ b和$ c，$ c和$ d，$ d和$ e，$ e和$ a之间的天数，然后以最大天差输出两个日期。

有没有办法用一个快速的mysql / php代码执行此操作，或者我应该使用以下脚本进行一些循环（在stackoverflow上的另一个问题上找到它）？

$now = time(); // or your date as well
$your_date = strtotime("2010-01-01");
$datediff = $now - $your_date;
echo floor($datediff/(60*60*24));

查询列出日期：

SELECT date AS count FROM table WHERE column1 = 'YES' AND data BETWEEN 1950-01-01 AND 2012-09-04

Answer 1

MySQL解决方案

假设每个日期都有一个顺序id 。 看到它在行动 。

架构

CREATE TABLE tbl (
  id tinyint,
  dt date);

INSERT INTO tbl VALUES 
(1, '1950-05-01'),
(2, '1965-08-10'),
(3, '1990-12-30'),
(4, '1990-12-29'),
(5, '2012-09-03')

询问

SELECT a.dt AS date1, 
    (SELECT dt FROM tbl WHERE id = a.id - 1) AS date2,
    DATEDIFF(a.dt, b.dt) AS diff
FROM tbl a
LEFT JOIN tbl b ON b.id = a.id -1
GROUP BY a.id
ORDER BY diff DESC
LIMIT 1

结果

|                         DATE1 |                           DATE2 | DIFF |
--------------------------------------------------------------------------
| August, 10 1965 00:00:00-0700 | December, 30 1990 00:00:00-0800 | 9273 |

PHP解决方案

$array = array('1950-05-01', '1965-08-10', '1990-12-30', '1990-12-29', '2012-09-03');

$maxDiff = 0;
$maxStart = NULL;
$maxEnd = NULL;

for($i = 1; $i <= count($array); $i++) {
    if(isset($array[$i])) {
        $diff = (strtotime($array[$i]) - strtotime($array[$i-1])) / (60*60*24);

        if($diff > $maxDiff) {
            $maxDiff = $diff;
            $maxStart = $array[$i-1];
            $maxEnd = $array[$i];
        }
    }
}

echo "The maximum days difference is between $maxStart and $maxEnd, with a difference of $maxDiff days";

结果

The maximum days difference is between 1965-08-10 and 1990-12-30, with a difference of 9273.0416666667 days

更新1

关于PHP解决方案，如果您的日期不是有序的，您可以使用sort($array);在循环之前对数组进行sort($array); 。

Answer 2

您可以使用此单语句解决方案：

SELECT   a.date date1,
         b.date date2,
         DATEDIFF(b.date, a.date) ddiff
FROM     (
         SELECT     @a_rn:=@a_rn+1 ascrank,
                    date
         FROM       tbl
         CROSS JOIN (SELECT @a_rn:=0) var_init
         WHERE      date BETWEEN '1950-05-01' AND '2012-09-04'
         ORDER BY   date
         ) a
JOIN     (
         SELECT     @b_rn:=@b_rn+1 ascrank,
                    date
         FROM       tbl
         CROSS JOIN (SELECT @b_rn:=-1) var_init
         WHERE      date BETWEEN '1950-05-01' AND '2012-09-04'
         ORDER BY   date
         ) b ON a.ascrank = b.ascrank
ORDER BY ddiff DESC
LIMIT    1

---

查询细分

---

给出这个示例数据集：

CREATE TABLE tbl (
  date DATE
);

INSERT INTO tbl VALUES
('1950-05-01'),
('1965-08-10'),
('1990-12-30'),
('1990-12-29'),
('2012-09-03');

我们希望找到连续的两个日期之间最大的区别（意义，因为按照升序排列的日期，发现日期和他们的直接日期之前的最大天差）。

我们期望输出：

+-------------+------------+--------+
| date1       | date2      | ddiff  |
+-------------+------------+--------+
| 1965-08-10  | 1990-12-29 | 9272   |
+-------------+------------+--------+

因为最大连续日期差异在1965-08-10和1990-12-29之间。

---

步骤1：

为了使前一个和下一个日期彼此相邻（为了方便DATEDIFF函数），我们要做的第一件事是根据日期的升序在每个日期附加一个排名编号。

因为日期的顺序不能依赖于除了它们之外的任何东西（不是自动递增的ID或等级字段等），我们必须自己手动计算等级。

我们通过使用MySQL变量来做到这一点。 使用变量的其他解决方案要求您执行三个或更多单独的语句。 我在查询本身中初始化变量的技术（通过CROSS JOIN ）使它包含在单个语句中。

SELECT     @a_rn:=@a_rn+1 ascrank,
           date
FROM       tbl
CROSS JOIN (SELECT @a_rn:=0) var_init
WHERE      date BETWEEN '1950-05-01' AND '2012-09-04'
ORDER BY   date 

呈现：

+----------+------------+
| ascrank  | date       |
+----------+------------+
| 1        | 1950-05-01 |
| 2        | 1965-08-10 |
| 3        | 1990-12-29 |
| 4        | 1990-12-30 |
| 5        | 2012-09-03 |
+----------+------------+

SQLFiddle演示

请注意WHERE条件，即日期必须在两个指定日期之间。 您可以在此处从脚本中插入开始/结束日期参数。

---

第2步：

现在我们已经对每个日期进行了排序，现在我们需要根据ascrank字段对结果进行移位内连接，以便我们获得彼此相邻的连续日期。 我们通过将结果包装在子选择中来完成此操作。

由于我们需要自我加入派生结果，因此我们必须仅使用稍微调整的参数复制上述步骤：

SELECT   *
FROM     (
         SELECT     @a_rn:=@a_rn+1 ascrank,
                    date
         FROM       tbl
         CROSS JOIN (SELECT @a_rn:=0) var_init
         WHERE      date BETWEEN '1950-05-01' AND '2012-09-04'
         ORDER BY   date
         ) a
JOIN     (
         SELECT     @b_rn:=@b_rn+1 ascrank,
                    date
         FROM       tbl
         CROSS JOIN (SELECT @b_rn:=-1) var_init
         WHERE      date BETWEEN '1950-05-01' AND '2012-09-04'
         ORDER BY   date
         ) b ON a.ascrank = b.ascrank

呈现：

+----------+-------------+----------+------------+
| ascrank  | date        | ascrank  | date       | 
+----------+-------------+----------+------------+
| 1        | 1950-05-01  | 1        | 1965-08-10 | 
| 2        | 1965-08-10  | 2        | 1990-12-29 | 
| 3        | 1990-12-29  | 3        | 1990-12-30 | 
| 4        | 1990-12-30  | 4        | 2012-09-03 | 
+----------+-------------+----------+------------+

SQLFiddle演示

“略微调整的参数”只是第二@b_rn选择中的ascrank变量（ @b_rn ）从-1而不是0 。 这样， a.ascrank = b.ascrank连接条件以a.ascrank = b.ascrank加入下一个日期。 我们也可以将两个变量初始化为0 ，但是在a.ascrank = b.ascrank-1的条件下加入，这将产生相同的结果。

但等等， 5岁的ascrank发生了什么？ 由于这是订单中的最后一个日期，因此在它之后不会有任何日期，因此它不需要出现在结果的左侧，只需要将其与其前一个日期进行比较。

---

第3步：

现在我们有彼此相邻的连续日期，我们可以在两者之间取日期差异（通过DATEDIFF() ）：

SELECT   a.date date1,
         b.date date2,
         DATEDIFF(b.date, a.date) ddiff
FROM     (
         SELECT     @a_rn:=@a_rn+1 ascrank,
                    date
         FROM       tbl
         CROSS JOIN (SELECT @a_rn:=0) var_init
         WHERE      date BETWEEN '1950-05-01' AND '2012-09-04'
         ORDER BY   date
         ) a
JOIN     (
         SELECT     @b_rn:=@b_rn+1 ascrank,
                    date
         FROM       tbl
         CROSS JOIN (SELECT @b_rn:=-1) var_init
         WHERE      date BETWEEN '1950-05-01' AND '2012-09-04'
         ORDER BY   date
         ) b ON a.ascrank = b.ascrank

呈现：

+-------------+------------+--------+
| date1       | date2      | ddiff  |
+-------------+------------+--------+
| 1950-05-01  | 1965-08-10 | 5580   |
| 1965-08-10  | 1990-12-29 | 9272   |
| 1990-12-29  | 1990-12-30 | 1      |
| 1990-12-30  | 2012-09-03 | 7918   |
+-------------+------------+--------+

SQLFiddle演示

---

第4步：

现在，选择最大ddiff值很简单。 我们通过在ddiff字段上使用ORDER BY / LIMIT 1技术来完成此ddiff ：

SELECT   a.date date1,
         b.date date2,
         DATEDIFF(b.date, a.date) ddiff
FROM     (
         SELECT     @a_rn:=@a_rn+1 ascrank,
                    date
         FROM       tbl
         CROSS JOIN (SELECT @a_rn:=0) var_init
         WHERE      date BETWEEN '1950-05-01' AND '2012-09-04'
         ORDER BY   date
         ) a
JOIN     (
         SELECT     @b_rn:=@b_rn+1 ascrank,
                    date
         FROM       tbl
         CROSS JOIN (SELECT @b_rn:=-1) var_init
         WHERE      date BETWEEN '1950-05-01' AND '2012-09-04'
         ORDER BY   date
         ) b ON a.ascrank = b.ascrank
ORDER BY ddiff DESC
LIMIT    1

呈现：

+-------------+------------+--------+
| date1       | date2      | ddiff  |
+-------------+------------+--------+
| 1965-08-10  | 1990-12-29 | 9272   |
+-------------+------------+--------+

最终结果的SQLFiddle演示

我们已经达到了最终结果。

Answer 3

我正在使用njk的表方案 - 并在我的mysql数据库上检查它。

方案

CREATE TABLE tbl (
  id tinyint,
  dt date);

INSERT INTO tbl VALUES 
(1, '1950-05-01'),
(2, '1965-08-10'),
(3, '1990-12-30'),
(4, '1990-12-29'),
(5, '2012-09-03')

QUERY

SELECT a.id, b.id, ABS(DATEDIFF(a.dt, b.dt)) AS ddiff
 FROM tbl AS a
 JOIN tbl AS b ON (a.id = (b.id + 1)) OR (a.id = (SELECT id FROM tbl ORDER BY id ASC LIMIT 1) AND b.id = (SELECT id FROM tbl ORDER BY id DESC LIMIT 1))
 ORDER BY ddiff DESC
 LIMIT 1

我正在连接所有连续的行(a.id = (b.id + 1))和第一行，最后一行如下： (a.id = (SELECT id FROM tbl ORDER BY id ASC LIMIT 1) AND b.id = (SELECT id FROM tbl ORDER BY id DESC LIMIT 1))看起来很奇怪，但工作得很好。 如果您只提到了5行，那么这就是

 SELECT a.id, b.id, ABS(DATEDIFF(a.dt, b.dt)) AS ddiff
  FROM tbl AS a
  JOIN tbl AS b ON (a.id = (b.id + 1)) OR (a.id = 1 AND b.id = 5)
  ORDER BY ddiff DESC
  LIMIT 1

编辑：结果是1 = $ a和5 = $ e

Answer 4

试试这个查询 -

SELECT
  t1.dt,
  @dt_next := (SELECT dt FROM tbl WHERE dt > t1.dt ORDER BY dt LIMIT 1) dt_next,
  DATEDIFF(@dt_next, t1.dt) max_diff
FROM tbl t1
ORDER BY max_diff DESC LIMIT 1;

+------------+------------+----------+
| dt         | dt_next    | max_diff |
+------------+------------+----------+
| 1965-08-10 | 1990-12-29 |     9272 |
+------------+------------+----------+

Answer 5

举个例子：

mysql> SELECT MIN(version) AS version FROM schema_migrations UNION SELECT MAX(version) FROM schema_migrations;
+----------------+
| version        |
+----------------+
| 20120828071352 |
| 20120830100526 |
+----------------+
2 rows in set (0.00 sec)

Answer 6

如果日期在一个表上你可以做类似的事情（这不是T-SQL，它只是一个算法，要获得previous_date，你需要在同一个表上的另一个选择top 1，例如aclias X X.date <=日期）

select date, datediff(date, previous_date)

并按第二列desc排序，因此第一行将是您想要的日期

Answer 7

从创建结果集的子查询开始，该结果集具有按升序排列的日期，以及从1开始并以1递增的INT字段（dateOrder）。

SET @a := 0;
SELECT date, (@a:=@a+1) AS dateOrder FROM dateTable ORDER BY date

现在我们可以通过使用a.dateOrder = b.dateOrder -1将此结果集连接到其自身的另一个副本来获取连续日期。 在该结果集中，每行包含原始表中的一对连续日期，并且很容易计算差异并对结果集进行排序以找到最大差异。

SET @a := 0; SET @b := 0;
SELECT a.date as firstDate, b.date as secondDate, 
  datediff(b.date, a.date) AS difference FROM (
    SELECT date, (@a:=@a+1) AS dateOrder FROM dateTable ORDER BY date ) a JOIN (
    SELECT date, (@b:=@b+1) AS dateOrder FROM dateTable ORDER BY date ) b 
  ON a.dateOrder = b.dateOrder - 1
ORDER BY difference desc;

您可以在查询末尾添加“限制1”子句，以仅获取第一行，其中最大值为“差异”。 请注意，您必须使用两个不同的变量来生成两个子查询的日期顺序。

Answer 8

返回日期值的查询是非确定性的...如果查询中没有ORDER BY子句，则无法保证以任何特定顺序返回行。

在MySQL中，查询可以返回您指定的结果集。 这是一种方法：

SELECT ABS(DATEDIFF(d.mydate,@prev_date))  AS days_diff
     , DATE_ADD(@prev_date,INTERVAL 0 DAY) AS date1
     , @prev_date := d.mydate              AS date2
  FROM ( SELECT @prev_date := NULL) i
  JOIN ( SELECT d1.*
           FROM (            -- query to return rows in a specific order
                             SELECT mydate       
                               FROM mytable3 
                              WHERE 1
                              ORDER BY foo
                ) d1
          UNION ALL 
         SELECT d2.*
           FROM (            -- query to return rows in a specific order (again)
                             SELECT mydate
                               FROM mytable3 
                              WHERE 1
                              ORDER BY foo
                   LIMIT 1
                 ) d2
       ) d
 ORDER BY days_diff DESC

笔记：

仅当您要考虑日期之间的天数时才需要ABS()函数，无论第一个日期是在第二个日期之前还是之后，因为DATEDIFF函数可以返回负值。

围绕@prev_date用户变量的DATE_ADD( ,INTERVAL 0 DAY)函数就是将返回值@prev_date为数据类型DATE。 `STR_TO_DATE（，'％Y-％m-％d'）函数也可以正常工作。 （不同之处在于DATE_ADD函数将与DATE，DATETIME和TIMESTAMP列一起使用，而无需指定格式字符串以包括小时，分钟，秒。）

别名为d1和d2的内联视图包含查询，该查询返回您希望行（日期）比较的SPECIFIED顺序中的日期列表。如果要保证来自那些行的一致结果，则需要这些行的顺序是确定性的。查询。

除了添加LIMIT 1子句之外，作为d2别名的内联视图中的查询与d1的查询相同。 因为您指定要将$ e与$ a进行比较，所以我们将“查询”的第一行“添加”到结尾，以便我们可以将第一行与查询的最后一行进行比较。

结果集中的date1列不是DATE数据类型，但可以很容易地转换为DATE

如果您希望从这两行返回的其他列以及日期值可以使用相同的方法轻松处理。 d1和d2的查询只需返回其他列：

SELECT ABS(DATEDIFF(d.mydate,@prev_date)) AS days_diff
     , @prev_foo                          AS foo1
     , @prev_date                         AS date1
     , @prev_foo  := d.foo                AS foo2
     , @prev_date := d.mydate             AS date2
  FROM ( SELECT @prev_date := NULL, @prev_foo := NULL) i
  JOIN ( SELECT d1.*
           FROM (            -- query to return rows in a specific order
                             SELECT mydate, foo
                               FROM mytable3 
                              WHERE 1
                              ORDER BY foo
                ) d1
          UNION ALL 
         SELECT d2.*
           FROM (            -- query to return rows in a specific order (again)
                             SELECT mydate, foo
                               FROM mytable3 
                              WHERE 1
                              ORDER BY foo
                   LIMIT 1
                 ) d2
       ) d
 ORDER BY days_diff DESC
 LIMIT 1

---

设置测试用例：

CREATE TABLE `mytable3` (`foo` varchar(1), `mydate` date);

INSERT INTO mytable3 VALUES 
('a','1950-05-01'),
('b','1965-08-10'),
('c','1990-12-30'),
('d','1990-12-29'),
('e','2012-09-03');

Answer 9

这是PHP解决方案

$dates  = array('1970-05-01', '1975-08-10', '1990-12-30', '1990-12-29', '2012-09-03');
$sorted = array();

foreach($dates as $i => $date) {
    $date2 = isset($dates[$i+1]) ? $dates[$i+1] : $dates[0];
    $diff  = (strtotime($date2) - strtotime($date))/(60 * 60 * 24);

    $sorted[abs($diff)] = array('start' => $date, 'end' => $date2);
}

ksort($sorted);

$result = end($sorted);

Answer 10

我会使用一些简单的PHP，因为它快速而整洁：

function get_the_two_consecutive_dates_with_the_maximum_days_difference($dates) {
    foreach ($dates as $i => $date) {

        $previousDate = $dates[$i - 1];
        if (!$previousDate) continue;

        $diff = strtotime($date) - strtotime($previousDate);
        if ($maxDiff < $diff) {
            $maxDiff = $diff;
            $dateA = $previousDate;
            $dateB = $date;
        }

    }
    return array($dateA, $dateB, $maxDiff);

}

// Usage
$arr = Array ( '2012-01-01', '2012-02-01', '2012-03-01', '2012-04-12', 
               '2012-05-10', '2012-08-05', '2012-09-01', '2012-09-04' );

var_dump(get_the_two_consecutive_dates_with_the_maximum_days_difference($arr));

Answer 11

我已经找到了使用PHP的DateTime类的解决方案。 原因是strtotime（）没有办法指定传递给它的日期的格式。 在我看来，这会对返回的内容产生歧义，所以我已经停止使用它来支持DateTime。

由于您给出的示例日期的顺序不正确，我假设它们需要先排序。 以下功能实现了这一目标： -

/**
 * Sorts an array of dates in given format into date order, oldest first
 * @param array $dates
 * @param type $format Optional format of dates.
 * 
 * @return array with dates in correct order.
 */
function sortArrayOfDates(array $dates, $format = 'Y-m-d')
{
    $result = array();
    foreach($dates as $date){
        $timeStamp = DateTime::createFromFormat($format, $date)->getTimestamp();
        $result[$timeStamp] = $date;
    }
    sort($result);
    return $result;
}

现在我们可以编写一个函数来完成这项工作： -

/**
 * Returns the longest gap between sets of dates
 * 
 * @param array $dates
 * @param string Optional. Format of dates.
 * 
 * @return array Containing the two dates with the longest interval and the length of the interval in days.
 */
private function longestGapBetweenDates(array $dates, $format = 'Y-m-d')
{
    $sortedDates = sortArrayOfDates($dates);
    $maxDiff = 0;
    $result = array();
    for($i = 0; $i < count($dates) - 1; $i++){
        $firstDate = DateTime::createFromFormat($format, $sortedDates[$i]);
        $secondDate = DateTime::createFromFormat($format, $sortedDates[$i + 1]);
        $diff = $secondDate->getTimestamp() - $firstDate->getTimestamp();
        if($diff > $maxDiff){
            $maxDiff = $diff;
            $result = array($firstDate->format($format), $secondDate->format($format), $firstDate->diff($secondDate)->days);
        }
    }
    return $result;
}

使用您的示例列表： -

$a = '1950-05-01';
$b = '1965-08-10';
$c = '1990-12-30';
$d = '1990-12-29';
$e = '2012-09-03';

var_dump(longestGapBetweenDates(array($a, $b, $c, $d, $e)));

输出： -

array
  0 => string '1965-08-10' (length=10)
  1 => string '1990-12-29' (length=10)
  2 => int 9272

作为奖励，我的功能也会为您提供两个日期之间的天数。

Answer 12

    Select t1.date as 'Date1', t2.date AS 'Date2', DATEDIFF(t2, t1) as 'DateDiff'
From    YourTable t1
    Left outer join YourTable t2
        ON     t1.Id <= t2.Id 
            OR (t1.Id = (Select Max(Id) From YourTable) AND t2.Id=(SELECT Min(Id) From YourTable) )
    Left outer join YourTable t3
        ON t1.Id < t3.Id AND t3.Id < t2.Id
    WHERE t3.Id IS NULL
    ORDER BY 'DateDiff' DESC
    Limit 1,1

Answer 13

要解决此问题，请使用具有此功能的数组：

<?php 
$date_array = array('1950-05-01','1965-08-10','1990-12-30','1990-12-29','2012-09-03');

function get_max_difference_dates($dates=array()){
    if(!count($dates)){
        return false;
    }
    $max_dates_diff = 0;
    $max_dates_diff_index = 0;
    for($i=0;$i<count($dates)-1;$i++){
        $temp_diff = strtotime($dates[$i+1]) - strtotime($dates[$i]);
        if($temp_diff>$max_dates_diff){
            $max_dates_diff = $temp_diff;
            $max_dates_diff_index = $i;
        }
    }
    return $max_dates_diff_index;
}

var_dump(get_max_difference_dates($date_array));

根据我的编译，上面的答案是"1" 。

在索引之后，您可以通过返回的索引获取日期并向其添加一个日期。

$indx = get_max_difference_dates($date_array);
$date1 = $date_array[$indx];
$date2 = $date_array[$indx+1];