উপযুক্ত পাথ খোঁজার সমস্যা সমাধানের জন্য JanusGraph গ্রাফ DBMS-এর প্রযোজ্যতা পরীক্ষা করা একটি পরীক্ষা

হাই সব. আমরা অফলাইন ট্রাফিক বিশ্লেষণের জন্য একটি পণ্য বিকাশ করছি। প্রজেক্টে বিভিন্ন অঞ্চলে পরিদর্শক রুটের পরিসংখ্যানগত বিশ্লেষণ সম্পর্কিত একটি কাজ রয়েছে।

এই কাজের অংশ হিসাবে, ব্যবহারকারীরা নিম্নলিখিত ধরণের সিস্টেম প্রশ্ন জিজ্ঞাসা করতে পারেন:

• কতজন দর্শক "A" এলাকা থেকে "B" এলাকায় চলে গেছে;
• কতজন দর্শনার্থী এলাকা "A" থেকে এলাকা "B" এলাকা "C" এবং তারপর "D" এলাকা দিয়ে গেছে;
• এলাকা "A" থেকে "B" এলাকায় যেতে একটি নির্দিষ্ট ধরনের দর্শকের কতক্ষণ সময় লাগে।

এবং অনুরূপ বিশ্লেষণাত্মক প্রশ্ন একটি সংখ্যা.

এলাকা জুড়ে দর্শকদের চলাচল একটি নির্দেশিত গ্রাফ। ইন্টারনেট পড়ার পরে, আমি আবিষ্কার করেছি যে গ্রাফ ডিবিএমএসগুলি বিশ্লেষণমূলক প্রতিবেদনের জন্যও ব্যবহৃত হয়। আমার দেখার ইচ্ছা ছিল কিভাবে গ্রাফ ডিবিএমএসগুলি এই ধরনের প্রশ্নের সাথে মোকাবিলা করবে (টি এল; ডিআর; দুর্বল).

আমি DBMS ব্যবহার করতে বেছে নিয়েছি জানুস গ্রাফ, গ্রাফ ওপেন-সোর্স DBMS-এর অসামান্য প্রতিনিধি হিসাবে, যা পরিপক্ক প্রযুক্তির স্ট্যাকের উপর নির্ভর করে, যা (আমার মতে) এটিকে শালীন অপারেশনাল বৈশিষ্ট্যগুলি প্রদান করা উচিত:

• BerkeleyDB স্টোরেজ ব্যাকএন্ড, Apache Cassandra, Scylla;
• জটিল সূচকগুলি লুসিন, ইলাস্টিকসার্চ, সোলারে সংরক্ষণ করা যেতে পারে।

JanusGraph এর লেখকরা লিখেছেন যে এটি OLTP এবং OLAP উভয়ের জন্যই উপযুক্ত।

আমি BerkeleyDB, Apache Cassandra, Scylla এবং ES এর সাথে কাজ করেছি এবং এই পণ্যগুলি প্রায়শই আমাদের সিস্টেমে ব্যবহৃত হয়, তাই আমি এই গ্রাফ DBMS পরীক্ষা করার বিষয়ে আশাবাদী ছিলাম। রকসডিবি-র উপর বার্কলেডিবি বেছে নেওয়া আমার কাছে অদ্ভুত মনে হয়েছে, তবে এটি সম্ভবত লেনদেনের প্রয়োজনীয়তার কারণে। যে কোনো ক্ষেত্রে, স্কেলযোগ্য, পণ্য ব্যবহারের জন্য, ক্যাসান্দ্রা বা সিলার উপর একটি ব্যাকএন্ড ব্যবহার করার পরামর্শ দেওয়া হয়।

আমি Neo4j বিবেচনা করিনি কারণ ক্লাস্টারিংয়ের জন্য একটি বাণিজ্যিক সংস্করণ প্রয়োজন, অর্থাৎ পণ্যটি ওপেন সোর্স নয়।

