¿Cómo almacenar una matriz en una columna en Sqlite3?

Question

¿Hay alguna forma de almacenar una matriz de enteros en una columna de la tabla? Quiero O/P como esto:

ident | value               | count 
----------------+------------------------------------------------------------------------------------------------------------------------+------- 
563 | [0:10]={"(0,0)","(1,100)","(2,200)","(3,300)","(4,400)","(5,500)"} | 6 

Esto ya lo he acheieved través postgres pero quiero misma o/p de SQLite también. Aquí el valor de columna almacena una matriz. Lo intenté con BLOB pero no funciona. Alguien me contó sobre el modo serializado pero no estoy seguro de cómo hacerlo.

Answer 1

SQLite3 no admite matrices directamente. Consulte here el tipo que admite. Básicamente, solo tiene Ints, Flotantes y Texto.

Para lograr lo que necesita, tiene que usar una codificación personalizada, o usar un FK, es decir, crear otra tabla, donde cada elemento de la matriz se almacena como una fila.

Answer 2

Esto es lo que ha ocurrido, aunque puede ser incorrecto: formato

<table> 
    <citation> 
    <citation ID> 
    <citation content> 
    <citation publication date> 

CREATE TABLE citation 
(
    citation_ID INTEGER PRIMARY KEY AUTOINCREMENT, 
    citation VARCHAR(255) 
    published datetime 
    ) 


<table> 
    <source doc> 
    <source doc ID> 
    <source doc content> 

CREATE TABLE source 
(
    source_ID INTEGER PRIMARY KEY AUTOINCREMENT, 
    source VARCHAR(5000) 
    ) 

<citation_to_source table> //table in question 
    <relationship> 
    <relationship ID> 
    <citation ID> 
    <source doc ID> 

CREATE TABLE citation_to_source //table in question 
(
    relationship_id INTEGER, 
    citation_ID INTEGER, 
      source_ID INTEGER, 
      FOREIGN KEY(citation_ID) REFERENCES citation(citation_ID) 
      FOREIGN KEY(source_ID) REFERENCES source(source_ID) 
    ) 

Salida:

<content> 
    <relationship ID> 
    <unique source document content> 
    <enumerate citation IDs> 

Answer 3

Esta es una manera de serializar y deserializar datos:

#include <string> 
#include <vector> 
#include <sstream> 
#include <iostream> 

std::vector<std::string> deserialize_array(std::string const &csv) 
{ 
    std::istringstream parse(csv); 
    std::vector<std::string> ret; 
    for(std::string token; std::getline(parse, token, ','); ret.push_back(token)); 
    return ret; 
} 

std::string serialize_array(std::string* array_ptr, std::size_t N) 
{ 
    std::ostringstream cat; 
    for(std::size_t index= 0; index< N; ++ index) 
    cat<< array_ptr[index]<< ','; 
    std::string ret= cat.str(); 
    return ret.substr(0, ret.size()-1); 
} 

int main() 
{ 
    std::string data= "1,2,3"; 
    std::cout<< "Data: "<< data<< std::endl; 
    std::vector<std::string> deserialized= deserialize_array(data); 
    std::string serialized= serialize_array(deserialized.data(), deserialized.size()); 
    std::cout<< "Serialized + Deserialized: "<< serialized<< std::endl; 
} 

En lugar de perder tiempo analizando paréntesis y comas adicionales, puede serializar como csv y leer dos por dos cuando el proceso ing los datos deserializados.

Answer 4

Disculpa a Necro Solo puedo resolver el problema y encontrar una solución.

Como el SQLite ya indicado no tiene soporte para matrices, por lo que no puede almacenarlas como tales. Prueba esto, tuve el mismo problema;

en lugar de almacenar elementos de la matriz individualmente, puede dolerlos como una cadena grande y usar la función de cadena o la expresión regular para analizarlos de nuevo en sus tipos. algunos C ejemplo #

int[] myArray = new int[] {8,4,345,378,34456,7}; 

string Arraystring = myArray[0].ToString(); 

for(int i = 1; i < myArray.Length; i++) { 
Arraystring += "," + myArray[i].ToString(); 

} 

este a su vez, la matriz en una sola cadena, ahora tomamos la cuerda y la inserta en la tabla como una cadena, cuando se lee la cadena de utilizar este código para obtener la matriz de vuelta. Otro ejemplo de C#

string value; //assign this via Reader 
string[] tokens = values.Split(','); 

int[] myItems = Array.ConvertAll<string, int>(tokens, int.Parse); 

esto sólo funcionará con matrices unidimensionales, multi-diemnesional puede ser complicado cuando se trata de analizar las cuerdas.