MySQL'de bir dizi değişkenini nasıl simüle edebilirim?

Görünen MySQL dizi değişkenleri yok. Onun yerine ne kullanmalıyım?

Önerilen iki alternatif var gibi görünüyor: Küme tipi bir skaler ve geçici tablolar . Bağlandığım soru ilkini akla getiriyor. Ancak dizi değişkenleri yerine bunları kullanmak iyi bir uygulama mı? Alternatif olarak, kümelerle gidersem, küme tabanlı deyim neye eşdeğer olur foreach?

Dizi değişkenleri yerine geçici tablolar kullanıyorum. En büyük çözüm değil ama işe yarıyor.

Alanlarını resmi olarak tanımlamanıza gerek olmadığını unutmayın, sadece bir SEÇİM kullanarak oluşturun:

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

(Ayrıca bkz . Tablo Oluştur kullanmadan select deyiminden geçici tablo oluşturma .)

Bunu MySQL'de WHILEdöngü kullanarak elde edebilirsiniz :

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;

DÜZENLEME: Alternatif olarak şunu kullanarak da yapabilirsiniz 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
 ...
);

MySql'in FIND_IN_SET () işlevini kullanmayı deneyin örn.

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

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

Not: Parametreyi CSV değerleriyle geçiriyorsanız, StoredProcedure'da değişken AYARLAMAK zorunda değilsiniz.

Günümüzde bir JSON dizisi kullanıyor bariz bir cevap olacaktır.

Bu eski ama yine de geçerli bir soru olduğu için kısa bir örnek oluşturdum. JSON işlevleri, mySQL 5.7.x / MariaDB 10.2.3'ten itibaren mevcuttur.

ELT () yerine bu çözümü tercih ediyorum çünkü gerçekten bir dizi gibi ve bu 'dizi' kodda yeniden kullanılabilir.

Ancak dikkatli olun: Bu (JSON) kesinlikle geçici bir tablo kullanmaktan çok daha yavaştır. Sadece daha kullanışlıdır. imo.

JSON dizisinin nasıl kullanılacağı aşağıda açıklanmıştır:

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

Ve burada bir fonksiyonda / prosedürde nasıl çalıştığını göstermek için küçük bir örnek:

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();

Diziler hakkında bilgim yok, ancak virgülle ayrılmış listeleri normal VARCHAR sütununda saklamanın bir yolu var.

Ve bu listede bir şey bulmanız gerektiğinde, FIND_IN_SET () işlevini kullanabilirsiniz.

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 ;

Bunun biraz geç bir yanıt olduğunu biliyorum, ancak yakın zamanda benzer bir sorunu çözmek zorunda kaldım ve bunun başkaları için yararlı olabileceğini düşündüm.

Arka fon

Aşağıdaki 'mytable' adlı tabloyu düşünün:

Sorun, yalnızca en son 3 kaydı tutmak ve systemid = 1 olan eski kayıtları silmekti (tablodaki diğer sistemid değerlerine sahip birçok başka kayıt olabilir)

Bunu basitçe ifadeyi kullanarak yapabilmen iyi olur.

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

Ancak bu MySQL'de henüz desteklenmemektedir ve bunu denerseniz, o zaman aşağıdaki gibi bir hata alırsınız:

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

Dolayısıyla, değişken kullanılarak IN seçiciye bir değerler dizisinin aktarıldığı bir geçici çözüm gereklidir. Bununla birlikte, değişkenlerin tek değerler olması gerektiğinden, bir diziyi simüle etmem gerekir . İşin püf noktası, diziyi virgülle ayrılmış değerler listesi (dize) olarak oluşturmak ve bunu değişkene aşağıdaki gibi atamaktır.

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);

@Myvar'da depolanan sonuç

5,6,7

Ardından, FIND_IN_SET seçici, simüle edilen diziden seçim yapmak için kullanılır

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

Birleşik nihai sonuç aşağıdaki gibidir:

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);

Bunun çok özel bir durum olduğunun farkındayım. Bununla birlikte, bir değişkenin bir değer dizisi depolaması gereken diğer herhangi bir duruma uyacak şekilde değiştirilebilir.

Umarım bu yardımcı olur.

İlişkili diziler istiyorsanız, sütunlarla (anahtar, değer) geçici bir bellek tablosu oluşturabilirsiniz. Bir bellek tablosuna sahip olmak, mysql'de dizilere sahip olmaya en yakın şeydir

İşte bunu nasıl yaptım.

İlk olarak, bir Uzun / Tamsayı / virgülle ayrılmış değerler listesinde bir değer olup olmadığını kontrol eden bir işlev oluşturdum:

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;

Artık virgülle ayrılmış bir kimlik listesinde aşağıdaki gibi bir kimlik arayabilirsiniz:

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

Ve bu işlevi bir WHERE yan tümcesinde şu şekilde kullanabilirsiniz:

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

Bu, bir "dizi" parametresini bir PROSEDÜR'e geçirmenin tek yoluydu.

Dizilerin amacı verimli olmak değil mi? Sadece değerler arasında yineleme yapıyorsanız, geçici (veya kalıcı) bir tablodaki imleç virgül aramaktan daha mantıklı değil mi? Ayrıca daha temiz. Arama "mysql CURSOR".

