Database Domanda: Modificare semplici tabelle relazionali per non relazionali?

StackOverflow https://stackoverflow.com/questions/938751

Domanda

Ho un'applicazione web in esecuzione su un database MySQL (in fase di sviluppo). Sto pensando di migrare la mia domanda di Google App Engine, e vorrei capire meglio come il mio semplice modello di database relazionale può essere trasformato per l'approccio non-relazionale.

Sono una persona database relazionale molto tempo, e non ho alcuna esperienza con DB colonne based come BigTable. Nel caso in cui Google supporta anche le piccole implementazioni di database relazionali, vorrei precisare che la mia domanda è generale e non specifico per Google -. Vorrei capire come modelli relazionali semplice può essere rappresentato in DB non relazionali

Il mio database (semplificato) è la seguente: 

Items Table
------------

ItemID  ItemName  ItemPriority
1       "Car"     7
2       "Table"   2
3       "Desk"    7

ItemProperties Table
---------------------

ItemID  Property        Importance 
1       "Blue"          1
1       "Four Wheels"   2
1       "Sedan"         0
2       "Rectangular"   1
2       "One Leg"       1

Ho molti articoli, ognuna con un nome e l'ID. Ogni prodotto ha diverse proprietà, ogni proprietà ha diversi parametri (ho detto solo il nome e la "importanza" di ogni proprietà, ma ci sono più). Ho decine di milioni di oggetti, ognuno ha centinaia di immobili.

Lo scenario di utilizzo: ricevo un ItemName come input, cercare il suo ID nella tabella degli elementi, e prenderti tutte le proprietà di tale ID. Ho poi eseguire alcune analisi sul elenco delle proprietà (in memoria), e restituire un risultato.

90% del lavoro è ricerca basata su un parametro, che (se ho capito bene) è il dolore-punto di DB non relazionali.

Qual è l'approccio raccomandato?

È stato utile?

Soluzione

Da qualcuno che ha lavorato con non-relazionali db per un po 'i tuoi due tabelle devono essere veramente facile da tradurre in un db non relazionale.

Prendere le due tabelle e li trasformano in un unico oggetto.

Articolo:  - Id  - Nome  - Proprietà     - prop1     - prop2

Conservare il tutto nelle colonne di dati-store (Big-balilla), documenti (CouchDB), o qualsiasi altra cosa che utilizza.

È possibile cercare oggetti da una delle IDS, nomi, o proprietà. Non ci sono unisce, che sono uno dei punti deboli più grandi di DBS non relazionali. le ricerche dei parametri non sono davvero un punto di dolore a meno che non sto capire cosa vuoi dire con questo. Potrebbe essere necessario fare più ricerche, ma la maggior parte delle volte che non è un problema e scale modo migliore di un RDBMS fa.

Nel tuo esempio io in realtà considero il modello non-relazionale per essere più semplice e più facile da implementare e da comprendere.

Ogni archivio dati non relazionali ha diverse convenzioni e vincoli anche se così è difficile fornire indicazioni in senso generale. CouchDB può creare un indice su una qualsiasi parte dell'oggetto con la vista, per esempio. Con BigTable potrebbe essere necessario memorizzare più copie dei dati denormalizzati per ottenere le ricerche veloci indicizzati. Altri avranno diverse cose da considerare quando si decide come memorizzare i dati. C'è un bel po 'di differenziazione là fuori una volta che si lascia il mondo di SQL.

Altri suggerimenti

GQL non supporta unisce. Si può ovviare a questo in due modi:

  • la raggiungi

Basta prendere l'oggetto, controllare la sua ItemID e query per ItemProperties con quel ItemID. Le tabelle sarebbero apparire esattamente come se li specificato. Certo, si tratta di due query, ma i due query sono semplici.

  • Modelli Usa Expando

In un modello Expando, è possibile creare nuovi campi in fase di esecuzione. Essi non saranno indicizzati, quindi se si desidera effettuare la ricerca su di essi può essere più lento, ma semplicemente il recupero è più che bene. È possibile utilizzare i tipi complessi come ListProperty, anche. Con questo tipo di flessibilità, si può essere in grado di pensare a un modo per mettere tutto nella tabella ItemProperties nella tabella Elementi, e risparmiare una query. Siate creativi.

Ho una struttura di database molto simile (i nostri "record" e "recordEntries" tabelle rispecchiano i tuoi "oggetti" e "itemProperties") e sto considerando una migrazione simile a un database non relazionale. Probabilmente ci andremo a CouchDB o memcachedb o qualcosa di simile, invece di Google.

Come te non ho esperienza di lavoro con i database non relazionali (né i miei sviluppatori). Tuttavia, abbiamo gettato un paio di idee in giro. I nostri pensieri attuali sono (utilizzando lo schema):

  • Primo: Riduci ciascun elemento più le sue proprietà degli elementi in un unico oggetto con campi (in sostanza, un documento XML) e roba nel database digitato per identificatore. Ogni volta che si recupera un elemento si torna tutti i itemProperties troppo.

Si noti la differenza che abbiamo è che indice di noi i nostri contenuti al di fuori del database (con Solr), e quindi non hanno bisogno di fare ricerche sul database stesso utilizzando il "nome" di proprietà, in modo YMMV.

  • Secondo: Stiamo facendo una lista fuori tutte le operazioni "relazionali" che stiamo facendo che non può essere supportata dal modello di cui sopra. Questo include un paio di operazioni di "raggruppamento", dove abbiamo interrogare elementi in base a un campo speciale nella tabella oggetto, e una query in cui si cerca di rilevare tutti gli elementi che sono stati recentemente modificati (precedentemente compiute da una query su una colonna di data in la tabella articolo). Stiamo inventando implementazioni alternative per ciascuno di questi casi (ci sono solo pochi, per fortuna).

Se questo si rivela troppo difficile, cercheremo lo stesso esercizio con un altro modello. Per fortuna, abbiamo il tempo per pianificare.

Un punto chiave per noi è che stiamo facendo tutto il nostro indicizzazione esternamente con Solr, quindi (per esempio) non abbiamo bisogno di fare ricerche nei database sui valori nei valori itemProperties, o di fare ricerche in base al nome del tavolo voce.

In ogni caso, questo è probabilmente non molto di aiuto, ma sarò curioso di vedere che tipo di soluzioni persone più esperte possono trovare.

PS: dedurre la vostra tavola proprietà deve avere miliardi di righe. Quanti esattamente, e l'hardware sono in esecuzione il server MySQL su? Stai avendo ancora problemi di scalabilità con MySQL?

È necessario appiattire tutto, penso che AppEngine permette strutture come

ID = 1, ItemName = auto, ItemPriority = 7, proprietà = (blu, 1), proprietà = (quattro ruote, 2), proprietà = (berlina, 0) ID = 2, ItemName = Tavolo, ItemPriority = 2, Proprietà = (rettangolare, 1), proprietà = (una gamba, 1) ID = 3, ItemName = scrivania, ItemPriority = 7

Si noti che lo stesso "campo" potrebbe avere più valori, e che si potrebbe usare più elementi in esso.

I tuoi dati di esempio sarebbero 3 righe in una tabella.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top