Mysql
 sql >> Teknologi Basis Data >  >> RDS >> Mysql

CREATE TABLE MySQL vs T-SQL dengan Contoh Sintaks

Apakah Anda seorang pengembang T-SQL yang mempelajari dasar-dasar MySQL? Kemudian, salah satu hal yang mungkin ingin Anda pelajari adalah pernyataan MySQL CREATE TABLE. Selain itu, cara tercepat untuk mempelajari platform database SQL baru adalah dengan membandingkan fungsionalitas dan sintaksisnya yang umum.

Itulah yang akan kita lakukan hari ini. Tapi sintaks lengkapnya banyak. Jadi, kami hanya akan membahas 5 poin dasar untuk membuat Anda siap dan berjalan dengan perintah MySQL CREATE TABLE.

Namun, sebelum kita melanjutkan, mari kita perjelas beberapa poin:

  1. Versi MySQL yang digunakan di sini adalah MySQL 8 menggunakan mesin penyimpanan InnoDB.
  2. Versi SQL Server yang digunakan di sini adalah SQL Server 2019.

Kedengarannya bagus? Mari kita mulai.

Membuat Pernyataan Tabel di MySQL dan T-SQL

Mari kita mulai perbandingan dengan mendefinisikan nama tabel.

Salah satu perbedaan sintaks yang terlihat di MySQL CREATE TABLE adalah tidak adanya nama skema. Begini caranya:

CREATE TABLE database_name.table_name

Apakah Anda memperhatikan nama tabel didahului dengan nama database? Sekarang, inilah format setara T-SQL yang Anda kenal:


CREATE TABLE database_name.schema_name.table_name

Mengapa? Karena di MySQL, skema identik dengan database. Nama database dan skema bersifat opsional. Namun, jika Anda perlu membuat tabel di database lain dalam skrip yang sama, ini adalah suatu keharusan.

Betul sekali. Menggunakan tanda kurung siku dalam nama tabel dan kolom akan memicu kesalahan di MySQL. Anda harus menggunakan sepasang backtick untuk menyertakan pengidentifikasi sebagai gantinya. Gambar 1 menunjukkan di mana Anda menemukannya pada tata letak keyboard AS:

Sekarang, lihat contohnya:

-- MySQL CREATE TABLE