Rastgele erişim için, sayısal olarak indekslenmiş birincil anahtara sahip geçici bir tablo. Maalesef alacağınız en hızlı erişim, gerçek bir rastgele erişim değil, bir karma tablodur.

Cevapların hiçbirinin ELT / FIELD'den bahsetmediğine şaşırdım.

ELT / FIELD, özellikle statik verileriniz varsa bir diziye çok benzer şekilde çalışır.

FIND_IN_SET de benzer şekilde çalışır, ancak yerleşik bir tamamlayıcı işlevi yoktur, ancak bir tane yazmak için yeterince kolaydır.

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)

Bu, değerler listesi için iyi çalışır:

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;

Set kullanan her iki sürüm de benim için çalışmadı (MySQL 5.5 ile test edildi). ELT () işlevi tüm kümeyi döndürür. WHILE ifadesinin yalnızca PROSEDÜR bağlamında geçerli olduğunu düşünerek onu çözümüme ekledim:

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__;

Dürüst olmak gerekirse, bunun iyi bir uygulama olduğunu düşünmüyorum. Gerçekten gerekli olsa bile, bu zar zor okunabilir ve oldukça yavaştır.

Aynı sorunu görmenin başka bir yolu. Umarım yardımcı olur

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,');

5.7.x'ten sonraki MYSQL sürümünde, bir diziyi depolamak için JSON türünü kullanabilirsiniz. Bir dizinin değerini bir anahtarla MYSQL aracılığıyla alabilirsiniz.

ELT (dizin numarası, dize1, dize2, dize3,…) işlevinden esinlenerek, aşağıdaki örneğin bir dizi örneği olarak çalıştığını düşünüyorum:

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

Umarım yardımcı olur.

Burada, virgülle ayrılmış bir dizede döngü yapmak için bir MySQL örneği verilmiştir.

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;

bu, get_from_delimiter_split_stringburada tanımlanan işlevi kullanır : https://stackoverflow.com/a/59666211/3068233

Bir dizi değişkeni gerçekten gerekli mi?

Soruyorum çünkü başlangıçta buraya MySQL tablo değişkeni olarak bir dizi eklemek isteyerek geldim. Veritabanı tasarımında nispeten yeniydim ve bunu tipik bir programlama dili tarzında nasıl yapacağımı düşünmeye çalışıyordum.

Ancak veritabanları farklıdır. Ben düşündüm ben bir değişken olarak bir dizi istedik, ama sadece bir ortak MySQL veritabanı uygulama değil çıkıyor.

Standart pratik

Dizilere alternatif çözüm, ek bir tablo eklemek ve ardından orijinal tablonuza bir yabancı anahtarla başvurmaktır.

Örnek olarak, bir evdeki herkesin mağazadan satın almak istediği tüm ürünleri takip eden bir uygulama hayal edelim.

Başlangıçta tasavvur ettiğim tabloyu oluşturma komutları şuna benzerdi:

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

Buy_list'i virgülle ayrılmış bir öğe dizisi veya buna benzer bir şey olarak düşündüğümü düşünüyorum.

Ancak MySQL'in dizi türü alanı yok, bu yüzden gerçekten böyle bir şeye ihtiyacım vardı:

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)
);

Burada fk_person adında bir kısıt tanımlıyoruz. Satın Alma Listesindeki 'kişi' alanının yabancı anahtar olduğunu söylüyor. Başka bir deyişle, başka bir tablodaki birincil anahtardır, özellikle de REFERANSLAR'ın ifade ettiği Kişi tablosundaki 'ad' alanıdır.

Kişi ve öğe kombinasyonunu da birincil anahtar olarak tanımladık, ancak teknik olarak bu gerekli değil.

Son olarak, bir kişinin listesindeki tüm öğeleri almak istiyorsanız, şu sorguyu çalıştırabilirsiniz:

SELECT item FROM BuyList WHERE person='John';

Bu size John'un listesindeki tüm öğeleri verir. Diziye gerek yok!

Böyle bir masamız varsa

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

ve dizi tablosu:

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 |

CONCAT fonksiyonu ile ikinci tablonun satırlarını tek bir dizi olarak seçebiliriz:

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         |
+------------+-------+--------+------------+-------------+

Sanırım bu yanıtı geliştirebilirim. Bunu dene:

'Şakalar' parametresi bir CSV'dir. yani. "1,2,3,4 ..... vb."

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;

Bu yöntem, iyileştirme için daha iyi olacağına inandığım, döngünün her yinelemesinde aranan CSV değerleri dizisini kademeli olarak kısaltır.

Birden fazla koleksiyon için buna benzer bir şey denerdim. MySQL acemisiyim. İşlev isimleri için üzgünüm, hangi isimlerin en iyi olacağına karar veremedim.

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');

Verileri bir dizi olarak veya tek bir satırda kaydetmek yerine, alınan her değer için farklı satırlar oluşturmalısınız. Bu, hepsini bir araya getirmek yerine anlamayı çok daha kolay hale getirecek.

PHP'nin serialize () yöntemini kullanmayı denediniz mi? Bu, bir değişken dizisinin içeriğini PHP'nin anladığı ve veritabanı için güvenli olan bir dizede saklamanıza izin verir (önce ondan kaçtığınızı varsayarak).

$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());

Numaralı bir dizi olmadan da aynısını yapabilirsiniz.

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

veya

$array3 = array(
    'somethingNew'
);