programming

Làm cách nào để chạy di chuyển trong Laravel trên máy chủ?

Bài viết này mô tả cách di chuyển một trang Laravel hiện có sang tài khoản A2 Hosting của bạn. Ví dụ: bạn có thể cần thực hiện việc này nếu bạn đã phát triển một trang web Laravel trên một máy tính khác hoặc muốn di chuyển một trang web Laravel hiện có từ một nhà cung cấp dịch vụ lưu trữ khác sang A2 Hosting

Mặc dù các máy chủ của Dịch vụ lưu trữ A2 tương thích với nhiều ứng dụng phần mềm khác nhau, chúng tôi không thể hỗ trợ khắc phục sự cố đối với các sự cố cụ thể của ứng dụng

Di chuyển Laravel

Để di chuyển một trang Laravel sang tài khoản lưu trữ của bạn, hãy làm theo các bước sau

Tải các tệp dự án Laravel lên tài khoản của bạn. Bạn có thể sử dụng Trình quản lý tệp cPanel hoặc SFTP để thực hiện việc này
Đăng nhập vào tài khoản của bạn bằng SSH
Để kích hoạt chạy Artisan bằng cách chỉ cần gõ artisan tại dấu nhắc lệnh, hãy gõ các lệnh sau. Thay thế tên người dùng bằng tên người dùng tài khoản của bạn và dự án bằng tên dự án của bạn.
```
echo 'alias artisan="php /home/username/project/artisan"' >> ~/.bashrc
source ~/.bashrc
```
Artisan là giao diện dòng lệnh cho Laravel. Khi bạn tạo một dự án Laravel, Artisan được cài đặt tự động trong thư mục dự án. Để biết thêm thông tin về Artisan, vui lòng truy cập http. // ấu trùng. com/docs/nghệ nhân
Để khách truy cập web có thể truy cập các tệp dự án Laravel, bạn phải sao chép tất cả các tệp trong thư mục /home/username/project/public vào thư mục public_html. Để thực hiện việc này, hãy nhập lệnh sau, thay thế dự án bằng tên dự án.
```
 cp -r ~/project/public/* ~/public_html
```
Ngoài ra, nếu bạn muốn sử dụng thư mục con bên dưới thư mục public_html, hãy sao chép các tệp công khai ở đó để thay thế. Ví dụ: lệnh sau sao chép tất cả các tệp công khai vào thư mục con laravel.
```
 cp -r ~/project/public/* ~/public_html/laravel
```
Trong trường hợp này, trang Laravel sẽ có thể truy cập được tại http. //www. thí dụ. com/laravel, ví dụ ở đâu. com đại diện cho tên miền của bạn
Trong thư mục public_html, mở chỉ mục. php trong trình soạn thảo văn bản ưa thích của bạn, sau đó sửa đổi nó như sau
- Xác định vị trí dòng sau.
```
require __DIR__.'/../vendor/autoload.php';
```
  Sửa đổi đường dẫn để bao gồm thư mục cài đặt Laravel. Ví dụ Laravel nằm trong thư mục project thì bạn thay đổi dòng như sau.
```
require __DIR__.'/../project/vendor/autoload.php'
```
- Xác định vị trí dòng sau.
```
require __DIR__.'/../bootstrap/app.php';
```
  Sửa đổi đường dẫn để bao gồm thư mục cài đặt Laravel. Ví dụ: nếu Laravel nằm trong thư mục dự án, bạn sẽ thay đổi dòng như sau.
```
require __DIR__.'/../project/bootstrap/app.php'
```
Lưu các thay đổi của bạn vào chỉ mục. tập tin php
Trong trình duyệt web của bạn, hãy truy cập http. //www. thí dụ. com, ví dụ ở đâu. com đại diện cho tên miền của bạn. Bạn sẽ thấy trang chào mừng của Laravel
Đảm bảo rằng bạn lặp lại các bước từ 4 đến 6 nếu bạn sửa đổi bất kỳ tệp trang web công cộng nào trong thư mục dự án

