Flere limits i sammen sql sætning?

Du kan vist nok lave en 'inner select' i SQL, så du på den måde kan lave limit. Er ikke helt sikker på hvordan det gøres, men mener at man kan gøre noget alla dette

 SELECT * 
 FROM topics
 LEFT JOIN
    (SELECT * 
     FROM posts 
     LIMIT 10)
 ON posts.post_topic = topics.topic_id
 RIGHT JOIN brugere
 ON bruegre.id = topics.topic_by
 WHERE topics.topic_cat = 'my category'
 ORDER BY topics.topic_id DESC 
 LIMIT 10;

Som sagt er jeg ikke sikker på koden, men mener at man kan gøre noget i den stil

Så burde løsningen være, at lave det som en subquery

Noget i den her retning:

 if ($stmt = $mysqli->prepare('
           SELECT 
                  topics.topic_id,
                  topics.topic_subject,
                  topics.topic_date,¨
                  topics.topic_cat,
                  topics.topic_by,
                  topics.images,
                  TmpPosts.post_content,
                  brugere.name 
            FROM 
                  topics 
       LEFT JOIN 
                  (select  * from posts ORDER by posts.ID  DESC LIMIT 10) as TmpPosts
              ON 
                  TmpPosts.post_topic = topics.topic_id 
      RIGHT JOIN 
                  brugere 
              ON 
                  brugere.id = topics.topic_by 
           WHERE 
                  topics.topic_cat = ? 
        ORDER BY 
                  topics.topic_id 
      DESC LIMIT 
                  ?, ?'))

Er ikke testet og kræver sikkert noget tilpasning.

EDIT: Tilpasset lidt, efter inspiration fra Martins forslag.

Tak for jeres svar.

Tanken er nu mere, at den enkelte første post høre med til topics overskrift, hvis man kan forklare det på den måde.

Derfor tænker jeg at man kunne lave en limit med 1, og hvor post_id høre til topic_id, som her:

if ($stmt = $mysqli->prepare('
SELECT 
                  topics.topic_id,
                  topics.topic_subject,
                  topics.topic_date,
                  topics.topic_cat,
                  topics.topic_by,
                  topics.images,
                  TmpPosts.post_content,
                  brugere.name 
            FROM 
                  topics 
       LEFT JOIN 
                  (select  * from posts WHERE posts.post_id = topics.topic_id ORDER by posts.post_id ASC LIMIT 1) as TmpPosts
              ON 
                  TmpPosts.post_topic = topics.topic_id 
      RIGHT JOIN 
                  brugere 
              ON 
                  brugere.id = topics.topic_by 
           WHERE 
                  topics.topic_cat = ? 
        ORDER BY 
                  topics.topic_id 
      DESC LIMIT 
                  ?, ?'))

Men her kommer fejlen:
Unknown column 'topics.topic_id' in 'where clause'

Det kan man måske ikke??

Den where du har inde i subqueryen kender ikke tabellen topics. Men jeg tror du kan gøre det nemmere, i det tilfælde du kun vil have den første.

Hvis jeg har gennemskuet din tabelstruktur korrekt, vil jeg gætte på, at du kan holde dig til dit oprindelige setup og tilføje DISTINCT til dit topic id.

SELECT DISTINCT topics.topic_id, ....

DISTINCT virker desværre ikke i denne sammenhæng, da hver den samme overskrift med samme url også bliver skrevet ud

Hvis du viser et diagram for din database. ER/EER diagram. Så bliver det meget nemmere at hjælpe dig.

Hmm.. Jeg ved ikke lige hvad et ER/EER diagram er, men jeg kan vise strukturen i sql:

`topics` (
`topic_id` int(8) NOT NULL auto_increment,
`topic_subject` varchar(255) collate utf8_danish_ci NOT NULL,
`topic_date` datetime NOT NULL,
`topic_cat` int(8) NOT NULL,
`topic_by` int(8) NOT NULL,
`topic_page_cat` int(11) NOT NULL,
`images` varchar(10000) collate utf8_danish_ci NOT NULL,
PRIMARY KEY (`topic_id`),
KEY `topic_cat` (`topic_cat`),
KEY `topic_by` (`topic_by`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_danish_ci AUTO_INCREMENT=88 ;


`posts` (
`post_id` int(8) NOT NULL auto_increment,
`post_content` text collate utf8_danish_ci NOT NULL,
`post_date` datetime NOT NULL,
`post_topic` int(8) NOT NULL,
`post_by` int(8) NOT NULL,
`posts_cat` int(11) NOT NULL,
`posts_cat_page` int(11) NOT NULL,
PRIMARY KEY (`post_id`),
KEY `post_topic` (`post_topic`),
KEY `post_by` (`post_by`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_danish_ci AUTO_INCREMENT=121 ;¨

Jeg er lidt i tvivl om din left og right join. For mit eget vedkommen, bliver jeg nød til at vide lidt mere om hvad det er du prøver at hive ud af databasen for at forstå din sql-query.

Da en left eller right join ikke nødvendigvis giver et specifikt udtræk. Men er mere bred spekteret. Kan også se at du har en brugere tabel, kan du også poste den da det muligvis kunne gøre det nemmere at gennemskue hvad du forsøger.

Læs evt om hvad et ER diagram er her.
http://en.wikipedia.org/wiki/Entity-relationship_model

Det er guld værd når man skal have hjælp til f.eks sådan noget her.

Når man designer databaser, så er det god skik at gennemgå (det er kedeligt men hjælper en del) 4 faser.

ER Diagram.
EER Diagram.
RD Skema.
Normalisering (helst til trejdle normaliserings form).

Dette er med til at fjerne eventuelle fejl som har lusket sig med, i ide fasen. Er med til at give et bedre flow igennem databasen og er med til at fjerne overflødig data.

Okay. Det skal jeg vist lige sætte mig lidt mere end i, før jeg ville prøve at lave et, så det ikke er forkert.

Jeg kan lige forklare, hvad det egentligt er jeg vil, så er det måske en smule lettere at hjælpe.

Jeg har disse 4 tabeller:

`posts` (
  `post_id` int(8) NOT NULL auto_increment,
  `post_content` text collate utf8_danish_ci NOT NULL,
  `post_date` datetime NOT NULL,
  `post_topic` int(8) NOT NULL,
  `post_by` int(8) NOT NULL,
  `posts_cat` int(11) NOT NULL,
  `posts_cat_page` int(11) NOT NULL,
  PRIMARY KEY  (`post_id`),
  KEY `post_topic` (`post_topic`),
  KEY `post_by` (`post_by`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_danish_ci AUTO_INCREMENT=121 ;¨



`topics` (
  `topic_id` int(8) NOT NULL auto_increment,
  `topic_subject` varchar(255) collate utf8_danish_ci NOT NULL,
  `topic_date` datetime NOT NULL,
  `topic_cat` int(8) NOT NULL,
  `topic_by` int(8) NOT NULL,
  `topic_page_cat` int(11) NOT NULL,
  `images` varchar(10000) collate utf8_danish_ci NOT NULL,
  PRIMARY KEY  (`topic_id`),
  KEY `topic_cat` (`topic_cat`),
  KEY `topic_by` (`topic_by`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_danish_ci AUTO_INCREMENT=88 ;


CREATE TABLE IF NOT EXISTS `brugere` (
  `id` int(11) NOT NULL auto_increment,
  `name` varchar(40) collate utf8_danish_ci NOT NULL,
  `email` varchar(80) collate utf8_danish_ci NOT NULL,
  `password` varchar(100) collate utf8_danish_ci NOT NULL,
  `name_level` int(3) NOT NULL,
  `blog_over` text collate utf8_danish_ci NOT NULL,
  `blog_left` text collate utf8_danish_ci NOT NULL,
  `blog_right` text collate utf8_danish_ci NOT NULL,
  PRIMARY KEY  (`id`),
  UNIQUE KEY `name_unique` (`name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_danish_ci AUTO_INCREMENT=51 ;

`categories` (
  `cat_id` int(8) NOT NULL auto_increment,
  `cat_name` varchar(255) collate utf8_danish_ci NOT NULL,
  `cat_description` varchar(255) collate utf8_danish_ci NOT NULL,
  `page_cat` int(3) NOT NULL,
  `images` varchar(1000) collate utf8_danish_ci NOT NULL,
  PRIMARY KEY  (`cat_id`),
  UNIQUE KEY `cat_name_unique` (`cat_name`),
  KEY `page_cat` (`page_cat`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_danish_ci AUTO_INCREMENT=15 ;

Det er egentligt meget simpelt. Jeg har en kategori, hvor jeg har har liste med alle indlæg. På denne side skal der kun vises 15 af dem - jeg har selv lavet et pagination-system til det, så det er ikke noget problem.

Det, der så skal udhentes er:
- topics.topic_id - Så url'en er korrekt.
- topics.topic_subject - Overskriften
- topics.topic_date - Datoen
- posts.post_content - men det skal være den første post, som hænger tråd med topics, så man kan læse det første indlæg uden at skulle ind i emnet.
- brugere.name - navnet på ham, som har oprettet emnet.


Med Steffans kode(længere oppe^) virkede det næsten, men det var posterne fra sidste topic til alle emner, som blev postet i browseren.

Jeg håber det hjalp lidt.

Det må være noget lign. dette måske:

 SELECT topics.*, p.post_content
 FROM topics
 JOIN ( 
     SELECT post_content, topic_id
     FROM posts
     GROUP BY topic_id
     ORDER BY post_id DESC
 ) AS p ON p.topic_id = topics.topic_id
 WHERE topic_cat = ?
 LIMIT ?, ?