تقدير المشروع
← كل المقالات

Hibernate مقابل Exposed: اختيار أفضل أداة للتخزين الدائم في Kotlin – الجولة 3

قارن بين Hibernate و Exposed من حيث جلب البيانات والتجميع الدفعي (batching) ومدى ملاءمتهما لـ Kotlin – واختر أداة التخزين الدائم الأنسب لك.

24 دقائق قراءة
الأداءKotlinKtorKotlinServerSideالتخزين الدائم

هذه هي الجولة الثالثة والأخيرة من مواجهة Hibernate مقابل Exposed – أهلًا بك!

إذا قرأت السلسلة منذ بدايتها، فمن المأمول أنك اكتسبت قدرًا لا بأس به من المعرفة، مثل:

  • أساسيات Hibernate و Exposed، وكيفية إعدادهما في بيئات مختلفة، وكيفية نمذجة بياناتك مع كل منهما.
  • الطرق المتنوعة التي يتيحها الإطاران لإنشاء البيانات وتحديثها وحذفها والاستعلام عنها، إضافةً إلى كيفية تعريف المعاملات (transactions) وضبطها.

يأخذك هذا المقال الأخير إلى موضوعات أكثر تقدمًا – وخاصة أداء الاستعلامات، وبعض المحاذير والمزالق في كل إطار، ومدى ملاءمة كل منهما لمنظومة Kotlin.

قراءة ممتعة!

اعتبارات الأداء

بما أن التعامل مع قواعد البيانات عمليات إدخال وإخراج (I/O)، فقد تتحول إلى اختناقات أداء خطيرة وتؤثر بوضوح في زمن الاستجابة والإنتاجية لتطبيقاتنا. ولهذا فإن تحسين أداء استعلامات قاعدة البيانات بعناية أمر بالغ الأهمية. يمكن لأطر التخزين الدائم أن تساعد كثيرًا هنا، لكن للأسف قد تجلب كذلك مشكلات إضافية خاصة بها، وذلك غالبًا بسبب سوء استخدامنا لها أو سوء فهمنا لطريقة عملها.

يغطي هذا القسم بعضًا من أكثر مشكلات الأداء شيوعًا المرتبطة بأطر التخزين الدائم، وسأحاول شرح كيف يمكن لكل من Hibernate و Exposed أن يساعدنا – أو يعترض طريقنا – عند التعامل معها.

جلب البيانات

إتقان جلب البيانات مفتاح أداء التطبيق. فأطر التخزين الدائم – وخاصة تلك التي تخفي تعقيد استعلامات قواعد البيانات – توفر عادةً مجموعة من الاستراتيجيات والآليات لتحميل البيانات، سواء تلقائيًا أو شبه تلقائي. وتمنحك هذه المقاربات، بصفتك مطورًا، درجات متفاوتة من التحكم في كيفية تحميل البيانات ووقته.

التحميل الكسول (Lazy loading) من أشهر الميزات المتعلقة بجلب البيانات، خاصة في أطر ORM. وهي آلية قد تفيدك وقد تضرك. ورغم أن هدفها تقليل كمية البيانات المحمّلة عند جلب كيانات ذات علاقات كثيرة، فإنها قد تسبب مشكلات بسهولة – ومنها مشكلة استعلامات N+1 سيئة السمعة. وقد تؤدي أيضًا إلى استثناءات وقت التشغيل لا تتوقعها للوهلة الأولى.

لكن التحميل الكسول ليس الميزة الوحيدة التي قد تؤذيك عند سوء استخدامها. فـالتحميل الاستباقي (Eager loading) قد يسبب مشكلات أداء أيضًا، خاصة عندما تكون للكيانات ارتباطات كثيرة جدًا أو تكون استراتيجيات الجلب مضبوطة بشكل خاطئ.

قد يسبب ذلك صداعًا بالتأكيد! لكن لا تقلق – يشرح هذا القسم كيف يتعامل Hibernate و Exposed مع جلب البيانات ويتعمق في تفاصيل آلياتهما.

جلب البيانات – Hibernate

في Hibernate يُعد جلب البيانات موضوعًا معقدًا ومتعدد الجوانب. يمكن تعريف استراتيجيات الجلب وإعادة تعريفها وتجاوزها بعدة طرق. والموضوع واسع إلى درجة أنه يستحق مقالة مدونة خاصة به. لذا سألامس السطح فقط هنا وأبقي الوصف موجزًا قدر الإمكان.

عند الحديث عن جلب البيانات في Hibernate، يجب أخذ بُعدين أساسيين في الحسبان:

  • التوقيت – متى تُجلب البيانات المرتبطة:
    • التحميل الاستباقي (Eager loading): تُحمَّل فورًا مع الكيان الرئيسي
    • التحميل الكسول (Lazy loading): تُحمَّل لاحقًا عند الوصول إليها
  • النطاق – أين يُعرَّف الجلب:
    • ثابت (Static): يُحدَّد في تعيين الكيان
    • ديناميكي (Dynamic): يُحدَّد وقت التشغيل لاستعلام معين

مع وضع هذين البُعدين في الذهن، لنرَ كيف يُعرَّف توقيت الجلب ضمن النطاقات المختلفة في Hibernate.

الإعلان الثابت عن استراتيجيات الجلب

يُعرَّف الجلب غالبًا بالإعلان عن FetchType للعلاقات بشكل ثابت، مباشرة في صنف الكيان:

