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

¿Hay alguna forma de almacenar una matriz de enteros en una columna de la tabla? Quiero o/p como este:

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

Esto ya lo logré a través de postgres, pero también quiero el mismo o/p de sqlite. Aquí el valor de la columna almacena una matriz. Lo probé a través de BLOB pero no funciona. Alguien me habló de la forma serializada, pero no estoy seguro de cómo hacerlo.

SQLite3 no admite matrices directamente. Ver aquí el tipo que admite. Básicamente, solo hace Ints, Floats y Text.

Para lograr lo que necesita, debe 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.

Lo siento por Necro, solo me encontré con el problema y encontré una solución.

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

En lugar de almacenar los elementos de la matriz individualmente, puede almacenarlos como una cadena grande y usar una función de cadena o una expresión regular para volver a analizarlos en sus tipos. Un ejemplo de C#

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

}

Esto convertirá la matriz en una sola cadena, ahora tomamos la cadena y la insertamos en la tabla como una cadena, cuando lea la cadena, use este código para recuperar la matriz. Otro ejemplo de C#

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

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

esto solo funcionará con matrices unidimensionales, las multidimensionales pueden ser complicadas cuando se trata de analizar las cadenas.

Esta es una forma 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 de dos en dos al procesar los datos deserializados.

Podría usar JSON.stringify y cuando lea los datos nuevamente JSON.parse. Por lo tanto, almacena una matriz como una cadena y puede analizarla fácilmente nuevamente en una matriz. De esta manera, también puede colocar matrices de matrices en la base de datos sqlite

Esto es lo que imagino, aunque puede ser incorrecto:

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

Formato de salida:

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