Elixir ' s ecto pertanyaan DSL: Beyond the Basics

Artikel ini membina asas -asas Ecto yang saya dilindungi dalam memahami Elixir's Ecto Query DSL: The Basics. Saya kini akan meneroka ciri -ciri ECTO yang lebih canggih, termasuk komposisi pertanyaan, menyertai dan persatuan, suntikan serpihan SQL, pemutus eksplisit, dan akses medan dinamik.

Sekali lagi, pengetahuan asas elixir diandaikan, serta asas -asas Ecto, yang saya dilindungi dalam pengenalan kepada Perpustakaan ELIXIR's Ecto.

Takeaways Key

Ecto membolehkan komposisi pertanyaan dalam elixir, membolehkan pemaju membuat pertanyaan yang boleh diguna semula dan menggabungkannya untuk pengering dan lebih banyak kod yang dapat dipelihara. Ini boleh dicapai dengan menggunakan sintaks pertanyaan kata kunci atau sintaks makro.
ECTO menyediakan keupayaan untuk mengendalikan hubungan meja (bergabung dan persatuan) dalam model. Persatuan, yang ditakrifkan menggunakan has_one/3, has_many/3, dan kepunyaan_to/3 makro, membolehkan pemaju mengendalikan hubungan meja yang dilaksanakan sebagai kunci asing dalam model.
Ecto menyokong suntikan serpihan SQL, ciri yang membolehkan kod SQL disuntik secara langsung ke dalam pertanyaan menggunakan fungsi Fragment/1. Ini berguna apabila pemaju perlu turun kembali ke SQL mentah untuk operasi yang tidak dilindungi oleh fungsi ECTO.
Ecto menyokong pemutus eksplisit dan akses medan dinamik. Pemutus eksplisit membolehkan pemaju untuk menentukan jenis ungkapan yang harus dilemparkan ke, sementara akses medan dinamik membolehkan mencari medan dari jadual yang diberikan, menjadikan pertanyaan lebih umum dan serba boleh.

Komposisi pertanyaan

pertanyaan berasingan di Ecto boleh digabungkan bersama, yang membolehkan pertanyaan yang boleh diguna semula dibuat.

Sebagai contoh, mari kita lihat bagaimana kita boleh membuat tiga pertanyaan berasingan dan menggabungkannya bersama untuk mencapai pengering dan lebih banyak kod yang boleh diguna semula:

<span>SELECT id, username FROM users;
</span><span>SELECT id, username FROM users WHERE username LIKE "%tp%";
</span><span>SELECT id, username FROM users WHERE username LIKE "%tp%" LIMIT 10, 0;
</span>

Versi SQL agak berulang, tetapi versi ECTO di sisi lain agak kering. Pertanyaan pertama (get_users_overview) hanyalah pertanyaan generik untuk mendapatkan maklumat pengguna asas. Pertanyaan kedua (search_by_username) membina yang pertama dengan menapis nama pengguna mengikut beberapa nama pengguna yang kami cari. Pertanyaan ketiga (paginate_query) membina kedua, di mana ia menghadkan hasil dan mengambilnya dari offset tertentu (untuk memberikan asas untuk penomboran).

offset <span>= 0
</span>username <span>= <span>"%tp%"</span>
</span>
<span># Keywords query syntax
</span>get_users_overview <span>= from u in Ectoing.User,
</span>  <span>select: [u.id, u.username]
</span>
search_by_username <span>= from u in get_users_overview,
</span>  <span>where: like(u.username, ^username)
</span>
paginate_query <span>= from search_by_username,
</span>  <span>limit: 10,
</span>  <span>offset: ^offset
</span>
<span># Macro syntax
</span>get_users_overview <span>= (Ectoing.User
</span><span>|> select([u], [u.id, u.username]))
</span>
search_by_username <span>= (get_users_overview
</span><span>|> where([u], like(u.username, ^username)))
</span>
paginate_query <span>= (search_by_username
</span><span>|> limit(10)
</span><span>|> offset(^offset))
</span>
Ectoing<span>.Repo.all paginate_query
</span>

Tidak sukar untuk membayangkan bahawa semua tiga pertanyaan di atas boleh digunakan bersama untuk memberikan hasil carian apabila pengguna tertentu dicari. Setiap juga boleh digunakan bersempena dengan pertanyaan lain untuk melaksanakan keperluan aplikasi lain juga, semuanya tanpa mengulangi bahagian pertanyaan di seluruh codebase.

menyertai dan persatuan