Các lược đồ cơ sở dữ liệu có thể được sửa đổi từ trạng thái hiện tại của chúng sang trạng thái mong muốn thông qua quá trình di chuyển. Điều này có thể bao gồm thêm bảng và cột, xóa mục hoặc thay đổi loại và ràng buộc
Chẳng hạn, nếu bạn đang làm việc trong một dự án nhóm và cần sửa đổi các yêu cầu của ứng dụng, bạn có thể cân nhắc việc thay đổi cơ sở dữ liệu
Thông thường, một bản cập nhật. tệp sql được chia sẻ với từng thành viên trong nhóm để nhập vào cơ sở dữ liệu của họ. Tuy nhiên, cách tiếp cận này không lý tưởng cũng như không thể mở rộng vì nhiều thứ có thể sai và khiến ứng dụng bị hỏng. Ví dụ: một thành viên trong nhóm có thể quên nhập tệp vào cơ sở dữ liệu của họ hoặc thậm chí nhập phiên bản lỗi thời của tệp. tập tin sql
Di chuyển hoạt động giống như kiểm soát phiên bản cho cơ sở dữ liệu của bạn, cho phép nhóm của bạn chia sẻ và xác định lược đồ cơ sở dữ liệu ứng dụng của bạn. Di chuyển Laravel rất cần thiết vì chúng giúp bạn giải quyết các vấn đề cộng tác cơ sở dữ liệu như vậy cho một nhóm. Các thành viên trong nhóm của bạn sẽ không cần cập nhật cơ sở dữ liệu của họ theo cách thủ công bất cứ khi nào họ lấy các thay đổi của bạn từ kiểm soát nguồn
Trong hướng dẫn này, bạn sẽ tìm hiểu tầm quan trọng của việc di chuyển trong ứng dụng Laravel của mình cũng như các lợi ích khác nhau của việc di chuyển Laravel cùng với các trường hợp sử dụng. Bạn cũng sẽ tìm hiểu các hành động, lệnh và sự kiện di chuyển khác nhau
Laravel Migration là gì?
Di chuyển Laravel cho phép các nhà phát triển nhanh chóng tạo, xóa và sửa đổi cơ sở dữ liệu ứng dụng mà không cần đăng nhập vào trình quản lý cơ sở dữ liệu hoặc thực hiện bất kỳ truy vấn SQL nào.
Điều quan trọng cần biết là Laravel cung cấp. Bạn ít có khả năng gặp phải các vấn đề hỗ trợ khi sử dụng chúng. Chúng bao gồm những điều sau đây
- MariaDB 10. 3+
- mysql 5. 7+
- PostgreSQL 10. 0+
- SQLite 3. 8. 8+
- Máy chủ SQL 2017+
Tại sao bạn lại sử dụng Laravel Migration?
Ngoài việc kiểm soát phiên bản, quá trình di chuyển giúp tự động hóa việc triển khai và tạo cơ sở dữ liệu tạm thời để chạy thử nghiệm dễ dàng hơn. Chúng cho phép bạn dễ dàng cấu trúc các mô hình và bảng của mình và là một tính năng cần thiết cho các trình gieo hạt trong ứng dụng của bạn
Seeding là một phương pháp đơn giản để tạo dữ liệu giả cho ứng dụng của bạn trong quá trình thử nghiệm
Di chuyển cũng hỗ trợ các nhà phát triển bằng cách hỗ trợ tổ chức môi trường, xác thực và triển khai an toàn các sửa đổi lược đồ
Với việc di chuyển, bạn có thể thay đổi các trường trong cơ sở dữ liệu của mình mà không cần xóa các bản ghi hiện có. Laravel theo dõi các lần di chuyển đã thực hiện trong cơ sở dữ liệu. Kết quả là, cơ sở dữ liệu có thể phát triển khi yêu cầu ứng dụng thay đổi
Cách tạo di chuyển
Mỗi tệp di chuyển xác định một bảng trong cơ sở dữ liệu của bạn. Nó chứa lược đồ để tạo hoặc sửa đổi bảng đó trong cơ sở dữ liệu. Laravel sử dụng lệnh
```
id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down[]
    {
        Schema::dropIfExists['user'];
    }
}
```
8 Artisan để tạo di chuyển cơ sở dữ liệu
________số 8_______
Lệnh tạo một tệp di chuyển trong thư mục cơ sở dữ liệu/di chuyển của ứng dụng của bạn. Laravel sử dụng tiền tố dấu thời gian trong tên tệp di chuyển để xác định thứ tự của các lần di chuyển—ví dụ:
```
id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down[]
    {
        Schema::dropIfExists['user'];
    }
}
```
9
Laravel cố gắng xác định tên bảng và hành động di chuyển dựa trên tên tệp. Nó cũng điền trước tệp di chuyển với tên bảng được chỉ định từ dự đoán đã thử. Bạn có thể tự xác định tên bảng trong tệp di chuyển nếu lần thử không thành công
Bạn có thể chỉ định một đường dẫn cụ thể trong ứng dụng của mình để di chuyển được tạo bằng cách sử dụng đối số
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=
DB_USERNAME=
DB_PASSWORD=
```
0 với lệnh
```
id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down[]
    {
        Schema::dropIfExists['user'];
    }
}
```
8
```
php artisan make:migration create_users_table --path=app/database/migrations
```
Cơ cấu di cư
Tệp di chuyển được tạo có định nghĩa lớp với các phương thức
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=
DB_USERNAME=
DB_PASSWORD=
```
2 và
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=
DB_USERNAME=
DB_PASSWORD=
```
3 theo mặc định. Phương thức
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=
DB_USERNAME=
DB_PASSWORD=
```
2 được gọi mỗi khi bạn chạy di chuyển. Tuy nhiên, phương pháp
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=
DB_USERNAME=
DB_PASSWORD=
```
3 được gọi bất cứ khi nào quá trình di chuyển cơ sở dữ liệu quay trở lại
Bạn có thể thay đổi cơ sở dữ liệu bằng cách thêm các bảng, cột hoặc chỉ mục mới bằng cách sử dụng phương thức
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=
DB_USERNAME=
DB_PASSWORD=
```
6, trong khi phương thức
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=
DB_USERNAME=
DB_PASSWORD=
```
3 thực hiện các hoạt động của phương thức
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=
DB_USERNAME=
DB_PASSWORD=
```
6 theo hướng ngược lại.

