MySQL Sélectionner des 7 derniers jours

J'ai lu quelques Posts ici et semble comme rien de spécial, mais je ne peux pas encore de sélectionner les entrées des derniers jours.

SELECT 
    p1.kArtikel, 
    p1.cName, 
    p1.cKurzBeschreibung, 
    p1.dLetzteAktualisierung, 
    p1.dErstellt, 
    p1.cSeo,
    p2.kartikelpict,
    p2.nNr,
    p2.cPfad

FROM 
    tartikel AS p1 WHERE DATE(dErstellt) > (NOW() - INTERVAL 7 DAY)

INNER JOIN 
    tartikelpict AS p2 
    ON (p1.kArtikel = p2.kArtikel) WHERE (p2.nNr = 1)

ORDER BY 
    p1.kArtikel DESC

LIMIT
    100;', $connection);

Si j'ajoute entre aujourd'hui et au cours des 7 derniers jours, mon Code n'affiche rien.

C'est le Post j'ai lu et utilisé dans mon Code.
Vous n'avez pas expliquer quelle est l'erreur que vous obtenez ou comment ce qui ne fonctionne pas. À moins que cette question est amélioré, il sera fermé une double question.
Je n'obtiens aucune sortie (pas d'Erreur, pas de résultat) Si j'ajoute une ligne avec DATE(dErstellt) > (NOW() - INTERVAL 7 DAY)

OriginalL'auteur karadayi | 2014-06-17

53

La WHERE clause est mal placée, elle doit suivre le tableau des références et des opérations de JOINTURE.

Quelque chose comme ceci:
```
 FROM tartikel p1 
 JOIN tartikelpict p2 
   ON p1.kArtikel = p2.kArtikel 
  AND p2.nNr = 1
WHERE p1.dErstellt >= DATE(NOW()) - INTERVAL 7 DAY
ORDER BY p1.kArtikel DESC
```
MODIFIER (trois ans plus tard)

Ci-dessus essentiellement répond à la question "j'ai essayé d'ajouter une clause where à ma requête et maintenant, la requête retourne une erreur, comment puis-je résoudre ce problème?"

À une question sur l'écriture d'une condition qui vérifie une plage de dates de "7 derniers jours"...

Cela dépend vraiment de l'interprétation de la spécification, ce que le type de données de la colonne dans la table (DATE ou DATETIME) et quelles sont les données disponibles... ce doit être retourné.

Pour résumer: l'approche générale consiste à identifier une "démarrer" pour la date/datetime gamme, et la "fin" de cette gamme, et le renvoi de ceux dans une requête. Prenons quelque chose de plus facile... toutes les lignes pour "hier".

Si notre colonne est de type DATE. Avant de nous intégrer une expression dans une requête, on peut le tester dans un SELECT simple
```
 SELECT DATE(NOW()) + INTERVAL -1 DAY 
```
et de vérifier le résultat retourné est ce que nous attendons. Ensuite, nous pouvons utiliser la même expression dans une clause where, en la comparant à une colonne de DATE comme ceci:
```
 WHERE datecol = DATE(NOW()) + INTERVAL -1 DAY
```
Pour un DATETIME ou TIMESTAMP colonne, on peut utiliser >= et < l'inégalité des comparaisons pour spécifier une plage
```
 WHERE datetimecol >= DATE(NOW()) + INTERVAL -1 DAY
   AND datetimecol <  DATE(NOW()) + INTERVAL  0 DAY
```
Pour "les 7 derniers jours", nous devons savoir si que cela signifie à partir de ce point, maintenant, de retour de 7 jours ... par exemple, le dernier 7*24 heures , y compris la composante temporelle dans la comparaison, ...
```
 WHERE datetimecol >= NOW() + INTERVAL -7 DAY
   AND datetimecol <  NOW() + INTERVAL  0 DAY
```
les sept derniers jours, non compris aujourd'hui
```
 WHERE datetimecol >= DATE(NOW()) + INTERVAL -7 DAY
   AND datetimecol <  DATE(NOW()) + INTERVAL  0 DAY
```
ou six dernières journées complètes et plus loin aujourd'hui ...
```
 WHERE datetimecol >= DATE(NOW()) + INTERVAL -6 DAY
   AND datetimecol <  NOW()       + INTERVAL  0 DAY
```
Je recommande de tester les expressions sur le côté droit, dans une instruction SELECT, on peut utiliser une variable définie par l'utilisateur à la place de NOW() pour le test, qui n'est pas attaché à ce que NOW() renvoie donc nous pouvons tester des frontières, à l'échelle de la semaine/du mois/de l'année limites, et ainsi de suite.
```
SET @clock = '2017-11-17 11:47:47' ;

SELECT DATE(@clock)
     , DATE(@clock) + INTERVAL -7 DAY 
     , @clock + INTERVAL -6 DAY 
```
Une fois que nous avons des expressions qui renvoient des valeurs de travail pour "début" et "fin" pour notre cas d'utilisation particulier, ce que nous entendons par "7 derniers jours", nous pouvons utiliser ces expressions dans la gamme des comparaisons dans la clause where.