Joins cukup mendasar ketika menanyakan, namun kita hanya menutupinya sekarang. Alasannya adalah kerana belajar tentang bergabung dalam Ecto sahaja tidak berguna: kita perlu tahu tentang persatuan juga. Walaupun ini tidak sukar untuk dipelajari, mereka tidak begitu remeh seperti topik lain yang diliputi setakat ini.

Cukup meletakkan, persatuan membolehkan pemaju mengendalikan hubungan meja (dilaksanakan sebagai kunci asing) dalam model. Mereka ditakrifkan dalam skema untuk setiap model menggunakan makro has_one/3 dan has_many/3 (untuk model yang mengandungi model lain), dan miliknya_to/3 makro (untuk model yang selain model lain - yang mempunyai kunci asing) .

Melihat aplikasi ectoing kami, kita dapat melihat satu contoh persatuan antara model ectoing.user dan model ectoing.message. Skema yang ditakrifkan dalam ectoing.user mentakrifkan persatuan berikut:

<span>SELECT id, username FROM users;
</span><span>SELECT id, username FROM users WHERE username LIKE "%tp%";
</span><span>SELECT id, username FROM users WHERE username LIKE "%tp%" LIMIT 10, 0;
</span>

kita dapat melihat bahawa satu pengguna mempunyai banyak mesej (ectoing.message), dan kami memanggil persatuan ini: mesej.

Dalam model ectoing.message, kami menentukan hubungan persatuan berikut:

offset <span>= 0
</span>username <span>= <span>"%tp%"</span>
</span>
<span># Keywords query syntax
</span>get_users_overview <span>= from u in Ectoing.User,
</span>  <span>select: [u.id, u.username]
</span>
search_by_username <span>= from u in get_users_overview,
</span>  <span>where: like(u.username, ^username)
</span>
paginate_query <span>= from search_by_username,
</span>  <span>limit: 10,
</span>  <span>offset: ^offset
</span>
<span># Macro syntax
</span>get_users_overview <span>= (Ectoing.User
</span><span>|> select([u], [u.id, u.username]))
</span>
search_by_username <span>= (get_users_overview
</span><span>|> where([u], like(u.username, ^username)))
</span>
paginate_query <span>= (search_by_username
</span><span>|> limit(10)
</span><span>|> offset(^offset))
</span>
Ectoing<span>.Repo.all paginate_query
</span>

di sini, kita mengatakan bahawa model, ectoing.message, tergolong dalam model ectoing.user. Kami juga menamakan Persatuan sebagai: Pengguna. Secara lalai, ecto akan menambahkan _id ke nama persatuan milik_to dan gunakannya sebagai nama kunci asing (jadi di sini, ia akan menjadi: user_id). Tingkah laku lalai ini boleh ditindih dengan secara manual menentukan nama kunci asing dengan menentukan pilihan asing_key. Contohnya:

has_many <span>:messages, Ectoing.Message
</span>

Mari kita lihat pertanyaan mudah yang menggunakan gabungan untuk mengambil pengguna dan mesej mereka:

belongs_to <span>:user, Ectoing.User
</span>

<span># Ectoing.Message
</span>belongs_to <span>:user, Ectoing.User, foreign_key: some_other_fk_name
</span>

Nilai yang dikembalikan:

<span>SELECT * FROM users u INNER JOIN messages m ON u.id = m.user_id WHERE u.id = 4;
</span>

dengan jelas, kami mempunyai beberapa persatuan yang dipunggah, termasuk: Persatuan Mesej. Memuatkan persatuan ini boleh dilakukan dalam salah satu daripada dua cara: dari set hasil pertanyaan atau dari dalam pertanyaan itu sendiri. Memuatkan persatuan dari set hasil boleh dilakukan dengan fungsi repo.preload:

<span># Keywords query syntax
</span>query <span>= from u in Ectoing.User,
</span>  <span>join: m in Ectoing.Message, on: u.id == m.user_id,
</span>  <span>where: u.id == 4
</span>
<span># Macro syntax
</span>query <span>= (Ectoing.User
</span><span>|> join(:inner, [u], m in Ectoing.Message, u.id == m.user_id)
</span><span>|> where([u], u.id == 4))
</span>
Ectoing<span>.Repo.all query
</span>

persatuan pemuatan dari dalam pertanyaan boleh dilakukan dengan menggunakan gabungan fungsi Assoc dan Preload:

