Come usate la clausola "WITH" in MySQL?


112

Sto convertendo tutte le mie query di SQL Server in MySQL e le mie query WITHin esse contenute non riescono. Ecco un esempio:

WITH t1 AS
(
     SELECT article.*, userinfo.*, category.*
     FROM question
     INNER JOIN userinfo ON userinfo.user_userid = article.article_ownerid
     INNER JOIN category ON article.article_categoryid = category.catid
     WHERE article.article_isdeleted = 0
)
SELECT t1.*
FROM t1
ORDER BY t1.article_date DESC
LIMIT 1, 3

1
Hai smorzato quella domanda, giusto? Non c'è alcun motivo per utilizzare un CTE lì.
JeremyWeir

2
@NeilMcGuigan Oh mio Dio! Questo è uno dei commenti più divertenti che ho visto su questo sito (anche se in realtà non è così divertente, ma la sfacciataggine!;)) +1.
Juan Carlos Coto

Penso che questa sia una domanda correlata o duplicata Generazione di una serie di date
Adam Porad

2
@NeilMcGuigan La maggior parte dei servizi di hosting offre solo MySQL o MariaDB, che senza contare il mal di testa del processo di migrazione da MySQL a PostgreSQL, è più facile aggiornare a MySQL 8 o MariaDB 10.2.1
Ivanzinho

Risposte:


135

MySQL precedente alla versione 8.0 non supporta la clausola WITH (CTE nel linguaggio SQL Server; Subquery Factoring in Oracle), quindi ti resta che usare:

  • Tabelle TEMPORANEE
  • Tabelle DERIVATE
  • visualizzazioni inline (effettivamente ciò che rappresenta la clausola WITH - sono intercambiabili)

La richiesta per la funzionalità risale al 2006.

Come accennato, hai fornito un cattivo esempio: non è necessario eseguire una sottoselezione se non stai alterando in alcun modo l'output delle colonne:

  SELECT * 
    FROM ARTICLE t
    JOIN USERINFO ui ON ui.user_userid = t.article_ownerid
    JOIN CATEGORY c ON c.catid =  t.article_categoryid
   WHERE t.published_ind = 0
ORDER BY t.article_date DESC 
   LIMIT 1, 3

Ecco un esempio migliore:

SELECT t.name,
       t.num
  FROM TABLE t
  JOIN (SELECT c.id
               COUNT(*) 'num'
          FROM TABLE c
         WHERE c.column = 'a'
      GROUP BY c.id) ta ON ta.id = t.id

24
Questo dovrebbe menzionare che CTE in genere supporta la ricorsione, cosa che non puoi fare con una sottoquery
Hogan

8
Questa domanda riguarda l '"imitazione" del supporto CTE in MySQL: una cosa che non si può fare è la funzionalità ricorsiva delle CTE in tutte le piattaforme che lo supportano, questo era il punto.
Hogan

8
Sì. E ancora non hanno attuato nel loro ramo di release. Apparentemente hanno "mostrato" questa "funzionalità" al PHPCONFERENCE2010 di Londra. Questo commento su quel bug report è significativo. [7 ottobre 2008 19:57] Stuart Friedberg: "Valeriy, voi ragazzi dovete avere un incredibile arretrato. Trentatre mesi tra la presentazione di una richiesta e l'ottenimento di un primo riconoscimento sono un periodo di tempo sbalorditivo. Grazie per aver considerato la richiesta. "
Shiva

5
Sembra che questo sia stato aggiunto a mysql 8 (il link è ancora bugs.mysql.com/bug.php?id=16244 )
Brian

9
Questa risposta deve uccidere - nel 2018, MySQL ora supporta la clausola WITH
jcansell

26

Mysql Developers Team ha annunciato che la versione 8.0 avrà espressioni di tabella comuni in MySQL (CTE) . Quindi sarà possibile scrivere query come questa:


WITH RECURSIVE my_cte AS
(
  SELECT 1 AS n
  UNION ALL
  SELECT 1+n FROM my_cte WHERE n<10
)
SELECT * FROM my_cte;
+------+
| n    |
+------+
|    1 |
|    2 |
|    3 |
|    4 |
|    5 |
|    6 |
|    7 |
|    8 |
|    9 |
|   10 |
+------+
10 rows in set (0,00 sec)


