Come posso simulare una variabile di array in MySQL?

E sembra che MySQL non ha le variabili di matrice. Cosa dovrei usare invece?

Sembrano essere suggerite due alternative: tabelle scalari e temporanee di tipo set . La domanda a cui mi sono collegato suggerisce la prima. Ma è buona pratica usare queste invece delle variabili array? In alternativa, se vado con gli insiemi, quale sarebbe l'equivalente idioma basato sugli insiemi foreach?

Bene, ho usato tabelle temporanee invece di variabili array. Non è la soluzione migliore, ma funziona.

Nota che non è necessario definire formalmente i loro campi, basta crearli usando un SELECT:

CREATE TEMPORARY TABLE IF NOT EXISTS my_temp_table
SELECT first_name FROM people WHERE last_name = 'Smith';

(Vedere anche Creare una tabella temporanea dall'istruzione select senza utilizzare Crea tabella .)

Puoi farlo in MySQL usando WHILEloop:

SET @myArrayOfValue = '2,5,2,23,6,';

WHILE (LOCATE(',', @myArrayOfValue) > 0)
DO
    SET @value = ELT(1, @myArrayOfValue);
    SET @myArrayOfValue= SUBSTRING(@myArrayOfValue, LOCATE(',',@myArrayOfValue) + 1);

    INSERT INTO `EXEMPLE` VALUES(@value, 'hello');
END WHILE;

EDIT: In alternativa puoi farlo usando UNION ALL:

INSERT INTO `EXEMPLE`
(
 `value`, `message`
)
(
 SELECT 2 AS `value`, 'hello' AS `message`
 UNION ALL
 SELECT 5 AS `value`, 'hello' AS `message`
 UNION ALL
 SELECT 2 AS `value`, 'hello' AS `message`
 UNION ALL
 ...
);

Prova a utilizzare la funzione FIND_IN_SET () di MySql ad es

SET @c = 'xxx,yyy,zzz';

SELECT * from countries 
WHERE FIND_IN_SET(countryname,@c);

Nota: non è necessario impostare la variabile in StoredProcedure se si passano parametri con valori CSV.

Oggigiorno l'utilizzo di un array JSON sarebbe una risposta ovvia.

Poiché questa è una domanda vecchia ma ancora rilevante, ho prodotto un breve esempio. Le funzioni JSON sono disponibili da mySQL 5.7.x / MariaDB 10.2.3

Preferisco questa soluzione rispetto a ELT () perché è molto più simile a un array e questo "array" può essere riutilizzato nel codice.

Ma attenzione: (JSON) è sicuramente molto più lento rispetto all'utilizzo di una tabella temporanea. È solo più utile. imo.

Ecco come utilizzare un array JSON:

SET @myjson = '["gmail.com","mail.ru","arcor.de","gmx.de","t-online.de",
                "web.de","googlemail.com","freenet.de","yahoo.de","gmx.net",
                "me.com","bluewin.ch","hotmail.com","hotmail.de","live.de",
                "icloud.com","hotmail.co.uk","yahoo.co.jp","yandex.ru"]';

SELECT JSON_LENGTH(@myjson);
-- result: 19

SELECT JSON_VALUE(@myjson, '$[0]');
-- result: gmail.com

E qui un piccolo esempio per mostrare come funziona in una funzione / procedura:

DELIMITER //
CREATE OR REPLACE FUNCTION example() RETURNS varchar(1000) DETERMINISTIC
BEGIN
  DECLARE _result varchar(1000) DEFAULT '';
  DECLARE _counter INT DEFAULT 0;
  DECLARE _value varchar(50);

  SET @myjson = '["gmail.com","mail.ru","arcor.de","gmx.de","t-online.de",
                "web.de","googlemail.com","freenet.de","yahoo.de","gmx.net",
                "me.com","bluewin.ch","hotmail.com","hotmail.de","live.de",
                "icloud.com","hotmail.co.uk","yahoo.co.jp","yandex.ru"]';

  WHILE _counter < JSON_LENGTH(@myjson) DO
    -- do whatever, e.g. add-up strings...
    SET _result = CONCAT(_result, _counter, '-', JSON_VALUE(@myjson, CONCAT('$[',_counter,']')), '#');

    SET _counter = _counter + 1;
  END WHILE;

  RETURN _result;
END //
DELIMITER ;

SELECT example();

Non so degli array, ma c'è un modo per memorizzare elenchi separati da virgole nella normale colonna VARCHAR.

