Sto pianificando correttamente il mio database / back-end?

2

Sono uno sviluppatore iOS e sinceramente non sto cercando di diventare un esperto di database proprio in questo momento, ma ho bisogno di sapere come pianificare correttamente quello che ritengo essere un bel cookie cutter social backend / database di stile di rete.

Terrò questo breve e dolce:

L'app per social network avrà utenti, post, commenti e preferiti.

Uso dei commenti come esempio:

Ogni commento è un oggetto che è stato creato nel mio backend per una classe chiamata "Commenti" (è eccessivo? Non vedo in quale altro modo si possa ottenere ma non riesco a credere a come un server gestirà così tanti singoli commenti se un'app diventa popolare, ma forse sto solo sottovalutando la potenza di un buon back-end?)

Un oggetto commento è composto da un URL per l'avatar del commentatore, l'ID utente del commentatore, un ID oggetto univoco, l'ID dell'oggetto post del commento e il testo del commento.

I post e i preferiti sarebbero anche propri classi / oggetti nel back-end e seguirebbero lo stesso modello dei commenti nell'esempio sopra.

Quindi la mia domanda principale è, sono in linea con quanto sopra? Voglio assicurarmi di strutturare correttamente il mio back-end.

La mia seconda domanda è: in che modo l'utente dovrebbe tenere traccia di tutti i loro post, commenti e preferiti?

La mia idea iniziale era di avere solo campi array per la classe User e memorizzare gli ID dei post, commenti e preferiti ad es. La classe utente ha un campo array chiamato "Post" con ID di oggetti post.

La cosa che mi confonde è la capacità eccessiva di tenere traccia di questi nella classe User, quando sto memorizzando l'ID dell'utente nei post, nei commenti e nelle classi preferite già? E poi vorrei solo interrogare quelle classi e filtrare per l'ID dell'utente, ma poi ci penso e se l'applicazione ha un sacco di utilizzo, potrebbe richiedere più tempo per interrogare tutti quegli oggetti e filtrare dall'ID dell'utente quando l'utente potrebbe tieni traccia dei loro oggetti attraverso i campi nella classe User.

Ultimo ma non meno importante, la scorsa settimana ho letto quanto segue in alcuni documenti di Parse.com (popolare Backend as a Service):

"Quando stai pensando a relazioni uno-a-molti e se implementare puntatori o matrici, ci sono diversi fattori da considerare: in primo luogo, quanti oggetti sono coinvolti in questa relazione? la relazione potrebbe contenere un numero molto grande (superiore a 100 o così) di oggetti, quindi è necessario utilizzare i puntatori. "

Sono confuso su cosa siano i pointer in un back-end?

Mi rendo conto che queste sono tutte domande piuttosto belle, ma voglio davvero assicurarmi di configurare correttamente il mio back-end e assicurarmi che la sua struttura abbia un senso.

Speriamo che alcuni di voi ragazzi siano disposti a leggere questo gigantesco muro di testo e aiutare un brutto fuori.

Grazie per l'aiuto!

    
posta user3344977 08.04.2015 - 06:54
fonte

1 risposta

7

Un po 'sui database relazionali

Una delle funzionalità più potenti dei database relazionali è la possibilità di connettere insiemi di dati attraverso punti comuni. Per farlo in modo efficiente, un database dovrebbe seguire le regole della normalizzazione . Per sommare queste regole, un database dovrebbe avere:

  1. Nessun elemento ripetuto o gruppo di elementi
  2. Nessuna dipendenza parziale su una chiave concatenata
  3. Nessuna dipendenza dagli attributi non chiave

Tenendo presenti queste regole, una tabella di esempio per i commenti potrebbe essere simile a questa:

----------------------------------------------------------------------    
| comments                                                           |
|--------------------------------------------------------------------|
| comment_id (key, auto-increment) |  comment  | post_id |  user_id  |
|----------------------------------|-----------|---------|-----------|
| 1                                | <text...> |    1    |   123452  |
----------------------------------------------------------------------   

Qui, comment_id è la "chiave" o identificatore univoco della tabella. È anche stato impostato su "incremento automatico", il che significa che aumenterà automaticamente il suo valore come "record" o righe, vengono aggiunti alla tabella. Come mostrato, la tabella contenente le informazioni relative ai commenti sa solo cosa ha bisogno di sapere. In che modo, quindi, metti in relazione le informazioni specifiche dell'utente con un commento? È qui che entra in gioco la parte "relazionale" del "database relazionale":

--------------------------------------------|
| users                                     |
|-------------------------------------------|--------------------------------|
| user_id (key, auto-increment) |   avatar  | additional fields not shown... |
|-------------------------------|-----------|--------------------------------|
| 123452                        | <img_url> |
---------------------------------------------

Tieni presente che la colonna user_id contiene gli stessi dati sia per la tabella comments che per la tabella users . In questo modo, puoi "unire" i dati delle due tabelle. Ad esempio, per ottenere tutti i commenti fatti da un utente, è possibile eseguire la query MySQL:

SELECT comment_id, comment, post_id FROM comments NATURAL JOIN users WHERE user_id=123452;

Questo metodo risponde anche alla domanda

how should the user should keep track of all of their posts, comments, and favorites?

La tabella user non dovrebbe tenere traccia di tali informazioni in sé, ma piuttosto le rispettive tabelle dovrebbero contenere riferimenti a un ID utente globalmente unico.

Quasi lì

Quindi, in sostanza, eri sulla buona strada. L'unico vero cambiamento dal modello che hai specificato è stato spostare le informazioni dell'avatar dell'utente nella tabella relativa agli utenti, invece che nella tabella relativa ai commenti.

Come sembra che tu stia distogliendo dall'uso di un database SQL raw, potresti considerare le tabelle come classi e utilizzare le regole di normalizzazione come linee guida per la progettazione.

Infine, la cosa di Pointers vs. Arrays: entrambi sono molto specifici del backend di Parse (e, ammettiamolo, nessuno dei due è spiegato molto bene). Il miglior confronto che riesco a fare è che i Puntatori sarebbero come Liste (come in Java o C #), e gli Array sarebbero come, beh, gli Array. La differenza tra i due è che gli array possono solo memorizzare una quantità predeterminata di dati, mentre gli elenchi (o puntatori, nel caso di Parse) possono memorizzare una quantità non specificata. In teoria, la quantità sarebbe infinita, ma in pratica la quantità è determinata dalla quantità di spazio disponibile nell'heap. Per ulteriori informazioni sulla differenza tra elenchi e array, consulta questa domanda . Se stai pianificando di utilizzare Parse, ti consiglio di utilizzare i puntatori in congiunzione con le tabelle di join (che sono essenzialmente wrapper attorno al metodo SQL descritto sopra), poiché queste sono le opzioni che offrono la massima flessibilità.

    
risposta data 08.04.2015 - 09:04
fonte

Leggi altre domande sui tag