कैसंड्रा 3.0 अपडेटेड एसएसटीबल प्रारूप

Question

this अंक के अनुसार, कैसंड्रा का स्टोरेज प्रारूप 3.0 में अपडेट किया गया था।

पहले मैं कैसेंड्रा-CLI इस्तेमाल कर सकते हैं, तो देखने के लिए कैसे SSTable बनाया गया है, कुछ इस तरह प्राप्त करने के लिए:

[default@test] list phonelists; 
------------------- 
RowKey: scott 
=> (column=, value=, timestamp=1374684062860000) 
=> (column=phonenumbers:bill, value='555-7382', timestamp=1374684062860000) 
=> (column=phonenumbers:jane, value='555-8743', timestamp=1374684062860000) 
=> (column=phonenumbers:patricia, value='555-4326', timestamp=1374684062860000) 
------------------- 
RowKey: john 
=> (column=, value=, timestamp=1374683971220000) 
=> (column=phonenumbers:doug, value='555-1579', timestamp=1374683971220000) 
=> (column=phonenumbers:patricia, value='555-4326', timestamp=137468397122 

क्या होगा कैसेंड्रा के नवीनतम संस्करण में की तरह आंतरिक औपचारिक देखो? क्या आप एक उदाहरण प्रदान कर सकते हैं?

ऊपर सूचीबद्ध तरीके से कैसंड्रा में तालिका के आंतरिक प्रतिनिधित्व को देखने के लिए मैं किस उपयोगिता का उपयोग कर सकता हूं, लेकिन एक नए एसएसटीबल प्रारूप के साथ?

जो कुछ मैंने इंटरनेट पर पाया है वह यह है कि विभाजन शीर्षलेख कॉलम नामों को कैसे संग्रहीत करता है, पंक्ति भंडार मूल्यों को संग्रहीत करता है और कोई डुप्लिकेट मान नहीं है।

मैं इसे कैसे देख सकता हूं?

Answer 1

3.0 sstable2json से पहले एसएसटीबल्स में डेटा कैसे व्यवस्थित किया जाता है, इसकी समझ के लिए उपयोगी उपयोगिता थी। यह सुविधा वर्तमान में कैसंड्रा 3.0 में मौजूद नहीं है, लेकिन अंत में एक विकल्प होगा। तब तक खुद और क्रिस लोहफिंक ने कैसंड्रा 3.0 के लिए sstable2json (sstable-tools) का विकल्प विकसित किया है जिसका उपयोग आप समझने के लिए कर सकते हैं कि डेटा कैसे व्यवस्थित किया जाता है। इसे CASSANDRA-7464 में उचित रूप से कैसंद्रा में लाने के बारे में कुछ बात है।

कैसेंड्रा और कैसेंड्रा 3.0 के पुराने संस्करणों के बीच भंडारण प्रारूप के बीच एक प्रमुख से अलग अब है कि एक SSTable पहले से था विभाजन का प्रतिनिधित्व और उनकी कोशिकाओं (उनके क्लस्टरिंग और स्तंभ नाम से पहचान) है कैसेंड्रा 3.0 एक SSTable साथ जबकि विभाजन और उनकी पंक्तियों का प्रतिनिधित्व करता है।

आप इन परिवर्तनों को जो एक महान काम विस्तार से समझा करता है के प्राथमिक डेवलपर द्वारा इस blog post पर जाकर और अधिक विस्तार में इन परिवर्तनों के बारे में पढ़ा सकते हैं।

सबसे बड़ा लाभ आप देखेंगे कि सामान्य स्थिति में आपका डेटा आकार घट जाएगा (कुछ मामलों में एक बड़े कारक द्वारा), क्योंकि सीक्यूएल द्वारा पेश किए गए ओवरहेड को कुछ महत्वपूर्ण संवर्द्धन से हटा दिया गया है।

create keyspace demo with replication = {'class': 'SimpleStrategy', 'replication_factor': 1}; 
use demo; 
create table phonelists (user text, person text, phonenumbers text, primary key (user, person)); 
insert into phonelists (user, person, phonenumbers) values ('scott', 'bill', '555-7382'); 
insert into phonelists (user, person, phonenumbers) values ('scott', 'jane', '555-8743'); 
insert into phonelists (user, person, phonenumbers) values ('scott', 'patricia', '555-4326'); 
insert into phonelists (user, person, phonenumbers) values ('john', 'doug', '555-1579'); 
insert into phonelists (user, person, phonenumbers) values ('john', 'patricia', '555-4326'); 

sstable2json सी * 2.2 उत्पादन:

[ 
{"key": "scott", 
"cells": [["bill:","",1451767903101827], 
      ["bill:phonenumbers","555-7382",1451767903101827], 
      ["jane:","",1451767911293116], 
      ["jane:phonenumbers","555-8743",1451767911293116], 
      ["patricia:","",1451767920541450], 
      ["patricia:phonenumbers","555-4326",1451767920541450]]}, 
{"key": "john", 
"cells": [["doug:","",1451767936220932], 
      ["doug:phonenumbers","555-1579",1451767936220932], 
      ["patricia:","",1451767945748889], 
      ["patricia:phonenumbers","555-4326",1451767945748889]]} 
] 

sstable उपकरण toJson सी * 3.0

यहाँ सी * 2 और 3

स्कीमा के बीच का अंतर दिखा एक उदाहरण है आउटपुट:

[ 
    { 
    "partition" : { 
     "key" : [ "scott" ] 
    }, 
    "rows" : [ 
     { 
     "type" : "row", 
     "clustering" : [ "bill" ], 
     "liveness_info" : { "tstamp" : 1451768259775428 }, 
     "cells" : [ 
      { "name" : "phonenumbers", "value" : "555-7382" } 
     ] 
     }, 
     { 
     "type" : "row", 
     "clustering" : [ "jane" ], 
     "liveness_info" : { "tstamp" : 1451768259793653 }, 
     "cells" : [ 
      { "name" : "phonenumbers", "value" : "555-8743" } 
     ] 
     }, 
     { 
     "type" : "row", 
     "clustering" : [ "patricia" ], 
     "liveness_info" : { "tstamp" : 1451768259796202 }, 
     "cells" : [ 
      { "name" : "phonenumbers", "value" : "555-4326" } 
     ] 
     } 
    ] 
    }, 
    { 
    "partition" : { 
     "key" : [ "john" ] 
    }, 
    "rows" : [ 
     { 
     "type" : "row", 
     "clustering" : [ "doug" ], 
     "liveness_info" : { "tstamp" : 1451768259798802 }, 
     "cells" : [ 
      { "name" : "phonenumbers", "value" : "555-1579" } 
     ] 
     }, 
     { 
     "type" : "row", 
     "clustering" : [ "patricia" ], 
     "liveness_info" : { "tstamp" : 1451768259908016 }, 
     "cells" : [ 
      { "name" : "phonenumbers", "value" : "555-4326" } 
     ] 
     } 
    ] 
    } 
] 

जबकि आउटपुट बड़ा है (यह टूल के परिणामस्वरूप अधिक है)। महत्वपूर्ण अंतर जो आप देख सकते हैं वे हैं:

1. डेटा अब विभाजन और उनके कक्षों के संग्रह के बजाय विभाजन और उनकी पंक्तियों (जिसमें कक्ष शामिल हैं) का संग्रह है।
2. टाइमस्टैम्प अब सेल स्तर पर पंक्ति स्तर (liveness_info) पर हैं।यदि कुछ पंक्ति कोशिकाएं अपने टाइमस्टैम्प में अंतर करती हैं, तो नया स्टोरेज इंजन स्पेस को बचाने और सेल स्तर पर अंतर को जोड़ने के लिए डेल्टा एन्कोडिंग करता है। इसमें टीटीएल भी शामिल है। जैसा कि आप कल्पना कर सकते हैं कि यदि आपके पास बहुत सारे गैर-कुंजी कॉलम हैं तो टाइमस्टैम्प को दोहराने की आवश्यकता नहीं है, इसलिए यह बहुत अधिक जगह बचाता है।
3. क्लस्टरिंग जानकारी (इस मामले में हम 'व्यक्ति' पर क्लस्टर हैं) अब सेल स्तर की बजाय पंक्ति स्तर पर मौजूद है, जो ओवरहेड का गुच्छा बचाता है क्योंकि क्लस्टरिंग कॉलम मानों को सेल पर नहीं होना चाहिए स्तर।

मैं नोट करना चाहिए कि इस विशिष्ट उदाहरण डेटा मामले में नया भंडारण इंजन के लाभ पूरी तरह से महसूस किया नहीं कर रहे हैं के बाद से वहाँ केवल 1 गैर क्लस्टरिंग स्तंभ।

यहां कई अन्य सुधार नहीं दिखाए गए हैं (जैसे पंक्ति-स्तर रेंज टॉम्बस्टोन स्टोर करने की क्षमता)।