commitLog e SSTables nel database Cassandra

Question

Recentemente ho iniziato a lavorare con il database Cassandra. Ho installato single node cluster nella mia casella locale. E sto lavorando con Cassandra 1.2.3.

stavo leggendo l'articolo su internet e ho trovato questo line-

Cassandra scrive vengono prima scritti in un registro commit (per durata), e quindi ad una struttura tabella in memoria chiamato memtable. Una scrittura è riuscita dopo essere stata scritta nel registro di commit e nella memoria, pertanto è un I/O disco molto minimale al momento della scrittura. Le scritture vengono raggruppate nella memoria e periodicamente scritte su disco in una tabella persistente. struttura denominata SSTable (tabella di stringhe ordinate).

Quindi, per comprendere le righe precedenti, ho scritto un semplice programma che scriverà nel database Cassandra utilizzando Pelops client. E sono stato in grado di inserire i dati nel database di Cassandra.

E ora sto cercando di vedere come sono stati scritti i miei dati in commit log e dove è lo commit log file? E anche come viene generato SSTables e dove posso trovarlo anche nella mia casella locale e cosa contiene anche.

Volevo vedere questi due file in modo da capire meglio come funziona Cassandra dietro le quinte.

Nel mio file cassandra.yaml, ho qualcosa di simile

# directories where Cassandra should store data on disk. 
data_file_directories: 
    - S:\Apache Cassandra\apache-cassandra-1.2.3\storage\data 

# commit log 
commitlog_directory: S:\Apache Cassandra\apache-cassandra-1.2.3\storage\commitlog 

# saved caches 
saved_caches_directory: S:\Apache Cassandra\apache-cassandra-1.2.3\storage\savedcaches 

Ma quando ho aperto commitLog, prima di tutto ha molti dati quindi il mio Notepad ++ non è in grado di aprire correttamente e se si apre, non riesco a vedere correttamente a causa di qualche codifica o cosa. E nella mia cartella di dati, non riesco a scoprire nulla?

Significato questa cartella è vuota per me-

S:\Apache Cassandra\apache-cassandra-1.2.3\storage\data\my_keyspace\users 

C'è qualcosa che mi manca qui? Qualcuno può spiegarmi come leggere i file commitLog e SSTables e dove posso trovare questi due file? E anche cosa succede esattamente dietro le quinte ogni volta che scrivo al database di Cassandra.

Aggiornato: -

codice che sto usando per inserire in Cassandra Database-

public class MyPelops { 

    private static final Logger log = Logger.getLogger(MyPelops.class); 

    public static void main(String[] args) throws Exception { 


     // ------------------------------------------------------------- 
     // -- Nodes, Pool, Keyspace, Column Family --------------------- 
     // ------------------------------------------------------------- 

     // A comma separated List of Nodes 
     String NODES = "localhost"; 

     // Thrift Connection Pool 
     String THRIFT_CONNECTION_POOL = "Test Cluster"; 

     // Keyspace 
     String KEYSPACE = "my_keyspace"; 

     // Column Family 
     String COLUMN_FAMILY = "users"; 

     // ------------------------------------------------------------- 
     // -- Cluster -------------------------------------------------- 
     // ------------------------------------------------------------- 

     Cluster cluster = new Cluster(NODES, 9160); 

     Pelops.addPool(THRIFT_CONNECTION_POOL, cluster, KEYSPACE); 

     // ------------------------------------------------------------- 
     // -- Mutator -------------------------------------------------- 
     // ------------------------------------------------------------- 

     Mutator mutator = Pelops.createMutator(THRIFT_CONNECTION_POOL); 

     log.info("- Write Column -"); 

     mutator.writeColumn(
       COLUMN_FAMILY, 
       "Row1", 
       new Column().setName(" Name ".getBytes()).setValue(" Test One ".getBytes()).setTimestamp(new Date().getTime())); 

     mutator.writeColumn(
       COLUMN_FAMILY, 
       "Row1", 
       new Column().setName(" Work ".getBytes()).setValue(" Engineer ".getBytes()).setTimestamp(new Date().getTime())); 

     log.info("- Execute -"); 
     mutator.execute(ConsistencyLevel.ONE); 

     // ------------------------------------------------------------- 
     // -- Selector ------------------------------------------------- 
     // ------------------------------------------------------------- 

     Selector selector = Pelops.createSelector(THRIFT_CONNECTION_POOL); 

     int columnCount = selector.getColumnCount(COLUMN_FAMILY, "Row1", 
       ConsistencyLevel.ONE); 
     System.out.println("- Column Count = " + columnCount); 

     List<Column> columnList = selector 
       .getColumnsFromRow(COLUMN_FAMILY, "Row1", 
         Selector.newColumnsPredicateAll(true, 10), 
         ConsistencyLevel.ONE); 
     System.out.println("- Size of Column List = " + columnList.size()); 

     for (Column column : columnList) { 
      System.out.println("- Column: (" + new String(column.getName()) + "," 
        + new String(column.getValue()) + ")"); 
     } 

     System.out.println("- All Done. Exit -"); 
     System.exit(0); 
    } 

} 

