Jak przechowywać tablicę w jednej kolumnie w Sqlite3?

Question

Czy istnieje sposób przechowywania tablicy liczb całkowitych w jednej kolumnie tabeli? Chcę o/p tak:

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

To już acheieved przez PostgreSQL, ale chcę sama O/P z SQLite również. Tutaj wartość kolumny przechowuj tablicę. Próbowałem przez BLOB, ale to nie działa. Ktoś powiedział mi o serializowanym sposobie, ale nie jestem pewien, jak to zrobić.

Answer 1

SQLite3 nie obsługuje bezpośrednio tablic. Zobacz here typ, który obsługuje. Zasadniczo, tylko Ints, Floats i Text.

Aby osiągnąć to, czego potrzebujesz, musisz użyć niestandardowego kodowania lub użyć FK, tj. Utworzyć inną tabelę, w której każdy element w tablicy jest zapisany jako wiersz.

Answer 2

To co ja sobie wyobrazić, choć może być nieprawidłowe: Format

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

wyjściowa:

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

Answer 3

Jest to jeden ze sposobów szeregowania i deserializacji danych:

#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; 
} 

Zamiast spędzać czas analizując nawiasy i dodatkowe przecinki, możesz serializować jako CSV i czytać dwa razy po procesie zserializowanych danych.

Answer 4

Przepraszam dla Necro Po prostu sam mogę rozwiązać problem i znaleźć rozwiązanie.

Jak już wspomniano, SQLite nie obsługuje tablic, więc nie można ich zapisać jako takich. Spróbuj tego, miałem ten sam problem;

zamiast pojedynczo przechowywać elementy tablicy, można je obciążyć jako duży ciąg i użyć funkcji łańcuchowej lub wyrażenia regularnego, aby je ponownie przeanalizować. niektóre C# przykład

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

} 

to okaże tablicy w jeden ciąg, teraz bierzemy ciąg i wstawić je do tabeli jako ciąg, kiedy czytasz ciąg użyć tego kodu, aby uzyskać tablicę z powrotem. Innym przykładem C#

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

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

to będzie działać tylko z tablic jednowymiarowych, multi-diemnesional może się trudne, jeśli chodzi o analizowanie sznurki.