<span>[%Ectoing.User{__meta__: #Ecto.Schema.Metadata<:loaded>,
</:loaded></span>  <span>firstname: <span>"Jane"</span>,
</span>  <span>friends_of: #Ecto.Association.NotLoaded<association :friends_of is not loaded>,
</association></span>  <span>friends_with: #Ecto.Association.NotLoaded<association :friends_with is not loaded>,
</association></span>  <span>id: 4,
</span>  <span>inserted_at: #Ecto.DateTime,
</span>  <span>messages: #Ecto.Association.NotLoaded<association :messages is not loaded>,
</association></span>  <span>surname: <span>"Doe"</span>,
</span>  <span>updated_at: #Ecto.DateTime,
</span>  <span>username: <span>"jane_doe"</span>},
</span> <span>%Ectoing.User{__meta__: #Ecto.Schema.Metadata<:loaded>,
</:loaded></span>  <span>firstname: <span>"Jane"</span>,
</span>  <span>friends_of: #Ecto.Association.NotLoaded<association :friends_of is not loaded>,
</association></span>  <span>friends_with: #Ecto.Association.NotLoaded<association :friends_with is not loaded>,
</association></span>  <span>id: 4,
</span>  <span>inserted_at: #Ecto.DateTime,
</span>  <span>messages: #Ecto.Association.NotLoaded<association :messages is not loaded>,
</association></span>  <span>surname: <span>"Doe"</span>,
</span>  <span>updated_at: #Ecto.DateTime,
</span>  <span>username: <span>"jane_doe"</span>}]
</span>

results <span>= Ectoing.Repo.all query
</span>Ectoing<span>.Repo.preload results, :messages
</span>

Sekarang, kami mempunyai persatuan mesej yang dimuatkan dalam hasilnya:

<span>SELECT * FROM users u INNER JOIN messages m ON u.id = m.user_id WHERE u.id = 4;
</span>

Persatuan secara tersirat menyertai lajur utama dan kunci utama untuk kami, dan oleh itu kami tidak perlu menentukan: pada klausa. Dari atas, kita juga dapat melihat bahawa ketika datang ke persatuan preloading, mereka tidak dimuatkan malas. Persatuan mesti dimuat secara eksplisit jika mereka dikehendaki.

Oleh kerana artikel ini secara khusus memberi tumpuan kepada DSL pertanyaan ECTO, kami tidak akan meliputi memasukkan, mengemas kini, atau memadam persatuan di sini. Untuk maklumat lanjut mengenai ini, lihat postingan blog yang bekerja dengan persatuan ECTO dan Embeds.

suntikan serpihan SQL

Walaupun ECTO menyediakan kita dengan banyak fungsi, ia hanya menyediakan fungsi untuk operasi biasa dalam SQL (ia tidak bertujuan untuk mencontohi keseluruhan bahasa SQL). Apabila kita perlu turun kembali ke SQL mentah, kita boleh menggunakan fungsi Fragment/1, membolehkan kod SQL disuntik secara langsung ke dalam pertanyaan.

Sebagai contoh, mari kita lakukan carian sensitif kes di medan nama pengguna:

<span>SELECT id, username FROM users;
</span><span>SELECT id, username FROM users WHERE username LIKE "%tp%";
</span><span>SELECT id, username FROM users WHERE username LIKE "%tp%" LIMIT 10, 0;
</span>

offset <span>= 0
</span>username <span>= <span>"%tp%"</span>
</span>
<span># Keywords query syntax
</span>get_users_overview <span>= from u in Ectoing.User,
</span>  <span>select: [u.id, u.username]
</span>
search_by_username <span>= from u in get_users_overview,
</span>  <span>where: like(u.username, ^username)
</span>
paginate_query <span>= from search_by_username,
</span>  <span>limit: 10,
</span>  <span>offset: ^offset
</span>
<span># Macro syntax
</span>get_users_overview <span>= (Ectoing.User
</span><span>|> select([u], [u.id, u.username]))
</span>
search_by_username <span>= (get_users_overview
</span><span>|> where([u], like(u.username, ^username)))
</span>
paginate_query <span>= (search_by_username
</span><span>|> limit(10)
</span><span>|> offset(^offset))
</span>
Ectoing<span>.Repo.all paginate_query
</span>

(di atas mengandungi SQL khusus MySQL. Jika anda menggunakan pangkalan data lain, maka ini tidak akan berfungsi untuk anda.)

Fungsi Fragment/1 mengambil kod SQL sebagai rentetan yang kami ingin menyuntik sebagai parameter pertama. Ia membolehkan lajur dan nilai terikat kepada serpihan kod SQL. Ini dilakukan melalui tempat letak (sebagai tanda tanya) dalam rentetan, dengan hujah -hujah berikutnya yang diserahkan kepada serpihan yang terikat kepada setiap pemegang tempat masing -masing.