E quando hai bisogno di trovare qualcosa in quella lista puoi usare la funzione FIND_IN_SET () .

DELIMITER $$
CREATE DEFINER=`mysqldb`@`%` PROCEDURE `abc`()
BEGIN
  BEGIN 
    set @value :='11,2,3,1,'; 
    WHILE (LOCATE(',', @value) > 0) DO
      SET @V_DESIGNATION = SUBSTRING(@value,1, LOCATE(',',@value)-1); 
      SET @value = SUBSTRING(@value, LOCATE(',',@value) + 1); 
      select @V_DESIGNATION;
    END WHILE;
  END;
END$$
DELIMITER ;

So che questa è una risposta un po 'tardiva, ma recentemente ho dovuto risolvere un problema simile e ho pensato che potesse essere utile ad altri.

sfondo

Considera la tabella seguente chiamata 'mytable':

Il problema era mantenere solo gli ultimi 3 record ed eliminare tutti i record meno recenti il ​​cui systemid = 1 (potrebbero esserci molti altri record nella tabella con altri valori di systemid)

Sarebbe bello se potessi farlo semplicemente usando l'affermazione

DELETE FROM mytable WHERE id IN (SELECT id FROM `mytable` WHERE systemid=1 ORDER BY id DESC LIMIT 3)

Tuttavia questo non è ancora supportato in MySQL e se lo provi, otterrai un errore come

...doesn't yet support 'LIMIT & IN/ALL/SOME subquery'

Quindi è necessaria una soluzione alternativa in base alla quale un array di valori viene passato al selettore IN utilizzando la variabile. Tuttavia, poiché le variabili devono essere valori singoli, avrei bisogno di simulare un array . Il trucco è creare l'array come un elenco di valori separati da virgole (stringa) e assegnarlo alla variabile come segue

SET @myvar := (SELECT GROUP_CONCAT(id SEPARATOR ',') AS myval FROM (SELECT * FROM `mytable` WHERE systemid=1 ORDER BY id DESC LIMIT 3 ) A GROUP BY A.systemid);

Il risultato memorizzato in @myvar è

5,6,7

Successivamente, il selettore FIND_IN_SET viene utilizzato per selezionare dall'array simulato

SELECT * FROM mytable WHERE FIND_IN_SET(id,@myvar);

Il risultato finale combinato è il seguente:

SET @myvar := (SELECT GROUP_CONCAT(id SEPARATOR ',') AS myval FROM (SELECT * FROM `mytable` WHERE systemid=1 ORDER BY id DESC LIMIT 3 ) A GROUP BY A.systemid);
DELETE FROM mytable WHERE FIND_IN_SET(id,@myvar);

Sono consapevole che questo è un caso molto specifico. Tuttavia può essere modificato per adattarsi a quasi tutti gli altri casi in cui una variabile deve memorizzare una matrice di valori.

Spero che questo aiuti.

Forse crea una tabella di memoria temporanea con colonne (chiave, valore) se vuoi array associativi. Avere una tabella di memoria è la cosa più simile ad avere array in mysql

Ecco come l'ho fatto.

Innanzitutto, ho creato una funzione che controlla se un valore Long / Integer / qualunque sia in un elenco di valori separati da virgole:

CREATE DEFINER = 'root'@'localhost' FUNCTION `is_id_in_ids`(
        `strIDs` VARCHAR(255),
        `_id` BIGINT
    )
    RETURNS BIT(1)
    NOT DETERMINISTIC
    CONTAINS SQL
    SQL SECURITY DEFINER
    COMMENT ''
BEGIN

  DECLARE strLen    INT DEFAULT 0;
  DECLARE subStrLen INT DEFAULT 0;
  DECLARE subs      VARCHAR(255);

  IF strIDs IS NULL THEN
    SET strIDs = '';
  END IF;

  do_this:
    LOOP
      SET strLen = LENGTH(strIDs);
      SET subs = SUBSTRING_INDEX(strIDs, ',', 1);

      if ( CAST(subs AS UNSIGNED) = _id ) THEN
        -- founded
        return(1);
      END IF;

      SET subStrLen = LENGTH(SUBSTRING_INDEX(strIDs, ',', 1));
      SET strIDs = MID(strIDs, subStrLen+2, strLen);

      IF strIDs = NULL or trim(strIds) = '' THEN
        LEAVE do_this;
      END IF;

  END LOOP do_this;

   -- not founded
  return(0);

END;

