Show HN: LearnDB - RDBMS ที่สร้างขึ้นใหม่ทั้งหมดด้วย Python ล้วน (โคลน SQLite)

 (github.com/spandanb)
3 คะแนน โดย GN⁺ 2023-08-14 | 1 ความคิดเห็น | แชร์ทาง WhatsApp
  • LearnDB คือ ระบบจัดการฐานข้อมูลเชิงสัมพันธ์ (RDBMS) และโคลน SQLite ที่สร้างขึ้นใหม่ทั้งหมด เพื่อทำความเข้าใจโครงสร้างภายในของฐานข้อมูลให้ลึกซึ้งยิ่งขึ้น
  • เขียนด้วย Python ล้วน จึงไม่มีขั้นตอนการ build โดยเป็นแบบ zero-configuration โดยค่าเริ่มต้น และมีโครงสร้างที่สามารถ override การตั้งค่าได้
  • มี learndb-sql ที่รองรับ select, from, where, group by, having, limit, order by พร้อม custom lexer และ parser ที่สร้างบน lark
  • ประกอบด้วยเอนจินที่รับคำสั่ง SQL เพื่อจัดการตารางและข้อมูลในฐานข้อมูล และโครงสร้างข้อมูลสำรองบนดิสก์แบบ btree
  • รองรับการใช้งานผ่าน REPL, การ import เป็น Python module และการส่งไฟล์คำสั่งให้เอนจิน
  • โค้ดเบสเหมาะสำหรับการลองเล่นและทดลองปรับแต่ง แต่มีข้อจำกัดสำคัญที่ทำให้ไม่ควรใช้เป็นโซลูชันจัดเก็บข้อมูลจริง
    • การคำนวณเลขทศนิยมแบบ floating-point เป็นการใช้งานที่ลดรูปอย่างมากเมื่อเทียบกับ IEEE754
    • ไม่รองรับฟังก์ชันอรรถประโยชน์ทั่วไป เช่น การขยาย wildcard column แบบ select * ...
  • ความต้องการสำหรับรันระหว่างพัฒนาคือระบบ Linux/macOS และ Python 3.9 ขึ้นไป และใช้ fcntl เพื่อการเข้าถึงแบบอ่านโดยเฉพาะสำหรับไฟล์ฐานข้อมูล
  • ใช้เอกสารอ้างอิงจากบทเรียนฐานข้อมูลของ cstack, SQLite Database System: Design and Implementation, เอกสารรูปแบบไฟล์ของ SQLite และเอกสารของ PostgreSQL

บทความที่เกี่ยวข้อง

1 ความคิดเห็น

 
GN⁺ 2023-08-14
ความคิดเห็นจาก Hacker News

  • ผมมองว่าการเขียนระบบแบบนี้ด้วยภาษาอย่าง Python กลับเป็น ตัวเลือกที่ยอดเยี่ยม ฐานข้อมูลมักเขียนด้วย C++ หรือ C แต่สำหรับผม Python อ่านง่ายกว่าและเข้าถึงได้ง่ายกว่ามาก
    ถ้าตั้งเป้าเรื่องประสิทธิภาพอย่างจริงจัง ก็ค่อยพอร์ตไปเป็นภาษาระดับต่ำในภายหลังได้ และในรูปแบบตอนนี้มันมีประโยชน์ในฐานะ เครื่องมือเพื่อการเรียนรู้
    ผมเองก็เคยสร้างฐานข้อมูลแบบกระจายที่คล้าย multi-model โดยผสม SQL/กราฟ Cypher/เอกสาร/สไตล์ DynamoDB ด้วย Python เพื่อเรียนรู้ว่าเอนจินฐานข้อมูลทำงานในสภาพแวดล้อมแบบกระจายได้อย่างไร: https://GitHub.com/samsquire/hash-db

    • เพราะแบบนั้นน่าจะมีชุมชน ฐานข้อมูลเชิงสัมพันธ์ ที่เป็น Java ล้วนอยู่ อย่างพวก Hypersonic, H2, Derby ถ้าไม่ต้องการสเกลระดับเครื่องใหญ่ ก็แจกจ่ายและใช้งานฐานข้อมูลได้ง่าย และถ้าจำเป็นก็ฝังไว้ในหน่วยความจำได้ง่ายด้วย
    • เห็นด้วยเต็มที่ ในแง่นั้นซีรีส์ ugit ที่สร้าง Git ขึ้นมาใหม่ตั้งแต่ต้นด้วย Python นั้นดีมาก: https://www.leshenko.net/p/ugit/
    • ไม่ค่อยแน่ใจนัก Python ก็แย่พอ ๆ กับ C/C++ แต่ข้อเสียคือถ้าจะเรียนรู้วิธีสร้างฐานข้อมูล ส่วนที่น่าสนใจซึ่งควรได้ลองทำหลายอย่างนั้นใช้ Python แตะได้ยาก
      ทั้ง C และ Python ถ้ามองข้ามการออกแบบภาษาที่แย่ ความไม่สอดคล้อง และกับดักต่าง ๆ แล้วดูเฉพาะส่วนง่าย ๆ ก็จะดูเหมือนเข้าถึงง่าย แต่กับ C อย่างน้อยยังมีโอกาสเรียนรู้วิธีทำให้ถูกต้องได้บ้าง ส่วน Python อาจทำให้ไม่รู้ด้วยซ้ำว่าโลกจริงเป็นอย่างไร
    • เป็นงานที่ยอดเยี่ยม ผมก็รู้สึกคล้ายกัน และ Python ช่วยให้โฟกัสกับ แนวคิดระดับสูง ได้ แต่ก็มีบางช่วงที่คิดว่าถ้าใช้ภาษาแบบ static type และคอมไพล์ได้ก็คงดี

  • นานมาแล้วเคยมีคน เขียน/พอร์ต SQLite ใหม่ จาก C เป็น C#: https://code.google.com/archive/p/csharp-sqlite/wikis/Letter...
    น่าสนใจด้วยว่า Dr. Richard Hipp ต้อนรับงานนั้นมากแค่ไหน
    บน GitHub น่าจะอยู่ที่นี่: https://github.com/CsharpDatabase/CsharpSQLite และอาจมีโคลนอื่น ๆ ตามมาอีก

  • ยอดเยี่ยมมาก แน่นอนว่าน่าจะเป็นประสบการณ์ที่สนุกและคุ้มค่า
    รู้ว่าไม่ได้ตั้งใจทำให้เร็ว แต่เพื่อความสนุก ลองทำ เบนช์มาร์ก สักสองสามตัวได้ไหม?

    • ออกนอกประเด็นนิดหน่อย แต่มีแหล่งข้อมูล งานบรรยาย หรือบล็อกโพสต์ดี ๆ ที่พูดถึง วิธีเขียนเบนช์มาร์ก ให้มีประโยชน์ไหม?
    • การลองนำอะไรอย่าง TPC-C ไปทำบน learndb แล้วดูว่าจะเป็นอย่างไรก็น่าจะเป็นแบบฝึกที่สนุก

  • โพสต์นี้ทำให้ได้รู้จักไลบรารีพาร์เซอร์สำหรับ Python ชื่อ Lark ซึ่งดูดีทีเดียว
    ทิวทอเรียล JSON บนเว็บไซต์ยอดเยี่ยมมาก มันแสดงวิธีสร้างพาร์เซอร์พื้นฐานสำหรับ JSON แล้วอธิบายวิธีปรับปรุงประสิทธิภาพค่อนข้างละเอียด: https://lark-parser.readthedocs.io/en/latest/json_tutorial.h...
    ไวยากรณ์ที่ใช้ในโปรเจกต์ RDBMS อยู่ที่นี่: https://github.com/spandanb/learndb-py/blob/master/learndb/l...

    • ขอแนะนำ Lark อย่างยิ่งสำหรับโปรเจกต์ Python ใช้งานง่าย
      IDE มีประโยชน์มากตอนดีบักไวยากรณ์: https://www.lark-parser.org/ide/
      EvaDB ใช้ Lark กับภาษาแบบ SQL-like ที่ปรับให้เหมาะกับการใช้โมเดล AI: https://github.com/georgia-tech-db/evadb/blob/master/evadb/p... https://github.com/georgia-tech-db/evadb/
      ถ้าชอบ Lark ก็น่าพิจารณาสนับสนุนด้วย: https://github.com/sponsors/lark-parser
    • DSL ในสตริงนี่นะ นั่นเป็นวิธีที่ดีจริงหรือ? ผมนึกไม่ออกว่าเคยใช้หรือต้องการสิ่งนี้ใน Python แต่คิดว่าน่าจะมีวิธีที่ดีกว่านี้ได้
      แค่ใช้ dict ที่มีคีย์ตามที่คาดไว้ และประกอบผ่านตัวดำเนินการบิต OR ก็น่าจะเข้ากับรูปแบบไวยากรณ์หลาย ๆ แบบได้คร่าว ๆ และอาจดีกว่าหรือเปล่า? import ก็ปล่อยให้เป็น import ไป แล้วน่าจะผสมกันได้ด้วยวิธีใดวิธีหนึ่ง
      นี่เป็นความคิดแรกหลังจากมองผ่าน ๆ ดังนั้นผมอาจพลาดอะไรไปก็ได้
    • ไม่ได้ตั้งใจให้ฟังดูเสียมารยาท และยอมรับว่างานนี้ยอดเยี่ยมและเป็นวิธีเรียนรู้สิ่งใหม่ ๆ แต่ถ้าการสร้างพาร์เซอร์ไม่ใช่เป้าหมายสุดท้าย หากเป็นเพียงวิธีนำ AST ไปประมวลผลในฐานข้อมูล ผมสงสัยว่าส่วนของพาร์เซอร์เพียงอย่างเดียวทำให้เรียนรู้อะไรได้บ้าง
      มีส่วนที่ต้องปรับแต่งต่อเนื่องเพื่อทำให้พาร์เซอร์ที่สร้างขึ้นมีประสิทธิภาพมากขึ้นหรือไม่?
      ขั้นตอนถัดไปที่สมเหตุสมผลคือการสร้าง แผนการคิวรีที่เหมาะสมที่สุด จาก AST หรือเปล่า?

  • ดีมาก
    SQLite อ่านยากมาก แต่ implementation นี้ค่อนข้างเข้าใจง่าย โดยเฉพาะส่วน virtual machine: https://github.com/spandanb/learndb-py/blob/master/learndb/v...
    ลองเทียบกับไฟล์นี้ได้: https://github.com/sqlite/sqlite/blob/master/src/vdbe.c
    แต่ก็สงสัยว่า LearnDB นี้สมบูรณ์แค่ไหน ที่ SQLite อ่านยากไม่ใช่แค่เพราะมันเก่าเท่านั้น แต่ยังเพราะต้องจัดการ SQL หลายส่วน และความซับซ้อนที่เกิดจากการทำตามสเปก SQL ด้วย
    SQLite มีชุดทดสอบที่ยอดเยี่ยมอยู่แล้ว ถ้าลองเอาชุดทดสอบนั้นมารันกับ implementation นี้ก็น่าจะดี

  • ดีจริง ๆ และดูเหมือนเป็นวิธีที่ดีสำหรับคนอย่างผมในการเรียน โครงสร้างข้อมูลและอัลกอริทึม ให้ดีขึ้น ผมอธิบายได้ว่า B+tree ทำงานอย่างไร แต่ถ้าให้เขียนโค้ดเองคงชะงักแน่
    ผมชอบฐานข้อมูลกับ Python เลยสนุกมากตอนลองไล่ดู

    • ใช่เลย implementation ของ B-tree เป็นแรงจูงใจแรกที่ทำให้เริ่มโปรเจกต์นี้ โดยเฉพาะรายละเอียดที่เกี่ยวกับการปรับสมดุลโหนดและการ split
      แถมการที่มันเป็นโครงสร้างที่เก็บบนดิสก์ ก็เพิ่มความซับซ้อนอีกอย่างเวลาคิดเรื่อง implementation

  • จะผ่าน ชุดทดสอบของ SQLite ได้มากแค่ไหนนะ?

  • รองรับ การรับประกัน ACID หรือ query planning/optimization ไหม?
    ไม่ได้ถามในเชิงว่ามันควรต้องทำได้ แต่อยากรู้ว่านอกจาก B-tree กับ SQL แล้วลองไปไกลถึงไหน
    ผมก็อยากลองทำอะไรแบบนี้สักวัน งานเจ๋งมาก

    • เรื่องการรับประกัน ACID นั้น ไม่มีแนวคิดของการรวมหลายคำสั่งให้เป็นอะตอมิก หรือก็คือ transaction
      แต่นอกนั้นมันเป็นฐานข้อมูลไฟล์เดียว และมีได้เพียง learndb instance เดียวเท่านั้นที่จัดการไฟล์ฐานข้อมูลได้ ดังนั้นในฐานะฐานข้อมูลแบบ single connection จึงได้ความสอดคล้องและการแยกกันทำงาน
      durability ก็ได้เท่าที่ไฟล์ซิสเต็มให้ความคงทนได้ ดังนั้นจึงอยู่สักจุดหนึ่งบนคุณสมบัติ ACID
      query planning/optimization ยังไม่ได้ implement แต่เคยคิดไว้ว่า optimization module จะวางไว้ตรงไหนได้บ้าง parser จะปล่อย AST ออกมา และสามารถ optimize AST นี้หรือ intermediate representation ที่ได้จากมันได้
      กล่าวคือสามารถ rewrite AST หรือลบ node ก่อนที่ VM จะ execute AST

  • ออกนอกเรื่องนิดหน่อย แต่ใน Python มีอะไรคล้าย mapDB ไหม?
    https://mapdb.org

  • โปรเจกต์ยอดเยี่ยมมาก โค้ดก็อ่านง่ายมาก และ คอมเมนต์ ก็ยอดเยี่ยม