bugs.mysql.com/bug.php?id=16244 (Questo è pianificato per 8.0) + (I CTE ricorsivi sono in MySQL 8.0.1 e più recenti)
gavenkoa

19

In Sql l'istruzione with specifica un set di risultati denominato temporaneo, noto come espressione di tabella comune (CTE). Può essere utilizzato per query ricorsive, ma in questo caso viene specificato come sottoinsieme. Se mysql consente i subselectes proverei

select t1.* 
from  (
            SELECT  article.*, 
                    userinfo.*, 
                    category.* 
            FROM    question INNER JOIN 
                    userinfo ON userinfo.user_userid=article.article_ownerid INNER JOIN category ON article.article_categoryid=category.catid
            WHERE   article.article_isdeleted = 0
     ) t1
ORDER BY t1.article_date DESC Limit 1, 3

Ecco un'introduzione per principianti a CTE thecodeframework.com/introduction-to-mysql-cte
Gagan

6

Ho seguito il collegamento condiviso da lisachenko e ho trovato un altro collegamento a questo blog: http://guilhembichot.blogspot.co.uk/2013/11/with-recursive-and-mysql.html

Il post illustra i modi per emulare i 2 usi di SQL WITH. Spiegazione davvero buona su come funzionano per eseguire una query simile a SQL WITH.

1) Usa WITH in modo da non dover eseguire più volte la stessa sottoquery

CREATE VIEW D AS (SELECT YEAR, SUM(SALES) AS S FROM T1 GROUP BY YEAR);
SELECT D1.YEAR, (CASE WHEN D1.S>D2.S THEN 'INCREASE' ELSE 'DECREASE' END) AS TREND
FROM
 D AS D1,
 D AS D2
WHERE D1.YEAR = D2.YEAR-1;
DROP VIEW D;

2) Le query ricorsive possono essere eseguite con una stored procedure che rende la chiamata simile a una ricorsiva con query.

CALL WITH_EMULATOR(
"EMPLOYEES_EXTENDED",
"
  SELECT ID, NAME, MANAGER_ID, 0 AS REPORTS
  FROM EMPLOYEES
  WHERE ID NOT IN (SELECT MANAGER_ID FROM EMPLOYEES WHERE MANAGER_ID IS NOT NULL)
",
"
  SELECT M.ID, M.NAME, M.MANAGER_ID, SUM(1+E.REPORTS) AS REPORTS
  FROM EMPLOYEES M JOIN EMPLOYEES_EXTENDED E ON M.ID=E.MANAGER_ID
  GROUP BY M.ID, M.NAME, M.MANAGER_ID
",
"SELECT * FROM EMPLOYEES_EXTENDED",
0,
""
);

E questo è il codice o la procedura memorizzata

# Usage: the standard syntax:
#   WITH RECURSIVE recursive_table AS
#    (initial_SELECT
#     UNION ALL
#     recursive_SELECT)
#   final_SELECT;
# should be translated by you to 
# CALL WITH_EMULATOR(recursive_table, initial_SELECT, recursive_SELECT,
#                    final_SELECT, 0, "").

# ALGORITHM:
# 1) we have an initial table T0 (actual name is an argument
# "recursive_table"), we fill it with result of initial_SELECT.
# 2) We have a union table U, initially empty.
# 3) Loop:
#   add rows of T0 to U,
#   run recursive_SELECT based on T0 and put result into table T1,
#   if T1 is empty
#      then leave loop,
#      else swap T0 and T1 (renaming) and empty T1
# 4) Drop T0, T1
# 5) Rename U to T0
# 6) run final select, send relult to client

# This is for *one* recursive table.
# It would be possible to write a SP creating multiple recursive tables.

delimiter |

CREATE PROCEDURE WITH_EMULATOR(
recursive_table varchar(100), # name of recursive table
initial_SELECT varchar(65530), # seed a.k.a. anchor
recursive_SELECT varchar(65530), # recursive member
final_SELECT varchar(65530), # final SELECT on UNION result
max_recursion int unsigned, # safety against infinite loop, use 0 for default
create_table_options varchar(65530) # you can add CREATE-TABLE-time options
# to your recursive_table, to speed up initial/recursive/final SELECTs; example:
# "(KEY(some_column)) ENGINE=MEMORY"
)