Quindi ora puoi cercare un ID in un elenco di ID separati da virgole, in questo modo:

select `is_id_in_ids`('1001,1002,1003',1002);

E puoi usare questa funzione all'interno di una clausola WHERE, come questa:

SELECT * FROM table1 WHERE `is_id_in_ids`('1001,1002,1003',table1_id);

Questo è stato l'unico modo che ho trovato per passare un parametro "array" a una PROCEDURA.

Lo scopo degli array non è essere efficienti? Se stai solo ripetendo i valori, penso che un cursore su una tabella temporanea (o permanente) abbia più senso della ricerca di virgole, no? Anche più pulito. Cerca "mysql DECLARE CURSOR".

Per l'accesso casuale una tabella temporanea con chiave primaria indicizzata numericamente. Sfortunatamente l'accesso più veloce che otterrai è una tabella hash, non un vero accesso casuale.

Sono sorpreso che nessuna delle risposte menzioni ELT / FIELD.

ELT / FIELD funziona in modo molto simile a un array, specialmente se hai dati statici.

Anche FIND_IN_SET funziona in modo simile ma non ha una funzione complementare incorporata ma è abbastanza facile scriverne una.

mysql> select elt(2,'AA','BB','CC');
+-----------------------+
| elt(2,'AA','BB','CC') |
+-----------------------+
| BB                    |
+-----------------------+
1 row in set (0.00 sec)

mysql> select field('BB','AA','BB','CC');
+----------------------------+
| field('BB','AA','BB','CC') |
+----------------------------+
|                          2 |
+----------------------------+
1 row in set (0.00 sec)

mysql> select find_in_set('BB','AA,BB,CC');
+------------------------------+
| find_in_set('BB','AA,BB,CC') |
+------------------------------+
|                            2 |
+------------------------------+
1 row in set (0.00 sec)

mysql>  SELECT SUBSTRING_INDEX(SUBSTRING_INDEX('AA,BB,CC',',',2),',',-1);
+-----------------------------------------------------------+
| SUBSTRING_INDEX(SUBSTRING_INDEX('AA,BB,CC',',',2),',',-1) |
+-----------------------------------------------------------+
| BB                                                        |
+-----------------------------------------------------------+
1 row in set (0.01 sec)

Funziona bene per l'elenco di valori:

SET @myArrayOfValue = '2,5,2,23,6,';

WHILE (LOCATE(',', @myArrayOfValue) > 0)
DO
SET @value = ELT(1, @myArrayOfValue);
    SET @STR = SUBSTRING(@myArrayOfValue, 1, LOCATE(',',@myArrayOfValue)-1);
    SET @myArrayOfValue = SUBSTRING(@myArrayOfValue, LOCATE(',', @myArrayOfValue) + 1);

    INSERT INTO `Demo` VALUES(@STR, 'hello');
END WHILE;

Entrambe le versioni che utilizzano i set non hanno funzionato per me (testate con MySQL 5.5). La funzione ELT () restituisce l'intero set. Considerando che l'istruzione WHILE è disponibile solo nel contesto PROCEDURE, l'ho aggiunta alla mia soluzione:

DROP PROCEDURE IF EXISTS __main__;

DELIMITER $
CREATE PROCEDURE __main__()
BEGIN
    SET @myArrayOfValue = '2,5,2,23,6,';

    WHILE (LOCATE(',', @myArrayOfValue) > 0)
    DO
        SET @value = LEFT(@myArrayOfValue, LOCATE(',',@myArrayOfValue) - 1);    
        SET @myArrayOfValue = SUBSTRING(@myArrayOfValue, LOCATE(',',@myArrayOfValue) + 1);
    END WHILE;
END;
$
DELIMITER ;

CALL __main__;

Ad essere onesti, non credo che questa sia una buona pratica. Anche se è davvero necessario, questo è appena leggibile e piuttosto lento.

Un altro modo per vedere lo stesso problema. Spero utile

DELIMITER $$
CREATE PROCEDURE ARR(v_value VARCHAR(100))
BEGIN

DECLARE v_tam VARCHAR(100);
DECLARE v_pos VARCHAR(100);

CREATE TEMPORARY TABLE IF NOT EXISTS split (split VARCHAR(50));

SET v_tam = (SELECT (LENGTH(v_value) - LENGTH(REPLACE(v_value,',',''))));
SET v_pos = 1;

WHILE (v_tam >= v_pos)
DO
    INSERT INTO split 
    SELECT SUBSTRING_INDEX(SUBSTRING_INDEX(v_value,',',v_pos),',', -1);
    SET v_pos = v_pos + 1;
