Penamaan kolom ID dalam tabel database

Saya bertanya-tanya pendapat orang tentang penamaan kolom ID dalam tabel database.

Jika saya memiliki tabel yang disebut Faktur dengan kunci utama dari kolom identitas, saya akan memanggil kolom itu InvoiceID sehingga saya tidak akan konflik dengan tabel lain dan jelas apa itu.

Di mana saya bekerja saat ini mereka telah memanggil semua ID kolom ID.

Jadi mereka akan melakukan hal berikut:

Select  
    i.ID 
,   il.ID 
From
    Invoices i
    Left Join InvoiceLines il
        on i.ID = il.InvoiceID

Sekarang, saya melihat beberapa masalah di sini:
1. Anda perlu alias kolom di pilih
2. ID = InvoiceID tidak pas di otak saya
3. Jika Anda tidak membuat alias tabel dan merujuk ke InvoiceID apakah sudah jelas tabel apa sudah menyala?

Apa pendapat orang lain tentang topik ini?

ID adalah Antipattern SQL. Lihat http://www.amazon.com/s/ref=nb_sb_ss_i_1_5?url=search-alias%3Dstripbooks&field-keywords=sql+antipatterns&sprefix=sql+a

Jika Anda memiliki banyak tabel dengan ID sebagai id, Anda membuat pelaporan yang jauh lebih sulit. Ini mengaburkan makna dan membuat kueri kompleks lebih sulit dibaca serta mengharuskan Anda menggunakan alias untuk membedakan laporan itu sendiri.

Lebih lanjut, jika seseorang cukup bodoh untuk menggunakan gabungan alami dalam database di mana mereka tersedia, Anda akan bergabung ke rekaman yang salah.

Jika Anda ingin menggunakan sintaks USING yang diizinkan oleh beberapa dbs, Anda tidak dapat menggunakan ID jika Anda menggunakan.

Jika Anda menggunakan ID Anda dapat dengan mudah berakhir dengan kesalahan bergabung jika Anda kebetulan menyalin sintaks bergabung (jangan beri tahu saya bahwa tidak ada yang pernah melakukan ini!) Dan lupa untuk mengubah alias dalam kondisi bergabung.

Jadi sekarang Anda punya

select t1.field1, t2.field2, t3.field3
from table1 t1 
join table2 t2 on t1.id = t2.table1id
join table3 t3 on t1.id = t3.table2id

saat yang Anda maksud

select t1.field1, t2.field2, t3.field3 
from table1 t1 
join table2 t2 on t1.id = t2.table1id
join table3 t3 on t2.id = t3.table2id

Jika Anda menggunakan tablenameID sebagai kolom id, jenis kesalahan tidak disengaja seperti ini jauh lebih kecil kemungkinannya untuk terjadi dan lebih mudah ditemukan.

Saya selalu lebih suka ID daripada TableName + ID untuk kolom id dan kemudian TableName + ID untuk kunci asing. Dengan begitu semua tabel memiliki nama yang sama untuk bidang id dan tidak ada deskripsi yang berlebihan. Ini tampak lebih sederhana bagi saya karena semua tabel memiliki nama bidang kunci utama yang sama.

Sejauh menggabungkan tabel dan tidak mengetahui field Id mana yang termasuk dalam tabel mana, menurut saya query harus ditulis untuk menangani situasi ini. Di mana saya bekerja, kami selalu mendahului bidang yang kami gunakan dalam pernyataan dengan alias tabel / tabel.

Ada pertengkaran aneh tentang hal ini di perusahaan saya akhir-akhir ini. Munculnya LINQ telah membuat pola tablename + ID yang berlebihan semakin terlihat konyol di mata saya. Saya pikir sebagian besar orang yang masuk akal akan mengatakan bahwa jika Anda menulis SQL Anda sedemikian rupa sehingga Anda harus menentukan nama tabel untuk membedakan FK, maka itu bukan hanya penghematan untuk mengetik, tetapi juga menambah kejelasan pada SQL Anda untuk digunakan saja ID di dalamnya Anda dapat dengan jelas melihat mana yang PK dan mana yang FK .

