NoSQL डेटाबेस में शामिल हों

इस पोस्ट में चर्चा की जाएगी कि कैसे NoSQL डेटाबेस में संग्रह कनेक्ट करना है mongodb, arangodb, Oridb और rethinkdb (NoSQL डेटाबेस होने के अलावा, वे एक नि: शुल्क संस्करण के साथ एक काफी वफादार लाइसेंस के साथ एकजुट होते हैं)। संबंधपरक डेटाबेस में, SQL JOIN का उपयोग करके समान कार्यक्षमता लागू की जाती है। इस तथ्य के बावजूद कि NoSQL डेटाबेस में CRUD के संचालन बहुत समान हैं और केवल विवरणों में भिन्न हैं, उदाहरण के लिए, एक डेटाबेस में, एक वस्तु बनाने के लिए ({...}) फ़ंक्शन का उपयोग दूसरे में डालें, ({...}), और में तीसरा - सेव ({...}), - प्रत्येक डेटाबेस में दो या अधिक संग्रह के चयन को पूरी तरह से अलग-अलग तरीकों से लागू किया जाता है। इसलिए, सभी डेटाबेस पर एक ही चयन करना दिलचस्प होगा। सभी डेटाबेस के लिए, दो तालिकाओं के लिए नमूना (कई-से-कई संबंध) पर विचार किया जाएगा।

उदाहरण के लिए, तालिकाओं का उपयोग किया जाएगा।

लेखक

• पहला नाम

पुस्तक

• नाम

KnigiAvtorov

• लेखक
• पुस्तक

मोंगोडब के लिए, तालिकाओं से चयन इस तरह लागू किया जाएगा:

const mongo = require('mongodb-bluebird'); mongo.connect("mongodb://localhost:27017/test").then(async function(db) { const author = db.collection('author'); const book = db.collection('book'); const bookauthor = db.collection('bookauthor'); ['Joe', 'John', 'Jack', 'Jeremy'].map(async (name) => await author.insert({name}) ); ['Art', 'Paint'].map(async (title) => await book.insert({title}) ); let Author = await author.findOne({ name: 'Joe' }); let Book = await book.findOne({ title: 'Paint' }); await bookauthor.insert({author: Author._id, book: Book._id}) Author = await author.findOne({ name: 'John' }); await bookauthor.insert({author: Author._id, book: Book._id}) Book = await book.findOne({ title: 'Art' }); await bookauthor.insert({author: Author._id, book: Book._id}) const result = await author.aggregate([{ $lookup:{ from: 'bookauthor', localField: '_id', foreignField: 'author', as: 'ba' }}, { $lookup: { from: 'book', localField: 'ba.book', foreignField: '_id', as: 'books' }}],{ }) }); 

SQL JOIN चयन के विपरीत, परिणामी चयन एक समतल तालिका नहीं होगी, जिसमें लेखक द्वारा लिखी गई कई पुस्तकों को दोहराया जाएगा, लेकिन एक श्रेणीबद्ध वस्तु जिसमें प्रत्येक लेखक को एक वस्तु द्वारा दर्शाया जाएगा, जिसमें उन किताबों की संपत्ति होगी, जिनमें बुक ऑब्जेक्ट की एक सरणी होती है। । मेरे दृष्टिकोण से, यह NoSQL डेटाबेस में एक बहुत बड़ा प्लस है। लेकिन आपको SQL JOIN के समान "फ्लैट" संस्करण की भी आवश्यकता हो सकती है। अनुरोध में इसे प्राप्त करने के लिए, आपको सरणियों के "विस्तार" को जोड़ने की आवश्यकता है: { $unwind: '$books' } ।

