Database ibrido di dati e colonne serializzati. Quali problemi dovrei aspettarmi

1

Ho un sistema che si comporta come un hub di messaggi. Normalizza i dati e li memorizza per essere prelevato da un sistema diverso. Attualmente converto il mio modello oggetto in tabelle e colonne per l'archiviazione. Mi sono reso conto che una buona parte dei dati viene archiviata in colonne e tabelle, ma in realtà non fa nulla di utile essendo separata in quel modo. Il mio sistema esegue solo ricerche e indici al livello più alto del modello dati. Posso risparmiare tempo e complessità memorizzando i dati che non vengono utilizzati per la ricerca come oggetti solo serializzati?

Ad esempio un ordine di base. Ha molti oggetti figlio come una collezione di oggetti ordinati, informazioni sulla spedizione, ecc.

Il mio sistema guarda solo la parte di livello superiore dell'ordine per effettuare il routing e la logica del resto è solo normalizzata e memorizzata per il ritiro più tardi.

La mia idea è di memorizzare le informazioni di ordine di livello superiore come lo stato degli ordini, la data di ricezione dell'ordine, dove l'ordine deve andare ecc. come colonne standard e tabelle se necessario. Ma i dettagli che possono variare notevolmente tra i sistemi sono memorizzati come blob serializzato. Vengono reidratati solo quando vengono effettivamente inviati altrove.

Ecco una classe in C # che descriverebbe l'idea.

 public class Order
 {

  public string OrderStatus { get; set; }//actual column 
  public DateTime OrderRecievedDate { get; set; }//actual column 
  public DateTime ShippedDate { get; set; }//actual column 
  public int DestinationId { get; set; }//actual column 
  public List<OrderItem> OrderItems { get; set; }//blob column, serialized
  public ShippingInformation ShippingInformaiton { get; set; }//blob column, serialized
 }

 public class OrderItem
 {
   public string Sku { get; set; }
   /*
   * Fifteen or 30 other properties
   * some are other classes with their own set of properties etc.
   */
   public AnotherObjectClass MoreInformation { get; set; }
 }
 public class ShippingInformaiton
 {
   public string TrackingNumber { get; set; }
   /*
    * fifteen or 30 other properties
    */
 }

La tabella sarebbe quindi simile a questa:

 CREATE TABLE [dbo].[Table1]
 (
  [Id] INT NOT NULL PRIMARY KEY, 
  [SourceSystemOrderId] NVARCHAR(50) NULL, 
  [OrderStatus] NVARCHAR(50) NULL, 
  [OrderRecievedDate] DATE NULL, 
  [ShippedDate] DATE NULL, 
  [DestinationId] INT NULL, 
  [OrderItems] VARBINARY(MAX) NULL, 
  [ShippingInformatin] VARBINARY(MAX) NULL
 )

Il mio sistema sta semplicemente memorizzando queste informazioni come un'area di attesa e quindi le rimuove dopo aver eseguito una logica. La maggior parte non verrà cercata o indicizzata al di fuori dell'oggetto / tabella di livello superiore.

Avrò un problema con l'archiviazione dei dati dell'oggetto serializzato?

- La memoria è peggiore del sovraccarico delle tabelle nidificate e delle colonne nulle?

Le prestazioni stanno allontanando un oggetto serializzato dall'archiviazione del database, meglio di 10 tavoli e tabelle figlio da estrarre?

    
posta Dan 20.06.2017 - 02:28
fonte

1 risposta

1

Basato su "i dettagli che possono variare notevolmente tra i sistemi ..." un database relazionale potrebbe non essere una scelta ideale. La tua preoccupazione per le prestazioni sarebbe un'altra ragione.

Non sembra proprio che questa applicazione possa trarre vantaggio da un database relazionale normalizzato. Non proverei a forzarlo, ma se si deve usare questo database, quindi scaricare questi record dettagliati in qualche blob o eventualmente in un campo xml se questo è il formato originale. Non è necessario convertirlo avanti e indietro se non ne hai bisogno.

    
risposta data 20.06.2017 - 07:26
fonte

Leggi altre domande sui tag