बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala · पाठ

Transactor से कनेक्ट करना

डेटाबेस की पहुँच सेट अप करें।

पाठ 1, कुल 4 में से13 चरण

Transactor से कनेक्ट करना, CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

Transactor क्या है?

Doobie, Scala के लिए JDBC की एक शुद्ध कार्यात्मक परत है। Transactor[F], Doobie के शुद्ध प्रोग्रामों और वास्तविक डेटाबेस कनेक्शन के बीच सेतु है।

Transactor जानता है कि JDBC Connection कैसे प्राप्त करना है, आपके प्रोग्राम को लेन-देन के भीतर कैसे चलाना है और संसाधनों को सुरक्षित रूप से कैसे मुक्त करना है।

इसे cats.effect.IO जैसे प्रभाव प्रकार F[_] द्वारा पैरामीटराइज़ किया जाता है।

import doobie._
import cats.effect.IO

val xa: Transactor[IO] = ???

ConnectionIO प्रोग्राम

Doobie क्वेरी, ConnectionIO[A] प्रकार के मान होते हैं। वे ऐसे गणना का वर्णन करते हैं जिसे JDBC कनेक्शन की आवश्यकता होती है, लेकिन वे अभी चलते नहीं हैं।

आप इन प्रोग्रामों को शुद्ध रूप से बनाते हैं, फिर उन्हें चलाने के लिए Transactor को सौंपते हैं। जब तक आप उन्हें चलाते नहीं हैं, तब तक डेटाबेस को छुआ नहीं जाता।

import doobie.implicits._

val program: ConnectionIO[Int] =
  sql"select 42".query[Int].unique

DriverManagerTransactor

सबसे सरल Transactor Transactor.fromDriverManager है। यह JDBC के DriverManager का उपयोग करके हर लेन-देन के लिए एक बिल्कुल नया कनेक्शन खोलता है।

इसके लिए ड्राइवर क्लास का नाम, JDBC URL, उपयोगकर्ता नाम और पासवर्ड चाहिए। यह परीक्षणों और स्क्रिप्ट के लिए ठीक है, लेकिन इसमें कनेक्शन पूल नहीं होता।

val xa = Transactor.fromDriverManager[IO](
  driver = "org.postgresql.Driver",
  url = "jdbc:postgresql://localhost:5432/app",
  user = "postgres",
  password = "secret",
  logHandler = None
)

प्रोग्राम चलाना

ConnectionIO को निष्पादित करने के लिए आप .transact(xa) कॉल करते हैं। इससे F[A], यहाँ IO[A], प्राप्त होता है।

Transactor प्रोग्राम को लेन-देन में लपेटता है: सफलता पर कमिट करता है और विफलता पर रोलबैक, तथा दोनों ही स्थितियों में कनेक्शन मुक्त करता है।

import doobie.implicits._

val result: IO[Int] =
  sql"select 42".query[Int].unique.transact(xa)

HikariCP के साथ पूलिंग

उत्पादन वातावरण के लिए आपको कनेक्शन पूल चाहिए। Doobie, HikariCP पर आधारित HikariTransactor उपलब्ध कराता है।

इसे Resource के रूप में बनाया जाता है, ताकि पूल सही ढंग से बंद हो सके। ब्लॉक करने वाले JDBC कार्यों के लिए आपको एक निष्पादन संदर्भ भी देना होता है।

import doobie.hikari.HikariTransactor
import cats.effect.IO

val xaRes: Resource[IO, HikariTransactor[IO]] =
  HikariTransactor.newHikariTransactor[IO](
    "org.postgresql.Driver",
    "jdbc:postgresql://localhost/app",
    "postgres", "secret",
    connectEC
  )

Resource क्यों?

पूल किया गया Transactor लंबे समय तक रहने वाली स्थिति का स्वामी होता है: खुले कनेक्शन और पृष्ठभूमि के थ्रेड। Resource[F, A] यह सुनिश्चित करता है कि त्रुटि या रद्दीकरण की स्थिति में भी प्राप्ति और मुक्ति एक-दूसरे से जुड़ी रहें।

आमतौर पर आप Transactor को स्टार्टअप पर एक बार बनाते हैं और पूरे ऐप के जीवनकाल में उसका पुनः उपयोग करते हैं।