उदाहरण में प्रस्तुत नमूना SQL LEFT JOIN का एक एनालॉग है, अर्थात, सभी लेखकों को नमूने में शामिल किया जाएगा, भले ही उनके पास किताबें न हों। SQL [INNER] JOIN का एनालॉग बनाने के लिए, आपको शर्त { $match: { books: { $ne: [ ] } } } , या यदि $ खोल का उपयोग किया गया हो तो जोड़ना होगा:

 { $unwind: { path: "$role", preserveNullAndEmptyArrays: false } } 

तो, चलो आरंगोडब पर चलते हैं, जो एक हाइब्रिड डेटाबेस है। दस्तावेजों के साथ काम करने के अलावा, यह ग्राफ़ के साथ काम करता है। सबसे पहले, आइए देखें कि कैसे आरंगोडब में आप केवल दस्तावेजों का उपयोग करके चयन कर सकते हैं (रेखांकन नहीं):

  FOR a IN author FOR ba IN bookauthor FILTER a._id == ba.author FOR b IN book FILTER b._id == ba.book SORT a.name, b.title RETURN { author: a, book: b } 

आरंगोडब संग्रह में शामिल होने के लिए कीवर्ड का उपयोग करता है, और सम्मिलित स्थिति को निर्दिष्ट करने के लिए फ़िल्टर करता है। इस मामले में प्राप्त नमूना SQL [INNER] JOIN के समान होगा (अर्थात, यह एक "फ्लैट" ऑब्जेक्ट होगा और इसमें खाली मान नहीं होंगे)

लेकिन कई वस्तुओं से चयन के लिए ग्राफ सुविधाओं का उपयोग करना बहुत अधिक सुविधाजनक है आरंगोडब में:

 const { Database, aql } = require('arangojs'); const db = new Database({ url: "http://localhost:8529" }); db.useDatabase("test"); db.useBasicAuth("test", "test"); const author = db.collection('author') const book = db.collection('book') const bookauthor = db.edgeCollection('bookauthor') void async function() { ['Joe', 'John', 'Jack', 'Jeremy'].map(async (name) => await author.save({name}) ); ['Art', 'Paint'].map(async (title) => await book.save({title}) ); let Author = await author.firstExample({ name: 'Joe' }); let Book = await book.firstExample({ title: 'Paint' }); await bookauthor.save({date: 'Some data'}, Author._id, Book._id) Author = await author.firstExample({ name: 'John' }); await bookauthor.save({date: 'Some data'}, Author._id, Book._id) Book = await book.firstExample({ title: 'Art' }); await bookauthor.save({date: 'Some data'}, Author._id, Book._id) const cursor = await db.query(aql` FOR a IN author FOR book_vertex, book_edge IN OUTBOUND a bookauthor COLLECT a1 = a INTO b1 RETURN {author: a1, books: b1[*].book_vertex} `); }(); 

अब हम संचार के लिए दस्तावेज़ का उपयोग नहीं कर रहे हैं, लेकिन बुकथोर के ग्राफ (किनारे) के किनारों का एक संग्रह है। IN OUTBOUND a bookauthor किसी दिए गए लेखक के लिए संबंधित दस्तावेजों का a संग्रह का चयन करता है, जिसे वह नाम book_vertex तहत प्रतिक्रिया में book_vertex । COLLECT a1 = a INTO b1 स्टेटमेंट COLLECT a1 = a INTO b1 SQL ग्रुप का एक एनालॉग है - यह एक एरे में एक मान जमा करता है जो ऑथर प्रत्येक मान के लिए b1 नाम के तहत प्रतिक्रिया में उपलब्ध होगा, जो कि प्रतिक्रिया में a1 के नाम से उपलब्ध होगा। निर्माण b1[*].book_vertex ऑब्जेक्ट से घोंसले के अनावश्यक स्तर को हटाने की अनुमति देता है ताकि परिणाम आगे के काम के लिए सुविधाजनक हो।