Misalnya

DARI Karyawan e KIRI GABUNG Pelanggan c ON e.ID = c.EmployeeID

memberi tahu saya tidak hanya bahwa keduanya terkait, tetapi mana yang PK dan mana yang FK . Sedangkan di gaya lama Anda dipaksa untuk melihat atau berharap nama mereka baik.

Kami menggunakan InvoiceID, tidak ID. Itu membuat kueri lebih mudah dibaca - ketika Anda melihatnya IDsendiri itu bisa berarti apa saja, terutama ketika Anda membuat alias tabel i.

Saya setuju dengan Keven dan beberapa orang lain di sini bahwa PK untuk sebuah tabel seharusnya hanya Id dan kunci asing mencantumkan OtherTable + Id.

Namun saya ingin menambahkan satu alasan yang baru-baru ini memberi bobot lebih pada argumen ini.

Dalam posisi saya saat ini, kami menggunakan kerangka entitas menggunakan generasi POCO. Menggunakan konvensi penamaan standar Id, PK memungkinkan pewarisan kelas poco dasar dengan validasi dan semacamnya untuk tabel yang berbagi sekumpulan nama kolom umum. Menggunakan Tablename + Id sebagai PK untuk masing-masing tabel ini menghancurkan kemampuan untuk menggunakan kelas dasar untuk ini.

Hanya beberapa makanan untuk dipikirkan.

Preferensi saya juga ID untuk kunci utama dan TableNameID untuk kunci asing. Saya juga ingin memiliki kolom "nama" di sebagian besar tabel tempat saya menyimpan pengenal yang dapat dibaca pengguna (yaitu nama :-)) dari entri tersebut. Struktur ini menawarkan fleksibilitas besar dalam aplikasi itu sendiri, saya dapat menangani tabel secara massal, dengan cara yang sama. Ini adalah hal yang sangat kuat. Biasanya perangkat lunak OO dibangun di atas database, tetapi perangkat OO tidak dapat diterapkan karena db itu sendiri tidak mengizinkannya. Memiliki kolom id dan name masih kurang baik, tetapi itu adalah sebuah langkah.

Pilih
i.ID, il.ID Dari Invoices i Left Join InvoiceLines il di i.ID = il.InvoiceID

Mengapa saya tidak bisa melakukan ini?

Select  
    Invoices.ID 
,   InvoiceLines.ID 
From
    Invoices
    Left Join InvoiceLines
        on Invoices.ID = InvoiceLines.InvoiceID

Menurut pendapat saya ini sangat mudah dibaca dan sederhana. Penamaan variabel sebagai i dan il adalah pilihan yang buruk secara umum.

Ini tidak terlalu penting, Anda kemungkinan besar akan mengalami masalah simalar di semua konvensi penamaan.

Tapi penting untuk konsisten sehingga Anda tidak perlu melihat definisi tabel setiap kali Anda menulis kueri.

Saya baru saja mulai bekerja di tempat yang hanya menggunakan "ID" (dalam tabel inti, direferensikan oleh TableNameID dalam kunci asing), dan telah menemukan DUA masalah produksi yang secara langsung disebabkan olehnya.

Dalam satu kasus, kueri menggunakan "... dengan ID masuk (SELECT ID FROM OtherTable ..." daripada "... where ID in (SELECT TransID FROM OtherTable ...".

Adakah yang bisa dengan jujur ​​mengatakan bahwa tidak akan jauh lebih mudah untuk dikenali jika nama yang lengkap dan konsisten digunakan di mana pernyataan yang salah akan berbunyi "... di mana TransID masuk (SELECT OtherTableID dari OtherTable ..."? Saya tidak berpikir begitu.

