SQL: répétez une ligne de résultat plusieurs fois, et numérotez les lignes

Vous pouvez utiliser une table de nombres

SELECT value, count, number
FROM table
    JOIN Numbers 
        ON table.count >= Numbers.number

voici un SQLFiddle utilisant MSSQL

MySQL est vraiment L'IE du monde de la base de données, c'est un tel Hold-Out quand il s'agit de normes et de fonctionnalités.

Fonctionne sur tous les principaux SGBDR à l'exception de MySQL:

with 
-- Please add this on Postgresql:
-- RECURSIVE
tbl_populate(value, cnt, ndx) as
(
  select value, cnt, 1 from tbl

  union all

  select t.value, t.cnt, tp.ndx + 1
  from tbl t
  join tbl_populate tp 
  on tp.value = t.value  
  and tp.ndx + 1 <= t.cnt
)
select * from tbl_populate
order by cnt, ndx

SQL Server:http://www.sqlfiddle.com/#!6 / 911a9/1

Oracle:http://www.sqlfiddle.com/#!4 / 198cd/1

Postgresql:http://www.sqlfiddle.com/#!1 / 0b03d/1

vous avez demandé une solution db-agnostique et @ Justin vous en a donné une belle.

Vous m'avez également demandé pour

des astuces pour le faire fonctionner sur une base de données

Il y en a un pour PostgreSQL:generate_series() est-ce que vous avez demandé pour le sortir de la boîte:

SELECT val, ct, generate_series(1, ct) AS index
FROM   tbl;

BTW, je préfère ne pas l'utiliser value et count comme noms de colonne. C'est une mauvaise pratique à utiliser mots réservés comme identificateurs. Utiliser val et ct à la place.

Créer une table de nombres - sa définition peut varier légèrement en fonction de la plate-forme (c'est pour SQL Server):

CREATE TABLE Numbers(Number INT PRIMARY KEY);

INSERT Numbers 
SELECT TOP 1000 ROW_NUMBER() OVER (ORDER BY name)
FROM sys.all_columns;

maintenant ce temp est aussi SQL Server, mais démontre la syntaxe de jointure qui devrait être valide dans les RDBMSes que vous spécifiez (bien que je vais avouer que je ne les utilise pas donc je ne peux pas les tester):

DECLARE @foo TABLE(value VARCHAR(32), [count] INT);

INSERT @foo SELECT 'foo', 1
UNION ALL SELECT 'bar', 3
UNION ALL SELECT 'baz', 2;

SELECT f.value, f.[count], [index] = n.Number
FROM @foo AS f, Numbers AS n
WHERE n.Number <= f.[count];

Résultats (encore une fois, SQL Serveur):

value | count | index
------+-------+------
foo   |     1 |     1
bar   |     3 |     1
bar   |     3 |     2
bar   |     3 |     3
baz   |     2 |     1
baz   |     2 |     2

Pour l'appréciation seulement, SQL Server 2005 et versions ultérieures peuvent gérer cela de façon récursive:

declare @Stuff as Table ( Name VarChar(10), Number Int )
insert into @Stuff ( Name, Number ) values ( 'foo', 1 ), ( 'bar', 3 ), ( 'baz', 2 )

select * from @Stuff

; with Repeat ( Name, Number, Counter ) as (
  select Name, Number, 1
    from @Stuff
    where Number > 0
  union all
  select Name, Number, Counter + 1
    from Repeat
    where Counter < Number
  )
select *
  from Repeat
  order by Name, Counter -- Group by name.
  option ( maxrecursion 0 )

par un simple JOIN vous pouvez atteindre le but de répéter les dossiers n fois.

La requête suivante répète chaque enregistrement 20 fois.

SELECT  TableName.*
FROM    TableName
JOIN    master.dbo.spt_values on type = 'P' and number < 20

Remarque:master.dbo.spt_values on type = 'P':

Ce tableau est utilisé pour obtenir une série de nombre qui est codé dur en elle par condition de type='P'.

Vous pouvez utiliser CTE:

WITH Numbers(Num) AS
(
    SELECT 1 AS Num
    UNION ALL 
    SELECT Num + 1
    FROM   Numbers c
    WHERE  c.Num < 1000
)

SELECT VALUE,COUNT, number
FROM   TABLE
       JOIN Numbers
            ON  TABLE.count >= Numbers.Num
OPTION(MAXRECURSION 1000)

Oracle, nous pourrions utiliser une combinaison de LEVEL et CROSS JOIN.

  SELECT *
    FROM yourtable
         CROSS JOIN (    SELECT ROWNUM index_t
                           FROM DUAL
                     CONNECT BY LEVEL <= (SELECT MAX (count_t) FROM yourtable))
   WHERE index_t <= count_t
ORDER BY VALUE, index_t;

DEMO