CREATE TABLE `testdatabase`.`person` (
  `BusinessEntityID` INT NOT NULL,
  `PersonType` NCHAR(2) NOT NULL,
  `Title` VARCHAR(8) NULL,
  `FirstName` NVARCHAR(50) NOT NULL,
  `MiddleName` VARCHAR(50) NULL,
  `LastName` VARCHAR(50) NOT NULL,
  `Suffix` NVARCHAR(10) NULL,
  `EmailPromotion` INT NOT NULL,
  `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
  PRIMARY KEY (`BusinessEntityID`));

Dari contoh kode di atas, pengidentifikasi nama tabel dan kolom diapit oleh tanda centang balik. Jika Anda tidak terbiasa melampirkan nama tabel dan kolom dengan ini, percayalah, Anda tidak sendirian.

Periksa kode yang setara dalam T-SQL di bawah ini:

-- T-SQL CREATE TABLE
CREATE TABLE [testdatabase].[dbo].[Person](
	[BusinessEntityID] [int] NOT NULL,
	[PersonType] [nchar](2) NOT NULL,
	[Title] [nvarchar](8) NULL,
	[FirstName] [nvarchar](50) NOT NULL,
	[MiddleName] [nvarchar](50) NULL,
	[LastName] [nvarchar](50) NOT NULL,
	[Suffix] [nvarchar](10) NULL,
	[EmailPromotion] [int] NOT NULL,
	[ModifiedDate] [datetime] NOT NULL DEFAULT GETDATE(),
 CONSTRAINT [PK_Person_BusinessEntityID] PRIMARY KEY  
  (
	[BusinessEntityID] ASC
  )
) ON [PRIMARY]

Tentu saja, Anda tidak perlu menyertakan pengidentifikasi ini. Tetapi jika Anda menggunakan kata atau spasi cadangan dalam nama tabel atau kolom, akan terjadi kesalahan.

Cara Buat Tabel Sementara

Menyukai meja sementara? Kemudian MySQL akan membiarkan Anda mengetik lebih banyak untuk menentukan tabel sementara. Lihat contohnya:

-- MySQL Temporary Table

CREATE TEMPORARY TABLE `MyTempTable`

Sementara itu, pembuat kode T-SQL digunakan untuk # simbol sebelum nama tabel. Lihat kode yang setara dari kode di atas:


-- T-SQL Temporary Table

CREATE TABLE #MyTempTable

Kami sudah selesai dengan definisi dan nama tabel. Mari kita lanjutkan dengan definisi kolom.

Sintaks Kolom MySQL

Anda tidak dapat memiliki tabel SQL dasar tanpa kolom. Jadi, apa persamaan dan perbedaan antara MySQL dan SQL Server?

Nama Kolom dan Tipe Data

Anda sudah tahu tentang backtick. Hal lain yang mendasar tentang nama kolom dan tipe data adalah sama di MySQL dan T-SQL. Lihat contoh di bawah ini:

CREATE TABLE `testdatabase`.`people`
(
    `ID` INT,
    `LastName` VARCHAR(50),
    ...
);

Namun, masih ada lagi.

Kolom Nullability

Kolom bisa nullable atau tidak. Anda dapat melakukannya dengan menambahkan NULL atau NOT NULL dalam definisi kolom.

Mari kita kembangkan contoh kita sebelumnya.

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NULL,
     ...
);

Ini hampir sama dengan T-SQL. Bagaimana dengan nilai default?

Nilai Default Kolom

Selanjutnya adalah nilai default kolom. Ini berguna saat Anda menyisipkan catatan tetapi tidak menentukan nilai tertentu untuk kolom. Mari kita perluas contoh kita sebelumnya lagi:

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NULL,
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
     ...
);

Tanggal Modifikasi kolom default ke tanggal dan waktu sistem saat ini. Jika Anda melakukan INSERT pada tabel ini seperti di bawah ini, akan selalu ada nilai untuk ModifiedDate .

INSERT INTO testdatabase.people
(ID, LastName, FirstName, MiddleName)
VALUES
(1,'Kirk','James','Tiberius');

Ini berfungsi seperti yang diharapkan setelah INSERT. Berikut screenshot dari dbForge Studio untuk MySQL:

MySQL Buat Tabel dengan Kunci Utama, Asing, dan Unik

Seperti di platform SQL mana pun, Anda dapat menentukan aturan pada data kolom tabel menggunakan batasan di MySQL. Karena ini penting untuk desain tabel, kita perlu mempertimbangkan poin berikutnya.

Pengembang T-SQL harus merasa betah dengan kunci utama MySQL, kunci asing, dan kunci unik.

Kunci Utama

Anda dapat menentukan satu atau beberapa kolom sebagai kunci utama. Sintaksnya hampir sama dengan di SQL Server. Ada pengecualian? Ya. Ini adalah penggunaan indeks berkerumun dan tidak berkerumun. Tapi mari kita simpan pembahasan ini di bagian selanjutnya.

Untuk saat ini, kami fokus pada sintaks kunci utama. Berikut adalah contoh yang sama yang kami miliki sebelumnya, tetapi kami menambahkan kolom ID sebagai kunci utama:

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL PRIMARY KEY,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NULL,
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW()
);

Mudah bukan?

Tetapi bagaimana jika Anda membutuhkan banyak kolom? Seperti di T-SQL, Anda memiliki 2 opsi. Periksa contoh di bawah ini:

-- OPTION 1: Let MySQL generate the constraint name

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
     PRIMARY KEY (`LastName`,`FirstName`,`MiddleName`)
);

-- OPTION 2: Specify your constraint name

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
    CONSTRAINT `pk_name` PRIMARY KEY (`LastName`, `FirstName`, `MiddleName`)
);

Itu saja untuk kunci utama.

Kunci Asing

Kendala penting lainnya adalah kunci asing. Ini digunakan untuk referensi silang tabel ke tabel lain:

CREATE TABLE `testdatabase`.`address`
(
    `ID` int NOT NULL PRIMARY KEY,
    `parent_id` int NOT NULL,
    `full_address` varchar(100) NOT NULL,
    CONSTRAINT `FK_address_parent_id` FOREIGN KEY (`parent_id`)
    REFERENCES `people` (`ID`)
);

Apakah Anda melihat kesamaan dengan T-SQL?

Kunci Unik

Terkadang, Anda ingin memastikan bahwa data yang dimasukkan ke dalam tabel adalah unik. MySQL juga mendukung kunci unik. Ini contohnya:

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
    CONSTRAINT `PK_people_id` PRIMARY KEY (`ID`),
    CONSTRAINT `IDX_name` UNIQUE KEY (`LastName`,`FirstName`,`MiddleName`)

);

Kode di atas akan memastikan bahwa hanya nama unik yang akan ditambahkan ke tabel.

Buat Contoh Indeks Tabel (Berkelompok dan Tidak Berkelompok)

Pada contoh sebelumnya, Anda telah melihat kunci primer dan sekunder dibuat. Tapi di mana indeks berkerumun dan tidak berkerumun? Itu terlihat karena di SQL Server Anda secara eksplisit menentukan kata kunci CLUSTERED untuk membuat indeks berkerumun.

Bagian yang menarik adalah MySQL tidak memiliki kata kunci CLUSTERED atau NONCLUSTERED. Bagaimana Anda membuat indeks berkerumun?

Sederhana. Cukup tentukan kolom sebagai kunci utama, dan mesin penyimpanan InnoDB akan menjadikannya indeks berkerumun. Pada contoh di bawah ini, ID adalah kunci utama DAN indeks berkerumun.

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
    CONSTRAINT `IDX_name` UNIQUE KEY (`LastName`,`FirstName`,`MiddleName`)
);

Jika Anda tidak menentukan kunci utama, indeks unik apa pun akan digunakan sebagai indeks berkerumun.

Kemudian lagi, jika Anda tidak memiliki kunci utama dan indeks unik, InnoDB membuat indeks berkerumun tersembunyi. Cek buktinya di sini.

Pertanyaan selanjutnya adalah, bagaimana dengan indeks yang tidak berkerumun?

Jika Anda sudah memiliki kunci utama sebagai indeks berkerumun, indeks lainnya tidak akan berkerumun atau sekunder. Selain itu, Anda hanya dapat memiliki satu indeks berkerumun.

Bagian selanjutnya akan membahas sintaks unik untuk MySQL CREATE TABLE yang tidak ditemukan di T-SQL.

Mengkloning dan Menyalin Sintaks Tabel MySQL

Mari kita bahas kloning meja. Kita bisa melakukannya di MySQL CREATE TABLE. Kemudian, kami akan menunjukkan padanan T-SQL.

Contoh di bawah ini membuat tabel dengan struktur yang sama dengan tabel pertama menggunakan CREATE TABLE…LIKE.

CREATE TABLE `people2` LIKE `people`

Kami baru saja mengkloning orang tabel menjadi orang2 . Namun, itu hanya struktur orang tabel yang telah disalin, bukan datanya. Itu juga menyalin batasan dan indeks utama dari tabel asli. Cukup berguna, jika Anda bertanya kepada saya.

Setara T-SQL terdekat adalah ini:

-- T-SQL way of cloning a table. The indexes & key constraints are not included, 
-- though

SELECT * INTO people2
FROM people
WHERE 1=0     -- this will cause the SELECT to return an empty result set.

Tetapi bagaimana jika Anda menginginkan datanya? Kemudian, CREATE TABLE…PILIH jawabannya:

CREATE TABLE `people3` AS
SELECT * FROM `people`;

Data apa pun yang ada di orang tabel, itu akan disalin ke people3 meja. Namun, perintah ini tidak akan menyertakan indeks dan batasan.

Sekarang, padanan T-SQL terdekat adalah ini:

-- T-SQL table copying

SELECT * INTO people3 
FROM people

Kesimpulan

Saya harap poin-poin di atas dapat membantu Anda memulai dan menjalankan MySQL CREATE TABLE dari perspektif pengembang SQL Server T-SQL.

Beberapa dari Anda akan lebih suka menggunakan alat grafis. Tetapi nanti, Anda akan menemukan diri Anda mencari referensi ketika Anda perlu membuat tabel kerja di prosedur tersimpan atau skrip ad-hoc Anda. Atau Anda hanyalah tipe orang yang mencari kontrol lebih dengan mengetik semuanya. Bagaimanapun, toko serba ada yang membandingkan sintaks dasar dapat menjadi penyelamat.

Jika Anda menyukai artikel ini, jangan ragu untuk membagikannya ke media sosial favorit Anda.

Selamat membuat kode, semuanya.


  1. Database
    2.   
  2. Mysql
    3.   
  3. Oracle
    4.   
  4. Sqlserver
    5.   
  5. PostgreSQL
    6.   
  6. Access
    7.   
  7. SQLite
    8.   
  8. MariaDB

  1. GALAT 1698 (28000):Akses ditolak untuk pengguna 'root'@'localhost'

  2. Bagaimana cara memasukkan variabel PHP di dalam pernyataan MySQL

  3. Tidak bisa mendapatkan boot musim semi untuk secara otomatis membuat skema database

  4. Hubungan antara katalog, skema, pengguna, dan database instance

  5. Bagaimana Fungsi MATCH() Bekerja di MySQL