spazio delle chiavi e la Colonna di famiglia che ho created-

create keyspace my_keyspace with placement_strategy = 'org.apache.cassandra.locator.SimpleStrategy' and strategy_options = {replication_factor:1}; 
use my_keyspace; 
create column family users with column_type = 'Standard' and comparator = 'UTF8Type'; 

Answer 1

siete quasi arrivati nella tua comprensione Tuttavia, mancano alcuni dettagli minuti.

Così spiegare le cose in modo strutturato, ciclo di Cassandra scrittura vita operativa è divisa in questi passaggi

• commitlog scrivere
• scrittura memtable
• scrittura sstable

Cassandra scrive sono prima scritto in un registro di commit (per la durabilità) e quindi in una struttura di tabella in memoria chiamata memtable. Si dice che una scrittura ha successo una volta scritta nel registro di commit e nella memoria, quindi al momento della scrittura è presente un I/O del disco molto minimale. Quando il memble esaurisce lo spazio, ovvero quando il numero di tasti supera determinati limiti (128 è predefinito) o quando raggiunge la durata (orologio cluster), viene memorizzato in uno spazio stabile e immutabile (questo meccanismo è chiamato Flushing). Una volta che le scritture sono state fatte su SSTable, puoi vedere i dati corrispondenti nella cartella dei dati, nel tuo caso è S:\Apache Cassandra\apache-cassandra-1.2.3\storage\data. Ogni SSTable compone principalmente di due file - file indice e dati del file

• file indice contiene - filtro Bloom e Key-Offset coppie

  • Bloom Filter: Un filtro Bloom, è uno spazio-efficiente probabilistico struttura dei dati che viene utilizzata per verificare se un elemento è un membro di un set. I falsi positivi sono possibili, ma i falsi negativi non lo sono. Cassandra utilizza i filtri bloom per salvare l'IO durante l'esecuzione di una ricerca chiave: ogni SSTable ha un filtro di fioritura associato che Cassandra controlla prima di eseguire qualsiasi ricerca di dischi, effettuando query per chiavi che non esistono quasi gratis
  • (Chiave, offset) coppie (punti in file di dati)

• file di dati contiene i dati effettivi delle colonne

E per quanto riguarda i file commitlog, questi sono i file crittografati mantenuto intrinsecamente da Cassandra, per le quali non si è in grado di vedere qualsiasi cosa correttamente.

UPDATE:

Memtable è una cache in memoria con contenuti memorizzati come chiave/colonna (dati sono ordinati per chiave). Ogni famiglia di colonne ha una memoria separata e recupera i dati della colonna dalla chiave. Quindi ora spero che tu sia in uno stato mentale chiaro per capire il fatto, perché non possiamo localizzarli sul nostro disco.

Nel tuo caso il tuo memble non è pieno, dato che le soglie dei meme non sono sbiancate e non causano arrossamenti. Si può sapere di più su MemtableThresholds here sebbene si raccomanda di non toccare quella manopola.

SSTableStructure:

• La cartella dati
  • KEYSPACE
    • CF
      • CompressionInfo.db
      • Data.db
      • Filter.db
      • Index.db
      • Statistics.db
      • istantanee // se vengono prese istantanee

Per ulteriori informazioni, consultare sstable