Masalah lainnya terjadi saat refactoring kode. Jika Anda menggunakan tabel temp sementara sebelumnya kueri keluar dari tabel inti maka kode lama membaca "... dbo.MyFunction (t.ID) ..." dan jika itu tidak diubah tetapi "t" sekarang merujuk ke a tabel temp daripada tabel inti, Anda bahkan tidak mendapatkan kesalahan - hanya hasil yang salah.

Jika menghasilkan kesalahan yang tidak perlu adalah sebuah tujuan (mungkin beberapa orang tidak memiliki cukup pekerjaan?), Maka konvensi penamaan semacam ini bagus. Jika tidak, penamaan yang konsisten adalah cara yang tepat.

Demi kesederhanaan, kebanyakan orang memberi nama kolom pada tabel ID. Jika memiliki referensi kunci asing di tabel lain, maka mereka secara eksplisit menyebutnya InvoiceID (untuk menggunakan contoh Anda) dalam kasus gabungan, Anda tetap aliasing tabel sehingga inv.ID eksplisit masih lebih sederhana daripada inv.InvoiceID

Saya pribadi lebih suka (seperti yang telah disebutkan di atas) Table.ID untuk PK dan TableID untuk FK . Bahkan (tolong jangan tembak saya) Microsoft Access merekomendasikan ini.

NAMUN, SAYA JUGA tahu pasti bahwa beberapa alat pembangkit menyukai TableID untuk PK karena mereka cenderung menghubungkan semua nama kolom yang mengandung 'ID' dalam kata, TERMASUK ID !!!

Bahkan desainer kueri melakukan ini di Microsoft SQL Server (dan untuk setiap kueri yang Anda buat, Anda akhirnya merobek semua hubungan yang baru dibuat tidak perlu di semua tabel di kolom ID)

DEMIKIANLAH Meskipun OCD internal saya membencinya, saya menggunakan konvensi TableID . Mari kita ingat bahwa ini disebut BASE Data , karena ini akan menjadi basis untuk banyak aplikasi yang akan datang. Dan semua teknologi Harus mendapatkan keuntungan normalisasi dengan baik dengan skema deskripsi yang jelas.

Tak perlu dikatakan bahwa SAYA menggambar garis saya ketika orang mulai menggunakan NamaTabel, TabelDeskripsi dan semacamnya. Menurut pendapat saya, konvensi harus melakukan hal berikut:

• Nama tabel: Pluralized. Ex. Para karyawan

• Alias ​​tabel: Nama tabel lengkap, tunggal. Ex.

  SELECT Employee.*, eMail.Address
  FROM Employees AS Employee LEFT JOIN eMails as eMail on Employee.eMailID = eMail.eMailID -- I would sure like it to just have the eMail.ID here.... but oh well

[Memperbarui]

Selain itu, ada beberapa postingan valid di utas ini tentang kolom duplikat karena "jenis hubungan" atau perannya. Contoh, jika Store memiliki EmployeeID , itu memberi tahu saya squat. Jadi terkadang saya melakukan sesuatu seperti Store.EmployeeID_Manager . Tentu itu sedikit lebih besar tetapi setidaknya orang tidak akan gila mencoba menemukan tabel ManagerID , atau apa yang dilakukan EmployeeID di sana. Ketika menanyakan DI MANA saya akan menyederhanakannya sebagai: SELECT EmployeeID_Manager sebagai ManagerID FROM Store

Melihat ini dari perspektif kamus data formal, saya akan menamai elemen data invoice_ID. Umumnya, nama elemen data akan unik dalam kamus data dan idealnya akan memiliki nama yang sama di seluruh, meskipun terkadang istilah kualifikasi tambahan mungkin diperlukan berdasarkan konteks misalnya elemen data bernama employee_IDdapat digunakan dua kali dalam bagan organisasi dan oleh karena itu memenuhi syarat sebagai supervisor_employee_IDdan subordinate_employee_IDmasing - masing.

