CouchGO! — Mempertingkatkan CouchDB dengan Pelayan Pertanyaan Ditulis dalam Go

Sejak sebulan lalu, saya telah secara aktif mengusahakan projek bukti konsep yang berkaitan dengan CouchDB, meneroka cirinya dan bersiap sedia untuk tugasan masa hadapan. Dalam tempoh ini, saya telah meneliti dokumentasi CouchDB beberapa kali untuk memastikan saya memahami cara semuanya berfungsi. Semasa membaca dokumentasi, saya menemui kenyataan bahawa walaupun CouchDB menghantar dengan Pelayan Pertanyaan lalai yang ditulis dalam JavaScript, mencipta pelaksanaan tersuai adalah agak mudah dan penyelesaian tersuai sudah wujud di alam liar.

Saya melakukan penyelidikan pantas dan menemui pelaksanaan yang ditulis dalam Python, Ruby atau Clojure. Memandangkan keseluruhan pelaksanaan nampaknya tidak terlalu lama, saya memutuskan untuk bereksperimen dengan CouchDB dengan cuba menulis Pelayan Pertanyaan tersuai saya sendiri. Untuk melakukan ini, saya memilih Pergi sebagai bahasa. Saya tidak mempunyai banyak pengalaman dengan bahasa ini sebelum ini, kecuali menggunakan templat Go dalam carta Helm, tetapi saya ingin mencuba sesuatu yang baharu dan berpendapat projek ini akan menjadi peluang yang baik untuknya.

Memahami Pelayan Pertanyaan

Sebelum memulakan kerja, saya menyemak semula dokumentasi CouchDB sekali lagi untuk memahami cara Pelayan Pertanyaan sebenarnya berfungsi. Menurut dokumentasi, gambaran keseluruhan peringkat tinggi Pelayan Pertanyaan agak mudah:

Pelayan Pertanyaan ialah proses luaran yang berkomunikasi dengan CouchDB melalui protokol JSON melalui antara muka stdio dan mengendalikan semua panggilan fungsi reka bentuk […].

Struktur arahan yang dihantar oleh CouchDB ke Pelayan Pertanyaan boleh dinyatakan sebagai [, <*argumen>] atau ["ddoc", , [, < funcname>], [, , …]] dalam kes dokumen reka bentuk.

Jadi pada asasnya, apa yang saya perlu lakukan ialah menulis aplikasi yang mampu menghuraikan JSON jenis ini daripada STDIO, melaksanakan operasi yang dijangkakan dan mengembalikan respons seperti yang dinyatakan dalam dokumentasi. Terdapat banyak jenis penghantaran yang terlibat untuk mengendalikan pelbagai perintah dalam kod Go. Butiran khusus tentang setiap arahan boleh didapati di bawah bahagian Protokol Pelayan Pertanyaan dalam dokumentasi.

Satu masalah yang saya hadapi di sini ialah Pelayan Pertanyaan seharusnya dapat mentafsir dan melaksanakan kod sewenang-wenangnya yang disediakan dalam dokumen reka bentuk. Mengetahui bahawa Go ialah bahasa yang disusun, saya menjangkakan akan terperangkap pada ketika ini. Syukurlah, saya segera menemui pakej Yeagi, yang mampu mentafsir kod Go dengan mudah. Ia membolehkan mencipta kotak pasir dan mengawal akses kepada pakej yang boleh diimport dalam kod yang ditafsirkan. Dalam kes saya, saya memutuskan untuk mendedahkan hanya pakej saya yang dipanggil couchgo, tetapi pakej standard lain juga boleh ditambah dengan mudah.

Memperkenalkan CouchGO!

Hasil kerja saya, aplikasi yang dipanggil CouchGO! muncul. Walaupun ia mengikut Protokol Pelayan Pertanyaan, ia bukanlah satu-sama-satu pelaksanaan semula versi JavaScript kerana ia mempunyai pendekatan tersendiri untuk mengendalikan fungsi dokumen reka bentuk.