END WHILE;

SELECT * FROM split;

DROP TEMPORARY TABLE split;

END$$


CALL ARR('1006212,1006404,1003404,1006505,444,');

Nella versione MYSQL successiva alla 5.7.x, puoi utilizzare il tipo JSON per memorizzare un array. È possibile ottenere il valore di un array da una chiave tramite MYSQL.

Ispirato dalla funzione ELT (numero indice, stringa1, stringa2, stringa3, ...), penso che il seguente esempio funzioni come esempio di array:

set @i := 1;
while @i <= 3
do
  insert into table(val) values (ELT(@i ,'val1','val2','val3'...));
set @i = @i + 1;
end while;

Spero che aiuti.

Ecco un esempio per MySQL per il ciclo attraverso una stringa delimitata da virgole.

DECLARE v_delimited_string_access_index INT;
DECLARE v_delimited_string_access_value VARCHAR(255);
DECLARE v_can_still_find_values_in_delimited_string BOOLEAN;

SET v_can_still_find_values_in_delimited_string = true;
SET v_delimited_string_access_index = 0;
WHILE (v_can_still_find_values_in_delimited_string) DO
  SET v_delimited_string_access_value = get_from_delimiter_split_string(in_array, ',', v_delimited_string_access_index); -- get value from string
  SET v_delimited_string_access_index = v_delimited_string_access_index + 1;
  IF (v_delimited_string_access_value = '') THEN
    SET v_can_still_find_values_in_delimited_string = false; -- no value at this index, stop looping
  ELSE
    -- DO WHAT YOU WANT WITH v_delimited_string_access_value HERE
  END IF;
END WHILE;

questo utilizza la get_from_delimiter_split_stringfunzione definita qui: https://stackoverflow.com/a/59666211/3068233

Una variabile array è davvero necessaria?

Lo chiedo perché originariamente sono arrivato qui volendo aggiungere un array come variabile di tabella MySQL. Ero relativamente nuovo nella progettazione di database e cercavo di pensare a come farlo in un tipico linguaggio di programmazione.

Ma i database sono diversi. Ho pensato che avrei voluto un array come una variabile, ma si scopre che non è solo una pratica database comune MySQL.

Pratica standard

La soluzione alternativa agli array consiste nell'aggiungere una tabella aggiuntiva e quindi fare riferimento alla tabella originale con una chiave esterna.

Ad esempio, immaginiamo un'applicazione che tenga traccia di tutti gli articoli che ogni persona in famiglia vuole acquistare nel negozio.

I comandi per creare la tabella che avevo originariamente immaginato avrebbero avuto un aspetto simile a questo:

#doesn't work
CREATE TABLE Person(
  name VARCHAR(50) PRIMARY KEY
  buy_list ARRAY
);

Penso di aver immaginato che buy_list fosse una stringa di elementi separati da virgole o qualcosa del genere.

Ma MySQL non ha un campo di tipo array, quindi avevo davvero bisogno di qualcosa del genere:

CREATE TABLE Person(
  name VARCHAR(50) PRIMARY KEY
);
CREATE TABLE BuyList(
  person VARCHAR(50),
  item VARCHAR(50),
  PRIMARY KEY (person, item),
  CONSTRAINT fk_person FOREIGN KEY (person) REFERENCES Person(name)
);

Qui definiamo un vincolo denominato fk_person. Dice che il campo "persona" in BuyList è una chiave esterna. In altre parole, è una chiave primaria in un'altra tabella, in particolare il campo "nome" nella tabella Persona, che è ciò che denota REFERENCES.

Abbiamo anche definito la combinazione di persona e oggetto come chiave primaria, ma tecnicamente non è necessario.

Infine, se desideri ottenere tutti gli elementi nell'elenco di una persona, puoi eseguire questa query:

SELECT item FROM BuyList WHERE person='John';

Questo ti dà tutti gli elementi sulla lista di John. Non sono necessari array!

Se abbiamo un tavolo come quello

mysql> select * from user_mail;
+------------+-------+
| email      | user | 
+------------+-------+-
| email1@gmail |     1 | 
| email2@gmail |     2 |
+------------+-------+--------+------------+

e la tabella degli array:

mysql> select * from user_mail_array;
+------------+-------+-------------+
| email      | user | preferences |
+------------+-------+-------------+
| email1@gmail |     1 |           1 |
| email1@gmail |     1 |           2 |
| email1@gmail |     1 |           3 |
| email1@gmail |     1 |           4 |
| email2@gmail |     2 |           5 |
| email2@gmail |     2 |           6 |