Jelas, konvensi penamaan bersifat subjektif dan masalah gaya. Saya telah menemukan pedoman ISO / IEC 11179 sebagai titik awal yang berguna.

Untuk DBMS, saya melihat tabel sebagai kumpulan entites (kecuali tabel yang hanya berisi satu baris misalnya tabel cofig, tabel konstanta, dll) misalnya tabel di mana my employee_IDadalah kuncinya akan dinamai Personnel. Jadi TableNameIDkonvensi tidak langsung berhasil untuk saya.

Saya telah melihat TableName.ID=PK TableNameID=FKgaya yang digunakan pada model data besar dan harus mengatakan saya merasa sedikit membingungkan: Saya lebih suka nama pengenal harus sama di seluruh yaitu tidak mengubah nama berdasarkan tabel mana yang kebetulan muncul. Sesuatu yang perlu diperhatikan adalah Gaya yang disebutkan di atas tampaknya digunakan di toko-toko yang menambahkan IDENTITYkolom (kenaikan otomatis) ke setiap tabel sambil menghindari kunci alami dan gabungan dalam kunci asing. Toko-toko tersebut cenderung tidak memiliki kamus data formal atau membangun dari model data. Sekali lagi, ini hanyalah masalah gaya dan masalah yang tidak saya ikuti secara pribadi. Jadi akhirnya, ini bukan untuk saya.

Semua yang dikatakan, saya dapat melihat kasus kadang-kadang menjatuhkan qualifier dari nama kolom ketika nama tabel memberikan konteks untuk melakukannya misalnya elemen bernama employee_last_namemungkin menjadi sederhana last_namedi Personneltabel. Alasannya di sini adalah bahwa domain tersebut adalah 'nama belakang orang' dan lebih cenderung UNIONdiedit dengan last_namekolom dari tabel lain daripada digunakan sebagai kunci asing di tabel lain, tapi sekali lagi ... Saya mungkin berubah pikiran, terkadang Anda tidak pernah tahu. Itulah masalahnya: pemodelan data adalah bagian seni, bagian sains.

Saya pikir Anda dapat menggunakan apa saja untuk "ID" selama Anda konsisten. Penting untuk memasukkan nama tabel. Saya akan menyarankan menggunakan alat pemodelan seperti Erwin untuk menegakkan konvensi dan standar penamaan sehingga saat menulis kueri, mudah untuk memahami hubungan yang mungkin ada di antara tabel.

Yang saya maksud dengan pernyataan pertama adalah, alih-alih ID Anda dapat menggunakan sesuatu yang lain seperti 'recno'. Jadi tabel ini akan memiliki PK invoice_recno dan seterusnya.

Cheers, Ben

Pilihan saya adalah InvoiceID untuk ID tabel. Saya juga menggunakan konvensi penamaan yang sama ketika digunakan sebagai kunci asing dan menggunakan nama alias cerdas dalam kueri.

 Select Invoice.InvoiceID, Lines.InvoiceLine, Customer.OrgName
 From Invoices Invoice
 Join InvoiceLines Lines on Lines.InvoiceID = Invoice.InvoiceID
 Join Customers Customer on Customer.CustomerID = Invoice.CustomerID

Tentu, ini lebih panjang dari beberapa contoh lainnya. Tapi tersenyumlah. Ini untuk anak cucu dan suatu hari nanti, beberapa pembuat kode junior yang malang harus mengubah karya Anda. Dalam contoh ini tidak ada ambiguitas dan karena tabel tambahan ditambahkan ke kueri, Anda akan berterima kasih atas verbositasnya.

Untuk nama kolom di database, saya akan menggunakan "InvoiceID".

Jika saya menyalin bidang ke dalam struct tanpa nama melalui LINQ, saya dapat menamainya "ID" di sana, jika itu satu-satunya ID dalam struktur.

