Kudu design tablet

1.  Logical composition

tablet

tablet yes kudu A horizontal partition of the table , Be similar to Hbase Of region Concept .

Every tablet Records that contain a continuous range of primary keys , Different tablet There will be no overlap in the key range of

, All of a watch tablet It forms the complete key space of this table , make the best of kudu Partition function of , It can effectively avoid data hotspot problems .

RowSet

Every tablet By a number of RowSet constitute , One RowSet It consists of a set of row data , For a given key That line of records , Will only appear in one RowSet Inside (MenRowSet or DiskRowSet). however RowSet The bond space of is not continuous ,

So different RowSet The key space range of will overlap , But the key will not repeat .

mutation

Insertion of data 、 modify 、 Delete unified name mutation

MemRowSet

MemRowSet Is a memory sorted by primary key B-tree( A row of data corresponds to this B-tree One of the entry, That is, a MRSRow example ), When inserting data, you will first enter MemRowSet, Then the data is visible to the query , In order to maintain the consistency of snapshots ( It can be understood that when reading and writing a row of data concurrently , You can read your own correct snapshot data ), Then all modifications to each row of data are required ( be called mutation) All need to be preserved , To form a mutation Linked list , As the of the line redo log. When the memory is full ,MemRowSet Will brush into the disk to form DiskRowSet, Then create a new MemRowSet.

DiskRowSet

MemRowSet Brush to save to form DiskRowSet, and

DiskRowSet Really stored as a series of cfile

; Every DiskRowSet Each line of records in the will correspond to a "rowid" （DiskRowSet It's kind of like an array ,"rowid" Corresponds to an array subscript and is not visible to the user ）,"rowid" There will be a mapping relationship with the primary key ：

• When the primary key is a single column primary key ,"rowid" In fact, it is built into the storage of primary key columns cfile in , The primary key is stored by sorting , Therefore, each primary key corresponds to one by default "rowid", Get through the primary key "rowid", Then from other cfile Quickly locate other columns , This is what we call
  primary key
  .

• 

• When the primary key is a composite primary key , There will be a separate index file (index cfile) Save the encoded composite primary key , In this way, you can provide the same functions as a single primary key .

• 

A row of data is stored in different columns cfile, When reading a row of complete records , Although you need to scan multiple cfile, But it has the same rowid, So you can still get the data of each column quickly .

Logically , Every DiskRowSet It consists of three parts , Namely ：

Base data

MemRowSet The columnar data formed after brushing to the disk

UNDO records

It can be done to base data Roll back to MemRowSet History before brushing the disk

REDO records

After the data is refreshed to disk , Yes Base data What we did mutation aggregate  , It is applied to read the data of the updated version

After that Base data and REDO delta On going Major compation Will create a new Base data And the new UNDO records

DeltaMemStore

Is a memory concurrency BTree, The key of the node is rowid And mutation Timestamp combination , When reading , And MemRowSet Medium mutation The processing logic is the same . When DeltaMemStore The size will be brushed to the disk to form DeltaFile, Then reset yourself to empty .

DeltaFile

UNDO records  and  REDO records  Stored in the same file format , called DeltaFile, It contains a series of mutation data .

2.  Reading and writing process

2.1  The data is in MemRowSet Reading and writing in

The first time the data is inserted, it will fall into MemRowSet, Subsequent updates 、 Delete 、 After deleting and reinserting these operations, a linked list will put these in chronological order mutations Save up , The logic is as follows ：

Every mutation Will be marked with a timestamp , Used for MVCC The main basis of , When in tx Submit a query when ,

• If tx<tx1, Express tx1 It hasn't been submitted yet , This row of data will be skipped

• Otherwise, it will tx1 Row data at copy To scanner The buffer , Then traverse mutation Linked list , Find all timestamps less than tx( Indicates that it occurs before the query ) Of mutation And buffer Merge the row data in .

If the single line is updated too often , Then insert at the end of the linked list every time mutation It's all one O(n) operation ; In addition, when reading data, you need to traverse the connection , This will also cause many cpu Cache loss .

2.2  The data is in DiskRowSet Reading and writing in

2.2.1  The update process ：

After the data is refreshed to the disk, the modification and deletion operations will not proceed MemRowSet, Instead, perform the following steps ：

• According to the primary key, combined with metadata and bloom filter, quickly locate the row record DiskRowSet

• Find the primary key index (index cfile) To determine the line rowid

• then mutation Will enter DeltaMemStore, then DeltaMemStore Will brush the disk to form DeltaFile, therefore DeltaMemStore and DeltaFile The contents are the same , But the latter is more compact after serialization , these DeltaFile Be called REDO files, And inside mutations It's called REDO records

HBase The method of non in situ update is adopted in , Convert the update operation and delete operation into the form of inserting a new piece of data , Although this can quickly update and delete , However, it will cause the specified conditions to be met rowkey, Column family 、 The column name requires more than one data , And may be distributed in different storefile in .

2.2.2  Reading process ：

• When you want to MemRowSet When reading the latest version of data immediately after refresh , Just scan Base data that will do

• If you want to backtrack the history , Then read it first base data, Then according to the timestamp of the current scanner, a series of UNDO records And base data Merge and restore the state of history .

• 

• After a period of data falling off the disk , The data may have changed , So there will be DeltaFiles, The scanning at this time is in addition to reading base data outside , Also need to REDO records Merge to get a new version of data

• 

3. RowSet Internal Delta compaction

DeltaMemStore Every time flush Will generate new delta file, Each scan requires delta File with the base data A merger , The reading performance will be worse and worse , therefore kudu There will be background tasks , Responsible for RowSet The inefficient physical storage layout is converted to a more efficient layout , This process is called “delta compactions”, There are mainly two types

3.1 Minor REDO delta compaction

Don't involve base data, Mainly to reduce delta Number of documents

3.2 Major REDO delta compaction

In addition to reducing delta In addition to the number of documents , You can also REDO records To UNDO records, because major Need to read and rewrite base data, and base data General than delta data Much more , therefore major The task is more than minor Tasks consume more performance .

Because of two kinds of compaction It all happened in RowSet Inside , and RowSet Inside the maintenance rowid, So it can run in the background completely independently , It doesn't need to be right compaction Lock the target data ,compaction After that, the result is exchanged with the input data , And then compaction Delete the previous file

4. RowSet Between Merging compactions

With tablet The data of ,DiskRowSet It will gradually accumulate , It will have performance impact on the following situations ：

• Random access ( Or update according to the primary key ), because RowSet The key ranges of may overlap , So you need to query all RowSet Key range to determine what the specified key may exist RowSet, adopt bloom filter Can effectively filter some RowSet And reduce physical scanning , But the extra pair bloom filter Access to will also increase memory and cpu Consumption of

• Range scan , In this case , With overlapping key ranges RowSet All need to be scanned ,bloom filter It cannot be filtered as effectively as random access .

• Sort scan , From each RowSet After scanning the target data , You need to RowSet The scanning results are summarized, merged and sorted ,RowSet The more , This process will consume more performance .

•