xaRes.use { xa =>
  program.transact(xa)
}

connectEC पूल

HikariCP को पूल से कनेक्शन मिलने तक प्रतीक्षा करने के लिए ExecutionContext चाहिए। Doobie इसके लिए ExecutionContexts.fixedThreadPool प्रदान करता है, जो स्वयं एक Resource है।

इसे अपने गणना पूल से अलग रखने पर ब्लॉक करने वाली कनेक्शन-प्राप्ति CPU-आधारित कार्यों को रोककर नहीं रखती।

import doobie.util.ExecutionContexts

val poolRes =
  for {
    ec <- ExecutionContexts.fixedThreadPool[IO](8)
    xa <- HikariTransactor.newHikariTransactor[IO](
            "org.postgresql.Driver", url, user, pass, ec)
  } yield xa

मौजूदा DataSource कॉन्फ़िगर करना

यदि आपके पास पहले से कॉन्फ़िगर किया हुआ javax.sql.DataSource है, जैसे कि ठीक से समायोजित Hikari इंस्टेंस, तो उसे सीधे Transactor.fromDataSource से लपेटें।

यह तब सामान्य है जब कोई फ़्रेमवर्क पूल का प्रबंधन करता है और आप केवल Doobie से उसका उपयोग करवाना चाहते हैं।

val xa = Transactor.fromDataSource[IO](
  dataSource = myDataSource,
  connectEC = connectEC
)

कनेक्शन का प्रारंभिक परीक्षण

एक सरल स्वास्थ्य जाँच है कि Transactor के माध्यम से select 1 चलाएँ। यदि यह परिणाम लौटाता है, तो आपका ड्राइवर, URL और प्रमाणीकरण विवरण सभी काम कर रहे हैं।

वास्तविक क्वेरी जोड़ने से पहले यह एक अच्छा पहला कदम है।

val check: IO[Int] =
  sql"select 1".query[Int].unique.transact(xa)

// check.unsafeRunSync() == 1

Transactor की आंतरिक संरचना: Strategy

Transactor इंटरप्रेटर और एक Strategy से बनाया जाता है। Strategy नियंत्रित करता है कि हर लेन-देन के आसपास क्या होता है: before, after, oops (त्रुटि पर) और always।

डिफ़ॉल्ट रणनीति ऑटो-कमिट बंद करती है, सफलता के बाद कमिट करती है, त्रुटि पर रोलबैक करती है और हमेशा कनेक्शन बंद करती है।

import doobie.util.transactor.Strategy

val noCommit = xa.copy(
  strategy0 = Strategy.default.copy(after = doobie.free.connection.unit)
)

लॉगिंग और दृश्यता

Doobie हर कथन, उसके तर्कों और समयावधि को लॉग कर सकता है। आधुनिक संस्करण हर Transactor के बजाय प्रत्येक क्वेरी के लिए LogHandler[F] जोड़ते हैं।

उत्पादन वातावरण में धीमी क्वेरी पहचानने और पैरामीटर बाइंडिंग सत्यापित करने के लिए यह अत्यंत उपयोगी है।

import doobie.util.log._

val handler: LogHandler[IO] = (ev: LogEvent) =>
  IO.println(ev.sql)

त्वरित जाँच

Transactor के बारे में अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

Transactor[F] शुद्ध ConnectionIO प्रोग्रामों को वास्तविक डेटाबेस से जोड़ता है। fromDriverManager परीक्षणों के लिए उपयुक्त है; HikariTransactor और fromDataSource पूलिंग के माध्यम से उत्पादन के लिए उपयुक्त हैं।

पूल किए गए Transactor को Resource के रूप में बनाएँ, प्रोग्राम को .transact(xa) से चलाएँ और कमिट, रोलबैक तथा सफ़ाई का काम डिफ़ॉल्ट Strategy पर छोड़ दें।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Scala सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 39
पाठ: 143

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “Transactor से कनेक्ट करना” पाठ निःशुल्क है?

हाँ—“Transactor से कनेक्ट करना” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“Transactor से कनेक्ट करना” में मैं क्या सीखूँगा?

डेटाबेस की पहुँच सेट अप करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।

“Transactor से कनेक्ट करना” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पर वापस जाएँ