Jika kolom TIDAK akan digunakan dalam kunci asing, sehingga hanya digunakan untuk mengidentifikasi baris secara unik untuk diedit atau dihapus, saya akan menamakannya "PK".

Jika Anda memberi setiap kunci nama unik, misalnya "invoices.invoice_id" daripada "invoices.id", maka Anda dapat menggunakan operator "gabungan alami" dan "menggunakan" tanpa khawatir. Misalnya

SELECT * FROM invoices NATURAL JOIN invoice_lines
SELECT * FROM invoices JOIN invoice_lines USING (invoice_id)

dari pada

SELECT * from invoices JOIN invoice_lines
    ON invoices.id = invoice_lines.invoice_id

SQL cukup bertele-tele tanpa membuatnya lebih bertele-tele.

Apa yang saya lakukan untuk menjaga agar semuanya tetap konsisten untuk diri saya sendiri (di mana tabel memiliki kunci utama satu kolom yang digunakan sebagai ID) adalah memberi nama kunci utama tabel Table_pk. Di mana pun saya memiliki kunci asing yang menunjuk ke kunci utama tabel itu, saya memanggil kolom PrimaryKeyTable_fk. Dengan cara itu saya tahu bahwa jika saya memiliki a Customer_pkdi tabel Pelanggan saya dan a Customer_fkdi tabel Pesanan saya, saya tahu bahwa tabel Pesanan mengacu pada entri di tabel Pelanggan.

Bagi saya, ini masuk akal terutama untuk gabungan yang menurut saya lebih mudah dibaca.

SELECT * 
FROM Customer AS c
    INNER JOIN Order AS c ON c.Customer_pk = o.Customer_fk

FWIW, standar baru kami (yang berubah, eh, maksud saya "berkembang", dengan setiap proyek baru) adalah:

• Nama bidang database huruf kecil
• Nama tabel huruf besar
• Gunakan garis bawah untuk memisahkan kata dalam nama bidang - ubah ini menjadi huruf Pascal dalam kode.
• pk_ awalan berarti kunci utama
• _id akhiran berarti bilangan bulat, ID kenaikan otomatis
• fk_ prefiks berarti kunci asing (tidak perlu sufiks)
• _VW akhiran untuk tampilan
• is_ awalan untuk boolean

Jadi, tabel bernama NAMES mungkin memiliki bidang pk_name_id, first_name, last_name, is_alive,dan fk_companytampilan yang disebut LIVING_CUSTOMERS_VW, didefinisikan seperti:

PILIH first_name, last_name
DARI KONTAK. NAMA
DI MANA (is_alive = 'True')

Namun, seperti yang dikatakan orang lain, hampir semua skema akan berhasil selama konsisten dan tidak mengaburkan makna Anda secara tidak perlu.

Saya sangat setuju dengan memasukkan nama tabel dalam nama field ID, untuk alasan yang Anda berikan. Secara umum, ini adalah satu-satunya bidang tempat saya akan menyertakan nama tabel.

Aku benci nama id biasa. Saya sangat memilih untuk selalu menggunakan invoice_id atau variannya. Saya selalu tahu tabel mana yang merupakan tabel otoritatif untuk id ketika saya membutuhkannya, tetapi ini membingungkan saya

SELECT * from Invoice inv, InvoiceLine inv_l where 
inv_l.InvoiceID = inv.ID 
SELECT * from Invoice inv, InvoiceLine inv_l where 
inv_l.ID = inv.InvoiceLineID 
SELECT * from Invoice inv, InvoiceLine inv_l where 
inv_l.ID = inv.InvoiceID 
SELECT * from Invoice inv, InvoiceLine inv_l where 
inv_l.InvoiceLineID = inv.ID 

Yang terburuk dari semuanya adalah campuran yang Anda sebutkan, benar-benar membingungkan. Saya harus bekerja dengan database di mana hampir selalu foo_id kecuali di salah satu id yang paling sering digunakan. Itu benar-benar neraka.

Saya lebih suka DomainName || 'INDO'. (yaitu DomainName + ID)

DomainName seringkali, tetapi tidak selalu, sama dengan TableName.

Masalah dengan ID dengan sendirinya adalah bahwa itu tidak meningkatkan skala. Setelah Anda memiliki sekitar 200 tabel, masing-masing dengan kolom pertama bernama ID, datanya mulai terlihat sama. Jika Anda selalu memenuhi syarat ID dengan nama tabel, itu sedikit membantu, tetapi tidak terlalu banyak.

DomainName & ID dapat digunakan untuk memberi nama kunci asing serta kunci utama. Ketika kunci luar diberi nama setelah kolom yang mereka referensikan, itu bisa menjadi bantuan mnemonik. Secara formal, tidak perlu mengaitkan nama kunci asing ke kunci yang dirujuknya, karena batasan integritas referensial akan membentuk referensi. Tapi ini sangat berguna saat membaca kueri dan pembaruan.

Terkadang, DomainName || 'ID' tidak dapat digunakan, karena akan ada dua kolom dalam tabel yang sama dengan nama yang sama. Contoh: Employees.EmployeeID dan Employees.SupervisorID. Dalam kasus tersebut, saya menggunakan RoleName || 'ID', seperti pada contoh.

Last but not least, saya menggunakan kunci alami daripada kunci sintetis bila memungkinkan. Ada situasi di mana kunci alami tidak tersedia atau tidak dapat dipercaya, tetapi ada banyak situasi di mana kunci alami adalah pilihan yang tepat. Dalam kasus tersebut, saya membiarkan kunci alami mengambil nama yang seharusnya dimiliki. Nama ini seringkali bahkan tidak memiliki huruf, 'ID' di dalamnya. Contoh: OrderNo dimana No adalah singkatan dari "Number".

Untuk setiap tabel saya memilih singkatan huruf pohon (misalnya Karyawan => Emp)

Dengan cara itu kunci utama numerik autonumber menjadi nkEmp .

Singkat, unik di seluruh database dan saya tahu persis propertinya dalam sekejap.

Saya menyimpan nama yang sama di SQL dan semua bahasa yang saya gunakan (kebanyakan C #, Javascript, VB6).

Lihat konvensi penamaan situs Interakt untuk sistem tabel dan kolom penamaan yang dipikirkan dengan matang. Metode ini menggunakan sufiks untuk setiap tabel ( _prduntuk tabel produk, atau _ctguntuk tabel kategori) dan menambahkannya ke setiap kolom dalam tabel tertentu. Jadi kolom identitas untuk tabel produk akan id_prddan oleh karena itu unik dalam database.

Mereka melangkah lebih jauh untuk membantu memahami kunci asing: Kunci asing dalam tabel produk yang mengacu pada tabel kategori akan idctg_prdsehingga jelas tabel mana yang dimilikinya ( _prdsufiks) dan ke tabel mana yang dirujuk (kategori) .

Keuntungannya adalah tidak ada ambiguitas dengan kolom identitas di tabel yang berbeda, dan Anda dapat mengetahui secara sekilas kolom mana yang dirujuk oleh kueri dengan nama kolom.

lihat juga Konvensi penamaan kunci primer / kunci asing

Anda dapat menggunakan konvensi penamaan berikut. Ini memiliki kekurangan tetapi memecahkan masalah khusus Anda.

1. Gunakan nama panggilan pendek (3-4 karakter) untuk nama tabel, yaitu Invoice - inv, InvoiceLines -invl
2. Beri nama kolom dalam tabel menggunakan nama panggilan tersebut, yaitu inv_id,invl_id
3. Untuk kolom referensi, gunakan invl_inv_idnama.

dengan cara ini Anda bisa mengatakan

SELECT * FROM Invoice LEFT JOIN InvoiceLines ON inv_id = invl_inv_id