Possiamo selezionare le righe della seconda tabella come un array con la funzione CONCAT:

mysql> SELECT t1.*, GROUP_CONCAT(t2.preferences) AS preferences
     FROM user_mail t1,user_mail_array t2
       where t1.email=t2.email and t1.user=t2.user
     GROUP BY t1.email,t1.user;

+------------+-------+--------+------------+-------------+
| email      | user | preferences |
+------------+-------+--------+------------+-------------+
|email1@gmail |     1 | 1,3,2,4     |
|email2@gmail |     2 | 5,6         |
+------------+-------+--------+------------+-------------+

Penso di poter migliorare questa risposta. Prova questo:

Il parametro "Pranks" è un CSV. cioè. "1,2,3,4 ..... ecc."

CREATE PROCEDURE AddRanks(
IN Pranks TEXT
)
BEGIN
  DECLARE VCounter INTEGER;
  DECLARE VStringToAdd VARCHAR(50);
  SET VCounter = 0;
  START TRANSACTION;
  REPEAT
    SET VStringToAdd = (SELECT TRIM(SUBSTRING_INDEX(Pranks, ',', 1)));
    SET Pranks = (SELECT RIGHT(Pranks, TRIM(LENGTH(Pranks) - LENGTH(SUBSTRING_INDEX(Pranks, ',', 1))-1)));
    INSERT INTO tbl_rank_names(rank)
    VALUES(VStringToAdd);
    SET VCounter = VCounter + 1;
  UNTIL (Pranks = '')
  END REPEAT;
  SELECT VCounter AS 'Records added';
  COMMIT;
END;

Questo metodo rende la stringa cercata di valori CSV progressivamente più breve con ogni iterazione del ciclo, che credo sarebbe meglio per l'ottimizzazione.

Proverei qualcosa di simile per più raccolte. Sono un principiante di MySQL. Mi dispiace per i nomi delle funzioni, non ho potuto decidere quali sarebbero i nomi migliori.

delimiter //

drop  procedure init_
//
create procedure init_()
begin
  CREATE TEMPORARY TABLE if not exists 
    val_store(  
    realm  varchar(30) 
    ,  id  varchar(30) 
    ,  val   varchar(255) 
    ,  primary key ( realm , id )
    );
end;
//

drop function if exists get_
//
create function get_( p_realm varchar(30) , p_id varchar(30) )
  returns varchar(255)
  reads sql data
begin 
  declare ret_val varchar(255);
  declare continue handler for 1146 set ret_val = null;
  select val into ret_val from val_store where id = p_id;
  return ret_val;
end;
//

drop procedure if exists set_
//
create procedure set_( p_realm varchar(30) , p_id varchar(30) , p_val varchar(255) )
begin
  call init_(); 
  insert into val_store (realm,id,val) values (p_realm , p_id , p_val) on duplicate key update val = p_val;
end;
//

drop   procedure if exists remove_
//
create procedure remove_( p_realm varchar(30) , p_id varchar(30) )
begin
  call init_();
  delete from val_store where realm = p_realm and id = p_id;
end;
//

drop   procedure if exists erase_
//
create procedure erase_( p_realm varchar(30) ) 
begin
  call init_();
  delete from val_store where realm = p_realm;
end;
//

call set_('my_array_table_name','my_key','my_value');

select get_('my_array_table_name','my_key');

Piuttosto che salvare i dati come array o in una sola riga, dovresti creare righe diverse per ogni valore ricevuto. Questo renderà molto più semplice capire piuttosto che mettere tutto insieme.

Hai provato a usare serialize () di PHP? Ciò ti consente di memorizzare il contenuto di un array di una variabile in una stringa che PHP comprende ed è sicura per il database (supponendo che tu l'abbia prima evitato).

$array = array(
    1 => 'some data',
    2 => 'some more'
);

//Assuming you're already connected to the database
$sql = sprintf("INSERT INTO `yourTable` (`rowID`, `rowContent`) VALUES (NULL, '%s')"
     ,  serialize(mysql_real_escape_string($array, $dbConnection)));
mysql_query($sql, $dbConnection) or die(mysql_error());

Puoi anche fare lo stesso senza un array numerato

$array2 = array(
    'something' => 'something else'
);

o

$array3 = array(
    'somethingNew'
);