BEGIN
  declare new_rows int unsigned;
  declare show_progress int default 0; # set to 1 to trace/debug execution
  declare recursive_table_next varchar(120);
  declare recursive_table_union varchar(120);
  declare recursive_table_tmp varchar(120);
  set recursive_table_next  = concat(recursive_table, "_next");
  set recursive_table_union = concat(recursive_table, "_union");
  set recursive_table_tmp   = concat(recursive_table, "_tmp"); 
  # Cleanup any previous failed runs
  SET @str =
    CONCAT("DROP TEMPORARY TABLE IF EXISTS ", recursive_table, ",",
    recursive_table_next, ",", recursive_table_union,
    ",", recursive_table_tmp);
  PREPARE stmt FROM @str;
  EXECUTE stmt; 
 # If you need to reference recursive_table more than
  # once in recursive_SELECT, remove the TEMPORARY word.
  SET @str = # create and fill T0
    CONCAT("CREATE TEMPORARY TABLE ", recursive_table, " ",
    create_table_options, " AS ", initial_SELECT);
  PREPARE stmt FROM @str;
  EXECUTE stmt;
  SET @str = # create U
    CONCAT("CREATE TEMPORARY TABLE ", recursive_table_union, " LIKE ", recursive_table);
  PREPARE stmt FROM @str;
  EXECUTE stmt;
  SET @str = # create T1
    CONCAT("CREATE TEMPORARY TABLE ", recursive_table_next, " LIKE ", recursive_table);
  PREPARE stmt FROM @str;
  EXECUTE stmt;
  if max_recursion = 0 then
    set max_recursion = 100; # a default to protect the innocent
  end if;
  recursion: repeat
    # add T0 to U (this is always UNION ALL)
    SET @str =
      CONCAT("INSERT INTO ", recursive_table_union, " SELECT * FROM ", recursive_table);
    PREPARE stmt FROM @str;
    EXECUTE stmt;
    # we are done if max depth reached
    set max_recursion = max_recursion - 1;
    if not max_recursion then
      if show_progress then
        select concat("max recursion exceeded");
      end if;
      leave recursion;
    end if;
    # fill T1 by applying the recursive SELECT on T0
    SET @str =
      CONCAT("INSERT INTO ", recursive_table_next, " ", recursive_SELECT);
    PREPARE stmt FROM @str;
    EXECUTE stmt;
    # we are done if no rows in T1
    select row_count() into new_rows;
    if show_progress then
      select concat(new_rows, " new rows found");
    end if;
    if not new_rows then
      leave recursion;
    end if;
    # Prepare next iteration:
    # T1 becomes T0, to be the source of next run of recursive_SELECT,
    # T0 is recycled to be T1.
    SET @str =
      CONCAT("ALTER TABLE ", recursive_table, " RENAME ", recursive_table_tmp);
    PREPARE stmt FROM @str;
    EXECUTE stmt;
    # we use ALTER TABLE RENAME because RENAME TABLE does not support temp tables
    SET @str =
      CONCAT("ALTER TABLE ", recursive_table_next, " RENAME ", recursive_table);
    PREPARE stmt FROM @str;
    EXECUTE stmt;
    SET @str =
      CONCAT("ALTER TABLE ", recursive_table_tmp, " RENAME ", recursive_table_next);
    PREPARE stmt FROM @str;
    EXECUTE stmt;
    # empty T1
    SET @str =
      CONCAT("TRUNCATE TABLE ", recursive_table_next);
    PREPARE stmt FROM @str;
    EXECUTE stmt;
  until 0 end repeat;
  # eliminate T0 and T1
  SET @str =
    CONCAT("DROP TEMPORARY TABLE ", recursive_table_next, ", ", recursive_table);
  PREPARE stmt FROM @str;
  EXECUTE stmt;
  # Final (output) SELECT uses recursive_table name
  SET @str =
    CONCAT("ALTER TABLE ", recursive_table_union, " RENAME ", recursive_table);
  PREPARE stmt FROM @str;
  EXECUTE stmt;
  # Run final SELECT on UNION
  SET @str = final_SELECT;
  PREPARE stmt FROM @str;
  EXECUTE stmt;
  # No temporary tables may survive:
  SET @str =
    CONCAT("DROP TEMPORARY TABLE ", recursive_table);
  PREPARE stmt FROM @str;
  EXECUTE stmt;
  # We are done :-)