Contohnya, dalam CouchGO!, tiada fungsi pembantu seperti emit. Untuk memancarkan nilai, anda hanya mengembalikannya daripada fungsi peta. Selain itu, setiap fungsi dalam dokumen reka bentuk mengikut corak yang sama: ia hanya mempunyai satu hujah, iaitu objek yang mengandungi sifat khusus fungsi, dan sepatutnya mengembalikan satu nilai sebagai hasilnya. Nilai ini tidak semestinya primitif; bergantung pada fungsi, ia mungkin objek, peta atau ralat.

Untuk mula bekerja dengan CouchGO!, anda hanya perlu memuat turun binari boleh laku daripada repositori GitHub saya, letakkannya di suatu tempat dalam contoh CouchDB dan tambah pembolehubah persekitaran yang membolehkan CouchDB memulakan CouchGO! proses.

Sebagai contoh, jika anda meletakkan couchgo boleh laku ke dalam direktori /opt/couchdb/bin, anda akan menambah pembolehubah persekitaran berikut untuk membolehkannya berfungsi.

export COUCHDB_QUERY_SERVER_GO="/opt/couchdb/bin/couchgo"

Fungsi Penulisan dengan CouchGO!

Untuk mendapatkan pemahaman pantas tentang cara menulis fungsi dengan CouchGO!, mari terokai antara muka fungsi berikut:

func Func(args couchgo.FuncInput) couchgo.FuncOutput { ... }

Setiap fungsi dalam CouchGO! akan mengikut corak ini, di mana Func digantikan dengan nama fungsi yang sesuai. Pada masa ini, CouchGO! menyokong jenis fungsi berikut:

• Peta
• Kurangkan
• Tapis
• Kemas kini
• Sahkan (validate_doc_update)

Mari kita periksa contoh dokumen reka bentuk yang menentukan paparan dengan peta dan mengurangkan fungsi, serta fungsi validate_doc_update. Selain itu, kami perlu menyatakan bahawa kami menggunakan Go sebagai bahasa.

{
  "_id": "_design/ddoc-go",
  "views": {
    "view": {
      "map": "func Map(args couchgo.MapInput) couchgo.MapOutput {\n\tout := couchgo.MapOutput{}\n\tout = append(out, [2]interface{}{args.Doc[\"_id\"], 1})\n\tout = append(out, [2]interface{}{args.Doc[\"_id\"], 2})\n\tout = append(out, [2]interface{}{args.Doc[\"_id\"], 3})\n\t\n\treturn out\n}",
      "reduce": "func Reduce(args couchgo.ReduceInput) couchgo.ReduceOutput {\n\tout := 0.0\n\n\tfor _, value := range args.Values {\n\t\tout += value.(float64)\n\t}\n\n\treturn out\n}"
    }
  },
  "validate_doc_update": "func Validate(args couchgo.ValidateInput) couchgo.ValidateOutput {\n\tif args.NewDoc[\"type\"] == \"post\" {\n\t\tif args.NewDoc[\"title\"] == nil || args.NewDoc[\"content\"] == nil {\n\t\t\treturn couchgo.ForbiddenError{Message: \"Title and content are required\"}\n\t\t}\n\n\t\treturn nil\n\t}\n\n\tif args.NewDoc[\"type\"] == \"comment\" {\n\t\tif args.NewDoc[\"post\"] == nil || args.NewDoc[\"author\"] == nil || args.NewDoc[\"content\"] == nil {\n\t\t\treturn couchgo.ForbiddenError{Message: \"Post, author, and content are required\"}\n\t\t}\n\n\t\treturn nil\n\t}\n\n\tif args.NewDoc[\"type\"] == \"user\" {\n\t\tif args.NewDoc[\"username\"] == nil || args.NewDoc[\"email\"] == nil {\n\t\t\treturn couchgo.ForbiddenError{Message: \"Username and email are required\"}\n\t\t}\n\n\t\treturn nil\n\t}\n\n\treturn couchgo.ForbiddenError{Message: \"Invalid document type\"}\n}",
  "language": "go"
}