গ্রাফ ডিবিএমএস বলে: "যদি এটি একটি গ্রাফের মতো দেখায় তবে এটিকে একটি গ্রাফের মতো বিবেচনা করুন!" - সৌন্দর্য!

প্রথমে, আমি একটি গ্রাফ আঁকলাম, যা গ্রাফ ডিবিএমএস-এর ক্যানন অনুসারে তৈরি করা হয়েছিল:

একটা সারমর্ম আছে Zone, এলাকার জন্য দায়ী. যদি ZoneStep এই অন্তর্গত Zone, তারপর তিনি এটি উল্লেখ করেন. সারাংশ Area, ZoneTrack, Person মনোযোগ দেবেন না, তারা ডোমেনের অন্তর্গত এবং পরীক্ষার অংশ হিসাবে বিবেচিত হয় না। মোট, এই ধরনের একটি গ্রাফ কাঠামোর জন্য একটি চেইন অনুসন্ধান ক্যোয়ারী দেখতে হবে:

g.V().hasLabel('Zone').has('id',0).in_()
       .repeat(__.out()).until(__.out().hasLabel('Zone').has('id',19)).count().next()

রাশিয়ান ভাষায় যা এইরকম: ID=0 সহ একটি অঞ্চল খুঁজুন, যে সমস্ত শীর্ষবিন্দু থেকে একটি প্রান্ত এটিতে যায় সেগুলি নিন (জোনস্টেপ), যতক্ষণ না আপনি সেই জোনস্টেপগুলি খুঁজে না পান যেখান থেকে জোনের প্রান্ত রয়েছে ID=19, এই ধরনের চেইন সংখ্যা গণনা করুন।

আমি গ্রাফে অনুসন্ধানের সমস্ত জটিলতা জানার ভান করি না, তবে এই প্রশ্নটি এই বইটির উপর ভিত্তি করে তৈরি করা হয়েছিল (https://kelvinlawrence.net/book/Gremlin-Graph-Guide.html).

আমি BerkeleyDB ব্যাকএন্ড ব্যবহার করে একটি JanusGraph গ্রাফ ডাটাবেসে 50 থেকে 3 পয়েন্টের দৈর্ঘ্যের 20 হাজার ট্র্যাক লোড করেছি, অনুযায়ী সূচী তৈরি করেছি নেতৃত্ব.

পাইথন ডাউনলোড স্ক্রিপ্ট:

from random import random
from time import time

from init import g, graph

if __name__ == '__main__':

    points = []
    max_zones = 19
    zcache = dict()
    for i in range(0, max_zones + 1):
        zcache[i] = g.addV('Zone').property('id', i).next()

    startZ = zcache[0]
    endZ = zcache[max_zones]

    for i in range(0, 10000):

        if not i % 100:
            print(i)

        start = g.addV('ZoneStep').property('time', int(time())).next()
        g.V(start).addE('belongs').to(startZ).iterate()

        while True:
            pt = g.addV('ZoneStep').property('time', int(time())).next()
            end_chain = random()
            if end_chain < 0.3:
                g.V(pt).addE('belongs').to(endZ).iterate()
                g.V(start).addE('goes').to(pt).iterate()
                break
            else:
                zone_id = int(random() * max_zones)
                g.V(pt).addE('belongs').to(zcache[zone_id]).iterate()
                g.V(start).addE('goes').to(pt).iterate()

            start = pt

    count = g.V().count().next()
    print(count)

আমরা একটি SSD-তে 4 কোর এবং 16 GB RAM সহ একটি VM ব্যবহার করেছি। JanusGraph এই কমান্ড ব্যবহার করে স্থাপন করা হয়েছিল:

docker run --name janusgraph -p8182:8182 janusgraph/janusgraph:latest

এই ক্ষেত্রে, সঠিক মিল অনুসন্ধানের জন্য ব্যবহৃত ডেটা এবং সূচীগুলি বার্কলেডিবিতে সংরক্ষণ করা হয়। আগে দেওয়া অনুরোধটি কার্যকর করার পরে, আমি কয়েক দশ সেকেন্ডের সমান একটি সময় পেয়েছি।

উপরের ৪টি স্ক্রিপ্ট সমান্তরালভাবে চালানোর মাধ্যমে, আমি ডকার লগে জাভা স্ট্যাকট্রেসের (এবং আমরা সবাই জাভা স্ট্যাকট্রেস পড়তে পছন্দ করি) এর একটি প্রফুল্ল স্রোতে DBMS কে কুমড়াতে পরিণত করতে পেরেছি।

কিছু চিন্তা করার পরে, আমি গ্রাফ ডায়াগ্রামটিকে নিম্নলিখিতগুলিতে সরল করার সিদ্ধান্ত নিয়েছি:

সিদ্ধান্ত নেওয়া যে সত্তা বৈশিষ্ট্য দ্বারা অনুসন্ধান করা প্রান্ত দ্বারা অনুসন্ধানের চেয়ে দ্রুততর হবে৷ ফলস্বরূপ, আমার অনুরোধ নিম্নলিখিত পরিণত হয়েছে:

g.V().hasLabel('ZoneStep').has('id',0).repeat(__.out().simplePath()).until(__.hasLabel('ZoneStep').has('id',19)).count().next()

রাশিয়ান ভাষায় যা এইরকম: ID=0 দিয়ে ZoneStep খুঁজুন, যতক্ষণ না আপনি ID=19-এর সাথে ZoneStep খুঁজে না পান ততক্ষণ না ফিরে স্টম্প করুন, এই ধরনের চেইনের সংখ্যা গণনা করুন।

আমি উপরে প্রদত্ত লোডিং স্ক্রিপ্টটি সরলীকৃত করেছি যাতে অপ্রয়োজনীয় সংযোগ তৈরি না হয়, নিজেকে গুণাবলীতে সীমাবদ্ধ করে।

অনুরোধটি সম্পূর্ণ হতে এখনও কয়েক সেকেন্ড সময় লেগেছিল, যা আমাদের কাজের জন্য সম্পূর্ণরূপে অগ্রহণযোগ্য ছিল, যেহেতু এটি কোনো ধরনের AdHoc অনুরোধের উদ্দেশ্যে মোটেই উপযুক্ত ছিল না।

আমি দ্রুততম ক্যাসান্দ্রা বাস্তবায়ন হিসাবে Scylla ব্যবহার করে JanusGraph স্থাপন করার চেষ্টা করেছি, কিন্তু এটি কোন উল্লেখযোগ্য কর্মক্ষমতা পরিবর্তনের দিকে পরিচালিত করেনি।

তাই "এটি একটি গ্রাফের মতো দেখায়" সত্ত্বেও, আমি দ্রুত প্রক্রিয়া করার জন্য গ্রাফ DBMS পেতে পারিনি। আমি সম্পূর্ণরূপে অনুমান করি যে এমন কিছু আছে যা আমি জানি না এবং JanusGraph এই অনুসন্ধানটি এক সেকেন্ডের ভগ্নাংশে সম্পাদন করতে পারে, তবে, আমি এটি করতে সক্ষম ছিলাম না।

যেহেতু সমস্যাটি এখনও সমাধান করা দরকার, তাই আমি যোগদান এবং টেবিলের পিভট সম্পর্কে চিন্তা করতে শুরু করেছি, যা কমনীয়তার পরিপ্রেক্ষিতে আশাবাদকে অনুপ্রাণিত করে না, তবে অনুশীলনে একটি সম্পূর্ণ কার্যকর বিকল্প হতে পারে।

আমাদের প্রকল্প ইতিমধ্যে Apache ClickHouse ব্যবহার করে, তাই আমি এই বিশ্লেষণাত্মক DBMS-এ আমার গবেষণা পরীক্ষা করার সিদ্ধান্ত নিয়েছি।

একটি সাধারণ রেসিপি ব্যবহার করে ক্লিকহাউস স্থাপন করা হয়েছে:

sudo docker run -d --name clickhouse_1 
     --ulimit nofile=262144:262144 
     -v /opt/clickhouse/log:/var/log/clickhouse-server 
     -v /opt/clickhouse/data:/var/lib/clickhouse 
     yandex/clickhouse-server

আমি এটিতে একটি ডাটাবেস এবং একটি টেবিল তৈরি করেছি:

CREATE TABLE 
db.steps (`area` Int64, `when` DateTime64(1, 'Europe/Moscow') DEFAULT now64(), `zone` Int64, `person` Int64) 
ENGINE = MergeTree() ORDER BY (area, zone, person) SETTINGS index_granularity = 8192

আমি নিম্নলিখিত স্ক্রিপ্ট ব্যবহার করে ডেটা দিয়ে এটি পূরণ করেছি:

from time import time

from clickhouse_driver import Client
from random import random

client = Client('vm-12c2c34c-df68-4a98-b1e5-a4d1cef1acff.domain',
                database='db',
                password='secret')

max = 20

for r in range(0, 100000):

    if r % 1000 == 0:
        print("CNT: {}, TS: {}".format(r, time()))

    data = [{
            'area': 0,
            'zone': 0,
            'person': r
        }]

    while True:
        if random() < 0.3:
            break

        data.append({
                'area': 0,
                'zone': int(random() * (max - 2)) + 1,
                'person': r
            })

    data.append({
            'area': 0,
            'zone': max - 1,
            'person': r
        })

    client.execute(
        'INSERT INTO steps (area, zone, person) VALUES',
        data
    )

যেহেতু সন্নিবেশগুলি ব্যাচে আসে, তাই JanusGraph-এর তুলনায় ফিলিং অনেক দ্রুত ছিল৷

JOIN ব্যবহার করে দুটি প্রশ্ন তৈরি করেছে। বিন্দু A থেকে বি পয়েন্টে যেতে:

SELECT s1.person AS person,
       s1.zone,
       s1.when,
       s2.zone,
       s2.when
FROM
  (SELECT *
   FROM steps
   WHERE (area = 0)
     AND (zone = 0)) AS s1 ANY INNER JOIN
  (SELECT *
   FROM steps AS s2
   WHERE (area = 0)
     AND (zone = 19)) AS s2 USING person
WHERE s1.when <= s2.when

3 পয়েন্টের মধ্য দিয়ে যেতে:

SELECT s3.person,
       s1z,
       s1w,
       s2z,
       s2w,
       s3.zone,
       s3.when
FROM
  (SELECT s1.person AS person,
          s1.zone AS s1z,
          s1.when AS s1w,
          s2.zone AS s2z,
          s2.when AS s2w
   FROM
     (SELECT *
      FROM steps
      WHERE (area = 0)
        AND (zone = 0)) AS s1 ANY INNER JOIN
     (SELECT *
      FROM steps AS s2
      WHERE (area = 0)
        AND (zone = 3)) AS s2 USING person
   WHERE s1.when <= s2.when) p ANY INNER JOIN
  (SELECT *
   FROM steps
   WHERE (area = 0)
     AND (zone = 19)) AS s3 USING person
WHERE p.s2w <= s3.when

অনুরোধগুলি, অবশ্যই, বেশ ভীতিকর দেখাচ্ছে; বাস্তব ব্যবহারের জন্য, আপনাকে একটি সফ্টওয়্যার জেনারেটর জোতা তৈরি করতে হবে। যাইহোক, তারা কাজ করে এবং তারা দ্রুত কাজ করে। প্রথম এবং দ্বিতীয় উভয় অনুরোধই 0.1 সেকেন্ডের কম সময়ে সম্পন্ন হয়। গণনা (*) 3 পয়েন্টের মধ্য দিয়ে যাওয়ার জন্য ক্যোয়ারী এক্সিকিউশন সময়ের একটি উদাহরণ এখানে দেওয়া হল:

SELECT count(*)
FROM 
(
    SELECT 
        s1.person AS person, 
        s1.zone AS s1z, 
        s1.when AS s1w, 
        s2.zone AS s2z, 
        s2.when AS s2w
    FROM 
    (
        SELECT *
        FROM steps
        WHERE (area = 0) AND (zone = 0)
    ) AS s1
    ANY INNER JOIN 
    (
        SELECT *
        FROM steps AS s2
        WHERE (area = 0) AND (zone = 3)
    ) AS s2 USING (person)
    WHERE s1.when <= s2.when
) AS p
ANY INNER JOIN 
(
    SELECT *
    FROM steps
    WHERE (area = 0) AND (zone = 19)
) AS s3 USING (person)
WHERE p.s2w <= s3.when

┌─count()─┐
│   11592 │
└─────────┘

1 rows in set. Elapsed: 0.068 sec. Processed 250.03 thousand rows, 8.00 MB (3.69 million rows/s., 117.98 MB/s.)

IOPS সম্পর্কে একটি নোট. ডেটা পপুলেট করার সময়, JanusGraph একটি মোটামুটি উচ্চ সংখ্যক IOPS তৈরি করেছে (চারটি ডেটা জনসংখ্যা থ্রেডের জন্য 1000-1300) এবং IOWAIT বেশ বেশি ছিল। একই সময়ে, ক্লিক হাউস ডিস্ক সাবসিস্টেমে ন্যূনতম লোড তৈরি করেছে।

উপসংহার

আমরা এই ধরনের অনুরোধের জন্য ClickHouse ব্যবহার করার সিদ্ধান্ত নিয়েছি। ক্লিকহাউসে লোড করার আগে অ্যাপাচি ফ্লিঙ্ক ব্যবহার করে ইভেন্ট স্ট্রীমকে প্রাক-প্রসেসিং করে বস্তুগত দৃষ্টিভঙ্গি এবং সমান্তরালকরণ ব্যবহার করে আমরা সবসময় প্রশ্নগুলিকে আরও অপ্টিমাইজ করতে পারি।

পারফরম্যান্সটি এত ভাল যে আমাদের সম্ভবত প্রোগ্রামগতভাবে পিভোটিং টেবিলগুলি সম্পর্কে ভাবতে হবে না। পূর্বে, আমাদের Apache Parquet-এ আপলোডের মাধ্যমে ভার্টিকা থেকে পুনরুদ্ধার করা ডেটার পিভটগুলি করতে হয়েছিল।

দুর্ভাগ্যবশত, একটি গ্রাফ DBMS ব্যবহার করার আরেকটি প্রচেষ্টা ব্যর্থ হয়েছে। আমি JanusGraph-এর কাছে একটি বন্ধুত্বপূর্ণ ইকোসিস্টেম খুঁজে পাইনি যা পণ্যের সাথে দ্রুত গতিতে উঠতে সহজ করে তোলে। একই সময়ে, সার্ভার কনফিগার করার জন্য, ঐতিহ্যগত জাভা পদ্ধতি ব্যবহার করা হয়, যা জাভা-এর সাথে পরিচিত নয় এমন লোকেদের রক্তের অশ্রু কাঁদাবে:

host: 0.0.0.0
port: 8182
threadPoolWorker: 1
gremlinPool: 8
scriptEvaluationTimeout: 30000
channelizer: org.janusgraph.channelizers.JanusGraphWsAndHttpChannelizer

graphManager: org.janusgraph.graphdb.management.JanusGraphManager
graphs: {
  ConfigurationManagementGraph: conf/janusgraph-cql-configurationgraph.properties,
  airlines: conf/airlines.properties
}

scriptEngines: {
  gremlin-groovy: {
    plugins: { org.janusgraph.graphdb.tinkerpop.plugin.JanusGraphGremlinPlugin: {},
               org.apache.tinkerpop.gremlin.server.jsr223.GremlinServerGremlinPlugin: {},
               org.apache.tinkerpop.gremlin.tinkergraph.jsr223.TinkerGraphGremlinPlugin: {},
               org.apache.tinkerpop.gremlin.jsr223.ImportGremlinPlugin: {classImports: [java.lang.Math], methodImports: [java.lang.Math#*]},
               org.apache.tinkerpop.gremlin.jsr223.ScriptFileGremlinPlugin: {files: [scripts/airline-sample.groovy]}}}}

serializers:
# GraphBinary is here to replace Gryo and Graphson
  - { className: org.apache.tinkerpop.gremlin.driver.ser.GraphBinaryMessageSerializerV1, config: { ioRegistries: [org.janusgraph.graphdb.tinkerpop.JanusGraphIoRegistry] }}
  - { className: org.apache.tinkerpop.gremlin.driver.ser.GraphBinaryMessageSerializerV1, config: { serializeResultToString: true }}
  # Gryo and Graphson, latest versions
  - { className: org.apache.tinkerpop.gremlin.driver.ser.GryoMessageSerializerV3d0, config: { ioRegistries: [org.janusgraph.graphdb.tinkerpop.JanusGraphIoRegistry] }}
  - { className: org.apache.tinkerpop.gremlin.driver.ser.GryoMessageSerializerV3d0, config: { serializeResultToString: true }}
  - { className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV3d0, config: { ioRegistries: [org.janusgraph.graphdb.tinkerpop.JanusGraphIoRegistry] }}
  # Older serialization versions for backwards compatibility:
  - { className: org.apache.tinkerpop.gremlin.driver.ser.GryoMessageSerializerV1d0, config: { ioRegistries: [org.janusgraph.graphdb.tinkerpop.JanusGraphIoRegistry] }}
  - { className: org.apache.tinkerpop.gremlin.driver.ser.GryoMessageSerializerV1d0, config: { serializeResultToString: true }}
  - { className: org.apache.tinkerpop.gremlin.driver.ser.GryoLiteMessageSerializerV1d0, config: {ioRegistries: [org.janusgraph.graphdb.tinkerpop.JanusGraphIoRegistry] }}
  - { className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerGremlinV2d0, config: { ioRegistries: [org.janusgraph.graphdb.tinkerpop.JanusGraphIoRegistry] }}
  - { className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerGremlinV1d0, config: { ioRegistries: [org.janusgraph.graphdb.tinkerpop.JanusGraphIoRegistryV1d0] }}
  - { className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV1d0, config: { ioRegistries: [org.janusgraph.graphdb.tinkerpop.JanusGraphIoRegistryV1d0] }}

processors:
  - { className: org.apache.tinkerpop.gremlin.server.op.session.SessionOpProcessor, config: { sessionTimeout: 28800000 }}
  - { className: org.apache.tinkerpop.gremlin.server.op.traversal.TraversalOpProcessor, config: { cacheExpirationTime: 600000, cacheMaxSize: 1000 }}

metrics: {
  consoleReporter: {enabled: false, interval: 180000},
  csvReporter: {enabled: false, interval: 180000, fileName: /tmp/gremlin-server-metrics.csv},
  jmxReporter: {enabled: false},
  slf4jReporter: {enabled: true, interval: 180000},
  gangliaReporter: {enabled: false, interval: 180000, addressingMode: MULTICAST},
  graphiteReporter: {enabled: false, interval: 180000}}
threadPoolBoss: 1
maxInitialLineLength: 4096
maxHeaderSize: 8192
maxChunkSize: 8192
maxContentLength: 65536
maxAccumulationBufferComponents: 1024
resultIterationBatchSize: 64
writeBufferHighWaterMark: 32768
writeBufferHighWaterMark: 65536
ssl: {
  enabled: false}

আমি ঘটনাক্রমে JanusGraph এর BerkeleyDB সংস্করণটি "পুট" করতে পেরেছি।

ডকুমেন্টেশনটি সূচীগুলির ক্ষেত্রে বেশ কুটিল, যেহেতু সূচীগুলি পরিচালনা করার জন্য আপনাকে গ্রোভিতে কিছু অদ্ভুত শামানবাদ সম্পাদন করতে হবে। উদাহরণস্বরূপ, গ্রেমলিন কনসোলে কোড লিখে একটি সূচক তৈরি করতে হবে (যা, বাক্সের বাইরে কাজ করে না)। সরকারী JanusGraph ডকুমেন্টেশন থেকে:

graph.tx().rollback() //Never create new indexes while a transaction is active
mgmt = graph.openManagement()
name = mgmt.getPropertyKey('name')
age = mgmt.getPropertyKey('age')
mgmt.buildIndex('byNameComposite', Vertex.class).addKey(name).buildCompositeIndex()
mgmt.buildIndex('byNameAndAgeComposite', Vertex.class).addKey(name).addKey(age).buildCompositeIndex()
mgmt.commit()

//Wait for the index to become available
ManagementSystem.awaitGraphIndexStatus(graph, 'byNameComposite').call()
ManagementSystem.awaitGraphIndexStatus(graph, 'byNameAndAgeComposite').call()
//Reindex the existing data
mgmt = graph.openManagement()
mgmt.updateIndex(mgmt.getGraphIndex("byNameComposite"), SchemaAction.REINDEX).get()
mgmt.updateIndex(mgmt.getGraphIndex("byNameAndAgeComposite"), SchemaAction.REINDEX).get()
mgmt.commit()

উত্তরভাষ

এক অর্থে, উপরের পরীক্ষাটি উষ্ণ এবং নরমের মধ্যে একটি তুলনা। আপনি যদি এটি সম্পর্কে চিন্তা করেন, একটি গ্রাফ ডিবিএমএস একই ফলাফল পেতে অন্যান্য ক্রিয়াকলাপ সম্পাদন করে। যাইহোক, পরীক্ষার অংশ হিসাবে, আমি একটি অনুরোধের সাথে একটি পরীক্ষাও পরিচালনা করেছি যেমন:

g.V().hasLabel('ZoneStep').has('id',0)
    .repeat(__.out().simplePath()).until(__.hasLabel('ZoneStep').has('id',1)).count().next()

যা হাঁটার দূরত্ব প্রতিফলিত করে। যাইহোক, এমনকি এই ধরনের ডেটাতেও, গ্রাফ ডিবিএমএস এমন ফলাফল দেখিয়েছে যা কয়েক সেকেন্ডের বেশি চলে গেছে... এটি অবশ্যই এই কারণে যে সেখানে পথ ছিল 0 -> X -> Y ... -> 1, যা গ্রাফ ইঞ্জিনও পরীক্ষা করেছে।

এমনকি একটি প্রশ্নের জন্য যেমন:

g.V().hasLabel('ZoneStep').has('id',0).out().has('id',1)).count().next()

আমি এক সেকেন্ডেরও কম সময়ের প্রক্রিয়াকরণের সাথে একটি উত্পাদনশীল প্রতিক্রিয়া পেতে অক্ষম ছিলাম।

গল্পের নৈতিকতা হল যে একটি সুন্দর ধারণা এবং দৃষ্টান্তমূলক মডেলিং পছন্দসই ফলাফলের দিকে নিয়ে যায় না, যা ক্লিকহাউসের উদাহরণ ব্যবহার করে অনেক বেশি দক্ষতার সাথে প্রদর্শিত হয়। এই নিবন্ধে উপস্থাপিত ব্যবহারের ক্ষেত্রে গ্রাফ ডিবিএমএস-এর জন্য একটি স্পষ্ট বিরোধী প্যাটার্ন, যদিও এটি তাদের দৃষ্টান্তে মডেলিংয়ের জন্য উপযুক্ত বলে মনে হয়।

উত্স: www.habr.com