Casting Explicit

Satu lagi cara ECTO menggunakan definisi skema model adalah secara automatik melengkapkan ekspresi interpolasi dalam pertanyaan kepada jenis medan masing -masing yang ditakrifkan dalam skema. Ekspresi interpolasi ini dibuang ke jenis medan yang dibandingkan dengan. Sebagai contoh, jika kita mempunyai serpihan pertanyaan seperti U.UserName> ^nama pengguna, di mana U.UserName ditakrifkan sebagai medan: nama pengguna ,: rentetan dalam skema, pembolehubah nama pengguna secara automatik akan dibuang ke rentetan oleh ecto.

kadang -kadang, bagaimanapun, kita tidak selalu mahu Ecto untuk membuang ekspresi interpolasi ke jenis medan yang ditakrifkan. Dan masa -masa lain, ECTO tidak akan dapat menyimpulkan jenis untuk membuang ungkapan kepada (biasanya, ini adalah apabila serpihan kod SQL terlibat). Dalam kedua -dua keadaan, kita boleh menggunakan fungsi Type/2 untuk menentukan ungkapan dan jenis yang harus dilemparkan ke.

Mari kita ambil kes pertama yang ingin membuang ekspresi kepada jenis lain, kerana ini adalah senario yang lebih menarik. Dalam aplikasi Ectoing kami, kami telah menggunakan makro ecto.schema.timestamps untuk menambah dua medan tambahan untuk setiap jadual kami: dikemas kini_at dan dimasukkan. Makro, secara lalai, menetapkan jenis medan ini untuk mempunyai jenis ecto.datetime. Sekarang, jika kita ingin melihat berapa banyak pengguna yang telah didaftarkan pada bulan semasa, kita boleh menggunakan pertanyaan mudah seperti yang berikut:

has_many <span>:messages, Ectoing.Message
</span>

Ini akan memberi kita ecto.casterror, kerana struktur ecto.date tidak boleh dilemparkan ke struktur ecto.datetime (kerana kita membandingkan ekspresi ecto.date interpolasi ke bidang jenis ecto.datetime ). Dalam kes ini, kita boleh membina struktur ecto.Datetime, atau kita boleh menentukan kepada Ecto yang kita ingin membuang ungkapan itu kepada ecto.date dan bukannya ecto.datetime:

belongs_to <span>:user, Ectoing.User
</span>

Sekarang, Ecto dengan gembira menerima pertanyaan. Selepas operasi pelakon, ia kemudian menerjemahkan ekspresi ecto.date interpolasi kepada asas: Jenis tarikh, yang kemudiannya membolehkan pangkalan data asas (MySQL, dalam kes ini) mengendalikan perbandingan antara tarikh dan datetime.

Akses medan dinamik

mari kita kembali kepada contoh kami dari menyusun pertanyaan bersama -sama, di mana kami melakukan carian nama pengguna:

<span>SELECT id, username FROM users;
</span><span>SELECT id, username FROM users WHERE username LIKE "%tp%";
</span><span>SELECT id, username FROM users WHERE username LIKE "%tp%" LIMIT 10, 0;
</span>

Seperti pertanyaan penomboran yang datang selepas itu, kita juga boleh menyebarkan pertanyaan ini, supaya ia dapat mencari mana -mana medan dari jadual yang diberikan. Ini boleh dilakukan dengan melakukan akses medan dinamik:

offset <span>= 0
</span>username <span>= <span>"%tp%"</span>
</span>
<span># Keywords query syntax
</span>get_users_overview <span>= from u in Ectoing.User,
</span>  <span>select: [u.id, u.username]
</span>
search_by_username <span>= from u in get_users_overview,
</span>  <span>where: like(u.username, ^username)
</span>
paginate_query <span>= from search_by_username,
</span>  <span>limit: 10,
</span>  <span>offset: ^offset
</span>
<span># Macro syntax
</span>get_users_overview <span>= (Ectoing.User
</span><span>|> select([u], [u.id, u.username]))
</span>
search_by_username <span>= (get_users_overview
</span><span>|> where([u], like(u.username, ^username)))
</span>
paginate_query <span>= (search_by_username
</span><span>|> limit(10)
</span><span>|> offset(^offset))
</span>
Ectoing<span>.Repo.all paginate_query
</span>