Arangodb में SQL LEFT JOIN टाइप क्वेरीज़ को लागू करना अधिक कठिन है क्योंकि के लिए - फ़िल्टर कथन SQL [INNER] JOIN के समान प्रतिबंध लगाता है। "बाएं कनेक्शन" को लागू करने के लिए, LET ऑपेररेटर और सबक्वेरी का उपयोग किया जाता है:

  const cursor = await db.query(aql` FOR a IN author LET books = ( FOR book_vertex, book_edge IN OUTBOUND a bookauthor RETURN book_vertex ) RETURN {author: a, books} `); 

इस मामले में, डेटा ग्रुपिंग की आवश्यकता नहीं है प्रत्येक लेखक के लिए एक उपश्रेणी की जाती है और प्रतिक्रिया में पहले से ही बुक ऑब्जेक्ट की एक गॉथिक सरणी होती है।

Oridb डेटाबेस पर जाएं। यह एक हाइब्रिड डेटाबेस भी है जो आपको दस्तावेज़ और ग्राफ़ दोनों के साथ काम करने की अनुमति देता है। ग्राफ के साथ काम करने की विचारधारा आरंगोडब में पिछले उदाहरण के समान है। यही है, संग्रह को जोड़ने के लिए, बुकथोर ग्राफ के किनारों के संग्रह का उपयोग किया जाता है।

 const OrientDB = require('orientjs'); const server = OrientDB({ host: 'localhost', port: 2424, }); void async function() { const db = server.use({ name:'test', username: 'test', password: 'test' }); await db.open(); try { await db.class.drop('Author UNSAFE'); } catch(ex) { console.log(ex) } try { await db.class.drop('Book UNSAFE'); } catch(ex) { console.log(ex) } try { await db.class.drop('BookAuthor UNSAFE'); } catch(ex) { console.log(ex) } const author = await db.class.create('Author', 'V'); const book = await db.class.create('Book', 'V'); const bookauthor = await db.class.create('BookAuthor', 'E'); ['Joe', 'John', 'Jack', 'Jeremy'].map(async (name) => await author.create({name}) ); ['Art', 'Paint'].map(async (title) => await book.create({title}) ); await author.list(); await book.list(); let Author = await db.select().from('Author').where({name: 'Joe'}).one(); let Book = await db.select().from('book').where({ title: 'Paint' }).one(); await db.create('EDGE', 'BookAuthor').from(Author['@rid']).to(Book['@rid']).set({date: 'Some data'}).one(); Author = await db.select().from('Author').where({name: 'John'}).one(); await db.create('EDGE', 'BookAuthor').from(Author['@rid']).to(Book['@rid']).set({date: 'Some data'}).one(); Book = await db.select().from('book').where({ title: 'Art' }).one(); await db.create('EDGE', 'BookAuthor').from(Author['@rid']).to(Book['@rid']).set({date: 'Some data'}).one(); const cursor = await db.query(`select name, out('BookAuthor').title as books from Author`).all() } () 

शायद ओरिएडब के पास सबसे सफल कार्यान्वयन है, जैसा कि यह SQL सिंटैक्स के सबसे करीब है और ग्राफ़ के साथ काम करने के मामले में संक्षिप्त है। एक्सप्रेशन out('BookAuthor').title as books from Author अर्थ ऑथर संग्रह के लिए चयन करना है जो बुकऑउथोर संग्रह से सभी आउटगोइंग किनारों को जोड़ता है जो लेखक संग्रह को पुस्तक संग्रह से जोड़ता है। इस मामले में, परिणामी वस्तु पदानुक्रमिक होगी (प्रत्येक लेखक के लिए एक वस्तु जो बुक ऑब्जेक्ट की एक सरणी के साथ है)। यदि आपको किसी समतल वस्तु में सरणी को "विस्तारित" करने की आवश्यकता है, तो UNWIND ऑपरेटर का उपयोग किया जाता है।