Ví dụ: phương thức
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=
DB_USERNAME=
DB_PASSWORD=
```
6 chứa lược đồ để tạo bảng mới, thêm cột mới vào bảng hoặc sửa đổi cột hiện có, trong khi phương thức
```
php artisan config:cache
```
0 chứa lược đồ để thực hiện ngược lại, như xóa bảng, xóa cột, v.v.
Bây giờ, bạn có thể sử dụng để tạo hoặc sửa đổi bảng theo bất kỳ phương pháp nào trong số này
Hãy xác định một di chuyển để tạo một bảng có tên là người dùng
```
id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down[]
    {
        Schema::dropIfExists['user'];
    }
}
```
```
php artisan config:cache
```
1 cho thấy rằng chúng ta đang tạo một bảng.
```
php artisan config:cache
```
2 loại bỏ bảng đã chỉ định [trong trường hợp này là 'người dùng'] nếu bảng đó tồn tại trên cơ sở dữ liệu bất cứ khi nào quá trình di chuyển quay trở lại
Chạy di chuyển
Trước khi chạy di chuyển của bạn,. cập nhật các. env trong thư mục gốc của ứng dụng với cấu hình cơ sở dữ liệu phù hợp với ví dụ sau, thay thế trình giữ chỗ bằng chi tiết cho cơ sở dữ liệu của bạn
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=
DB_USERNAME=
DB_PASSWORD=
```
Xóa bộ đệm là tùy chọn nhưng có thể cần thiết ở đây. Chạy lệnh sau trong terminal để làm điều đó
```
php artisan config:cache
```
Sử dụng lệnh
```
php artisan config:cache
```
3 Artisan để thực hiện tất cả các lần di chuyển đang chờ xử lý của bạn tới cơ sở dữ liệu
```
php artisan migrate
```
Dựa trên quá trình di chuyển được xác định trước đó, bạn sẽ thấy bảng người dùng trong cơ sở dữ liệu của mình với năm cột.
```
php artisan config:cache
```
4,
```
php artisan config:cache
```
5,
```
php artisan config:cache
```
6,
```
php artisan config:cache
```
7 và
```
php artisan config:cache
```
8.
```
php artisan config:cache
```
9 trong tệp di chuyển của bạn tạo ra các cột
```
php artisan config:cache
```
7 và
```
php artisan config:cache
```
8 cho cơ sở dữ liệu
Bảng, cột và chỉ mục
Một cơ sở dữ liệu chứa nhiều bảng. Cả cột và hàng đều có mặt trong mọi bảng
Chỉ mục là một cấu trúc dữ liệu hỗ trợ các hoạt động truy xuất dữ liệu dễ dàng trên các bảng với chi phí ghi bổ sung và không gian lưu trữ cần thiết để duy trì cấu trúc dữ liệu chỉ mục. Thay vì tìm kiếm qua từng hàng mỗi khi truy cập bảng cơ sở dữ liệu, bạn có thể sử dụng chỉ mục để định vị dữ liệu nhanh chóng
Những cái bàn
Tạo bảng
Bảng là tập hợp các đối tượng dữ liệu trong cơ sở dữ liệu được tổ chức theo định dạng bảng bao gồm các hàng và cột
Bạn có thể sử dụng phương thức
```
php artisan migrate
```
2 trên Schema facade để tạo một bảng cơ sở dữ liệu mới. Phương thức
```
php artisan migrate
```
2 có hai đối số. tên của bảng làm đối số đầu tiên và một bao đóng chấp nhận đối tượng Blueprint để xác định bảng mới làm đối số thứ hai
Như bạn có thể thấy trong đoạn mã bên dưới,
```
php artisan migrate
```
4 chấp nhận 'người dùng', là tên bảng, làm đối số đầu tiên của chúng tôi. Đối số thứ hai là một hàm đóng trong đó lớp Blueprint với đối tượng $table của nó được truyền dưới dạng tham số. Đối tượng $table này được sử dụng để tạo/sửa đổi một cột cho bảng
```
php artisan migrate
```
5
```
Schema::create['users', function [Blueprint $table] {
            $table->id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
```
```
php artisan migrate
```
6. Điều này tạo ra một cột chuỗi có tên trong bảng người dùng
```
php artisan migrate
```
7. Điều này tạo ra một cột ID tăng tự động sẽ là khóa chính cho bảng này
```
php artisan migrate
```
8. Điều này tạo ra các cột updated_at và created_at TIMESTAMP. Các cột này sẽ chứa dấu thời gian khi dữ liệu được chèn và cập nhật trong cơ sở dữ liệu, tương ứng
Các cột này không bắt buộc. Bạn quyết định các cột sẽ bao gồm dựa trên nhu cầu của ứng dụng của bạn
Sửa đổi bảng của bạn
Để đổi tên bảng, hãy sử dụng phương pháp
```
php artisan migrate
```
9 trên mặt tiền
```
Schema::create['users', function [Blueprint $table] {
            $table->id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
```
0. Trước khi đổi tên bảng, hãy xác nhận rằng tất cả các ràng buộc khóa ngoại trên bảng đó đều có tên rõ ràng trong tệp di chuyển của bạn thay vì cho phép Laravel gán tên dựa trên quy ước. Mặt khác, tên ràng buộc khóa ngoại sẽ tham chiếu đến bảng cũ
Trong đoạn mã dưới đây, chúng tôi đã đổi tên bảng
```
php artisan migrate
```
5 thành
```
Schema::create['users', function [Blueprint $table] {
            $table->id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
```
2
```
Schema::rename[$from, $to];

Schema::rename['users', 'fund_users'];
```
Bạn có thể sử dụng phương thức
```
Schema::create['users', function [Blueprint $table] {
            $table->id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
```
3 trên mặt tiền Schema để xóa bảng. Xoá bảng là thao tác ngược lại của việc tạo, do đó, nó có thể nằm trong phương thức
```
Schema::create['users', function [Blueprint $table] {
            $table->id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
```
4 của tệp di chuyển. Bằng cách này, bảng sẽ bị hủy bất cứ khi nào bạn quay lại quá trình di chuyển của mình.
Bây giờ trong đoạn mã bên dưới, hãy bỏ bảng
```
php artisan migrate
```
5. Bạn có thể thận trọng hơn bằng cách sử dụng
```
Schema::create['users', function [Blueprint $table] {
            $table->id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
```
6, vì vậy nó sẽ kiểm tra xem bảng có tồn tại trước khi xóa nó không và nếu nó không tồn tại, nó sẽ tiếp tục thực hiện lệnh tiếp theo mà không cần cố gắng xóa
Nếu bạn sử dụng
```
Schema::create['users', function [Blueprint $table] {
            $table->id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
```
7 cho một bảng không tồn tại, nó sẽ ngắt quá trình thực thi và trả về thông báo lỗi
```
Schema::drop['users'];

//or
 
Schema::dropIfExists['users'];
```
Có nhiều phương pháp Schema hữu ích khác có trong.
Dưới đây là một số ví dụ
```
Schema::create['users', function [Blueprint $table] {
            $table->id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
```
8. Cái này kiểm tra xem cơ sở dữ liệu có bảng tên là
```
php artisan migrate
```
5 không
```
Schema::rename[$from, $to];

Schema::rename['users', 'fund_users'];
```
0. Điều này kiểm tra xem cơ sở dữ liệu có bảng
```
php artisan migrate
```
5 với một cột có tên là
```
php artisan config:cache
```
6
Cột
Trong cơ sở dữ liệu quan hệ, mỗi hàng của cơ sở dữ liệu có một cột tương ứng chứa một nhóm các giá trị dữ liệu cùng kiểu. Các cột của bảng xác định cấu trúc của dữ liệu, trong khi các hàng của nó điền dữ liệu vào cơ sở dữ liệu
Tạo một cột
Để cập nhật các bảng hiện có với các cột bổ sung, hãy sử dụng phương thức table[] trong Schema facade. Nó chấp nhận các đối số giống như phương thức
```
Schema::rename[$from, $to];

Schema::rename['users', 'fund_users'];
```
3. Bạn có thể chọn kiểu dữ liệu của cột từ bất kỳ. Bây giờ, trong đoạn mã dưới đây, tôi sẽ thêm một cột bổ sung
```
Schema::rename[$from, $to];

Schema::rename['users', 'fund_users'];
```
4 vào bảng
```
php artisan migrate
```
5
```
Schema::table['users', function [Blueprint $table] {
    $table->double['wallet'];
}];
```
Nếu bạn đã di chuyển một bảng vào cơ sở dữ liệu của mình và cần sửa đổi bảng đó [ví dụ: giả sử bạn đang thêm một cột khác], bạn nên tạo một tệp di chuyển mới để sửa đổi.
Điều này là do tệp di chuyển đã được thực thi trừ khi bạn muốn khôi phục quá trình di chuyển, thực hiện các thay đổi đối với tệp và di chuyển lại. Quay ngược quá trình di chuyển có nghĩa là loại bỏ bảng/cột đó cũng như dữ liệu chứa trong đó; .
Ngoài ra, Laravel cung cấp cho phép một cột có các thuộc tính bổ sung. Với điều này, bạn có thể đặt giá trị mặc định cho cột ví bằng công cụ sửa đổi
```
Schema::rename[$from, $to];

Schema::rename['users', 'fund_users'];
```
6
```
php artisan make:migration create_users_table --path=app/database/migrations
```
0
Thả một cột
Để thả cột, bạn có thể sử dụng phương pháp
```
Schema::rename[$from, $to];

Schema::rename['users', 'fund_users'];
```
7 trên mặt tiền
```
Schema::create['users', function [Blueprint $table] {
            $table->id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
```
0. Trong phương thức
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=
DB_USERNAME=
DB_PASSWORD=
```
3 của tệp di chuyển này, bạn có thể thả cột
```
php artisan make:migration create_users_table --path=app/database/migrations
```
1
Tôi đã viết một bài viết giải thích về việc thêm và xóa các cột khỏi các bảng hiện có trong quá trình di chuyển laravel
Sửa đổi một cột
Để sửa đổi/đổi tên một cột, bạn phải sử dụng trình quản lý gói Composer để cài đặt gói
```
Schema::drop['users'];

