Salvare l'array PHP su MySQL?

Qual è un buon modo per salvare un array di dati in un singolo campo mysql?

Inoltre, una volta che ho interrogato quell'array nella tabella mysql, qual è un buon modo per riportarlo in forma di array?

Serializzare e deserializzare la risposta?

Non esiste un modo valido per memorizzare un array in un singolo campo.

È necessario esaminare i dati relazionali e apportare le modifiche appropriate allo schema. Vedere l'esempio di seguito per un riferimento a questo approccio.

Se è necessario salvare l'array in un singolo campo, le funzioni serialize()e unserialize()faranno il trucco. Ma non puoi eseguire query sul contenuto effettivo.

In alternativa alla funzione di serializzazione c'è anche json_encode()e json_decode().

Considera il seguente array

$a = array(
    1 => array(
        'a' => 1,
        'b' => 2,
        'c' => 3
    ),
    2 => array(
        'a' => 1,
        'b' => 2,
        'c' => 3
    ),
);

Per salvarlo nel database è necessario creare una tabella come questa

$c = mysql_connect($server, $username, $password);
mysql_select_db('test');
$r = mysql_query(
    'DROP TABLE IF EXISTS test');
$r = mysql_query(
    'CREATE TABLE test (
      id INTEGER UNSIGNED NOT NULL,
      a INTEGER UNSIGNED NOT NULL,
      b INTEGER UNSIGNED NOT NULL,
      c INTEGER UNSIGNED NOT NULL,
      PRIMARY KEY (id)
    )');

Per lavorare con i record puoi eseguire query come queste (e sì, questo è un esempio, attenzione!)

function getTest() {
    $ret = array();
    $c = connect();
    $query = 'SELECT * FROM test';
    $r = mysql_query($query,$c);
    while ($o = mysql_fetch_array($r,MYSQL_ASSOC)) {
        $ret[array_shift($o)] = $o;
    }
    mysql_close($c);
    return $ret;
}
function putTest($t) {
    $c = connect();
    foreach ($t as $k => $v) {
        $query = "INSERT INTO test (id,".
                implode(',',array_keys($v)).
                ") VALUES ($k,".
                implode(',',$v).
            ")";
        $r = mysql_query($query,$c);
    }
    mysql_close($c);
}

putTest($a);
$b = getTest();

La connect()funzione restituisce una risorsa di connessione mysql

function connect() {
    $c = mysql_connect($server, $username, $password);
    mysql_select_db('test');
    return $c;
}

In generale, sì, serializzare e deserializzare sono la strada da percorrere.

Se i tuoi dati sono qualcosa di semplice, però, il salvataggio come una stringa delimitata da virgole sarebbe probabilmente meglio per lo spazio di archiviazione. Se sai che il tuo array sarà solo un elenco di numeri, per esempio, allora dovresti usare implode / explode. È la differenza tra 1,2,3e a:3:{i:0;i:1;i:1;i:2;i:2;i:3;}.

In caso contrario, serializzare e deserializzare il lavoro per tutti i casi.

Usa semplicemente la funzione serializza PHP:

<?php
$myArray = array('1', '2');
$seralizedArray = serialize($myArray);
?>

Tuttavia, se stai usando array semplici come quello potresti anche usare implode ed explode.Usa un array vuoto invece di nuovo.

Serializza / Annulla la serializzazione dell'array per l'archiviazione in un database

Visita http://php.net/manual/en/function.serialize.php

Dal manuale PHP:

Guarda sotto "Reso" nella pagina

Restituisce una stringa contenente una rappresentazione del flusso di byte del valore che può essere archiviata ovunque.

Si noti che questa è una stringa binaria che può includere byte nulli e deve essere archiviata e gestita come tale. Ad esempio, l'output di serialize () dovrebbe generalmente essere memorizzato in un campo BLOB in un database, piuttosto che in un campo CHAR o TEXT.

Nota: se si desidera archiviare html in un BLOB, assicurarsi di codificarlo in base64 o potrebbe interrompere la funzione di serializzazione.

Codifica di esempio:

$YourSerializedData = base64_encode(serialize($theHTML));

$YourSerializedData è ora pronto per essere archiviato in BLOB.

Dopo aver ottenuto i dati dal blob, è necessario base64_decode quindi deserializzare la decodifica dell'esempio:

$theHTML = unserialize(base64_decode($YourSerializedData));

Il modo migliore, che ho scoperto a me stesso, è salvare l'array come stringa di dati con caratteri separatori

$array = array("value1", "value2", "value3", "...", "valuen");
$array_data = implode("array_separator", $array);

$query = "INSERT INTO my_tbl_name (id, array_data) VALUES(NULL,'" . $array_data . "');";

È quindi possibile cercare i dati, archiviati nel proprio array con una semplice query

$query = "SELECT * FROM my_tbl_name WHERE array_data LIKE '%value3%'";