(Certains développeurs préfèrent utiliser le DATE_ADD et DATE_SUB fonctions à la place de la + INTERVAL val DAY/HOUR/MINUTE/MONTH/YEAR syntaxe.

Et MySQL fournit quelques fonctions pratiques pour travailler avec DATE, DATETIME et TIMESTAMP types de données... DATE, LAST_DAY,

Certains développeurs préfèrent calculer le début et la fin dans un autre code, et de l'approvisionnement des littéraux de chaîne dans la requête SQL, telles que la requête soumise à la base de données est
```
  WHERE datetimecol >= '2017-11-10 00:00'
    AND datetimecol <  '2017-11-17 00:00'
```
Et que l'approche fonctionne aussi. (Ma préférence serait de convertir explicitement ces littéraux de chaîne en DATETIME, soit avec CONVERTIR ou juste le + INTERVALLE de truc...
```
  WHERE datetimecol >= '2017-11-10 00:00' + INTERVAL 0 SECOND
    AND datetimecol <  '2017-11-17 00:00' + INTERVAL 0 SECOND
```
Ci-dessus suppose que nous sommes stockage des "dates" en DATE, DATETIME et/ou de types de données TIMESTAMP, et de ne pas stocker des chaînes de caractères dans une variété de formats, par exemple 'dd/mm/yyyy', m/d/yyyy, les dates juliennes, ou de façon sporadique non-canonique de formats, ou comme un certain nombre de secondes depuis le début de l'époque, cette réponse aurait besoin d'être beaucoup plus long.

Je n'ai jamais su au sujet de l'INTERVALLE de commande. Assez cool outil pour ajouter à la boîte à outils. Merci !
une demande pour la plage de dates de "7 derniers jours" peut aussi être satisfait par dtcol >= DATE(NOW()) + INTERVAL -7 DAY AND dtcol < DATE(NOW)). Nous n'avons pas donné d'indication à la question de savoir si la colonne référencée est la DATE ou DATETIME, ou quel fuseau horaire qui est dans. (Il pourrait être stockée dans l'UTC, et nous voulons une conversion à un fuseau horaire local. Bas de ligne... si vous regardez la question, il semble que le problème de l'OP est d'essayer de les corriger, c'est l'ajout de la clause where de la requête. (Qui d'ailleurs pourquoi l'exemple SQL est marqué "quelque Chose comme ça" au lieu de "Solution".)
élargi réponse à inclure une discussion des interprétations possibles de "7 derniers jours", et la discussion générale de l'approche à prendre par écrit des conditions pour une variété de date/datetime plages.
ce sujet de la "cours des sept derniers jours, y compris aujourd'hui" l'affaire??
pour ce cas, l'approche est la même. Développer des expressions qui renvoient à la démarrer et fin pour la date/datetime gamme. Ma première coupe à interpréter "des sept derniers jours complets plus aujourd'hui" est de début et de fin renvoyées par ces expressions, d'abord testé dans une instruction SELECT: SELECT DATE(NOW()) + INTERVAL - 7 DAY AS start_, DATE(NOW() + INTERVAL 1 DAY AS end_. Une fois que j'ai des expressions qui répondent à la spécification, j'aimerais utiliser ces expressions dans une clause where dans la forme t.dt >= start_expr AND t.dt < end_expr.

OriginalL'auteur spencer7593

Puisque vous êtes en utilisant une JOINTURE INTERNE, vous pouvez simplement mettre les conditions de la clause where, comme ceci:

SELECT 
    p1.kArtikel, 
    p1.cName, 
    p1.cKurzBeschreibung, 
    p1.dLetzteAktualisierung, 
    p1.dErstellt, 
    p1.cSeo,
    p2.kartikelpict,
    p2.nNr,
    p2.cPfad  
FROM 
    tartikel AS p1 INNER JOIN tartikelpict AS p2 
    ON p1.kArtikel = p2.kArtikel
WHERE
  DATE(dErstellt) > (NOW() - INTERVAL 7 DAY)
  AND p2.nNr = 1
ORDER BY 
  p1.kArtikel DESC
LIMIT
    100;

OriginalL'auteur fthiella

Vous devez vous connecter pour publier un commentaire.