Fungsi medan/2 digunakan untuk apabila medan perlu ditentukan secara dinamik. Hujah pertamanya adalah jadual medan yang akan diakses, dan hujah kedua adalah nama medan itu sendiri, yang ditentukan sebagai atom. Menggunakan pertanyaan umum seperti di atas, kita boleh merangkumnya dalam fungsi dan menggunakan parameter untuk mencari mana -mana medan yang diberikan dari jadual yang dinyatakan dalam pertanyaan yang diberikan.

Kesimpulan

Dalam kedua -dua ini dan artikel terdahulu saya mengenai DSL pertanyaan ECTO, kami telah meliputi banyak perkara yang mampu. Ciri -ciri yang disebutkan harus meliputi sebahagian besar kes yang dihadapi ketika menggunakan ECTO dalam aplikasi. Tetapi masih terdapat beberapa topik yang belum dilindungi (seperti awalan pertanyaan). Terdapat juga semua ciri-ciri baru yang akan datang dalam pelepasan 2.0 yang dijangkakan oleh ECTO, termasuk sub pertanyaan, pertanyaan agregasi, dan banyak persatuan. Ini, serta ciri -ciri lain yang tidak khusus untuk DSL pertanyaan ECTO, akan diliputi dalam artikel masa depan - jadi tunggu!

Soalan Lazim (Soalan Lazim) Mengenai Elixir's Ecto Query DSL

Apakah Elixir's Ecto Querying DSL dan mengapa ia penting? Ia menyediakan cara untuk menulis pertanyaan dalam sintaks yang dekat dengan SQL, tetapi dengan manfaat tambahan keselamatan masa kompilasi, integrasi yang lebih baik dengan kod elixir, dan potensi untuk penggunaan semula dan kod semula. Ia penting kerana ia membolehkan pemaju menulis pertanyaan yang kompleks dengan cara yang lebih mudah dibaca dan dapat dipelihara, mengurangkan kemungkinan kesilapan dan membuat kod lebih mudah difahami dan diubah suai. Ecto menyediakan cara untuk menentukan persatuan antara jadual menggunakan has_many, has_one, dan milik makro. Persatuan ini membolehkan anda menanyakan data berkaitan dengan cara yang mudah dan cekap. Sebagai contoh, jika anda mempunyai skema pengguna dan setiap pengguna mempunyai banyak jawatan, anda boleh mengambil semua jawatan untuk pengguna dengan pertanyaan mudah. ? Anda boleh menggunakan kata kunci Join untuk menyertai jadual, dari kata kunci untuk membuat subqueries, dan berfungsi seperti SUM, AVG, MIN, dan MAX untuk melakukan agregasi. Ini menjadikan ECTO alat yang berkuasa untuk menanyakan data dengan cara yang kompleks.

Bagaimanakah ecto mengendalikan transaksi?

ECTO menyediakan fungsi repo.transaction yang membolehkan anda melaksanakan pelbagai operasi dalam satu transaksi. Sekiranya mana -mana operasi gagal, semua perubahan yang dibuat dalam urus niaga dilancarkan. Ini memastikan konsistensi dan integriti data. SQLITE. Anda boleh menentukan jenis pangkalan data semasa menyediakan repositori Ecto anda. cara terkawal dan boleh diterbalikkan. Anda boleh menjana fail penghijrahan menggunakan tugas campuran, dan kemudian menentukan perubahan dalam fail penghijrahan menggunakan dsl ecto. Ya, ECTO menyediakan fungsi perubahan yang membolehkan anda mengesahkan data sebelum dimasukkan atau dikemas kini dalam pangkalan data. Anda boleh menentukan peraturan pengesahan dalam skema anda, dan kemudian gunakan fungsi changeSet untuk menggunakan peraturan ini pada data. sambungan. Ini membolehkannya untuk mengendalikan pelbagai pertanyaan serentak, memastikan aplikasi anda tetap responsif walaupun di bawah beban berat. Cara yang tinggi, cara yang ditarik untuk menulis pertanyaan, anda juga boleh menggunakan fungsi ecto.adapters.sql.Query untuk melaksanakan pertanyaan SQL mentah jika diperlukan. Ecto menyediakan fungsi ecto.query.api.dynamic yang membolehkan anda membina pertanyaan secara dinamik, tanpa skema yang telah ditetapkan. Ini berguna apabila anda perlu membina pertanyaan berdasarkan input pengguna atau data runtime yang lain.

Atas ialah kandungan terperinci Elixir ' s ecto pertanyaan DSL: Beyond the Basics. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!