Malay

Tutorial PostgreSQL

PostgreSQL maju

Interfaces PostgreSQL

PostgreSQL - AUTO INCREMENT

Hello, aspiring database enthusiasts! Today, we're going to dive into one of the most useful features in PostgreSQL: the AUTO INCREMENT functionality. As your friendly neighborhood computer teacher, I'm excited to guide you through this topic, even if you're completely new to programming. So, grab a cup of coffee, and let's embark on this learning adventure together!

PostgreSQL - Auto Increment

What is AUTO INCREMENT?

Before we jump into the nitty-gritty, let's understand what AUTO INCREMENT actually means. Imagine you're organizing a big party and need to give each guest a unique number. Instead of manually assigning numbers, wouldn't it be great if you had a magical counter that automatically increased for each new guest? That's essentially what AUTO INCREMENT does in databases!

In PostgreSQL, AUTO INCREMENT is a feature that automatically generates a unique number for each new row in a table. It's particularly useful when you need a unique identifier for each record, like a customer ID or an order number.

Syntax

Now, let's look at how we can use AUTO INCREMENT in PostgreSQL. The syntax is quite straightforward, but don't worry if it looks a bit intimidating at first. We'll break it down step by step.

CREATE TABLE table_name (
column_name SERIAL PRIMARY KEY,
other_column1 data_type,
other_column2 data_type,
...
);

Let's dissect this syntax:

  1. CREATE TABLE table_name: This part creates a new table with the name you specify.
  2. column_name SERIAL PRIMARY KEY: This is where the magic happens!
  • column_name is the name you want to give to your auto-incrementing column.
  • SERIAL is a PostgreSQL-specific data type that creates an auto-incrementing integer column.
  • PRIMARY KEY ensures that this column will contain unique values and can be used to identify each row.
  1. The rest of the lines define other columns in your table.

Example

Let's put this into practice with a real-world example. Imagine we're creating a database for a small library. We want to keep track of books, and each book should have a unique ID.

CREATE TABLE books (
book_id SERIAL PRIMARY KEY,
title VARCHAR(100) NOT NULL,
author VARCHAR(100) NOT NULL,
publication_year INTEGER
);

In this example:

  • book_id is our auto-incrementing column. It will automatically assign a unique number to each new book.
  • title and author are VARCHAR columns to store the book's title and author name.
  • publication_year is an INTEGER column to store the year the book was published.

Now, let's add some books to our table:

INSERT INTO books (title, author, publication_year)
VALUES ('To Kill a Mockingbird', 'Harper Lee', 1960);

INSERT INTO books (title, author, publication_year)
VALUES ('1984', 'George Orwell', 1949);

INSERT INTO books (title, author, publication_year)
VALUES ('The Great Gatsby', 'F. Scott Fitzgerald', 1925);

Notice that we didn't specify a value for book_id. PostgreSQL will automatically generate these values for us. If we now query our table:

SELECT * FROM books;

We might see something like this:

book_id title author publication_year
1 To Kill a Mockingbird Harper Lee 1960
2 1984 George Orwell 1949
3 The Great Gatsby F. Scott Fitzgerald 1925

As you can see, PostgreSQL has automatically assigned unique book_id values to each row, starting from 1 and incrementing by 1 for each new entry.

Behind the Scenes

Now, you might be wondering, "How does PostgreSQL know what number to use next?" Great question! Behind the scenes, PostgreSQL uses a sequence to keep track of the next available number.

When you use the SERIAL data type, PostgreSQL automatically creates a sequence for that column. A sequence is like a counter that remembers the last number it gave out and knows to give out the next number when asked.

You can actually see this sequence if you look at the table details:

\d books

This command will show you something like:

Table "public.books"
Column      |          Type          | Collation | Nullable |           Default
-----------------+------------------------+-----------+----------+------------------------------
book_id         | integer                |           | not null | nextval('books_book_id_seq'::regclass)
title           | character varying(100) |           | not null |
author          | character varying(100) |           | not null |
publication_year| integer                |           |          |
Indexes:
"books_pkey" PRIMARY KEY, btree (book_id)

See that nextval('books_book_id_seq'::regclass) part? That's PostgreSQL using the sequence to get the next value for book_id.

A Word of Caution

While AUTO INCREMENT is incredibly useful, it's important to remember that it doesn't guarantee consecutive numbers without gaps. If you insert a row and then delete it, that number won't be reused. This is actually a good thing for data integrity, but it's something to keep in mind.

For example, if we delete the second book:

DELETE FROM books WHERE book_id = 2;

And then insert a new book:

INSERT INTO books (title, author, publication_year)
VALUES ('Pride and Prejudice', 'Jane Austen', 1813);

Our table might look like this:

book_id title author publication_year
1 To Kill a Mockingbird Harper Lee 1960
3 The Great Gatsby F. Scott Fitzgerald 1925
4 Pride and Prejudice Jane Austen 1813

Notice that book_id 2 is missing, and the new book got book_id 4.

Conclusion

And there you have it, folks! You've just learned about AUTO INCREMENT in PostgreSQL. We've covered what it is, how to use it, and even peeked under the hood to see how it works. Remember, AUTO INCREMENT is like having a helpful librarian who automatically assigns a unique number to each new book that arrives, saving you the trouble of keeping track yourself.

As you continue your journey in the world of databases, you'll find AUTO INCREMENT to be a trusty companion, making your life easier when you need to assign unique identifiers. Keep practicing, stay curious, and before you know it, you'll be a PostgreSQL wizard!

Happy coding, and may your queries always return the results you expect!

PostgreSQL - AUTO INCREMENT (Dalam Bahasa Melayu)

Hai, para enthuwista pangkalan data yang sedang membangun kemahiran anda! Hari ini, kita akan melihat salah satu ciri paling berguna dalam PostgreSQL: fungsi AUTO INCREMENT. Sebagai guru komputer di lingkungan jiran anda, saya gembira untuk menghidangkan anda melalui topik ini, bahkan jika anda masih agak baru dalam programming. Jadi, ambil secangkir kopi, dan mari kita mulakan pengembaraan belajar ini bersama!

Apa Itu AUTO INCREMENT?

Sebelum kita masuk ke detil, mari kita memahami apa yang dimaksud AUTO INCREMENT. Bayangkan anda sedang menganjurkan pesta besar dan perlu memberikan nombor unik kepada setiap tetamu. Bila anda boleh secara manual memberikan nombor, tidakkah lebih baik jika anda memiliki penghitung yang secara automatik meningkat untuk setiap tetamu baru? Itu sebenarnya apa yang AUTO INCREMENT lakukan dalam pangkalan data!

Dalam PostgreSQL, AUTO INCREMENT adalah ciri yang secara automatik menghasilkan nombor unik untuk setiap baris baru dalam jadual. Ia sangat berguna ketika anda perlu penanda unik untuk setiap rekod, seperti ID pelanggan atau nombor pesanan.

Sintaks

Sekarang, mari kita lihat bagaimana kita dapat menggunakan AUTO INCREMENT dalam PostgreSQL. Sintaksnya cukup mudah, tetapi jangan bimbang jika ia nampak sedikit menakutkan pada permulaan. Kita akan merobahnya secara berperingkat.

CREATE TABLE table_name (
column_name SERIAL PRIMARY KEY,
other_column1 data_type,
other_column2 data_type,
...
);

mari kitaongkai sintaks ini:

  1. CREATE TABLE table_name: Bahagian ini mencipta jadual baru dengan nama yang anda tentukan.
  2. column_name SERIAL PRIMARY KEY: Di sini adalah tempat magik berlaku!
  • column_name adalah nama yang anda hendak berikan kepada kolom peningkat automatik.
  • SERIAL adalah jenis data khusus PostgreSQL yang mencipta kolom integer peningkat automatik.
  • PRIMARY KEY memastikan bahawa kolom ini akan mengandungi nilai unik dan boleh digunakan untuk mengenalpasti setiap baris.
  1. Baris selepasnya menentukan kolom lain dalam jadual anda.

Contoh

Mari kita buat praktik dengan contoh dunia nyata. Bayangkan kita sedang mencipta pangkalan data untuk perpustakaan kecil. Kita mahu mengesan buku-buku, dan setiap buku hendak memiliki ID unik.

CREATE TABLE books (
book_id SERIAL PRIMARY KEY,
title VARCHAR(100) NOT NULL,
author VARCHAR(100) NOT NULL,
publication_year INTEGER
);

Dalam contoh ini:

  • book_id adalah kolom peningkat automatik kami. Ia akan secara automatik memberikan nombor unik kepada setiap buku baru.
  • title dan author adalah kolom VARCHAR untuk menyimpan judul buku dan nama pengarang.
  • publication_year adalah kolom INTEGER untuk menyimpan tahun penerbitan buku.

Sekarang, mari kita tambah beberapa buku ke jadual kami:

INSERT INTO books (title, author, publication_year)
VALUES ('To Kill a Mockingbird', 'Harper Lee', 1960);

INSERT INTO books (title, author, publication_year)
VALUES ('1984', 'George Orwell', 1949);

INSERT INTO books (title, author, publication_year)
VALUES ('The Great Gatsby', 'F. Scott Fitzgerald', 1925);

Perhatikan bahawa kami tidak menentukan nilai untuk book_id. PostgreSQL akan secara automatik menghasilkan nilai ini untuk kami. Jika kita sekarang membuat queri jadual kami:

SELECT * FROM books;

Kami mungkin akan melihat sesuatu seperti ini:

book_id title author publication_year
1 To Kill a Mockingbird Harper Lee 1960
2 1984 George Orwell 1949
3 The Great Gatsby F. Scott Fitzgerald 1925

Seperti yang anda lihat, PostgreSQL telah secara automatik memberikan nilai book_id unik kepada setiap baris, bermula dari 1 dan meningkat 1 untuk setiap entri baru.

Dalam Tengah Tindakan

Sekarang, anda mungkin bertanya-tanya, "Bagaimana PostgreSQL tahu nombor berapa yang hendak digunakan next?" Pertanyaan hebat! Di belakang tabir, PostgreSQL menggunakan sekuens untuk mengesan nombor yang tersedia berikutnya.

Bila anda menggunakan jenis data SERIAL, PostgreSQL secara automatik mencipta sekuens untuk kolom itu. Sekuens adalah seperti penghitung yang mengingati nombor terakhir yang ia keluarkan dan tahu untuk memberikan nombor berikutnya apabila diminta.

Anda sebenarnya boleh melihat sekuens ini jika anda melihat detil jadual:

\d books

Perintah ini akan menunjukkan sesuatu seperti ini:

Table "public.books"
Column      |          Type          | Collation | Nullable |           Default
-----------------+------------------------+-----------+----------+------------------------------
book_id         | integer                |           | not null | nextval('books_book_id_seq'::regclass)
title           | character varying(100) |           | not null |
author          | character varying(100) |           | not null |
publication_year| integer                |           |          |
Indexes:
"books_pkey" PRIMARY KEY, btree (book_id)

Lihat bagian nextval('books_book_id_seq'::regclass)? Itu adalah PostgreSQL menggunakan sekuens untuk mendapatkan nombor berikutnya untuk book_id.

Catatan Peringatan

Walaupun AUTO INCREMENT sangat berguna, penting untuk mengingat bahawa ia tidak menjamin nombor berurutan tanpa kekosongan. Jika anda memasukkan baris dan kemudian menghapuskannya, nombor itu tidak akan digunakan lagi. Ini sebenarnya baik untuk integriti data, tetapi ia adalah sesuatu yang perlu diingat.

Sebagai contoh, jika kita menghapus buku kedua:

DELETE FROM books WHERE book_id = 2;

Dan kemudian memasukkan buku baru:

INSERT INTO books (title, author, publication_year)
VALUES ('Pride and Prejudice', 'Jane Austen', 1813);

Jadual kita mungkin akan tampak seperti ini:

book_id title author publication_year
1 To Kill a Mockingbird Harper Lee 1960
3 The Great Gatsby F. Scott Fitzgerald 1925
4 Pride and Prejudice Jane Austen 1813

Perhatikan bahawa book_id 2 hilang, dan buku baru mendapat book_id 4.

Kesimpulan

Dan di sini, teman-teman! Anda telah belajar tentang AUTO INCREMENT di PostgreSQL. Kita telah meliputi apa itu, bagaimana menggunakannya, dan bahkan melihat bagaimana ia bekerja di belakang tabir. Ingat, AUTO INCREMENT adalah seperti memiliki petugas perpustakaan yang membantu secara automatik memberikan nombor unik kepada setiap buku yang baru tiba, menyimpan anda dari kerjaan mengawasi sendiri.

Sementara anda terus menjalani perjalanan anda di dunia pangkalan data, anda akan menemukan AUTO INCREMENT menjadi seorang teman yang dapat dipercayai, membuat kehidupan anda lebih mudah saat anda perlu memberikan penanda unik. Terus latihan, tetap ciekawon, dan sebelum anda tahu, anda akan menjadi ahli PostgreSQL!

Selamat coding, dan semoga queri anda selalu mengembalikan hasil yang anda harap!

Credits: Image by storyset

Tutorial Sebelumnya:
PostgreSQL - Subquery
Tutorial Seterusnya:
PostgreSQL - Keistimewaan