@Entity
@Table(name = "board_games")
open class BoardGame(
// other properties ommited for brevity
) {
    @OneToMany(mappedBy = "boardGame", fetch = FetchType.LAZY)
    @Fetch(FetchMode.SUBSELECT)
    open var ratings: MutableSet<Rating> = mutableSetOf()
// ...
}

@Entity
@Table(name = "ratings")
open class Rating(
// other properties ommited for brevity
) {
    @ManyToOne(fetch = FetchType.LAZY)
    @Fetch(FetchMode.SELECT)
    @JoinColumn(name = "board_game_id", nullable = false, updatable = false)
    open val boardGame: BoardGame

// ...
}

يعرّف المثال أعلاه علاقة @OneToMany من الكيان BoardGame إلى Ratings الخاصة به. نحدّدها كسولة صراحةً، مع أن ذلك غير لازم هنا فعليًا – فـ Hibernate يجعل كل علاقة @OneToMany و @ManyToMany كسولة افتراضيًا.

ثم هناك الكيان Rating الذي يعرّف علاقة @ManyToOne تشير عائدةً إلى BoardGame. وهذه نحدّدها كسولة صراحةً، لأن Hibernate يجعل علاقات @ManyToOne و @OneToOne استباقية افتراضيًا.

وإلى جانب تعريف FetchType، ربما لاحظت التعليق التوضيحي الإضافي @Fetch. فـ FetchType جزء من معيار JPA ويحدد متى تُجلب الكيانات المرتبطة، بينما التعليق @Fetch خاص بـ Hibernate ويحدد كيف يُنفَّذ الجلب.

يقدّم @Fetch ثلاثة خيارات:

  • SELECT – يعمل مع الارتباطات الاستباقية والكسولة. في وضع الجلب هذا تُحمَّل الكيانات المرتبطة باستعلام ثانوي (يُنفَّذ بعد الاستعلام الرئيسي). وهو الافتراضي للعلاقات غير الاستباقية وعرضة لمشكلة استعلامات N+1.
  • JOIN – يعمل فقط مع الارتباطات الاستباقية. ويطلب من Hibernate تحميل الكيانات المرتبطة ضمن الاستعلام الأساسي بواسطة JOIN. وهو وضع الجلب الافتراضي للعلاقات الاستباقية.
  • SUBSELECT – يعمل مع الارتباطات الاستباقية والكسولة، لكن مع المجموعات (collections) فقط. وكما في نوع الجلب SELECT، يعتمد على استعلام ثانوي – لكن بدلًا من تنفيذ استعلام لكل كيان أب، يضمّن الـ SELECT الأصلي في جملة IN بحيث تُحمَّل جميع الكيانات المرتبطة دفعة واحدة. وبذلك تُتجنَّب مشكلة N+1.

لنتوقف لحظة وننظر متى قد تحدث مشكلة استعلامات N+1 سيئة السمعة.

تخيّل أننا تجاهلنا التعليق @Fetch(FetchMode.SUBSELECT) على الخاصية BoardGame.ratings – وعاملناها كارتباط كسول عادي باستخدام FetchMode.SELECT الافتراضي.

ثم انظر إلى هذا الكود:

val boardGames = session.byMultipleIds(BoardGame::class.java).multiLoad(boardGameIds)

boardGames.forEach { boardGame ->
   println("Found board game: ${boardGame.title}")
   println("Found board game ratings: ${boardGame.ratings}") // N + 1 queries!
}

هنا، كل وصول إلى boardGame.ratings يطلق استعلام SQL منفصلًا.

لكن لو غيّرت استراتيجية الجلب إلى FetchType.EAGER، فستختفي المشكلة، لأن JOIN هو وضع الجلب الافتراضي لـ FetchType.EAGER. وعندها تُحمَّل ألعاب اللوح وتقييماتها معًا في استعلام واحد باستخدام JOIN.

ولكن – إذا وضعت @Fetch(FetchMode.SELECT) صراحةً على ارتباط استباقي، فستعود مشكلة N+1. وهنا ستظهر حتى أبكر من النسخة الكسولة – مباشرة بعد تنفيذ الاستعلام الرئيسي.

الإعلان الديناميكي عن استراتيجيات الجلب

أظهر القسم السابق كيف يمكن الإعلان عن استراتيجيات الجلب بشكل ثابت. لكن كما ذُكر سابقًا، يتيح Hibernate أيضًا تحديد استراتيجيات جلب ديناميكية – أي إعدادات جلب تُطبَّق وقت التشغيل على استعلام معين. وتذكّر أن الاستراتيجيات الديناميكية تتقدم دائمًا على أي إعدادات جلب ثابتة معرّفة في كياناتك.

لنرَ ما يقدمه Hibernate هنا.

يمنحك Hibernate ثلاث آليات رئيسية لتحديد استراتيجيات الجلب ديناميكيًا:

  1. الاستعلامات (HQL و Criteria API)

تتيح لك كل من HQL (Hibernate Query Language) و Criteria API تحديد الارتباطات التي تُجلب استباقيًا. ويمكنك تحقيق ذلك بواسطة:

  • جملة JOIN FETCH في HQL،
  • الدالة Root.fetch() في Criteria API.

فيما يلي مثال من تطبيق متجر ألعاب اللوح لدينا، نريد فيه تحميل BoardGame مع جميع Ratings الخاصة به استباقيًا:

// HQL
val boardGame = session.createQuery(
   "FROM BoardGame bg LEFT JOIN FETCH bg.ratings WHERE bg.title = :title",
   BoardGame::class.java)
   .setParameter("title", "Dune: Imperium")
   .singleResult

// Criteria API
val criteriaBuilder = session.criteriaBuilder
val query = criteriaBuilder.createQuery(BoardGame::class.java)
val root = query.from(BoardGame::class.java)

root.fetch<BoardGame, Rating>("ratings", JoinType.LEFT)

query.select(root).where(
   criteriaBuilder.equal(root.get<String>("title"), "Dune: Imperium")
)

val boardGame = session.createQuery(query).singleResult

هذا موضع قد تتسلل فيه مشكلة استعلامات N+1 دون أن تلاحظها ما لم تنتبه.

افترض أن الخاصية BoardGame.ratings معلنة بـ FetchType.EAGER، إما ضمنيًا (دون التعليق @Fetch) أو صراحةً بـ @Fetch(FetchMode.JOIN).

لنقارن الآن بين طريقتين لتحميل لعبة لوح بمعرّفها:

// direct entity find by ID 
val boardGameByFind = session.find(BoardGame::class.java, boardGameId)
   ?: throw EntityNotFoundException()

println("Board game ${boardGameByFind.title} has the following ratings: ${boardGameByFind.ratings}")

// HQL query
val boardGameByHQL = session.createQuery(
   "FROM BoardGame WHERE id = :id",
   BoardGame::class.java
)
.setParameter("id", boardGameId)
.singleResult

println("Board game ${boardGameByHQL.title} has the following ratings: ${boardGameByHQL.ratings}")

ربما تتوقع أن تحمّل الطريقتان كلتاهما ratings الخاصة بـ BoardGame استباقيًا عبر جملة JOIN في الاستعلام الرئيسي، أليس كذلك؟

ليس تمامًا.

في الحالة الأولى (session.find(...)) يُحترم FetchMode.JOIN، ويحمّل استعلام واحد كل شيء.

أما في الحالة الثانية (مع HQL) فـيُتجاهل التعليق الثابت @Fetch(FetchMode.JOIN)، ويشغّل Hibernate استعلام SELECT منفصلًا لتحميل التقييمات.

والسبب أن الجلب الديناميكي يتقدم دائمًا على الإعلانات الثابتة. وفي حالة HQL يعني هذا: ما لم تستخدم JOIN FETCH صراحةً، فلن تُجرى أي عمليات ربط (joins) – مهما أعلن الكيان. لذا إذا كنت تعتمد على التعليقات @Fetch(FetchMode) أثناء استخدام استعلامات HQL، فضع هذه الدقيقة في اعتبارك.

  1. JPA Entity Graphs

مع مخططات الكيانات (entity graphs) في JPA يمكنك بناء مخطط جلب مخصص بسرد الارتباطات التي ينبغي جلبها صراحةً. ويمكن تسمية هذه المخططات وإعادة استخدامها، بل ويمكن أن تحتوي على مخططات فرعية للعلاقات المتداخلة.

إليك مخطط كيان بسيطًا يجلب BoardGame مع Ratings الخاصة به:

@NamedEntityGraph(
   name = "BoardGame.ratings",
   attributeNodes = [NamedAttributeNode("ratings")]
)
@Entity
@Table(name = "board_games")
open class BoardGame(

وإليك كيف يُستخدم هذا المخطط في استعلام:

val boardGame = session.find(
   BoardGame::class.java,
   boardGameId,
   mapOf("jakarta.persistence.fetchgraph" to session.getEntityGraph("BoardGame.ratings")))

بهذا الضبط يحمّل Hibernate Ratings استباقيًا باستخدام JOIN – حتى عندما تكون الخاصية ratings معلنة بـ FetchType.LAZY في صنف الكيان.

محاذير مهمة: مع مخطط الكيان، يُعامَل كل ارتباط مذكور في المخطط على أنه FetchType.EAGER، بينما يُعامَل كل ارتباط آخر (غير مذكور في المخطط) على أنه FetchType.LAZY – مهما قالت التعليقات الثابتة!

  1. ملفات الجلب في Hibernate (Fetch Profiles)

ملفات الجلب هي نظير Hibernate لمخططات الكيانات في JPA. وتكون مفيدة بشكل خاص حيث لا تُدعم مخططات الكيانات – مثلًا عند الجلب بالمعرّف الطبيعي (natural ID). لا يمكن الجمع بين مخططات الكيانات وملفات الجلب. وعند تعريف الاثنين معًا، تفوز مخططات الكيانات.

لنفترض أن الحقل title معلن بوصفه @NaturalId للكيان BoardGame. عندها يمكننا تعريف ملف جلب وتطبيقه كما يلي:

@FetchProfile(
   name = "BoardGame.ratings",
   fetchOverrides = [
       FetchOverride(
           entity = BoardGame::class,
           association = "ratings",
           mode = FetchMode.JOIN
       )
   ]
)
@Entity
@Table(name = "board_games")
open class BoardGame(
   @NaturalId
   @Column(name = "title", nullable = false)
   open var title: String,

ثم نطبّقه في استعلام هكذا:

session.enableFetchProfile("BoardGame.ratings")

val boardGame = session.bySimpleNaturalId(BoardGame::class.java)
   .load("Dune: Imperium")

بهذه الطريقة أخبرنا Hibernate بتحميل ratings الخاصة بـ BoardGame استباقيًا ضمن استعلام واحد باستخدام JOIN.

لاحظ أن ملف الجلب يأخذ قائمة من FetchOverrides. لذا، وكما يوحي اسمه، فإن ملف الجلب يتجاوز فقط استراتيجيات الجلب للارتباطات المحددة التي تختارها، بينما تحتفظ الارتباطات الأخرى بقيم FetchTypes الافتراضية أو المعلنة ثابتًا. وهذا عكس سلوك مخطط الجلب الموصوف سابقًا، الذي يتجاوز كل ارتباطات الكيان المعني.

فخ استثناء التهيئة الكسولة

هناك مسألة أخرى أريد التنبيه إليها. كما ذكرت في بداية قسم Data Fetching، يمكن للتحميل الكسول أن يساعدك حقًا على جعل استعلاماتك أسرع – لكن من السهل جدًا أيضًا إساءة استخدامه، مما قد ينتج عنه أخطاء وقت التشغيل. دعني أوضح ما أقصده.

تخيّل نقطة نهاية REST تجلب BoardGame بمعرّفه. للتعامل مع هذا الطلب، يصل تطبيقك أولًا إلى REST Controller، الذي يستدعي Domain Service، الذي يعتمد بدوره على JPA Repository لتحميل الكيان BoardGame. وحين يصل الكيان إلى المتحكم (Controller) يُحوَّل إلى DTO يستخدم كل حقول الكيان، بما فيها ratings المعلنة بـ FetchType.LAZY. والمعاملة (transaction) ملفوفة حول دالة الخدمة (Service).

يوضح المخطط أدناه التدفق الموصوف للتو و“بلطف” يبرز النقطة في التدفق التي يمكن توقع حدوث استثناء عندها:

مخطط لعبة اللوح

وهكذا قد يبدو ذلك في الكود:

// BoardGamesService
@Transactional(readOnly = true)
open fun findBoardGame(id: Long): BoardGame {
   val game = boardGamesRepository.findById(id).orElseThrow { EntityNotFoundException() }
   // some additional business logic here
   return game
}

// BoardGamesController
val boardGame = boardGameService.findBoardGame(boardGameId)
val boardGameDto = BoardGameDto(
   ratings = boardGame?.ratings?.map { RatingDto(it.rating) } ?: emptyList() // BOOM!
   // other properties omitted
)

في هذا السيناريو ستحصل على org.hibernate.LazyInitializationException. يطلقه Hibernate لأنك تحاول الوصول إلى الخاصية ratings لكيان BoardGame لم يُحمَّل بعد بسبب FetchType.LAZY. ولأن هذا يحدث خارج حدود المعاملة، لم يعد Hibernate قادرًا على تحميل التقييمات من قاعدة البيانات – ولهذا يفشل وقت التشغيل.

أنا واثق أنك تعرف هذه المشكلة وتتجنب عادةً مثل هذه المواقف في كودك. لكن للأسف ليس الجميع كذلك – وما زالت هذه المشكلة تظهر في قواعد كود العديد من التطبيقات الإنتاجية. ولهذا اخترت مناقشتها بقدر أكبر من التفصيل في هذا القسم.

بهذا ينتهي جلب البيانات في Hibernate. ستجد كل ما تحتاجه في هذا الموضوع، وبعمق أكبر مما غطيته هنا، في قسم Fetching في توثيق Hibernate.

جلب البيانات – Exposed

جلب البيانات أبسط بكثير في Exposed منه في Hibernate، لذا سيكون هذا القسم أقصر بدرجة كبيرة.

بدايةً، هذا القسم يخص Exposed DAO فقط، لأن Exposed DSL هو في جوهره غلاف رقيق حول استعلامات SQL. فـ Exposed يحمّل فقط البيانات التي تطلبها صراحةً في استعلام DSL – ولا يوجد تحميل كسول.

التحميل الاستباقي والكسول في Exposed DAO

في وحدة ORM الخفيفة لديهم – Exposed DAO – اعتمد مؤلفو Exposed افتراضًا بسيطًا. فاختاروا جعل كل علاقة في كيانات Exposed محمّلة كسولًا افتراضيًا. لكن هذا لا يعني أن Exposed يقصرك على الارتباطات الكسولة فقط. يمكنك اختيار تحميل كيانات مرتبطة معينة استباقيًا وقت التشغيل، لكل استعلام على حدة.

دعني أولًا أذكّرك بكيفية تعريف العلاقات في كيانات Exposed DAO، باستخدام كياني BoardGame و Rating مثالًا:

class BoardGame(id: EntityID<Long>): LongEntity(id) {
   companion object: EntityClass<Long, BoardGame>(BoardGamesTable)

   val ratings by Rating referrersOn RatingsTable.boardGameId
    // other properties omitted for brevity
}

class Rating(id: EntityID<Long>) : LongEntity(id) {
   companion object : LongEntityClass<Rating>(RatingsTable)

   var boardGame by BoardGame referencedOn RatingsTable.boardGameId
   // other properties omitted as well
}

ستلاحظ وجود دالتين infix مختلفتين لتعريف علاقة:

  • referencedOn – تعلن العلاقة في الكيان الواقع على الجانب المالك لها (الابن). هنا الجانب المالك هو الكيان Rating، المعيَّن إلى RatingsTable، وهو المكان الذي يُخزَّن فيه العمود boardGameId فعليًا.
  • referrersOn – تعلن العلاقة في الكيان الواقع على الجانب المقابل لها (الأب). في المثال أعلاه، الكيان BoardGame هو ذلك الجانب المقابل، لأن جدوله الأساسي لا يحتوي على أي معلومات عن العلاقة. لاحظ أن العلاقة في الكيان BoardGame تشير صراحةً إلى العمود RatingsTable.boardGameId بوصفه المُحيل.

ومع وضع ذلك في الاعتبار، إليك كيف يمكنك تحميل BoardGame مع جميع Ratings الخاصة به استباقيًا:

// Eagerly loading ratings for a single board game
val boardGame = BoardGame.findById(1L)?.load(BoardGame::ratings)
println(boardGame)
println(boardGame?.ratings?.toList())

// Eagerly loading ratings for multiple board games
val boardGames = BoardGame.all().with(BoardGame::ratings)
boardGames.forEach {
   println(it)
   println(it.ratings.toList())
}

لنستعرض ما يفعله الكود أعلاه.

إنه يعرض مثالين مختلفين للتحميل الاستباقي في Exposed DAO. في الأول، نبحث عن كيان BoardGame واحد ونستدعي الدالة load(BoardGame::ratings) على النتيجة، بحيث تُحمَّل جميع تقييمات هذا BoardGame فورًا. وخلف الكواليس، ينفّذ Exposed استعلام SQL منفصلًا يحمّل كل كيان Rating مرتبط بمجرد أن يعيد الاستعلام الأساسي BoardGame. ولو لم يكن هناك استدعاء load()، لنُفّذ استعلام SQL ذاته لاحقًا – عند أول وصول إلى الخاصية BoardGame.ratings.

أما المثال الثاني فيوضح كيفية تحميل التقييمات المرتبطة بعدة كيانات BoardGame استباقيًا – هنا نحصل عليها عبر الدالة all(). وهذه المرة، استدعينا الدالة with(BoardGame::ratings) على مجموعة BoardGames المُعادة لتحميل كل Ratings لكل نسخة BoardGame فيها استباقيًا. عندها ينفّذ Exposed استعلام SQL إضافيًا واحدًا فقط لتحميل كل Ratings المرتبطة، بجملة IN تأخذ كل معرّفات BoardGame وسائط لها. ولو لم تكن هناك الدالة with()، لحُمّلت تقييمات كل BoardGame على حدة عند أول وصول – مما ينتج عنه مشكلة استعلامات N+1.

ربما لاحظت أن Exposed DAO لا يوفر أي وسيلة لتحميل الكيان الرئيسي مع كل الكيانات المرتبطة استباقيًا في استعلام واحد عبر جملة JOIN، كما يفعل Hibernate مع FetchMode.JOIN. يتطلب Exposed دائمًا استعلامًا ثانويًا.

استخدام العلاقات خارج المعاملة

هناك نقطة أخرى جديرة بالذكر. بما أن كل ارتباط محمّل (كسول أو استباقي) يُحفظ في ذاكرة تخزين مؤقت خاصة بالمعاملة، فهو متاح فقط داخل كتلة المعاملة. ولاستخدام الارتباطات خارج المعاملة، عليك ضبط keepLoadedReferencesOutOfTransaction في DatabaseConfig:

val db = Database.connect(
   url = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1",
   driver = "org.h2.Driver",
   databaseConfig = DatabaseConfig {
       keepLoadedReferencesOutOfTransaction = true // this option allows to use associations outside of transaction block
   })

val boardGame = transaction {
   BoardGame.findById(1L)?.load(BoardGame::ratings)
}

println(boardGame)
println(boardGame?.ratings?.toList())

وبدون ذلك الإعداد، سيطلق الاستدعاء boardGame?.ratings?.toList() في المثال أعلاه استثناءً.

وتشبه هذه الحالة إلى حد كبير LazyInitializationException في Hibernate التي ناقشناها سابقًا. لكن هنا تتأثر الارتباطات المحمّلة استباقيًا أيضًا.

تتوفر تفاصيل أكثر عن التحميل الكسول والاستباقي في Exposed في قسم Relationships من توثيق Exposed.

التجميع الدفعي (Batching)

التجميع الدفعي عامل آخر يؤثر في أداء التطبيقات التي تعمل مع قواعد البيانات العلائقية. تأتي مشغلات JDBC بميزة التجميع الدفعي المدمجة، التي تتيح إرسال استعلامات SQL المجمّعة إلى خادم قاعدة البيانات دفعة واحدة بدل إرسالها فرادى. ويمكن أن يقلل ذلك عدد الرحلات الشبكية بين التطبيق وخادم قاعدة البيانات.

يوضح هذا القسم كيف يستفيد كل من إطاري التخزين الدائم من التجميع الدفعي في JDBC.

التجميع الدفعي – Hibernate

افتراضيًا لا يجمّع Hibernate الاستعلامات دفعيًا ويرسل كل استعلام على حدة. ويمكنك تغيير ذلك بسهولة بضبط هذه الخاصية (مثلًا في hibernate.properties):

hibernate.jdbc.batch_size=20

يوجّه هذا الإعداد Hibernate إلى استخدام التجميع الدفعي في JDBC وإرسال ما يصل إلى 20 استعلامًا في كل دفعة إلى خادم قاعدة البيانات.

ويمكن أيضًا ضبط المعامل لكل جلسة على حدة:

sessionFactory.inTransaction { session ->
   session.jdbcBatchSize = 10
   // ...
}

وهذا يتجاوز الخاصية hibernate.jdbc.batch_size.

من الآن فصاعدًا يمكنك ببساطة إدراج كيانات جديدة في حلقة، وسيجمّع Hibernate الاستعلامات دفعيًا خلف الكواليس:

sessionFactory.inTransaction { session ->
   val batchSize = session.properties.getOrDefault("hibernate.jdbc.batch_size", 10) as Int

   for (i in 0..99) {
       if (i > 0 && i % batchSize == 0) {
           session.flush()
           session.clear()
       }

       session.persist(BoardGame("BoardGame$i", 1, i, 10 * i))
       println("BoardGame$i created")
   }
}

ربما لاحظت الكود الذي يفرّغ الجلسة ويمسحها دوريًا (flush و clear) بناءً على المتغير batchSize. وهذه القطعة الصغيرة من الكود المتكرر تبقي الذاكرة المستخدمة من سياق التخزين الدائم في أصغر حد ممكن. وقد لا تكون ضرورية تمامًا هنا، لأننا ننشئ 100 كيان BoardGame فقط، لكنها بوجه عام ممارسة موصى بها.

ومع ضبط hibernate.jdbc.batch_size، يمكن لاستعلامات التحديث أن تستفيد أيضًا من التجميع الدفعي في JDBC. انظر إلى هذا المثال:

sessionFactory.inTransaction { session ->
   val batchSize = session.properties.getOrDefault("hibernate.jdbc.batch_size", 10) as Int

   val scrollableResults = session.createQuery("FROM BoardGame", BoardGame::class.java)
       .scroll()

   var count = 0
   while (scrollableResults.next()) {
       val boardGame = scrollableResults.get()
       boardGame.title = boardGame.title + "_new"

       if (count++ % batchSize == 0) {
           session.flush()
           session.clear()
       }
   }
}

إلى جانب استدعاءي session.flush() و session.clear() اللذين شرحتهما سابقًا، ينصح فريق Hibernate أيضًا باستخدام ScrollableResults عند تحميل البيانات للتحديثات الدفعية. وفي المثال يتم ذلك باستدعاء scroll() على session.createQuery(). والغاية هي الاستفادة من المؤشرات على جانب الخادم (server-side cursors) للاستعلامات التي قد تعيد صفوفًا كثيرة.

قبل إغلاق هذا القسم، أريد مشاركة نقطة مهمة أخرى. تذكّر أن Hibernate يعطّل التجميع الدفعي في JDBC تلقائيًا وبصمت للكيانات التي تستخدم مولّد المعرّفات IDENTITY. لذا إذا كانت خاصية المفتاح الأساسي في كيانك تحمل التعليق التوضيحي التالي، فلن يعمل التجميع الدفعي:

@GeneratedValue(strategy = GenerationType.IDENTITY)

التجميع الدفعي – Exposed

يستطيع Exposed أيضًا الاستفادة من الإدراج الدفعي في JDBC، ويتم ذلك عبر Table DSL. وسيبدو إدراج عدة صفوف في الجدول board_games باستخدام Exposed هكذا:

val boardGamesToCreate = (0..99).map {
   BoardGameData(title = "BoardGame$it", minPlayers = 1, maxPlayers = 4, playTime = 60)
}

BoardGamesTable.batchInsert(data = boardGamesToCreate, shouldReturnGeneratedValues = false) {
   this[BoardGamesTable.title] = it.title
   this[BoardGamesTable.minPlayers] = it.minPlayers
   this[BoardGamesTable.maxPlayers] = it.maxPlayers
   this[BoardGamesTable.playTimeInMinutes] = it.playTime
}

تأخذ BoardGamesTable.batchInsert() عددًا من المعاملات، أهمها الإلزامية:

  • data – مجموعة من القيم المستخدمة في جسم الإدراج الدفعي،
  • body – دالة مسؤولة عن تحويل عنصر واحد من المعامل data إلى صف جديد في جدول Exposed.

وإلى جانب هذين، يستخدم المثال أعلاه معاملًا آخر:

  • shouldReturnGeneratedValues – يحدد ما إذا كانت الدالة تعيد القيم المولّدة تلقائيًا للصفوف الجديدة (مثل المعرّفات المتزايدة تلقائيًا). وإذا لم تكن هذه القيم مطلوبة، فإن ضبطه على false أفضل للأداء.

التحديثات الدفعية ممكنة في Exposed أيضًا، رغم أنها أصعب في العثور عليها وأقل توثيقًا من الإدراجات الدفعية. فلا يوفر Table DSL دالة batchUpdate() مريحة (على الأقل حتى وقت كتابة هذا المقال). ومع ذلك يمكنك تحقيقها هكذا:

BatchUpdateStatement(BoardGamesTable).apply {
   boardGamesForUpdate.forEach { boardGameRow ->
       addBatch(boardGameRow[BoardGamesTable.id])

       this[BoardGamesTable.title] = "Updated ${boardGameRow[BoardGamesTable.title]}"
   }

   execute(TransactionManager.current())
}

هنا، النوع boardGamesForUpdate هو List<ResultRow>، لكن أي مجموعة بيانات تصلح. والجزء الأساسي في BatchUpdateStatement هو تمرير معرّف الصف المراد تحديثه إلى الدالة addBatch()، مع القيم الفعلية المراد تحديثها.

من الواضح أن Exposed يتعامل مع التجميع الدفعي بشكل مختلف إلى حد ما عن Hibernate. فليس في Exposed إعداد batch_size – وإنما يقدّم طريقة صريحة لإطلاق العمليات الدفعية. ونتيجةً لذلك عليك أن تقرر بنفسك أين يحدث التجميع الدفعي باستخدام واجهة برمجية مخصصة، لكنك تحصل في المقابل على تحكم وشفافية أكبر.

والغريب أن Exposed يفتقر إلى أي توثيق رسمي مفصل عن التجميع الدفعي، رغم أنه يمكن العثور على بعض المعلومات في القسم المخصص لعمليات CRUD – وخاصة عن الإدراجات الدفعية.

التكامل مع ميزات Kotlin

بما أن هذا المقال كله عن Kotlin، فمن الطبيعي أن نسأل كيف يستفيد كل من الإطارين المناقَشين هنا من ميزات Kotlin الأصيلة، ومدى سهولة كتابة كود Kotlin بهما ومتعته. لننظر في كل منهما على حدة.

Hibernate

لا عجب أن Hibernate بُني حصريًا لـ Java ومع وضع Java وحدها في الاعتبار. وهذا ليس ذنب أحد – فـ Hibernate في الواقع أقدم بكثير من Kotlin، وربما أقدم من معظم لغات JVM الأخرى غير Java. وهذا يجعل Hibernate إطارًا ناضجًا جدًا ومجرَّبًا في الميدان، لكنه أيضًا مرتبط بشدة ببنية Java النحوية، لذا يبدو أقل طبيعية إلى حد ما في اللغات الأخرى.

وبالنسبة إلى ميزات Kotlin، لا يوفر Hibernate تكاملًا مخصصًا ولا واجهات برمجية ولا DSLs ولا أي شيء من هذا القبيل. إنه صالح تمامًا للاستخدام في مشاريع Kotlin، لكن ذلك بفضل قابلية التشغيل البيني بين Kotlin و Java، لا بفضل Hibernate نفسه. ويمكن استخدام السكر النحوي في Kotlin في كيانات Hibernate أو واجهات الاستعلام تمامًا كما مع أي مكتبة Java بحتة أخرى.

والأكثر إثارة للقلق قليلًا أنه، بسبب متطلبات محددة وصارمة في مواصفة JPA، يجبرنا Hibernate على التخلي عن بعض مزايا Kotlin الجميلة، مما يؤدي إلى مزيد من الكود المتكرر (boilerplate). وقد غطيت معظم هذه المشكلات في قسم Mapping & Schema Definition عند الحديث عن كيانات Hibernate. وخلاصةً، هذه هي قيود JPA التي أقصدها أساسًا:

  • يجب أن يوفر صنف الكيان مُنشئًا بلا معاملات (no-arg constructor)،
  • لا يمكن أن يكون صنف الكيان final،
  • لا يمكن أن تكون أي من دوال صنف الكيان أو متغيرات النسخة الدائمة فيه final.

وبسببها، إما أن تفتح (open) كل صنف كيان وخصائصه يدويًا، وتضيف مُنشئات افتراضية، وتتخلى عن data classes وعدم القابلية للتغيير، أو تعتمد على إضافات بناء من جهات خارجية تعدّل البايت كود الخاص بك.

Exposed

بما أن Exposed مكتوب بلغة Kotlin ومن أجل Kotlin، فمن الطبيعي أن تتوقع تكاملًا أفضل بكثير مع ميزات Kotlin الأصيلة – وهذا بالضبط ما هو عليه الحال.

دعني أركّز على بعض صيغ Kotlin المعبّرة المحددة وأوضح كيف يستخدمها Exposed لتسهيل الأمور وتحسين تجربة المطور:

  • data classes – من الغريب أن Exposed لا يعتمد صراحةً على data classes – إحدى أروع ميزات Kotlin (تنبيه: رأي شخصي!). فجداول Exposed DSL تُعلَن ككائنات (objects)، وأصناف كيانات Exposed DAO مبنية بطريقة تجعل تعريفها كـ data classes صعبًا. لكن هذا لا يمنعك من استخدام data classes في الكود الذي يعمل مع Exposed. بل العكس – يمكنك ذلك بالتأكيد، ويبدو طبيعيًا وبسيطًا جدًا. وهذا مفيد بشكل خاص عند تحويل ResultRows إلى كائنات المجال:
val boardGames = BoardGamesTable.selectAll().map {
   BoardGameData(
       it[BoardGamesTable.id].value,
       it[BoardGamesTable.title],
       it[BoardGamesTable.minPlayers],
       it[BoardGamesTable.maxPlayers],
       it[BoardGamesTable.playTimeInMinutes]
   )
}
  • infix functions – تؤتي الدوال infix ثمارها حقًا في استعلامات Exposed DSL. فمع دوال infix مثل eq, greater, lessEq, like, and, or, etc. تُقرأ الشروط في تعبيرات where بشكل أكثر طبيعية وتصبح أوضح:
BoardGamesTable.selectAll()
   .where { (BoardGamesTable.maxPlayers lessEq 4) and (BoardGamesTable.title like "Aeon's End%") }
   .toList()
  • extension functions – يستخدم Exposed دوال الامتداد (extension functions) بكثافة (للاطلاع، انظر الدوال الكثيرة في حزمة org.jetbrains.exposed.sql). كما يشجع المطورين على استخدام دوال الامتداد في كودهم الخاص لتخصيص الاستعلامات وإعادة استخدامها. فمثلًا يمكنك كتابة دوال امتداد خاصة بك لـ ResultRow تحوّله بأناقة إلى كائنات المجال لديك:
fun ResultRow.toBoardGameData() = BoardGameData(
   id = this[BoardGamesTable.id].value,
   title = this[BoardGamesTable.title],
   minPlayers = this[BoardGamesTable.minPlayers],
   maxPlayers = this[BoardGamesTable.maxPlayers],
   playTime = this[BoardGamesTable.playTimeInMinutes]
)
  • lambdas with receivers – وصلت قدرة Kotlin على تمرير تعبير lambda كمعامل خارج قائمة المعاملات الرئيسية إلى Exposed أيضًا. وتجعل lambdas with receivers استعلامات Exposed DSL أكثر تعبيرًا واختصارًا وقابلية للقراءة:
BoardGamesTable.insert {
   it[title] = "Champions of Midgard"
   it[minPlayers] = 2
   it[maxPlayers] = 4
   it[playTimeInMinutes] = 90
}

BoardGamesTable.selectAll()
   .where { BoardGamesTable.playTimeInMinutes lessEq 90 }
   .forEach {
       // ...
   }
  • type safety – يُروَّج لـ Exposed DSL ككل على أنه صيغة آمنة الأنواع تشبه SQL. وهذا يساعد حقًا عند كتابة استعلامات Exposed، لأن كل جزء من استعلام SQL النموذجي (مثل SELECT و JOIN و WHERE)، إضافةً إلى وسائط تلك الجمل، يُتحقَّق منه عند الترجمة ويحصل على إكمال الصيغة في بيئة التطوير (IDE):
BoardGamesTable.innerJoin(RatingsTable)
   .select(BoardGamesTable.title, RatingsTable.rating.avg())
   .groupBy(BoardGamesTable.title)
   .where { BoardGamesTable.title like "Aeon's End%" }
   .forEach {
       println("Average rating of ${it[BoardGamesTable.title]} is ${it[RatingsTable.rating.avg()]}")
   }
  • nullability handling – أقول إن معالجة Kotlin لقابلية القيم للإلغاء (nullability) تكون في أفضل حالاتها عند تعريف المخطط (schema) – أي خصائص جداول Exposed التي تمثل أعمدة قاعدة البيانات. فـ Exposed لا يعرّف الأعمدة بالتعليقات التوضيحية أو آليات الضبط الأخرى؛ بل تفعل ذلك بكود Kotlin فقط. ونتيجةً لذلك يُتحقَّق من نوع خصائصك وقابليتها للإلغاء معًا عند الترجمة:
object RatingsTable: LongIdTable("ratings") {
   val rating: Column<Int> = integer("rating")
   val comment: Column<String?> = varchar("comment", 256).nullable() // actual nullable type
  • coroutines – رغم أن الوصول إلى قاعدة البيانات مع معظم مشغلات JDBC اليوم ما زال حاجبًا (blocking)، فإن coroutines تشق طريقها تدريجيًا إلى Exposed أيضًا. فدوال مثل newSuspendedTransaction() و withSuspendTransaction() تتيح لك العمل مع Exposed داخل كتل suspend مع تمرير CoroutineContext، وتتيح suspendedTransactionAsync() تشغيل بعض كود Exposed بشكل غير متزامن وانتظار نتيجته لاحقًا في كودك:
suspend fun findBoardGame(id: Long): BoardGameData? = newSuspendedTransaction(Dispatchers.IO) {
   BoardGamesTable.selectAll().find { it[BoardGamesTable.id].value == id }?.toBoardGameData()
}

suspend fun getAllBardGames(): Deferred<List<BoardGameData>> = suspendedTransactionAsync(Dispatchers.IO) {
   BoardGamesTable.selectAll().map { it.toBoardGameData() }
}

الخلاصة: Hibernate أم Exposed؟

لنلخص بسرعة موضوعات اليوم (اعتبارات الأداء والتكامل مع Kotlin). وبعد ذلك يأتي الحكم النهائي الذي يختتم السلسلة كلها.

اعتبارات الأداء

كلاهما يدعم التحميل الكسول والتحميل الاستباقي والتجميع الدفعي – لكل منهما سهولة استخدامه ومحاذيره.

يقدّم Hibernate خيارات أكثر (مثل ملفات الجلب ومخططات الكيانات)، إلى جانب فرص أكثر لإطلاق النار على قدمك.

أما Exposed فأبسط وأكثر قابلية للتنبؤ – خاصة لمن يفضّل الجلب الصريح للبيانات وطبقات تجريد أرق.

التكامل مع Kotlin

بالنسبة إلى كثيرين، قد يرجّح هذا الكفة.

يعمل Hibernate مع Kotlin، لكنه لم يُبنَ له قط. وبسبب قيود متعددة، قد يعيق أحيانًا حتى استخدام صيغ Kotlin معينة.

أما Exposed، في المقابل، فيحتضن صيغ Kotlin بالكامل مثل دوال الامتداد و DSLs و lambdas with receivers ودعم coroutines وغيرها. وإذا كانت كتابة Kotlin معبّرة وفق أسلوب اللغة هي الأهم لك، فمن المرجّح أن يبدو Exposed أكثر طبيعية.

أفكار ختامية

عندما تبني تطبيق مؤسسات قائمًا على Spring ويتطلب التوافق مع JPA وأدوات ناضجة ودعمًا من القطاع، فإن Hibernate خيار آمن وقوي (خاصة إذا كنت تعرفه جيدًا). فقط ضع في اعتبارك إسهابه ونقاط الاحتكاك مع Kotlin.

وعندما تبني تطبيق Kotlin خفيفًا، خاصة مع Ktor أو منظومات حديثة أخرى، وتهتم بالتحكم والإيجاز وواجهات برمجية موجّهة لـ Kotlin أولًا – فمن المرجّح أن يناسبك Exposed أكثر.

باختصار: يتألق Hibernate عندما تحتاج إلى التجريد والتوافق. ويتألق Exposed عندما تسعى إلى الوضوح وتجربة مطور أصيلة لـ Kotlin.

أيًّا كان اختيارك، اعرف المفاضلات، واحتضن صيغ منظومتك – ولا تدع إطار التخزين الدائم يملي عليك عمارتك.