Cómo almacenar matrices en MySQL?

La razón por la que no hay matrices en SQL, es porque la mayoría de la gente realmente no lo necesita. Las bases de datos relacionales (SQL es exactamente eso) funcionan utilizando relaciones, y la mayoría de las veces, lo mejor es asignar una fila de una tabla a cada "bit de información". Por ejemplo, donde usted puede pensar "Me gustaría una lista de cosas aquí", en su lugar hacer una nueva tabla, vinculando la fila en una tabla con la fila en otra tabla.[1] De esa manera, puedes representar relaciones M:N. Otra ventaja es que esos enlaces no desordenará la fila que contiene el elemento vinculado. Y la base de datos puede indexar esas filas. Los arrays normalmente no están indexados.

Si no necesita bases de datos relacionales, puede usar, por ejemplo, un almacén de clave-valor.

Lea acerca de normalización de la base de datos, por favor. La regla de oro es " [Cada] [atributo] no clave debe proporcionar un hecho sobre la clave, la clave completa, y nada más que la clave.". Una matriz hace demasiado. Tiene múltiples hechos y almacena el pedido (que no está relacionado con la relación en sí). Y el rendimiento es pobre (ver arriba).

Imagina que tienes una mesa de personas y tienes una mesa con llamadas telefónicas de personas. Ahora puedes hacer que cada persona tenga una lista de sus llamadas telefónicas. Pero cada persona tiene muchas otras relaciones con muchas otras cosas. ¿Eso significa que mi tabla person debe contener una matriz para cada cosa a la que está conectado? No, eso no es un atributo de la persona en sí.

[1]: Está bien si la tabla de enlace solo tiene dos columnas (las claves principales de cada tabla)! Sin embargo, si la relación en sí tiene atributos adicionales, deben representarse en esta tabla como columnas.

MySQL 5.7 ahora proporciona un tipo de datos JSON . Este nuevo tipo de datos proporciona una nueva forma conveniente de almacenar datos complejos: listas, diccionarios, etc.

Dicho esto, los rrays no mapean bien las bases de datos, por lo que los mapas objeto-relacionales pueden ser bastante complejos. Históricamente, las personas han almacenado listas/matrices en MySQL creando una tabla que las describe y agregando cada valor como su propio registro. La tabla puede tener solo 2 o 3 columnas, o puede contener muchas más. Cómo almacenar este tipo de los datos realmente dependen de las características de los datos.

Por ejemplo, ¿la lista contiene un número estático o dinámico de entradas? ¿Se mantendrá la lista pequeña, o se espera que crezca a millones de registros? ¿Habrá muchas lecturas en esta mesa? Muchas escrituras? ¿Muchas actualizaciones? Todos estos son factores que deben tenerse en cuenta al decidir cómo almacenar las colecciones de datos.

También, Key: Value data stores / Document stores tales como Cassandra, MongoDB, Redis etc proporcionan una buena solución también. Solo tenga en cuenta dónde se almacenan los datos (si se almacenan en el disco o en la memoria). No es necesario que todos sus datos estén en la misma base de datos. Algunos datos no se asignan bien a una base de datos relacional y es posible que tenga razones para almacenarlos en otro lugar, o es posible que desee usar una base de datos clave:valor en memoria como una caché en caliente para los datos almacenados en el disco en algún lugar o como un almacenamiento efímero para cosas como sesiones.

Una nota lateral a considerar, puede almacenar matrices en Postgres.

En MySQL, utilice el tipo JSON.

Contra las respuestas anteriores, el estándar SQL ha incluido tipos de matriz durante casi veinte años; son útiles, incluso si MySQL no los ha implementado.

En tu ejemplo, sin embargo, es probable que quieras crear tres tablas: persona y fruta, luego person_fruit para unirlas.

DROP TABLE IF EXISTS person_fruit;
DROP TABLE IF EXISTS person;
DROP TABLE IF EXISTS fruit;

CREATE TABLE person (
  person_id   INT           NOT NULL AUTO_INCREMENT,
  person_name VARCHAR(1000) NOT NULL,
  PRIMARY KEY (person_id)
);

CREATE TABLE fruit (
  fruit_id    INT           NOT NULL AUTO_INCREMENT,
  fruit_name  VARCHAR(1000) NOT NULL,
  fruit_color VARCHAR(1000) NOT NULL,
  fruit_price INT           NOT NULL,
  PRIMARY KEY (fruit_id)
);

CREATE TABLE person_fruit (
  pf_id     INT NOT NULL AUTO_INCREMENT,
  pf_person INT NOT NULL,
  pf_fruit  INT NOT NULL,
  PRIMARY KEY (pf_id),
  FOREIGN KEY (pf_person) REFERENCES person (person_id),
  FOREIGN KEY (pf_fruit) REFERENCES fruit (fruit_id)
);

INSERT INTO person (person_name)
VALUES
  ('John'),
  ('Mary'),
  ('John'); -- again

INSERT INTO fruit (fruit_name, fruit_color, fruit_price)
VALUES
  ('apple', 'red', 1),
  ('orange', 'orange', 2),
  ('pineapple', 'yellow', 3);

INSERT INTO person_fruit (pf_person, pf_fruit)
VALUES
  (1, 1),
  (1, 2),
  (2, 2),
  (2, 3),
  (3, 1),
  (3, 2),
  (3, 3);

Si desea asociar a la persona con una variedad de frutas, puede hacerlo con una vista:

DROP VIEW IF EXISTS person_fruit_summary;
CREATE VIEW person_fruit_summary AS
  SELECT
    person_id                                                                                              AS pfs_person_id,
    max(person_name)                                                                                       AS pfs_person_name,
    cast(concat('[', group_concat(json_quote(fruit_name) ORDER BY fruit_name SEPARATOR ','), ']') as json) AS pfs_fruit_name_array
  FROM
    person
    INNER JOIN person_fruit
      ON person.person_id = person_fruit.pf_person
    INNER JOIN fruit
      ON person_fruit.pf_fruit = fruit.fruit_id
  GROUP BY
    person_id;

La vista muestra lo siguiente datos:

+---------------+-----------------+----------------------------------+
| pfs_person_id | pfs_person_name | pfs_fruit_name_array             |
+---------------+-----------------+----------------------------------+
|             1 | John            | ["apple", "orange"]              |
|             2 | Mary            | ["orange", "pineapple"]          |
|             3 | John            | ["apple", "orange", "pineapple"] |
+---------------+-----------------+----------------------------------+

En 5.7.22, querrás usar JSON_ARRAYAGG, en lugar de hackear el array desde una cadena.

Utilice BLOB de tipo de campo de base de datos para almacenar matrices.

Ref: http://us.php.net/manual/en/function.serialize.php

Devuelve valores

Devuelve una cadena que contiene una representación de flujo de bytes de valor que se puede almacenar en cualquier lugar.

Tenga en cuenta que esta es una cadena binaria que puede incluir bytes nulos, y necesita ser almacenado y manejado como tal. Por ejemplo, serializar() la salida generalmente debe almacenarse en un campo BLOB en una base de datos, en lugar de un CHAR o campo de TEXTO.

Puedes almacenar tu array usando group_Concat así

 INSERT into Table1 (fruits)  (SELECT GROUP_CONCAT(fruit_name) from table2)
 WHERE ..... //your clause here

AQUÍ un ejemplo en fiddle