SELECT date AS count FROM table WHERE column1 = 'YES' AND data BETWEEN 1950-01-01 AND 2012-09-04
13 Réponses :
juste exemple:
Mais ils ne seront pas " deux dates consécutives i>".
Si les dates sont sur une table, vous pouvez faire quelque chose comme (ce n'est pas le T-SQL, son juste un algorithme, pour obtenir le précédent_date dont vous auriez besoin de nouveau Sélectionnez le top 1 sur la même table avec un aclias x Par exemple, où x.Date <= date) et commande par la deuxième colonne descendre, la première ligne serait la date à laquelle vous voulez P> P>
En supposant que chaque date a un identifiant schéma fort > p> séquentiel code>. Voyez-le en action . P> The maximum days difference is between 1965-08-10 and 1990-12-30, with a difference of 9273.0416666667 days
Mais la bonne réponse serait la date $ A et la date $ E - dans la solution PHP, vous devez ajouter la première valeur à la fin de la matrice et faire un ABS sur le diff!
@Delpedro non, l'OP demande des dates consécutives i>.
Oui, mais consécutif de la manière dont ils sont écrits et non consécutifs dans l'ordre chronologique - Quote: "Explication:" Explication: le script doit calculer le nombre de jours entre $ A et B, $ B et $ C, $ C et $ C, $ c et d $ D, $ D et $ E, $ E et $ A, puis produirez les deux dates avec la différence de jours maximum. "
@Delpedro comme vous le lisez, ma solution PHP fonctionnera, moins le dernier $ E code> et $ a code> différence.
Les jointures sont douces, je dois m'entraîner. Bonne réponse
+1 CODE> Belle réponse. Oh au fait, merci pour le Bon exemple
@JW 웃 Êtes-vous en désaccord avec la discussion? Je ne vois aucun commentaire de votre part.
Démarrez avec une sous-requête qui crée un ensemble de résultats comportant les dates de l'ordre croissant et un champ Int (DatedAnd) qui commence à 1 et incréments de 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;
J'utilise le schéma de table de NJK - et vérifié sur mon MySQL DB.
schéma strong> p> strong> p> Je rejoint toutes les lignes consécutives édition: le résultat est 1 = $ a et 5 = $ e p> p> p> p> P> (a.id = (b.id + 1)) code> et la première ligne avec le dernier comme celui-ci: (A.Id = (Sélectionnez ID de la commande TBL par ID ASC Limite 1) et b.Id = (sélectionnez ID de la commande TBL par ID DE LA LIMITE 1) CODE> Qui a l'air étrange mais fonctionne très bien. Si vous n'avez que les 5 lignes que vous avez mentionnées, ce serait p>
Et si la colonne ID n'est pas inutile avec la différence de 1?
@Angelin: Oui, cette requête dépend d'une gamme contiguë de valeurs d'identification, ce qui est quelque chose que nous ne pouvons pas garantir. L'inclusion d'une clause où, comme dans la requête OP ( où column1 = 'oui' code>) indique que certaines valeurs d'identification seront omises). Bonne prise.
Vous pouvez utiliser cette solution mono-instruction:
+-------------+------------+--------+ | date1 | date2 | ddiff | +-------------+------------+--------+ | 1965-08-10 | 1990-12-29 | 9272 | +-------------+------------+--------+
Votre requête ne compare pas $ e avec $ A comme dans la question mentionnée.
@Delpedro, je crois que c'est une erreur sur la partie de la puissance. Avec le fait que les dates sont commandées dans l'ordre croissant (comme indiqué par l'OP dans les commentaires de la question), si les dernières et dernières dates sont autorisées à être comparées, la différence maximale sera toujours i > b> Soyez la différence entre la première et la dernière date ... qui est aussi simple que SELECT MIN (date), max (date), datrodiff (max (date), min (date)) de TBL Où date entre '1950-05-01' et '2012-09-04' code>.
ils ne sont pas commandés, $ C> $ D
@Delpedro, note que l'OP récupère les dates à l'aide de SQL sans la clause code> par code>, qui peut indiquer que les dates de l'OP sont extraites sans ordre défini. Puisque nous le faisons purement en SQL, la commande par code> Les clauses de ma solution prennent soin de cela.
Voici la solution 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);
Essayez cette requête -
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 | +------------+------------+----------+
Pour ce faire, utilisez une matrice avec cette fonction: La réponse à ce qui précède selon ma compilation est Après l'index de la CA d'obtenir les dates de l'index retourné et en en ajoutant un à celui-ci. P> "1" code>. p> $indx = get_max_difference_dates($date_array);
$date1 = $date_array[$indx];
$date2 = $date_array[$indx+1];
J'utiliserais un PHP simple, car il est rapide et propre:
Votre requête qui renvoie les valeurs de date est non déterministe ... absent un Dans MySQL, une requête peut renvoyer le jeu de résultats spécifié. Voici une approche: p> Remarques: b> p> Les vues en ligne aliasés comme La requête dans la vue inline aliasée comme La colonne si vous voulez que d'autres colonnes sont renvoyées des deux rangées, ainsi que le La valeur de la date, qui peut être facilement traitée à l'aide de la même approche. Les requêtes dans au boîtier de test de configuration : p> Ordre par code> Clause de votre requête, rien ne garantit que les lignes seront renvoyées dans un ordre particulier. ABS () code> fonction est nécessaire Seulement si vous souhaitez envisager le nombre de jours entre les dates, que la première date soit avant ou après la deuxième date, puisque la fonction datrodiff code> peut renvoyer une valeur négative. P> < p> Le date_add (, intervalle 0 jour) code> fonction autour de la variable @prev_date code> est juste là pour lancer la valeur de retour à la date de type DataType. Une fonction `str_to_Date (,% y-% m-% d ') fonctionnerait également. (La différence est que la fonction Date_Add fonctionnera avec la date, la dateTime et les colonnes horodatampes sans avoir à spécifier une chaîne de format pour inclure des heures, des minutes, des secondes.) P> d1 < / code> et d2 code> contient la requête qui renvoie la liste des dates dans l'ordre spécifié que vous souhaitez que les lignes (dates) comparées. Vous avez besoin de l'ordre de ces lignes pour être déterministe si vous souhaitez garantir un résultat cohérent de la requête. P> d2 code> est identique à la requête dans d1 code>, sauf pour l'ajout de la clause limite 1. Parce que vous avez précisé que vous vouliez comparer $ e à $ a $ A, nous "clip sur" cette première ligne de la requête à la fin afin que nous puissions comparer cette première ligne avec la dernière ligne de la requête. P> date1 code> dans l'ensemble de résultats n'est pas un type de données de date, mais il peut facilement être jeté à une date p> d1 code> et d2 code> ont juste besoin de renvoyer les colonnes supplémentaires: p>
Je suis allé pour une solution en utilisant PHP's DateTime classe. La raison en est que Strtotime () n'a pas le moyen de spécifier le format des dates qui lui sont transmises. Dans mon esprit, cela crée une ambiguïté sur ce qui sera retourné, alors j'ai cessé de l'utiliser en faveur de DateTime.
Comme l'exemple des dates que vous avez données ne sont pas dans le bon ordre, j'ai supposé qu'ils doivent être triés d'abord . La fonction suivante réalise ceci: - p> Nous pouvons maintenant écrire une fonction pour faire le travail: - p> avec Votre exemple de liste: - p> sortie: - p> comme bonus ma fonction vous donne le nombre de jours entre les deux dates aussi. P> p>
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
S'il vous plaît montrer la requête qui récupère ces dates.
Cette requête retournera un nombre unique (le nombre d'enregistrements dans
table code> qui répondent aux critères de filtrage), pas une liste de dates.Désolé, j'ai commis une erreur: D J'ai mis à jour la question
Semblable à cela? Stackoverflow.com/ Questions / 5178373 / ...
@Wecontest Comment est la commande i> b> des dates "consécutives" déterminées?
@Zanebien Les enregistrements sont commandés par date décroissant.
La question n'a pas de sens! Ces enregistrements ne peuvent pas être commandés par date décroissant, sinon la différence maximale est toujours entre le premier et le dernier élément. S'il vous plaît, essayez de vous expliquer le problème et de vérifier les exemples de données. Cela aiderait si vous fournissez un exemple de données et un résultat attendu. Cela fonctionne comme un cas de test pour toute solution proposée également.
Je suis d'accord avec Mikkorantalainenen. Les $ E et A $ A ne sont pas tous satisfaisants. Si vous en avez besoin, il n'ya pas de point de la totalité du travail ardue.Jo pour une différence maximale entre le premier et le dernier élément