END|

delimiter ;

5

La funzione 'Common Table Expression' non è disponibile in MySQL, quindi devi andare a creare una vista o una tabella temporanea da risolvere, qui ho usato una tabella temporanea.

La procedura memorizzata qui menzionata risolverà la tua esigenza. Se voglio ottenere tutti i membri del mio team e i loro membri associati, questa procedura memorizzata aiuterà:

----------------------------------
user_id   |   team_id
----------------------------------
admin     |   NULL
ramu      |   admin
suresh    |   admin
kumar     |   ramu
mahesh    |   ramu
randiv    |   suresh
-----------------------------------

Codice:

DROP PROCEDURE `user_hier`//
CREATE DEFINER=`root`@`localhost` PROCEDURE `user_hier`(in team_id varchar(50))
BEGIN
declare count int;
declare tmp_team_id varchar(50);
CREATE TEMPORARY TABLE res_hier(user_id varchar(50),team_id varchar(50))engine=memory;
CREATE TEMPORARY TABLE tmp_hier(user_id varchar(50),team_id varchar(50))engine=memory;
set tmp_team_id = team_id;
SELECT COUNT(*) INTO count FROM user_table WHERE user_table.team_id=tmp_team_id;
WHILE count>0 DO
insert into res_hier select user_table.user_id,user_table.team_id from user_table where user_table.team_id=tmp_team_id;
insert into tmp_hier select user_table.user_id,user_table.team_id from user_table where user_table.team_id=tmp_team_id;
select user_id into tmp_team_id from tmp_hier limit 0,1;
select count(*) into count from tmp_hier;
delete from tmp_hier where user_id=tmp_team_id;
end while;
select * from res_hier;
drop temporary table if exists res_hier;
drop temporary table if exists tmp_hier;
end

Questo può essere chiamato usando:

mysql>call user_hier ('admin')//

2

Questa funzionalità è chiamata espressione di tabella comune http://msdn.microsoft.com/en-us/library/ms190766.aspx

Non sarai in grado di fare la cosa esatta in mySQL, la cosa più semplice sarebbe probabilmente creare una vista che rispecchi quel CTE e selezionare dalla vista. Puoi farlo con le sottoquery, ma funzionerà davvero male. Se ti imbatti in CTE che eseguono la ricorsione, non so come potresti ricrearlo senza utilizzare procedure memorizzate.

EDIT: Come ho detto nel mio commento, quell'esempio che hai pubblicato non ha bisogno di un CTE, quindi devi averlo semplificato per la domanda poiché può essere scritto come

SELECT article.*, userinfo.*, category.* FROM question
     INNER JOIN userinfo ON userinfo.user_userid=article.article_ownerid
     INNER JOIN category ON article.article_categoryid=category.catid
     WHERE article.article_isdeleted = 0
 ORDER BY article_date DESC Limit 1, 3

4
@derobert: Non è vero. Una vista ha metadati (cioè CREATE/DROP VIEW), e puoi concedere privilegi su una vista.
Bill Karwin,

1

Mi è piaciuta la risposta di @ Brad da questo thread , ma volevo un modo per salvare i risultati per un'ulteriore elaborazione (MySql 8):

-- May need to adjust the recursion depth first
SET @@cte_max_recursion_depth = 10000 ; -- permit deeper recursion

-- Some boundaries 
set @startDate = '2015-01-01'
    , @endDate = '2020-12-31' ; 

-- Save it to a table for later use
drop table if exists tmpDates ;
create temporary table tmpDates as      -- this has to go _before_ the "with", Duh-oh! 
    WITH RECURSIVE t as (
        select @startDate as dt
      UNION
        SELECT DATE_ADD(t.dt, INTERVAL 1 DAY) FROM t WHERE DATE_ADD(t.dt, INTERVAL 1 DAY) <= @endDate
    )
    select * FROM t     -- need this to get the "with"'s results as a "result set", into the "create"
;

-- Exists?
select * from tmpDates ;

Che produce:

dt        |
----------|
2015-01-01|
2015-01-02|
2015-01-03|
2015-01-04|
2015-01-05|
2015-01-06|
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.