और अंत में, पुनर्विचार पर विचार करें। इतना समय पहले नहीं, इस डेटाबेस को विकसित करने वाली टीम मौजूद नहीं थी और विकास को खुले समुदाय में स्थानांतरित कर दिया। मैं इसे तुरंत कहता हूं, क्योंकि किसी ने इस खबर को छोड़ दिया होगा। एक अधिक विस्तृत परिचित से पहले, यह मुझे लगता है कि सबसे सुविधाजनक rethinkdb में JOIN का कार्यान्वयन था। शायद इसलिए कि इस तरह के अवसर को डेटाबेस एपीआई में तुरंत शामिल किया गया था, और यहां तक ​​कि जुड़ने () को भी कहा जाता है। लेकिन फिर यह पता चला कि सब कुछ इतना रसपूर्ण नहीं है, और सभी कार्यों में जो समान रूप से कुशलता से काम करते हैं और सही प्रश्नों के निर्माण के लिए पर्याप्त लचीलापन रखते हैं। हमारा वही एंड-टू-एंड उदाहरण अब पुनर्विचार पर लागू किया गया है:

 r = require('rethinkdb') void async function() { const conn = await r.connect({ host: 'localhost', port: 28015 }); try { await r.db('test').tableDrop('author').run(conn); await r.db('test').tableDrop('book').run(conn); await r.db('test').tableDrop('bookauthor').run(conn); } catch (ex) { console.log(ex) } await r.db('test').tableCreate('author').run(conn); await r.db('test').tableCreate('book').run(conn); await r.db('test').tableCreate('bookauthor').run(conn); await r.db('test').table('bookauthor').indexCreate('author').run(conn); await r.db('test').table('bookauthor').indexCreate('book').run(conn); await r.db('test').table('bookauthor').indexWait('author', 'book').run(conn); ['Joe', 'John', 'Jack', 'Jeremy'].map(async (name) => await r.db('test').table('author').insert({ name }).run(conn) ); ['Art', 'Paint'].map(async (title) => await r.db('test').table('book').insert({ title }).run(conn) ); let Author = await r.db('test').table('author').filter({ name: 'Joe' }).run(conn).then(authors => authors.next()); let Book = await r.db('test').table('book').filter({ title: 'Paint' }).run(conn).then(books => books.next()); await r.db('test').table('bookauthor').insert({author: Author.id, book: Book.id}).run(conn); Author = await r.db('test').table('author').filter({ name: 'John' }).run(conn).then(authors => authors.next()); await r.db('test').table('bookauthor').insert({author: Author.id, book: Book.id}).run(conn); Book = await r.db('test').table('book').filter({ title: 'Art' }).run(conn).then(books => books.next()); await r.db('test').table('bookauthor').insert({author: Author.id, book: Book.id}).run(conn); const cursor = await r.db('test').table('author') .eqJoin('id', r.db('test').table('bookauthor'), {index: 'author'}).zip() .eqJoin('book', r.db('test').table('book')).zip().run(conn); }(); 

आपको ऐसे बिंदुओं पर ध्यान देना चाहिए। इस उदाहरण में, eJJoin () फ़ंक्शन का उपयोग करके माध्यमिक सूचकांक संचार को लागू किया गया था, जो वस्तुओं को जोड़ने पर जोड़े का उपयोग कर सकता है: प्राथमिक कुंजी के साथ प्राथमिक कुंजी या माध्यमिक कुंजी के साथ प्राथमिक कुंजी (लेकिन माध्यमिक कुंजी के साथ माध्यमिक कुंजी नहीं)। अधिक जटिल परिस्थितियों के लिए, मानचित्र () फ़ंक्शन का उपयोग किया जाता है, जो समझने में अधिक कठिन परिमाण का एक आदेश है। जोइन को लागू करने वाले अन्य कार्यों को अनुकूलित नहीं किया जाता है (संभवतः, मूल्यों की एक पूरी गणना लागू की गई है)।

उदाहरणों का पाठ भंडार में स्थित है ।

apapacy@gmail.com
4 जून, 2018