Sekarang, mari pecahkan setiap fungsi bermula dengan fungsi peta:

func Map(args couchgo.MapInput) couchgo.MapOutput {
  out := couchgo.MapOutput{}
  out = append(out, [2]interface{}{args.Doc["_id"], 1})
  out = append(out, [2]interface{}{args.Doc["_id"], 2})
  out = append(out, [2]interface{}{args.Doc["_id"], 3})

  return out
}

In CouchGO!, there is no emit function; instead, you return a slice of key-value tuples where both key and value can be of any type. The document object isn't directly passed to the function as in JavaScript; rather, it's wrapped in an object. The document itself is simply a hashmap of various values.

Next, let’s examine the reduce function:

func Reduce(args couchgo.ReduceInput) couchgo.ReduceOutput {
  out := 0.0
  for _, value := range args.Values {
    out += value.(float64)
  }
  return out
}

Similar to JavaScript, the reduce function in CouchGO! takes keys, values, and a rereduce parameter, all wrapped into a single object. This function should return a single value of any type that represents the result of the reduction operation.

Finally, let’s look at the Validate function, which corresponds to the validate_doc_update property:

func Validate(args couchgo.ValidateInput) couchgo.ValidateOutput {
  if args.NewDoc["type"] == "post" {
    if args.NewDoc["title"] == nil || args.NewDoc["content"] == nil {
      return couchgo.ForbiddenError{Message: "Title and content are required"}
    }

    return nil
  }

  if args.NewDoc["type"] == "comment" {
    if args.NewDoc["post"] == nil || args.NewDoc["author"] == nil || args.NewDoc["content"] == nil {
      return couchgo.ForbiddenError{Message: "Post, author, and content are required"}
    }

    return nil
  }

  return nil
}

In this function, we receive parameters such as the new document, old document, user context, and security object, all wrapped into one object passed as a function argument. Here, we’re expected to validate if the document can be updated and return an error if not. Similar to the JavaScript version, we can return two types of errors: ForbiddenError or UnauthorizedError. If the document can be updated, we should return nil.

For more detailed examples, they can be found in my GitHub repository. One important thing to note is that the function names are not arbitrary; they should always match the type of function they represent, such as Map, Reduce, Filter, etc.

CouchGO! Performance

Even though writing my own Query Server was a really fun experience, it wouldn’t make much sense if I didn’t compare it with existing solutions. So, I prepared a few simple tests in a Docker container to check how much faster CouchGO! can:

• Index 100k documents (indexing in CouchDB means executing map functions from views)
• Execute reduce function for 100k documents
• Filter change feed for 100k documents
• Perform update function for 1k requests

I seeded the database with the expected number of documents and measured response times or differentiated timestamp logs from the Docker container using dedicated shell scripts. The details of the implementation can be found in my GitHub repository. The results are presented in the table below.

Test	CouchGO!	CouchJS	Boost
Indexing	141.713s	421.529s	2.97x
Reducing	7672ms	15642ms	2.04x
Filtering	28.928s	80.594s	2.79x
Updating	7.742s	9.661s	1.25x

As you can see, the boost over the JavaScript implementation is significant: almost three times faster in the case of indexing, more than twice as fast for reduce and filter functions. The boost is relatively small for update functions, but still faster than JavaScript.

Conclusion

As the author of the documentation promised, writing a custom Query Server wasn’t that hard when following the Query Server Protocol. Even though CouchGO! lacks a few deprecated functions in general, it provides a significant boost over the JavaScript version even at this early stage of development. I believe there is still plenty of room for improvements.

If you need all the code from this article in one place, you can find it in my GitHub repository.

Thank you for reading this article. I would love to hear your thoughts about this solution. Would you use it with your CouchDB instance, or maybe you already use some custom-made Query Server? I would appreciate hearing about it in the comments.

Don’t forget to check out my other articles for more tips, insights, and other parts of this series as they are created. Happy hacking!

Atas ialah kandungan terperinci CouchGO! — Mempertingkatkan CouchDB dengan Pelayan Pertanyaan Ditulis dalam Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!