usa la funzione explode () per convertire la stringa "array_data" in array

$array = explode("array_separator", $array_data);

nota che questo non funziona con gli array multidimensionali e assicurati che il tuo "array_separator" sia unico e non esistesse nei valori degli array.

Stai attento !!! se prendi solo i dati di un modulo e lo metti nel database, sarai in trappola, perché i dati del modulo non sono sicuri per SQL! devi gestire il valore del tuo modulo con mysql_real_escape_string o se usi MySQLi mysqli :: real_escape_string o se il valore è intero o booleano cast (int) (booleano) su di essi

$number = (int)$_POST['number'];
$checked = (boolean) $_POST['checked'];

$name = mysql_real_escape_string($db_pt, $_POST['name']);
$email = mysqli_obj->real_escape_string($_POST['email']);

Serializzare e deserializzare sono piuttosto comuni per questo. Puoi anche usare JSON tramite json_encode e json_decode per un formato meno specifico di PHP.

Come accennato prima - Se non hai bisogno di cercare dati all'interno dell'array, puoi usare serialize - ma questo è "solo php". Quindi consiglierei di usare json_decode / json_encode - non solo per le prestazioni ma anche per la leggibilità e la portabilità (altri linguaggi come javascript possono gestire i dati json_encoded).

Uhh, non so perché tutti suggeriscano di serializzare l'array.

Dico, il modo migliore è adattarlo effettivamente allo schema del database. Non ho idea (e non hai fornito indizi) sull'effettivo significato semantico dei dati nel tuo array, ma ci sono generalmente due modi per memorizzare sequenze del genere

create table mydata (
  id int not null auto_increment primary key,
  field1 int not null,
  field2 int not null,
  ...
  fieldN int not null
)

In questo modo stai memorizzando il tuo array in una singola riga.

create table mydata (
    id int not null auto_increment primary key,
    ...
)

create table myotherdata (
    id int not null auto_increment primary key,
    mydata_id int not null,
    sequence int not null,
    data int not null
)

Lo svantaggio del primo metodo è, ovviamente, che se hai molti elementi nel tuo array, lavorare con quella tabella non sarà la cosa più elegante. È anche poco pratico (possibile, ma anche abbastanza inelegante - basta rendere le colonne annullabili) lavorare con sequenze di lunghezza variabile.

Per il secondo metodo, puoi avere sequenze di qualsiasi lunghezza, ma di un solo tipo. Ovviamente puoi fare in modo che un tipo varchar o qualcosa del genere e serializzare gli elementi del tuo array. Non è la cosa migliore da fare, ma sicuramente meglio che serializzare l'intero array, giusto?

Ad ogni modo, uno qualsiasi di questi metodi ottiene un chiaro vantaggio di essere in grado di accedere a un elemento arbitrario della sequenza e non devi preoccuparti di serializzare array e cose brutte del genere.

Quanto a riaverlo indietro. Bene, ottieni la riga / sequenza di righe appropriata con una query e, beh, usa un ciclo .. giusto?

Puoi salvare il tuo array come json.
c'è documentazione per il tipo di dati json: https://dev.mysql.com/doc/refman/5.7/en/json.html
Penso che questa sia la soluzione migliore e ti aiuterà a mantenere il tuo codice più leggibile evitando funzioni folli .
Mi aspetto che questo ti sia utile.

Sì, serializzare / deserializzare è ciò che ho visto di più in molti progetti open source.

Suggerirei di usare implodere / esplodere con un carattere che sai non sarà contenuto in nessuno dei singoli elementi dell'array. Quindi memorizzalo in SQL come stringa.

controlla la funzione implode, poiché i valori sono in un array, vuoi mettere i valori dell'array in una query mysql che inserisce i valori in una tabella.

$query = "INSERT INto hardware (specifications) VALUES (".implode(",",$specifications).")";

Se i valori nella matrice sono valori di testo, sarà necessario aggiungere virgolette

$query = "INSERT INto hardware (specifications) VALUES ("'.implode("','",$specifications)."')";

mysql_query($query);

Inoltre, se non desideri valori duplicati, imposta "INto" su "IGNORE" e nella tabella verranno inseriti solo valori univoci.

puoi inserire un oggetto serializzato (array) in mysql, esempio serialize($object)e puoi annullare la classificazione dell'oggetto exampleunserialize($object)

Invece di salvarlo nel database, salvarlo in un file e richiamarlo in seguito.

Quello che fanno molte app php (come sugarcrm) è usare semplicemente var_export per riprodurre tutti i dati dell'array in un file. Questo è ciò che utilizzo per salvare i dati delle mie configurazioni:

private function saveConfig() {
    file_put_contents($this->_data['pathtocompileddata'],'<?php' . PHP_EOL . '$acs_confdata = ' . var_export($this->_data,true) . ';');        
}

Penso che questo sia un modo migliore per salvare i tuoi dati!