//or
 
Schema::dropIfExists['users'];
```
0. Để cài đặt nó, hãy chạy lệnh này
```
php artisan make:migration create_users_table --path=app/database/migrations
```
2
Ngoài ra, bạn cần đưa cấu hình sau vào cấu hình/cơ sở dữ liệu của ứng dụng. php để sử dụng phương pháp
```
Schema::drop['users'];

//or
 
Schema::dropIfExists['users'];
```
1
```
php artisan make:migration create_users_table --path=app/database/migrations
```
3
Bây giờ bạn có thể sử dụng phương pháp
```
Schema::drop['users'];

//or
 
Schema::dropIfExists['users'];
```
2 để sửa đổi loại và thuộc tính của các cột hiện có
```
php artisan make:migration create_users_table --path=app/database/migrations
```
4
Bạn có thể sử dụng phương pháp
```
Schema::drop['users'];

//or
 
Schema::dropIfExists['users'];
```
3 trên mặt tiền
```
Schema::create['users', function [Blueprint $table] {
            $table->id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
```
0 để đổi tên cột. Hãy đổi tên
```
php artisan config:cache
```
5 thành
```
Schema::drop['users'];

//or
 
Schema::dropIfExists['users'];
```
6
```
php artisan make:migration create_users_table --path=app/database/migrations
```
5
chỉ mục
Chỉ mục là công cụ mạnh mẽ được sử dụng ẩn trong cơ sở dữ liệu để tăng tốc độ truy vấn. Lập chỉ mục các truy vấn mạnh mẽ bằng cách cung cấp cho người dùng cách tìm kiếm dữ liệu họ cần một cách nhanh chóng
Một chỉ mục có thể được coi là một con trỏ tới thông tin của bảng. Tốt nhất nên cẩn thận khi sử dụng chỉ mục, đặc biệt là khi bảng được cập nhật thường xuyên. Chỉ mục luôn được tạo lại với mỗi lần cập nhật, làm chậm hệ thống
Một ví dụ tuyệt vời về loại chỉ mục là
```
Schema::drop['users'];

//or
 
Schema::dropIfExists['users'];
```
7. Nó yêu cầu tất cả các giá trị trong cột đó là duy nhất. Điều này có nghĩa là các giá trị không thể được lặp lại trong cột đó. Trong ví dụ sau, bạn sẽ tạo chỉ mục cho cột
```
Schema::drop['users'];

//or
 
Schema::dropIfExists['users'];
```
8 trong bảng
```
php artisan migrate
```
5 là duy nhất.
```
php artisan make:migration create_users_table --path=app/database/migrations
```
6
Có các khóa khác, bao gồm khóa chính và khóa ngoại
Khóa ngoại trong bảng cơ sở dữ liệu quan hệ là một cột hoặc tập hợp các cột kết nối dữ liệu từ hai bảng khác nhau. Nó đề cập đến khóa chính của một bảng khác, tạo liên kết giữa hai bảng và dùng làm tham chiếu chéo giữa chúng
Bây giờ, hãy giới thiệu bảng
```
Schema::table['users', function [Blueprint $table] {
    $table->double['wallet'];
}];
```
0 vào cơ sở dữ liệu của bạn trong tệp di chuyển mới. Bảng
```
Schema::table['users', function [Blueprint $table] {
    $table->double['wallet'];
}];
```
0 phải có khóa ngoại để tham chiếu người dùng sở hữu cuốn sách. Một quy ước đặt tên tốt cho khóa ngoại trong Laravel là
```
Schema::table['users', function [Blueprint $table] {
    $table->double['wallet'];
}];
```
2. Điều này là do Laravel cố đoán bảng và cột được tham chiếu dựa trên tên của khóa ngoại.
Bạn cũng có thể đặt khóa ngoại ưa thích của mình và sử dụng các thuộc tính
```
Schema::table['users', function [Blueprint $table] {
    $table->double['wallet'];
}];
```
3 và
```
Schema::table['users', function [Blueprint $table] {
    $table->double['wallet'];
}];
```
4 để trỏ tới cột và bảng được tham chiếu tương ứng. Bằng cách này, Laravel bỏ qua dự đoán đã thử và sử dụng bảng và cột được tham chiếu đã được xác định
Sử dụng
```
Schema::table['users', function [Blueprint $table] {
    $table->double['wallet'];
}];
```
5 trong ví dụ này tham chiếu cột
```
php artisan config:cache
```
4 trên bảng
```
php artisan migrate
```
5. Trong phương pháp này, bạn phải xác định user_id là một
```
Schema::table['users', function [Blueprint $table] {
    $table->double['wallet'];
}];
```
8 trước khi xác định các thuộc tính khóa ngoại của nó.
```
php artisan make:migration create_users_table --path=app/database/migrations
```
7
Laravel cũng cung cấp một phương thức ngắn hơn chỉ sử dụng tên của khóa ngoại để xác định tên của bảng và cột được tham chiếu. Điều này ngắn hơn vì sẽ không cần khai báo
```
Schema::table['users', function [Blueprint $table] {
    $table->double['wallet'];
}];
```
8 và bao gồm các thuộc tính
```
Schema::table['users', function [Blueprint $table] {
    $table->double['wallet'];
}];
```
3 và
```
Schema::table['users', function [Blueprint $table] {
    $table->double['wallet'];
}];
```
4 cho khóa ngoại hoặc cũng khai báo
```
Schema::table['users', function [Blueprint $table] {
    $table->double['wallet'];
}];
```
8. Bạn cũng có thể tiếp tục và bao gồm các thuộc tính khóa ngoại khác như
```
php artisan make:migration create_users_table --path=app/database/migrations
```
03, v.v.
```
php artisan make:migration create_users_table --path=app/database/migrations
```
8
Phương thức
```
php artisan make:migration create_users_table --path=app/database/migrations
```
03 là tùy chọn và cho phép bạn chỉ định tên bảng nếu các quy ước không phù hợp với tên bảng của bạn
Các phương thức
```
php artisan make:migration create_users_table --path=app/database/migrations
```
05 và
```
php artisan make:migration create_users_table --path=app/database/migrations
```
06 cho phép bạn chỉ định hành động cần thực hiện khi khóa ngoại bị xóa hoặc cập nhật. Hành động xếp tầng có nghĩa là khi các hàng trong bảng cha bị xóa, các cột khóa ngoại phù hợp trong bảng con cũng bị xóa, tạo ra một thao tác xóa xếp tầng. Do đó, nếu bạn xóa một người dùng, sách của họ cũng bị xóa
Mọi công cụ sửa đổi cột bổ sung phải được gọi trước
```
php artisan make:migration create_users_table --path=app/database/migrations
```
07
```
php artisan make:migration create_users_table --path=app/database/migrations
```
9
Xóa di chuyển
Không có lệnh Artisan để loại bỏ di chuyển. Tuy nhiên, việc xóa di chuyển phụ thuộc vào việc chúng đã được thực thi trong cơ sở dữ liệu hay chưa
Sử dụng
```
php artisan make:migration create_users_table --path=app/database/migrations
```
08 để kiểm tra xem quá trình di chuyển của bạn đã được thực hiện chưa nếu bạn không chắc chắn
Nếu bạn chưa chạy
```
php artisan make:migration create_users_table --path=app/database/migrations
```
09 để thực hiện di chuyển, bạn có thể xóa tệp di chuyển
Tuy nhiên, nếu việc di chuyển đã được thực hiện, bạn nên làm theo các bước sau
1. Tốt nhất là quay ngược quá trình di chuyển đó bằng cách chạy
```
php artisan make:migration create_users_table --path=app/database/migrations
```
  10. Hãy nhớ rằng bạn không muốn khôi phục tất cả các lần di chuyển, vì vậy hãy bao gồm số lô của quá trình di chuyển sẽ được khôi phục. Nó sẽ giống như
```
php artisan make:migration create_users_table --path=app/database/migrations
```
  11_______12_______12
2. Sau đó, xóa tệp di chuyển
Dập tắt di chuyển
Khi ứng dụng của bạn phát triển theo thời gian, nó có thể cần nhiều lần di chuyển hơn. Do đó, bạn có thể đã nhận được nhiều tệp di chuyển trong thư mục cơ sở dữ liệu/di chuyển của mình. Bạn có thể nén các tệp di chuyển của mình thành một tệp SQL duy nhất bằng cách sử dụng lệnh
```
php artisan make:migration create_users_table --path=app/database/migrations
```
13
```
id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down[]
    {
        Schema::dropIfExists['user'];
    }
}
```
0
Khi bạn chạy lệnh này, Laravel sẽ tạo một tệp "lược đồ" trong thư mục cơ sở dữ liệu/lược đồ của ứng dụng của bạn.
Sau đó, nếu bạn cố gắng di chuyển cơ sở dữ liệu của mình lần đầu tiên trong ứng dụng của mình, Laravel sẽ chạy các câu lệnh SQL trong tệp lược đồ trước. Sau đó, nó sẽ chạy các lần di chuyển còn lại không có trong kết xuất lược đồ sau khi chạy các dòng trong tệp lược đồ
sự kiện di chuyển
Laravel cung cấp một số sự kiện di chuyển công văn cho phép bạn thực hiện các hành động tiếp theo sau khi thao tác di chuyển đã được thực thi. Ví dụ: bạn có thể gửi email cho quản trị viên mỗi khi quá trình di chuyển hoàn tất.
- ```
php artisan make:migration create_users_table --path=app/database/migrations
```
  14. Điều này được sử dụng khi một đợt di chuyển sắp được thực hiện
- ```
php artisan make:migration create_users_table --path=app/database/migrations
```
  15. Điều này được sử dụng khi một lần di chuyển sắp được thực hiện
- ```
php artisan make:migration create_users_table --path=app/database/migrations
```
  16. Điều này được sử dụng khi một đợt di chuyển đã kết thúc thực hiện
- ```
php artisan make:migration create_users_table --path=app/database/migrations
```
  17. Điều này được sử dụng khi một lần di chuyển đã kết thúc thực thi.
Những sự kiện này mở rộng lớp
```
php artisan make:migration create_users_table --path=app/database/migrations
```
18 theo mặc định. Bây giờ, bạn có thể đăng ký tương ứng với bất kỳ sự kiện nào trong số này trong thư mục app\Providers\EventServiceProvider
```
id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down[]
    {
        Schema::dropIfExists['user'];
    }
}
```
1
Bạn có thể đọc chính thức để hiểu các sự kiện tốt hơn
Các lệnh di chuyển khác
Laravel có một số lệnh Artisan khác giúp cho việc di chuyển trở nên dễ sử dụng, bao gồm các lệnh sau
Quay trở lại di chuyển
Bạn có thể muốn hoàn nguyên đợt di chuyển cuối cùng về cơ sở dữ liệu của mình. Thay vì xóa các cột và bảng khỏi trình quản lý cơ sở dữ liệu, bạn có thể chạy lệnh Artisan này
```
id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down[]
    {
        Schema::dropIfExists['user'];
    }
}
```
2
Bạn cũng có thể khôi phục một số đợt di chuyển bằng cách sử dụng tùy chọn
```
php artisan make:migration create_users_table --path=app/database/migrations
```
19 và số lô. Laravel theo dõi tất cả
```
php artisan make:migration create_users_table --path=app/database/migrations
```
20 trên bảng migrations, bao gồm số đợt migrations
```
id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down[]
    {
        Schema::dropIfExists['user'];
    }
}
```
3
Nó khôi phục hai đợt di chuyển cuối cùng vào cơ sở dữ liệu của bạn. Bạn có thể kiểm tra bảng di chuyển trong cơ sở dữ liệu của mình nếu bạn không chắc chắn về số lô di chuyển để khôi phục
Đặt lại di chuyển
Bạn có thể sử dụng lệnh
```
php artisan make:migration create_users_table --path=app/database/migrations
```
21 để khôi phục tất cả các lần di chuyển ứng dụng của mình trong cơ sở dữ liệu
```
id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down[]
    {
        Schema::dropIfExists['user'];
    }
}
```
4
Làm mới di chuyển
Bạn có thể sử dụng lệnh
```
php artisan make:migration create_users_table --path=app/database/migrations
```
22 để tạo lại toàn bộ cơ sở dữ liệu của mình. Nó khôi phục tất cả các lần di chuyển của bạn và thực hiện lại lệnh di chuyển
```
id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down[]
    {
        Schema::dropIfExists['user'];
    }
}
```
5
Lệnh đó thường bị nhầm với
```
php artisan make:migration create_users_table --path=app/database/migrations
```
23. Lệnh
```
php artisan make:migration create_users_table --path=app/database/migrations
```
23 loại bỏ tất cả các bảng trong cơ sở dữ liệu trước khi thực hiện lệnh di chuyển.
```
id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down[]
    {
        Schema::dropIfExists['user'];
    }
}
```
6
Cần hết sức thận trọng với
```
php artisan make:migration create_users_table --path=app/database/migrations
```
25 trên các ứng dụng chia sẻ cơ sở dữ liệu vì nó loại bỏ tất cả các bảng trong cơ sở dữ liệu đó
Tạo một mô hình với di chuyển
Khi tạo một mô hình, bạn có thể sử dụng tùy chọn —migration [hoặc -m] để tạo một sự di chuyển cơ sở dữ liệu tương ứng
```
id[];
            $table->string['name'];
            $table->string['role'];
            $table->timestamps[];
        }];
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down[]
    {
        Schema::dropIfExists['user'];
    }
}
```
7
Sử dụng lệnh này, Laravel tạo một Thể loại. php tệp mô hình trong thư mục ứng dụng/Mô hình và tệp di chuyển
```
php artisan make:migration create_users_table --path=app/database/migrations
```
26 trong cơ sở dữ liệu/di chuyển
Bớt tư tưởng
Bạn đã đi một chặng đường dài, xin chúc mừng
Trong bài viết này, bạn đã học cách sử dụng di chuyển để cải thiện các ứng dụng Laravel của mình. Mã nguồn cho các tệp di chuyển, bao gồm các ví dụ được đánh dấu, có sẵn trên GitHub. Bạn cũng có thể tìm thêm thông tin về việc di chuyển Laravel trong tài liệu chính thức. Bây giờ bạn có thể thấy rằng việc di chuyển là cần thiết để theo dõi các thay đổi của cơ sở dữ liệu, hỗ trợ phát hiện lỗi và khôi phục trong trường hợp xảy ra lỗi
Nếu bạn muốn thấy sức mạnh của Laravel kết hợp với ButterCMS, hãy xem hướng dẫn của chúng tôi. Cách xây dựng blog với Laravel [và gửi thông báo chậm]

Làm cách nào để chạy di chuyển trong Laravel?

Để xem các lệnh di chuyển, hãy mở cửa sổ Git bash và nhập lệnh "php artisan list". Lệnh này liệt kê tất cả các lệnh có sẵn trong Laravel. .

di cư. tươi

di cư. Tải về

di cư. Làm tươi

di cư. cài lại

di cư. phục hồi

di cư. tình trạng

Làm cách nào để di chuyển trong Laravel bằng cmd?

Cấu trúc di chuyển .

sử dụng Chiếu sáng\Cơ sở dữ liệu\Di chuyển\Di chuyển;

sử dụng Chiếu sáng\Cơ sở dữ liệu\Schema\Bản thiết kế;

trả lại lớp mới mở rộng Di chuyển

* Chạy di chuyển. *

* @return vô hiệu

chức năng công khai lên[] {

Lược đồ. tạo ['chuyến bay', chức năng [Bản thiết kế $table] { $table->id[];

Cách di chuyển cơ sở dữ liệu được sử dụng trong Laravel?

Di chuyển giống như kiểm soát phiên bản cho cơ sở dữ liệu của bạn, cho phép nhóm của bạn sửa đổi và chia sẻ lược đồ cơ sở dữ liệu của ứng dụng . Di chuyển thường được ghép nối với trình tạo lược đồ của Laravel để xây dựng lược đồ cơ sở dữ liệu của ứng dụng của bạn.

Di chuyển Laravel

Laravel Migration là gì?

Tại sao bạn lại sử dụng Laravel Migration?

Cách tạo di chuyển

Cơ cấu di cư

Chạy di chuyển

Bảng, cột và chỉ mục

Những cái bàn

Tạo bảng

Sửa đổi bảng của bạn

Cột

Tạo một cột

Thả một cột

Sửa đổi một cột

chỉ mục

Xóa di chuyển

Dập tắt di chuyển

sự kiện di chuyển

Các lệnh di chuyển khác

Quay trở lại di chuyển

Đặt lại di chuyển

Làm mới di chuyển

Tạo một mô hình với di chuyển

Bớt tư tưởng

Làm cách nào để chạy di chuyển trong Laravel?

Làm cách nào để di chuyển trong Laravel bằng cmd?

Cách di chuyển cơ sở dữ liệu được sử dụng trong Laravel?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề