MariaDB - szybki przewodnik

Aplikacja bazy danych istnieje niezależnie od aplikacji głównej i przechowuje zbiory danych. Każda baza danych wykorzystuje jeden lub wiele interfejsów API do tworzenia, uzyskiwania dostępu, zarządzania, wyszukiwania i replikacji zawartych w niej danych.

Bazy danych korzystają również z nierelacyjnych źródeł danych, takich jak obiekty lub pliki. Jednak bazy danych okazują się najlepszą opcją w przypadku dużych zbiorów danych, które ucierpiałyby z powodu powolnego pobierania i zapisywania z innymi źródłami danych.

Systemy zarządzania relacyjnymi bazami danych (RDBMS) przechowują dane w różnych tabelach. Relacje między tymi tabelami są ustanawiane za pomocą kluczy podstawowych i kluczy obcych.

RDBMS oferuje następujące funkcje -

• Umożliwiają one implementację źródła danych z tabelami, kolumnami i indeksami.

• Zapewniają integralność odwołań w wierszach wielu tabel.

• Automatycznie aktualizują indeksy.

• Interpretują zapytania i operacje SQL związane z manipulowaniem danymi z tabel lub ich pozyskiwaniem.

Terminologia RDBMS

Zanim zaczniemy omawiać MariaDB, przyjrzyjmy się kilku terminom związanym z bazami danych.

• Database - Baza danych to źródło danych składające się z tabel zawierających powiązane dane.

• Table - Tabela, czyli arkusz kalkulacyjny, to macierz zawierająca dane.

• Column- Kolumna, oznaczająca element danych, to struktura przechowująca dane jednego typu; na przykład daty wysyłki.

• Row- Wiersz to struktura grupująca dane powiązane; na przykład dane klienta. Jest również znany jako krotka, wpis lub rekord.

• Redundancy - Termin ten odnosi się do dwukrotnego przechowywania danych w celu przyspieszenia działania systemu.

• Primary Key- Odnosi się do unikalnej, identyfikującej wartości. Ta wartość nie może pojawić się dwukrotnie w tabeli i jest z nią powiązany tylko jeden wiersz.

• Foreign Key - Klucz obcy służy jako łącze między dwiema tabelami.

• Compound Key- Klucz złożony lub klucz złożony to klucz odwołujący się do wielu kolumn. Odnosi się do wielu kolumn ze względu na brak wyjątkowej jakości.

• Index - Indeks jest praktycznie identyczny z indeksem książki.

• Referential Integrity - Ten termin odnosi się do zapewnienia, że ​​wszystkie wartości kluczy obcych wskazują na istniejące wiersze.

Baza danych MariaDB

MariaDB to popularne rozwidlenie MySQL stworzone przez pierwotnych programistów MySQL. Wyrosło z obaw związanych z przejęciem MySQL przez Oracle. Oferuje wsparcie zarówno dla małych zadań przetwarzania danych, jak i potrzeb przedsiębiorstw. Ma być bezpośrednim zamiennikiem MySQL, wymagającym jedynie prostej dezinstalacji MySQL i instalacji MariaDB. MariaDB oferuje te same funkcje co MySQL i wiele więcej.

Kluczowe cechy MariaDB

Ważnymi cechami MariaDB są -

• Cała MariaDB podlega licencji GPL, LGPL lub BSD.

• MariaDB obejmuje szeroki wybór silników pamięci masowej, w tym wysokowydajnych silników pamięci masowej, do pracy z innymi źródłami danych RDBMS.

• MariaDB używa standardowego i popularnego języka zapytań.

• MariaDB działa w wielu systemach operacyjnych i obsługuje wiele różnych języków programowania.

• MariaDB oferuje obsługę PHP, jednego z najpopularniejszych języków tworzenia stron internetowych.

• MariaDB oferuje technologię klastrów Galera.

• MariaDB oferuje również wiele operacji i poleceń niedostępnych w MySQL i eliminuje / zastępuje funkcje negatywnie wpływające na wydajność.

Pierwsze kroki

Przed rozpoczęciem tego samouczka upewnij się, że masz podstawową wiedzę o PHP i HTML, w szczególności o materiałach omówionych w naszych samouczkach dotyczących PHP i HTML.

Ten przewodnik koncentruje się na używaniu MariaDB w środowisku PHP, więc nasze przykłady będą najbardziej przydatne dla programistów PHP.

Zdecydowanie zalecamy przejrzenie naszego samouczka PHP, jeśli nie znasz go lub potrzebujesz go.

Wszystkie pliki do pobrania dla MariaDB znajdują się w sekcji Pobieranie na oficjalnej stronie internetowej fundacji MariaDB. Kliknij łącze do żądanej wersji, aby wyświetlić listę plików do pobrania dla wielu systemów operacyjnych, architektur i typów plików instalacyjnych.

Instalowanie w systemie LINUX / UNIX

Jeśli masz głęboką wiedzę na temat systemów Linux / Unix, po prostu pobierz źródło, aby zbudować swoją instalację. Zalecanym sposobem instalacji jest użycie pakietów dystrybucyjnych. MariaDB oferuje pakiety dla następujących dystrybucji Linux / Unix -

• RedHat/CentOS/Fedora
• Debian/Ubuntu

Następujące dystrybucje zawierają pakiet MariaDB w swoich repozytoriach -

• openSUSE
• Arch Linux
• Mageia
• Mint
• Slackware

Wykonaj następujące kroki, aby zainstalować w środowisku Ubuntu -

Step 1 - Zaloguj się jako użytkownik root.

Step 2 - Przejdź do katalogu zawierającego pakiet MariaDB.

Step 3 - Zaimportuj klucz podpisu GnuPG z następującym kodem -

sudo apt-key adv --recv-keys --keyserver keyserver.ubuntu.com 0xcbcb082a1bb943db

Step 4 - Dodaj MariaDB do sources.listplik. Otwórz plik i dodaj następujący kod -

sudo add-apt-repository 'deb http://ftp.osuosl.org/pub/mariadb/repo/5.5/ubuntuprecise main'

Step 5 - Odśwież system, wykonując następujące czynności -

sudo apt-get update

Step 6 - Zainstaluj MariaDB za pomocą następujących -

sudo apt-get install mariadb-server

Instalowanie w systemie Windows

Po zlokalizowaniu i pobraniu zautomatyzowanego pliku instalacyjnego (MSI) wystarczy dwukrotnie kliknąć plik, aby rozpocząć instalację. Kreator instalacji przeprowadzi Cię przez każdy etap instalacji i wszelkie niezbędne ustawienia.

Przetestuj instalację, uruchamiając ją z wiersza polecenia. Przejdź do lokalizacji instalacji, zwykle w katalogu, i wpisz następujące polecenie w wierszu polecenia -

mysqld.exe --console

Jeśli instalacja się powiedzie, zobaczysz komunikaty związane z uruchamianiem. Jeśli się nie pojawi, możesz mieć problemy z uprawnieniami. Upewnij się, że Twoje konto użytkownika ma dostęp do aplikacji. Klienci graficzni są dostępni do administrowania MariaDB w środowisku Windows. Jeśli uważasz, że wiersz poleceń jest niewygodny lub kłopotliwy, poeksperymentuj z nim.

Testowanie instalacji

Wykonaj kilka prostych czynności, aby potwierdzić działanie i instalację MariaDB.

Use the Admin Utility to Get Server Status

Wyświetl wersję serwera za pomocą pliku binarnego mysqladmin.

[root@host]# mysqladmin --version

Powinien wyświetlać wersję, dystrybucję, system operacyjny i architekturę. Jeśli nie widzisz danych wyjściowych tego typu, sprawdź instalację pod kątem problemów.

Execute Simple Commands with a Client

Wywołaj wiersz polecenia dla MariaDB. Powinno to połączyć Cię z MariaDB i umożliwić wykonywanie poleceń. Wprowadź proste polecenie w następujący sposób -

mysql> SHOW DATABASES;

Po instalacji

Po pomyślnej instalacji MariaDB ustaw hasło roota. Nowa instalacja będzie miała puste hasło. Wprowadź następujące informacje, aby ustawić nowe hasło -

mysqladmin -u root password "[enter your password here]";

Wprowadź następujące dane, aby połączyć się z serwerem przy użyciu nowych poświadczeń -

mysql -u root -p
Enter password:*******

Aktualizacja w systemie Windows

Jeśli masz już zainstalowany MySQL w swoim systemie Windows i chcesz uaktualnić do MariaDB; nie odinstalowuj MySQL i nie instaluj MariaDB. Spowoduje to konflikt z istniejącą bazą danych. Zamiast tego należy zainstalować MariaDB, a następnie użyć kreatora aktualizacji w pliku instalacyjnym systemu Windows.

Opcje pliku MySQL my.cnf powinny działać z MariaDB. Jednak MariaDB ma wiele funkcji, których nie ma w MySQL.

Rozważ następujące konflikty w swoim pliku my.cnf -

• MariaDB używa domyślnie silnika Aria dla plików tymczasowych. Jeśli masz dużo plików tymczasowych, zmień rozmiar bufora kluczy, jeśli nie używasz tabel MyISAM.

• Jeśli aplikacje często łączą się / rozłączają, zmień rozmiar pamięci podręcznej wątków.

• Jeśli używasz ponad 100 połączeń, użyj puli wątków.

Zgodność

MySQL i MariaDB są zasadniczo identyczne. Jest jednak wystarczająco dużo różnic, aby powodować problemy podczas aktualizacji. Przejrzyj więcej z tych kluczowych różnic w bazie wiedzy MariaDB.

Przed próbą uruchomienia MariaDB należy najpierw określić jej bieżący stan, działanie lub zamknięcie. Istnieją trzy opcje uruchamiania i zatrzymywania MariaDB -

• Uruchom mysqld (plik binarny MariaDB).
• Uruchom skrypt startowy mysqld_safe.
• Uruchom skrypt startowy mysql.server.

Jeśli zainstalowałeś MariaDB w niestandardowej lokalizacji, może być konieczna edycja informacji o lokalizacji w plikach skryptów. Zatrzymaj MariaDB, po prostu dodając parametr „stop” do skryptu.

Jeśli chcesz uruchamiać go automatycznie pod Linuksem, dodaj skrypty startowe do swojego initsystem. Każda dystrybucja ma inną procedurę. Zapoznaj się z dokumentacją systemu.

Tworzenie konta użytkownika

Utwórz nowe konto użytkownika za pomocą następującego kodu -

CREATE USER 'newusername'@'localhost' IDENTIFIED BY 'userpassword';

Ten kod dodaje wiersz do tabeli użytkowników bez uprawnień. Możesz również użyć wartości skrótu dla hasła. Przyznaj uprawnienia użytkownika za pomocą następującego kodu -

GRANT SELECT, INSERT, UPDATE, DELETE ON database1 TO 'newusername'@'localhost';

Inne uprawnienia obejmują prawie wszystkie polecenia lub operacje możliwe w MariaDB. Po utworzeniu użytkownika wykonaj polecenie „FLUSH PRIVILEGES” w celu odświeżenia tabel grantów. Pozwala to na użycie konta użytkownika.

Plik konfiguracyjny

Po kompilacji w systemie Unix / Linux plik konfiguracyjny „/etc/mysql/my.cnf” powinien zostać zmodyfikowany, aby wyglądał następująco -

# Example mysql config file.
# You can copy this to one of:
# /etc/my.cnf to set global options,
# /mysql-data-dir/my.cnf to get server specific options or
# ~/my.cnf for user specific options.

#

# One can use all long options that the program supports.
# Run the program with --help to get a list of available options

# This will be passed to all mysql clients
[client]
#password = my_password
#port = 3306
#socket = /tmp/mysql.sock

# Here is entries for some specific programs
# The following values assume you have at least 32M ram

# The MySQL server
[mysqld]
#port = 3306
#socket = /tmp/mysql.sock
temp-pool

# The following three entries caused mysqld 10.0.1-MariaDB (and possibly other
   versions) to abort...
# skip-locking
# set-variable = key_buffer = 16M
# set-variable = thread_cache = 4

loose-innodb_data_file_path = ibdata1:1000M
loose-mutex-deadlock-detector
gdb

######### Fix the two following paths

# Where you want to have your database
data = /path/to/data/dir

# Where you have your mysql/MariaDB source + sql/share/english
language = /path/to/src/dir/sql/share/english

[mysqldump]
quick
MariaDB
8
set-variable = max_allowed_packet=16M
[mysql]
no-auto-rehash

[myisamchk]
set-variable = key_buffer = 128M

Edytuj wiersze „data =” i „language =”, aby dopasować je do swojego środowiska.

Po modyfikacji pliku przejdź do katalogu źródłowego i wykonaj następujące czynności -

./scripts/mysql_install_db --srcdir = $PWD --datadir = /path/to/data/dir -- user = $LOGNAME

Pomiń „$PWD” variable if you added datadir to the configuration file. Ensure “$LOGNAME ”jest używany w przypadku wersji 10.0.1 MariaDB.

Polecenia administracyjne

Zapoznaj się z poniższą listą ważnych poleceń, których będziesz regularnie używać podczas pracy z MariaDB -

• USE [database name] - Ustawia bieżącą domyślną bazę danych.

• SHOW DATABASES - Wyświetla listę baz danych aktualnie znajdujących się na serwerze.

• SHOW TABLES - Wyświetla wszystkie nietymczasowe tabele.

• SHOW COLUMNS FROM [table name] - Zawiera informacje o kolumnach dotyczące określonej tabeli.

• SHOW INDEX FROM TABLENAME [table name] - Zawiera informacje o indeksie tabeli dotyczące określonej tabeli.

• SHOW TABLE STATUS LIKE [table name]\G – - Dostarcza tabelom informacje o tabelach nietymczasowych i wzorcu, który pojawia się po klauzuli LIKE jest używany do pobierania nazw tabel.

MariaDB współpracuje z szeroką gamą języków programowania i platform, takich jak PHP, C #, JavaScript, Ruby on Rails, Django i nie tylko. PHP pozostaje najpopularniejszym ze wszystkich dostępnych języków ze względu na swoją prostotę i znaczenie historyczne. Ten przewodnik skupi się na PHP we współpracy z MariaDB.

PHP udostępnia szereg funkcji do pracy z bazą danych MySQL. Funkcje te wykonują zadania, takie jak uzyskiwanie do nich dostępu lub wykonywanie operacji, i są w pełni zgodne z MariaDB. Po prostu wywołaj te funkcje tak, jak każdą inną funkcję PHP.

Funkcje PHP, których będziesz używać w MariaDB, są zgodne z następującym formatem -

mysql_function(value,value,...);

Druga część funkcji określa jej działanie. Dwie funkcje używane w tym przewodniku są następujące -

mysqli_connect($connect); mysqli_query($connect,"SQL statement");

Poniższy przykład ilustruje ogólną składnię wywołania PHP do funkcji MariaDB -

<html>
   <head>
      <title>PHP and MariaDB</title>
   </head>

   <body>
      <?php
         $retval = mysql_function(value, [value,...]); if( !$retval ) {
            die ( "Error: Error message here" );
         }
         // MariaDB or PHP Statements
      ?>
   </body>
</html>

W następnej sekcji przyjrzymy się podstawowym zadaniom MariaDB przy użyciu funkcji PHP.

Jednym ze sposobów nawiązania połączenia z MariaDB jest użycie pliku binarnego mysql w wierszu polecenia.

MYSQL Binary

Przejrzyj przykład podany poniżej.

[root@host]# mysql -u root -p

Enter password:******

Kod podany powyżej łączy się z MariaDB i udostępnia wiersz polecenia do wykonywania poleceń SQL. Po wpisaniu kodu powinna pojawić się wiadomość powitalna informująca o pomyślnym połączeniu z numerem wersji.

Welcome to the MariaDB monitor. Commands end with ; or \g. 
Your MariaDB connection id is 122323232 
Server version: 5.5.40-MariaDB-log
  
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.  
mysql>

W przykładzie zastosowano uprawnienia administratora, ale każdy użytkownik z uprawnieniami może oczywiście uzyskać dostęp do monitu MariaDB i wykonywać operacje.

Odłącz się od MariaDB za pośrednictwem exit polecenie w następujący sposób -

mysql> exit

Skrypt połączenia PHP

Innym sposobem łączenia się i odłączania od MariaDB jest użycie skryptu PHP. PHP zapewniamysql_connect()funkcja otwierania połączenia z bazą danych. Używa pięciu opcjonalnych parametrów i zwraca identyfikator łącza MariaDB po udanym połączeniu lub fałsz w przypadku nieudanego połączenia. Zapewnia równieżmysql_close() funkcja do zamykania połączeń z bazą danych, która używa pojedynczego parametru.

Składnia

Zapoznaj się z następującą składnią skryptu połączenia PHP -

connection mysql_connect(server,user,passwd,new_link,client_flag);

Opis parametrów znajduje się poniżej -

Sr.No	Parametr i opis
1	server Ten opcjonalny parametr określa nazwę hosta, na którym działa serwer bazy danych. Jego domyślna wartość to „localhost: .3036”.
2	user Ten opcjonalny parametr określa nazwę użytkownika uzyskującego dostęp do bazy danych. Jego wartością domyślną jest właściciel serwera.
3	passwd Ten opcjonalny parametr określa hasło użytkownika. Jego domyślna wartość jest pusta.
4	new_link Ten opcjonalny parametr określa, że ​​przy drugim wywołaniu mysql_connect() z identycznymi argumentami zamiast nowego połączenia zostanie zwrócony identyfikator bieżącego połączenia.
5	client flags Ten opcjonalny parametr wykorzystuje kombinację następujących wartości stałych - MYSQL_CLIENT_SSL - używa szyfrowania ssl. MYSQL_CLIENT_COMPRESS - Używa protokołu kompresji. MYSQL_CLIENT_IGNORE_SPACE - Pozwala na spację po nazwach funkcji. MYSQL_CLIENT_INTERACTIVE - pozwala na interaktywne przekroczenie limitu czasu w sekundach braku aktywności przed zamknięciem połączenia.

Zapoznaj się ze składnią skryptu rozłączania PHP podaną poniżej -

bool mysql_close ( resource $link_identifier );

Jeśli pominiesz zasób, ostatnio otwarty zasób zostanie zamknięty. Zwraca wartość true w przypadku pomyślnego zamknięcia lub false.

Wypróbuj poniższy przykładowy kod, aby połączyć się z serwerem MariaDB -

<html>
   <head>
      <title>Connect to MariaDB Server</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'guest1'; $dbpass = 'guest1a';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
      
         if(! $conn ) { die('Could not connect: ' . mysql_error()); } echo 'Connected successfully'; mysql_close($conn);
      ?>
   </body>
</html>

Po pomyślnym połączeniu zobaczysz następujące dane wyjściowe -

mysql> Connected successfully

Tworzenie lub usuwanie baz danych w MariaDB wymaga uprawnień nadawanych zwykle tylko użytkownikom root lub administratorom. W ramach tych kont masz dwie opcje tworzenia bazy danych - plik binarny mysqladmin i skrypt PHP.

plik binarny mysqladmin

Poniższy przykład demonstruje użycie pliku binarnego mysqladmin do tworzenia bazy danych o nazwie Products -

[root@host]# mysqladmin -u root -p create PRODUCTS
Enter password:******

PHP Utwórz skrypt bazy danych

PHP wykorzystuje mysql_queryfunkcji w tworzeniu bazy danych MariaDB. Funkcja używa dwóch parametrów, z których jeden jest opcjonalny i zwraca albo wartość „prawda”, jeśli się powiedzie, albo „fałsz”, jeśli nie.

Składnia

Przejrzyj następujące kwestie create database script składnia -

bool mysql_query( sql, connection );

Opis parametrów znajduje się poniżej -

S.Nr	Parametr i opis
1	sql Ten wymagany parametr składa się z zapytania SQL potrzebnego do wykonania operacji.
2	connection Jeśli nie jest określony, ten opcjonalny parametr używa ostatnio używanego połączenia.

Wypróbuj poniższy przykładowy kod do tworzenia bazy danych -

<html>
   <head>
      <title>Create a MariaDB Database</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'root';
         $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }

         echo 'Connected successfully<br />';
         $sql = 'CREATE DATABASE PRODUCTS'; $retval = mysql_query( $sql, $conn );
      
         if(! $retval ) { die('Could not create database: ' . mysql_error()); } echo "Database PRODUCTS created successfully\n"; mysql_close($conn);
      ?>
   </body>
</html>

Po pomyślnym usunięciu zobaczysz następujący wynik -

mysql> Database PRODUCTS created successfully 
mysql> SHOW DATABASES; 
+-----------------------+ 
| Database              | 
+-----------------------+ 
| PRODUCTS              | 
+-----------------------+

Tworzenie lub usuwanie baz danych w MariaDB wymaga uprawnień, zazwyczaj nadawanych tylko użytkownikom root lub administratorom. W ramach tych kont masz dwie opcje usuwania bazy danych: plik binarny mysqladmin i skrypt PHP.

Pamiętaj, że usunięte bazy danych są nieodwracalne, więc zachowaj ostrożność podczas wykonywania tej operacji. Co więcej, skrypty PHP używane do usuwania taknot poprosi o potwierdzenie przed usunięciem.

plik binarny mysqladmin

Poniższy przykład pokazuje, jak użyć pliku binarnego mysqladmin do usunięcia istniejącej bazy danych -

[root@host]# mysqladmin -u root -p drop PRODUCTS
Enter password:******
mysql> DROP PRODUCTS
ERROR 1008 (HY000): Can't drop database 'PRODUCTS'; database doesn't exist

Skrypt PHP Drop Database

PHP wykorzystuje mysql_queryfunkcja usuwania baz danych MariaDB. Funkcja używa dwóch parametrów, z których jeden jest opcjonalny i zwraca albo wartość „prawda”, jeśli się powiedzie, albo „fałsz”, jeśli nie.

Składnia

Zapoznaj się z następującą składnią skryptu bazy danych drop -

bool mysql_query( sql, connection );

Opis parametrów znajduje się poniżej -

Sr.No	Parametr i opis
1	sql Ten wymagany parametr składa się z zapytania SQL potrzebnego do wykonania operacji.
2	connection Jeśli nie jest określony, ten opcjonalny parametr używa ostatnio używanego połączenia.

Wypróbuj poniższy przykładowy kod do usuwania bazy danych -

<html>
   <head>
      <title>Delete a MariaDB Database</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'root';
         $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }
         echo 'Connected successfully<br />';
         
         $sql = 'DROP DATABASE PRODUCTS'; $retval = mysql_query( $sql, $conn );
         
         if(! $retval ){ die('Could not delete database: ' . mysql_error()); } echo "Database PRODUCTS deleted successfully\n"; mysql_close($conn);
      ?>
   </body>
</html>

Po pomyślnym usunięciu zobaczysz następujący wynik -

mysql> Database PRODUCTS deleted successfully

Po nawiązaniu połączenia z MariaDB należy wybrać bazę danych do pracy, ponieważ może istnieć wiele baz danych. Zadanie to można wykonać na dwa sposoby: z wiersza poleceń lub za pomocą skryptu PHP.

Wiersz polecenia

Wybierając bazę danych w wierszu polecenia, po prostu użyj polecenia SQL ‘use’ -

[root@host]# mysql -u root -p

Enter password:******

mysql> use PRODUCTS;

Database changed

mysql> SELECT database();  
+-------------------------+ 
| Database                | 
+-------------------------+ 
| PRODUCTS                | 
+-------------------------+

Po wybraniu bazy danych wszystkie kolejne polecenia będą działały na wybranej bazie danych.

Note- Wszystkie nazwy (np. Baza danych, tabela, pola) uwzględniają wielkość liter. Upewnij się, że polecenia są zgodne z właściwym przypadkiem.

PHP Wybierz skrypt bazy danych

PHP zapewnia mysql_select_dbfunkcja wyboru bazy danych. Funkcja używa dwóch parametrów, z których jeden jest opcjonalny i zwraca wartość „true” w przypadku pomyślnego wyboru lub false w przypadku niepowodzenia.

Składnia

Przejrzyj poniższą składnię skryptu wyboru bazy danych.

bool mysql_select_db( db_name, connection );

Opis parametrów znajduje się poniżej -

S.Nr	Parametr i opis
1	db_name Ten wymagany parametr określa nazwę używanej bazy danych.
2	connection Jeśli nie jest określony, ten opcjonalny parametr używa ostatnio używanego połączenia.

Wypróbuj następujący przykładowy kod do wybierania bazy danych -

<html>
   <head>
      <title>Select a MariaDB Database</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'guest1';
         $dbpass = 'guest1a'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }
         echo 'Connected successfully';
         
         mysql_select_db( 'PRODUCTS' );
         mysql_close($conn);
      ?>
   </body>
</html>

Po pomyślnym wybraniu zobaczysz następujący wynik -

mysql> Connected successfully

Dobre definicje pól są niezbędne do optymalizacji bazy danych. Idealne podejście wymaga użycia wyłącznie pola wymaganego typu i rozmiaru. Na przykład, jeśli będziesz używać tylko pola o szerokości pięciu znaków, nie definiuj pola o szerokości 20 znaków. Typy pól (lub kolumn) są również znane jako typy danych ze względu na typy danych przechowywane w polu.

Typy danych MariaDB można podzielić na wartości liczbowe, daty i godziny oraz ciągi.

Numeryczne typy danych

Numeryczne typy danych obsługiwane przez MariaDB są następujące -

• TINYINT - Ten typ danych reprezentuje małe liczby całkowite mieszczące się w zakresie ze znakiem od -128 do 127 oraz z zakresu bez znaku od 0 do 255.

• BOOLEAN - Ten typ danych wiąże wartość 0 z „fałszem”, a wartość 1 z „prawdą”.

• SMALLINT - Ten typ danych reprezentuje liczby całkowite w zakresie ze znakiem od -32768 do 32768 oraz z zakresu bez znaku od 0 do 65535.

• MEDIUMINT - Ten typ danych reprezentuje liczby całkowite w zakresie ze znakiem od -8388608 do 8388607 oraz z zakresu bez znaku od 0 do 16777215.

• INT(also INTEGER)- Ten typ danych reprezentuje liczbę całkowitą o normalnym rozmiarze. Zakres oznaczony jako bez znaku obejmuje zakres od 0 do 4294967295. Po podpisaniu (ustawienie domyślne) zakres obejmuje od -2147483648 do 2147483647. Gdy kolumna jest ustawiona na ZEROFILL (stan bez znaku), wszystkie jej wartości są poprzedzone zerami w celu umieszczenia M cyfr w wartości INT.

• BIGINT - Ten typ danych reprezentuje liczby całkowite z zakresu ze znakiem od 9223372036854775808 do 9223372036854775807 oraz z zakresu bez znaku od 0 do 18446744073709551615.

• DECIMAL(także DEC, NUMERIC, FIXED) - Ten typ danych reprezentuje dokładne liczby stałoprzecinkowe, gdzie M określa jego cyfry, a D określa cyfry po przecinku. Wartość M nie dodaje „-” ani kropki dziesiętnej. Jeśli D jest ustawione na 0, nie pojawia się żadna część dziesiętna ani ułamkowa, a wartość zostanie zaokrąglona do najbliższego DECIMAL podczas WSTAWIANIA. Maksymalna dozwolona liczba cyfr to 65, a maksymalna dla miejsc po przecinku to 30. Wartość domyślna dla M w przypadku pominięcia to 10, a 0 dla D w przypadku pominięcia.

• FLOAT - Ten typ danych reprezentuje małą, zmiennoprzecinkową liczbę o wartości 0 lub liczbie z następujących zakresów -

  • -3,402823466E + 38 do -1,175494351E-38

  • Od 1.175494351E-38 do 3.402823466E + 38

• DOUBLE (również REAL i DOUBLE PRECISION) - Ten typ danych reprezentuje liczby zmiennoprzecinkowe o normalnym rozmiarze o wartości 0 lub z następujących zakresów -

  • -1,7976931348623157E + 308 do -2,2250738585072014E-308

  • 2.2250738585072014E-308 do 1.7976931348623157E + 308

• BIT- Ten typ danych reprezentuje pola bitowe, przy czym M określa liczbę bitów przypadających na wartość. W przypadku pominięcia M wartością domyślną jest 1. Wartości bitów można zastosować z „b '[wartość]'”, gdzie wartość reprezentuje wartość bitu w 0 i 1. Wypełnienie zerowe następuje automatycznie od lewej strony na całej długości; na przykład „10” staje się „0010”.

Typy danych daty i godziny

Typy danych daty i godziny obsługiwane przez MariaDB są następujące -

• DATE - Ten typ danych reprezentuje zakres dat od „1000-01-01” do „9999-12-31” i używa formatu daty „RRRR-MM-DD”.

• TIME - Ten typ danych reprezentuje zakres czasu od „-838: 59: 59,999999” do „838: 59: 59,999999”.

• DATETIME- Ten typ danych reprezentuje zakres od „1000-01-01 00: 00: 00.000000” do „9999-12-31 23: 59: 59.999999”. Używa formatu „RRRR-MM-DD GG: MM: SS”.

• TIMESTAMP- Ten typ danych reprezentuje znacznik czasu w formacie „RRRR-MM-DD GG: MM: DD”. Znajduje zastosowanie głównie w szczegółowym określaniu czasu modyfikacji bazy danych, np. Wstawienia lub aktualizacji.

• YEAR- Ten typ danych przedstawia rok w formacie 4-cyfrowym. Format czterocyfrowy dopuszcza wartości z zakresu od 1901 do 2155 i 0000.

String DataTypes

Wartości typu ciągu obsługiwane przez MariaDB są następujące -

• String literals - Ten typ danych reprezentuje sekwencje znaków ujęte w cudzysłowy.

• CHAR- Ten typ danych reprezentuje ciąg o stałej długości, z prawej strony, zawierający spacje o określonej długości. M reprezentuje długość kolumny zawierającą znaki z zakresu od 0 do 255, jej domyślna wartość to 1.

• VARCHAR - Ten typ danych reprezentuje łańcuch o zmiennej długości z zakresem M (maksymalna długość kolumny) od 0 do 65535.

• BINARY - Ten typ danych reprezentuje binarne ciągi bajtów, z M jako długością kolumny w bajtach.

• VARBINARY - Ten typ danych reprezentuje binarne ciągi bajtów o zmiennej długości, z M jako długością kolumny.

• TINYBLOB- Ten typ danych reprezentuje kolumnę typu blob o maksymalnej długości 255 (28-1) bajtów. W pamięci każdy używa jednobajtowego przedrostka długości wskazującego ilość bajtów w wartości.

• BLOB- Ten typ danych reprezentuje kolumnę typu blob o maksymalnej długości 65 535 (216 - 1) bajtów. W pamięci każdy używa dwubajtowego prefiksu długości wskazującego ilość bajtów w wartości.

• MEDIUMBLOB- Ten typ danych reprezentuje kolumnę typu blob o maksymalnej długości 16 777 215 (2 ²⁴ - 1) bajtów. W pamięci każdy używa przedrostka o długości trzech bajtów, wskazującego ilość bajtów w wartości.

• LONGBLOB- Ten typ danych reprezentuje kolumnę typu blob o maksymalnej długości 4294 967 295 (2 ³² - 1) bajtów. W pamięci każdy używa czterobajtowego prefiksu długości wskazującego ilość bajtów w wartości.

• TINYTEXT- Ten typ danych reprezentuje kolumnę tekstową o maksymalnej długości 255 (2 ⁸ - 1) znaków. W pamięci każdy używa jednobajtowego przedrostka długości wskazującego ilość bajtów w wartości.

• TEXT- Ten typ danych reprezentuje kolumnę tekstową o maksymalnej długości 65 535 (2 ¹⁶ - 1) znaków. W pamięci każdy używa dwubajtowego prefiksu długości wskazującego ilość bajtów w wartości.

• MEDIUMTEXT- Ten typ danych reprezentuje kolumnę tekstową o maksymalnej długości 16 777 215 (2 ²⁴ - 1) znaków. W pamięci każdy używa przedrostka o długości trzech bajtów, wskazującego ilość bajtów w wartości.

• LONGTEXT- Ten typ danych reprezentuje kolumnę tekstową o maksymalnej długości 4 294 967 295 lub 4 GB (2 ³² - 1) znaków. W pamięci każdy używa czterobajtowego prefiksu długości wskazującego ilość bajtów w wartości.

• ENUM - Ten typ danych reprezentuje obiekt typu string mający tylko jedną wartość z listy.

• SET- Ten typ danych reprezentuje obiekt łańcuchowy mający zero lub więcej wartości z listy, z maksymalnie 64 elementami. Wartości SET występują wewnętrznie jako wartości całkowite.

W tym rozdziale dowiemy się, jak tworzyć tabele. Przed utworzeniem tabeli najpierw określ jej nazwę, nazwy pól i definicje pól.

Poniżej znajduje się ogólna składnia tworzenia tabeli -

CREATE TABLE table_name (column_name column_type);

Przejrzyj polecenie zastosowane do utworzenia tabeli w bazie PRODUKTÓW -

databaseproducts_ tbl(
   product_id INT NOT NULL AUTO_INCREMENT,
   product_name VARCHAR(100) NOT NULL,
   product_manufacturer VARCHAR(40) NOT NULL,
   submission_date DATE,
   PRIMARY KEY ( product_id )
);

W powyższym przykładzie użyto „NOT NULL” jako atrybutu pola, aby uniknąć błędów spowodowanych wartością zerową. Atrybut „AUTO_INCREMENT” instruuje MariaDB, aby dodała następną dostępną wartość do pola ID. Klucz podstawowy słowa kluczowego definiuje kolumnę jakoprimary key. Klucz podstawowy można zdefiniować w wielu kolumnach oddzielonych przecinkami.

Dwie główne metody tworzenia tabel to użycie wiersza poleceń i skryptu PHP.

Wiersz polecenia

Użyj polecenia CREATE TABLE, aby wykonać zadanie, jak pokazano poniżej -

root@host# mysql -u root -p
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> CREATE TABLE products_tbl(
   -> product_id INT NOT NULL AUTO_INCREMENT,
   -> product_name VARCHAR(100) NOT NULL,
   -> product_manufacturer VARCHAR(40) NOT NULL,
   -> submission_date DATE,
   -> PRIMARY KEY ( product_id )
   -> );
mysql> SHOW TABLES;
+------------------------+
| PRODUCTS               |
+------------------------+
| products_tbl           |
+------------------------+

Upewnij się, że wszystkie polecenia są zakończone średnikiem.

PHP Utwórz skrypt tabeli

PHP zapewnia mysql_query()do tworzenia tabel. Drugi argument zawiera niezbędne polecenie SQL -

<html>
   <head>
      <title>Create a MariaDB Table</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'root'; $dbpass = 'rootpassword';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
      
         if(! $conn ){ die('Could not connect: ' . mysql_error()); } echo 'Connected successfully<br />'; $sql = "CREATE TABLE products_tbl( ".
            "product_id INT NOT NULL AUTO_INCREMENT, ".
            "product_name VARCHAR(100) NOT NULL, ".
            "product_manufacturer VARCHAR(40) NOT NULL, ".
            "submission_date DATE, ".
            "PRIMARY KEY ( product_id )); ";
      
         mysql_select_db( 'PRODUCTS' );
         $retval = mysql_query( $sql, $conn ); if(! $retval ) {
            die('Could not create table: ' . mysql_error());
         }
         echo "Table created successfully\n";
         
         mysql_close($conn);
      ?>
   </body>
</html>

Po pomyślnym utworzeniu tabeli zobaczysz następujące dane wyjściowe -

mysql> Table created successfully

W tym rozdziale nauczymy się usuwać tabele.

Usunięcie tabeli jest bardzo łatwe, ale pamiętaj, że wszystkie usunięte tabele są nieodwracalne. Ogólna składnia usuwania tabeli jest następująca -

DROP TABLE table_name ;

Istnieją dwie opcje usuwania tabeli: użyj wiersza poleceń lub skryptu PHP.

Wiersz polecenia

W wierszu polecenia po prostu użyj pliku DROP TABLE Polecenie SQL -

root@host# mysql -u root -p
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> DROP TABLE products_tbl

mysql> SELECT * from products_tbl
ERROR 1146 (42S02): Table 'products_tbl' doesn't exist

Skrypt PHP Drop Table

PHP zapewnia mysql_query()do upuszczania stołów. Po prostu przekaż jego drugi argument odpowiednią komendę SQL -

<html>
   <head>
      <title>Create a MariaDB Table</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'root'; $dbpass = 'rootpassword';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
         
         if(! $conn ) { die('Could not connect: ' . mysql_error()); } echo 'Connected successfully<br />'; $sql = "DROP TABLE products_tbl";
         mysql_select_db( 'PRODUCTS' );
         $retval = mysql_query( $sql, $conn ); if(! $retval ) {
            die('Could not delete table: ' . mysql_error());
         }
         echo "Table deleted successfully\n";
         
         mysql_close($conn);
      ?>
   </body>
</html>

Po pomyślnym usunięciu tabeli zobaczysz następujący wynik -

mysql> Table deleted successfully

W tym rozdziale nauczymy się, jak wstawiać dane do tabeli.

Wstawienie danych do tabeli wymaga polecenia INSERT. Ogólna składnia polecenia to INSERT, po której następuje nazwa tabeli, pola i wartości.

Przejrzyj jego ogólną składnię podaną poniżej -

INSERT INTO tablename (field,field2,...) VALUES (value, value2,...);

Instrukcja wymaga użycia pojedynczych lub podwójnych cudzysłowów dla wartości łańcuchowych. Inne opcje instrukcji obejmują instrukcje „INSERT ... SET”, instrukcje „INSERT ... SELECT” i kilka innych opcji.

Note - Funkcja VALUES (), która pojawia się w instrukcji, ma zastosowanie tylko do instrukcji INSERT i zwraca NULL, jeśli zostanie użyta w innym miejscu.

Istnieją dwie opcje wykonywania operacji: użyj wiersza poleceń lub użyj skryptu PHP.

Wiersz polecenia

Po wyświetleniu monitu istnieje wiele sposobów wykonania wybranej operacji. Poniżej podano standardowe oświadczenie -

belowmysql>
INSERT INTO products_tbl (ID_number, Nomenclature) VALUES (12345,“Orbitron 4000”);
mysql> SHOW COLUMNS FROM products_tbl;
+-------------+-------------+------+-----+---------+-------+
| Field       | Type        | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+
| ID_number   | int(5)      |      |     |         |       |
| Nomenclature| char(13)    |      |     |         |       |
+-------------+-------------+------+-----+---------+-------+

Możesz wstawić wiele wierszy -

INSERT INTO products VALUES (1, “first row”), (2, “second row”);

Możesz również zastosować klauzulę SET -

INSERT INTO products SELECT * FROM inventory WHERE status = 'available';

Skrypt wstawiania PHP

Użyj tej samej instrukcji „INSERT INTO ...” w funkcji PHP, aby wykonać operację. Będziesz używaćmysql_query() funkcja ponownie.

Przejrzyj przykład podany poniżej -

<?php
   if(isset($_POST['add'])) {
      $dbhost = 'localhost:3036'; $dbuser = 'root';
      $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
         die('Could not connect: ' . mysql_error());
      }

      if(! get_magic_quotes_gpc() ) {
         $product_name = addslashes ($_POST['product_name']);
         $product_manufacturer = addslashes ($_POST['product_name']);
      } else {
         $product_name = $_POST['product_name'];
         $product_manufacturer = $_POST['product_manufacturer'];
      }
      $ship_date = $_POST['ship_date'];
      $sql = "INSERT INTO products_tbl ". "(product_name,product_manufacturer, ship_date) ". "VALUES"."('$product_name','$product_manufacturer','$ship_date')";

      mysql_select_db('PRODUCTS');
      $retval = mysql_query( $sql, $conn ); if(! $retval ) {
         die('Could not enter data: ' . mysql_error());
      }

      echo "Entered data successfully\n";
      mysql_close($conn);
   }
?>

Po pomyślnym wstawieniu danych zobaczysz następujące dane wyjściowe -

mysql> Entered data successfully

Będziesz także współpracować z oświadczeniami walidacyjnymi z instrukcjami wstawiania, takimi jak sprawdzenie poprawności wprowadzania danych. MariaDB udostępnia w tym celu szereg opcji, z których niektóre są automatyczne.

W tym rozdziale nauczymy się wybierać dane z tabeli.

Instrukcje SELECT pobierają wybrane wiersze. Mogą zawierać instrukcje UNION, klauzulę porządkową, klauzulę LIMIT, klauzulę WHERE, klauzulę GROUP BY ... HAVING i podzapytania.

Przejrzyj następującą ogólną składnię -

SELECT field, field2,... FROM table_name, table_name2,... WHERE...

Instrukcja SELECT zapewnia wiele opcji określania używanej tabeli -

• database_name.table_name

• table_name.column_name

• database_name.table_name.column_name

Wszystkie instrukcje Select muszą zawierać jedną lub więcej select expressions. Wybierz wyrażenia składają się z jednej z następujących opcji -

• Nazwa kolumny.

• Wyrażenie zawierające operatory i funkcje.

• Specyfikacja „nazwa_tabeli. *” W celu wybrania wszystkich kolumn w danej tabeli.

• Znak „*”, aby zaznaczyć wszystkie kolumny ze wszystkich tabel określonych w klauzuli FROM.

Do wykonania instrukcji select można wykorzystać wiersz polecenia lub skrypt PHP.

Wiersz polecenia

W wierszu polecenia wykonaj następujące instrukcje -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> SELECT * from products_tbl
+-------------+---------------+
| ID_number   | Nomenclature  |
+-------------+---------------+
| 12345       | Orbitron 4000 |
+-------------+---------------+

PHP Select Script

Użyj tych samych instrukcji SELECT w funkcji PHP, aby wykonać operację. Będziesz używaćmysql_query()funkcja ponownie. Przejrzyj przykład podany poniżej -

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT product_id, product_name,product_manufacturer, ship_date FROM products_tbl';
   mysql_select_db('PRODUCTS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {
      echo "Product ID :{$row['product_id']} <br> ". "Name: {$row['product_name']} <br> ".
         "Manufacturer: {$row['product_manufacturer']} <br> ". "Ship Date : {$row['ship_date']} <br>".
         "--------------------------------<br>";
   }

   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

Po pomyślnym pobraniu danych zobaczysz następujący wynik -

Product ID: 12345
Nomenclature: Orbitron 4000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 12346
Nomenclature: Orbitron 3000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
mysql> Fetched data successfully

Najlepsze praktyki sugerują zwalnianie pamięci kursora po każdej instrukcji SELECT. PHP zapewniamysql_free_result()funkcji w tym celu. Przejrzyj jego użycie, jak pokazano poniżej -

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl';
   mysql_select_db('PRODUCTS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_NUM)) {
      echo "Product ID :{$row[0]} <br> ". "Name: {$row[1]} <br> ".
         "Manufacturer: {$row[2]} <br> ". "Ship Date : {$row[3]} <br> ".
         "--------------------------------<br>";
   }

   mysql_free_result($retval); echo "Fetched data successfully\n"; mysql_close($conn);
?>

WHEREklauzule filtrują różne instrukcje, takie jak SELECT, UPDATE, DELETE i INSERT. Przedstawiają kryteria służące do określenia działania. Zwykle pojawiają się po nazwie tabeli w instrukcji, a ich stan następuje. Klauzula WHERE zasadniczo działa jak instrukcja if.

Przejrzyj ogólną składnię klauzuli WHERE podaną poniżej -

[COMMAND] field,field2,... FROM table_name,table_name2,... WHERE [CONDITION]

Zwróć uwagę na następujące cechy klauzuli WHERE -

• Jest to opcjonalne.

• Pozwala określić dowolny warunek.

• Pozwala na określenie wielu warunków za pomocą operatora AND lub OR.

• Uwzględnianie wielkości liter dotyczy tylko stwierdzeń korzystających z porównań LIKE.

Klauzula WHERE pozwala na użycie następujących operatorów -

Operator
=! =
> <
> = <=

Klauzule WHERE mogą być używane w wierszu polecenia lub w skrypcie PHP.

Wiersz polecenia

W wierszu polecenia po prostu użyj standardowego polecenia -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> SELECT * from products_tbl WHERE product_manufacturer = 'XYZ Corp';
+-------------+----------------+----------------------+
| ID_number   | Nomenclature   | product_manufacturer |
+-------------+----------------+----------------------+
| 12345       | Orbitron 4000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12346       | Orbitron 3000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12347       | Orbitron 1000  | XYZ Corp             |
+-------------+----------------+----------------------+

Przejrzyj przykład przy użyciu AND stan -

SELECT *
FROM products_tbl
WHERE product_name = 'Bun Janshu 3000';
AND product_id <= 344;

Ten przykład łączy warunki AND i OR

SELECT *
FROM products_tbl
WHERE (product_name = 'Bun Janshu 3000' AND product_id < 344)
OR (product_name = 'Bun Janshu 3000');

Skrypty PHP wykorzystujące klauzulę Where

Zatrudnij mysql_query() funkcja w operacjach używających klauzuli WHERE -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl WHERE product_manufacturer = "XYZ Corp"'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Product ID :{$row['product_id']} <br> ".
         "Name: {$row['product_name']} <br> ". "Manufacturer: {$row['product_manufacturer']} <br> ".
         "Ship Date: {$row['ship_date']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

Po pomyślnym pobraniu danych zobaczysz następujący wynik -

Product ID: 12345
Nomenclature: Orbitron 4000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 12346
Nomenclature: Orbitron 3000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
Product ID: 12347
Nomenclature: Orbitron 1000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
mysql> Fetched data successfully

Plik UPDATEpolecenie modyfikuje istniejące pola, zmieniając wartości. Używa klauzuli SET, aby określić kolumny do modyfikacji i określić nowe przypisane wartości. Te wartości mogą być wyrażeniem lub wartością domyślną pola. Ustawienie wartości domyślnej wymaga użycia słowa kluczowego DEFAULT. Polecenie może również wykorzystywać klauzulę WHERE do określenia warunków aktualizacji i / lub klauzulę ORDER BY do aktualizacji w określonej kolejności.

Przejrzyj następującą ogólną składnię -

UPDATE table_name SET field=new_value, field2=new_value2,...
[WHERE ...]

Wykonaj polecenie UPDATE z wiersza poleceń lub za pomocą skryptu PHP.

Wiersz polecenia

W wierszu polecenia po prostu użyj standardowego katalogu głównego -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> UPDATE products_tbl
   SET nomenclature = 'Fiber Blaster 300Z' WHERE ID_number = 112;
mysql> SELECT * from products_tbl WHERE ID_number='112';
+-------------+---------------------+----------------------+
| ID_number   | Nomenclature        | product_manufacturer |
+-------------+---------------------+----------------------+
| 112         | Fiber Blaster 300Z  | XYZ Corp             |
+-------------+---------------------+----------------------+

PHP Update Query Script

Zatrudnij mysql_query() funkcja w instrukcjach polecenia UPDATE -

<?php
   $dbhost = ‘localhost:3036’; $dbuser = ‘root’;
   $dbpass = ‘rootpassword’; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die(‘Could not connect: ‘ . mysql_error());
   }

   $sql = ‘UPDATE products_tbl SET product_name = ”Fiber Blaster 300z” WHERE product_id = 112’; mysql_select_db(‘PRODUCTS’); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die(‘Could not update data: ‘ . mysql_error()); } echo “Updated data successfully\n”; mysql_close($conn);
?>

Po pomyślnej aktualizacji danych zobaczysz następujące dane wyjściowe -

mysql> Updated data successfully

Polecenie DELETE usuwa wiersze tabeli z określonej tabeli i zwraca usuniętą ilość. Uzyskaj dostęp do ilości usuniętej za pomocą funkcji ROW_COUNT (). Klauzula WHERE określa wiersze, aw przypadku jej braku wszystkie wiersze są usuwane. Klauzula LIMIT kontroluje liczbę usuniętych wierszy.

W instrukcji DELETE dla wielu wierszy usuwa tylko te wiersze, które spełniają warunek; klauzule LIMIT i WHERE są niedozwolone. Instrukcje DELETE umożliwiają usuwanie wierszy z tabel w różnych bazach danych, ale nie pozwalają na usuwanie z tabeli, a następnie wybieranie z tej samej tabeli w podzapytaniu.

Przejrzyj następującą składnię DELETE -

DELETE FROM table_name [WHERE …]

Wykonaj polecenie DELETE z wiersza poleceń lub za pomocą skryptu PHP.

Wiersz polecenia

W wierszu polecenia po prostu użyj standardowego polecenia -

root@host# mysql –u root –p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> DELETE FROM products_tbl WHERE product_id=133;
mysql> SELECT * from products_tbl WHERE ID_number='133';
ERROR 1032 (HY000): Can't find record in 'products_tbl'

PHP Delete Query Script

Użyj mysql_query() funkcja w instrukcjach polecenia DELETE -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'DELETE FROM products_tbl WHERE product_id = 261'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die('Could not delete data: ' . mysql_error()); } echo "Deleted data successfully\n"; mysql_close($conn);
?>

Po pomyślnym usunięciu danych zobaczysz następujący wynik -

mysql> Deleted data successfully
mysql> SELECT * from products_tbl WHERE ID_number='261';
ERROR 1032 (HY000): Can't find record in 'products_tbl'

Klauzula WHERE umożliwia pobieranie danych, gdy operacja używa dokładnego dopasowania. W sytuacjach wymagających wielu wyników o wspólnych cechach, rozszerzenieLIKE klauzula umożliwia dopasowanie szerokiego wzorca.

Klauzula LIKE sprawdza dopasowanie do wzorca, zwracając wartość true lub false. Wzorce używane do porównania akceptują następujące symbole wieloznaczne: „%”, co oznacza liczbę znaków (0 lub więcej); i „_”, co oznacza pojedynczy znak. Znak wieloznaczny „_” pasuje tylko do znaków w swoim zestawie, co oznacza, że ​​będzie ignorował znaki łacińskie podczas używania innego zestawu. Dopasowania domyślnie nie uwzględniają wielkości liter, co wymaga dodatkowych ustawień uwzględniających wielkość liter.

Klauzula NOT LIKE umożliwia testowanie przeciwnego warunku, podobnie jak w przypadku not operator.

Jeśli wyrażenie lub wzorzec instrukcji ma wartość NULL, wynikiem jest NULL.

Przejrzyj ogólną składnię klauzuli LIKE podaną poniżej -

SELECT field, field2,... FROM table_name, table_name2,...
WHERE field LIKE condition

Zastosuj klauzulę LIKE w wierszu polecenia lub w skrypcie PHP.

Wiersz polecenia

W wierszu polecenia po prostu użyj standardowego polecenia -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * from products_tbl
   WHERE product_manufacturer LIKE 'XYZ%';
+-------------+----------------+----------------------+
| ID_number   | Nomenclature   | product_manufacturer |
+-------------+----------------+----------------------+
| 12345       | Orbitron 4000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12346       | Orbitron 3000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12347       | Orbitron 1000  | XYZ Corp             |
+-------------+----------------+----------------------+

Skrypt PHP wykorzystujący klauzulę Like

Użyj mysql_query() funkcja w instrukcjach wykorzystujących klauzulę LIKE

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl WHERE product_manufacturer LIKE "xyz%"'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Product ID:{$row['product_id']} <br> ".
         "Name: {$row['product_name']} <br> ". "Manufacturer: {$row['product_manufacturer']} <br> ".
         "Ship Date: {$row['ship_date']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

Po pomyślnym pobraniu danych zobaczysz następujący wynik -

Product ID: 12345
Nomenclature: Orbitron 4000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 12346
Nomenclature: Orbitron 3000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
Product ID: 12347
Nomenclature: Orbitron 1000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
mysql> Fetched data successfully

Plik ORDER BYklauzula, jak wspomniano w poprzednich dyskusjach, sortuje wyniki oświadczenia. Określa kolejność obsługiwanych danych i zawiera opcję sortowania w kolejności rosnącej (ASC) lub malejącej (DESC). W przypadku pominięcia specyfikacji zamówienia domyślna kolejność jest rosnąca.

Klauzule ORDER BY pojawiają się w wielu różnych instrukcjach, takich jak DELETE i UPDATE. Zawsze pojawiają się na końcu instrukcji, a nie w podzapytaniu lub przed funkcją zestawu, ponieważ działają na ostatecznej tabeli wynikowej. Nie można również użyć liczby całkowitej do zidentyfikowania kolumny.

Przejrzyj ogólną składnię klauzuli ORDER BY podaną poniżej -

SELECT field, field2,... [or column] FROM table_name, table_name2,...
ORDER BY field, field2,... ASC[or DESC]

Użyj klauzuli ORDER BY w wierszu polecenia lub w skrypcie PHP.

Wiersz polecenia

W wierszu polecenia po prostu użyj standardowego polecenia -

root@ host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed

mysql> SELECT * from products_tbl ORDER BY product_manufacturer ASC
+-------------+----------------+----------------------+
| ID_number   | Nomenclature   | product_manufacturer |
+-------------+----------------+----------------------+
| 56789       | SuperBlast 400 | LMN Corp             |
+-------------+----------------+----------------------+
| 67891       | Zoomzoom 5000  | QFT Corp             |
+-------------+----------------+----------------------+
| 12347       | Orbitron 1000  | XYZ Corp             |
+-------------+----------------+----------------------+

Skrypt PHP wykorzystujący klauzulę kolejności

Skorzystaj z mysql_query() funkcja ponownie w wypowiedziach z klauzulą ​​ORDER BY -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl ORDER BY product_manufacturer DESC'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Product ID :{$row['product_id']} <br> ".
         "Name: {$row['product_name']} <br> ". "Manufacturer: {$row['product_manufacturer']} <br> ".
         "Ship Date : {$row['ship_date']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

Po pomyślnym pobraniu danych zobaczysz następujący wynik -

Product ID: 12347
Nomenclature: Orbitron 1000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 67891
Nomenclature: Zoomzoom 5000
Manufacturer: QFT Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 56789
Nomenclature: SuperBlast 400
Manufacturer: LMN Corp
Ship Date: 01/04/17
----------------------------------------------
mysql> Fetched data successfully

W poprzednich dyskusjach i przykładach badaliśmy pobieranie z jednej tabeli lub pobieranie wielu wartości z wielu źródeł. Większość rzeczywistych operacji na danych jest znacznie bardziej złożonych i wymaga agregacji, porównania i pobierania z wielu tabel.

JOINspozwalają na scalenie dwóch lub więcej tabel w jeden obiekt. Są one wykorzystywane przez instrukcje SELECT, UPDATE i DELETE.

Przejrzyj ogólną składnię instrukcji wykorzystującej JOIN, jak pokazano poniżej -

SELECT column
FROM table_name1
INNER JOIN table_name2
ON table_name1.column = table_name2.column;

Zwróć uwagę na starą składnię JOINS używającą niejawnych złączeń i żadnych słów kluczowych. Możliwe jest użycie klauzuli WHERE w celu uzyskania sprzężenia, ale słowa kluczowe działają najlepiej w przypadku czytelności, obsługi i najlepszych praktyk.

Złącza JOIN występują w wielu formach, takich jak sprzężenie lewe, sprzężenie prawe lub sprzężenie wewnętrzne. Różne typy złączeń oferują różne typy agregacji w oparciu o wspólne wartości lub cechy.

Użyj JOIN w wierszu poleceń lub za pomocą skryptu PHP.

Wiersz polecenia

W wierszu polecenia po prostu użyj standardowej instrukcji -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed

mysql> SELECT products.ID_number, products.Nomenclature, inventory.inventory_ct
   FROM products
   INNER JOIN inventory
   ON products.ID_numbeer = inventory.ID_number;
+-------------+----------------+-----------------+
| ID_number   | Nomenclature   | Inventory Count |
+-------------+----------------+-----------------+
| 12345       | Orbitron 4000  | 150             |
+-------------+----------------+-----------------+
| 12346       | Orbitron 3000  | 200             |
+-------------+----------------+-----------------+
| 12347       | Orbitron 1000  | 0               |
+-------------+----------------+-----------------+

Skrypt PHP za pomocą JOIN

Użyj mysql_query() funkcja do wykonania operacji łączenia -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT a.product_id, a.product_manufacturer, b.product_count FROM products_tbl a, pcount_tbl b WHERE a.product_manufacturer = b.product_manufacturer'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Manufacturer:{$row['product_manufacturer']} <br> ".
         "Count: {$row['product_count']} <br> ". "Product ID: {$row['product_id']} <br> ".
         "--------------------------------<br>";
   }

   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

Po pomyślnym pobraniu danych zobaczysz następujący wynik -

ID Number: 12345
Nomenclature: Orbitron 4000
Inventory Count: 150
--------------------------------------
ID Number: 12346
Nomenclature: Orbitron 3000
Inventory Count: 200
--------------------------------------
ID Number: 12347
Nomenclature: Orbitron 1000
Inventory Count: 0
--------------------------------------
mysql> Fetched data successfully

Podczas pracy z wartościami NULL pamiętaj, że są to wartości nieznane. Nie są to puste łańcuchy ani zero, które są prawidłowymi wartościami. Podczas tworzenia tabeli specyfikacje kolumn pozwalają ustawić je tak, aby akceptowały wartości null lub odrzucały je. Po prostu użyj klauzuli NULL lub NOT NULL. Ma to zastosowanie w przypadku braku informacji o rekordach, takich jak numer identyfikacyjny.

Zmienne zdefiniowane przez użytkownika mają wartość NULL do momentu jawnego przypisania. Przechowywane parametry rutynowe i zmienne lokalne pozwalają na ustawienie wartości NULL. Gdy zmienna lokalna nie ma wartości domyślnej, ma wartość NULL.

NULL nie rozróżnia wielkości liter i ma następujące aliasy -

• UNKNOWN (wartość logiczna)
• \N

Operatory NULL

Standardowe operatory porównania nie mogą być używane z wartością NULL (np. =,>,> =, <=, <Lub! =), Ponieważ wszystkie porównania z wartością NULL zwracają NULL, a nie true lub false. Porównania z wartością NULL lub ewentualnie zawierające ją muszą używać operatora „<=>” (NULL-SAFE).

Inni dostępni operatorzy to -

• IS NULL - testuje wartość NULL.

• NIE JEST NULL - potwierdza brak wartości NULL.

• ISNULL - zwraca wartość 1 w przypadku wykrycia wartości NULL i 0 w przypadku jej braku.

• COALESCE - Zwraca pierwszą inną niż NULL wartość z listy lub zwraca wartość NULL w przypadku jej braku.

Sortowanie wartości NULL

W operacjach sortowania wartości NULL mają najniższą wartość, więc kolejność DESC skutkuje wartościami NULL na dole. MariaDB umożliwia ustawienie wyższej wartości dla wartości NULL.

Można to zrobić na dwa sposoby, jak pokazano poniżej -

SELECT column1 FROM product_tbl ORDER BY ISNULL(column1), column1;

W inny sposób -

SELECT column1 FROM product_tbl ORDER BY IF(column1 IS NULL, 0, 1), column1 DESC;

Funkcje NULL

Funkcje generalnie zwracają wartość NULL, gdy jakiekolwiek parametry mają wartość NULL. Istnieją jednak funkcje zaprojektowane specjalnie do zarządzania wartościami NULL. Oni są -

• IFNULL()- Jeśli pierwsze wyrażenie nie ma wartości NULL, zwraca je. Kiedy zwraca wartość NULL, zwraca drugie wyrażenie.

• NULLIF() - Zwraca NULL, gdy porównywane wyrażenia są równe, jeśli nie, zwraca pierwsze wyrażenie.

Funkcje takie jak SUMA i AVG ignorują wartości NULL.

Wstawianie wartości NULL

Po wstawieniu wartości NULL do kolumny zadeklarowanej jako NIE NULL, występuje błąd. W domyślnym trybie SQL kolumna NOT NULL wstawi zamiast tego domyślną wartość na podstawie typu danych.

Gdy pole jest TIMESTAMP, AUTO_INCREMENT lub wirtualną kolumną, MariaDB inaczej zarządza wartościami NULL. Wstawienie do kolumny AUTO_INCREMENT powoduje wstawienie następnej liczby w sekwencji w jej miejsce. W polu TIMESTAMP MariaDB przypisuje zamiast tego bieżący znacznik czasu. W kolumnach wirtualnych, temat omówiony w dalszej części tego samouczka, przypisywana jest wartość domyślna.

Indeksy UNIQUE mogą zawierać wiele wartości NULL, jednak klucze podstawowe nie mogą mieć wartości NULL.

Wartości NULL i polecenie Alter

W przypadku użycia polecenia ALTER do zmodyfikowania kolumny w przypadku braku specyfikacji NULL MariaDB automatycznie przypisuje wartości.

Oprócz dopasowywania wzorców dostępnych w klauzulach LIKE, MariaDB oferuje dopasowywanie oparte na wyrażeniach regularnych za pośrednictwem operatora REGEXP. Operator przeprowadza dopasowanie do wzorca dla wyrażenia łańcuchowego na podstawie podanego wzorca.

MariaDB 10.0.5 wprowadziła wyrażenia regularne PCRE, które radykalnie zwiększają zakres dopasowywania do takich obszarów, jak wzorce rekurencyjne, asercje przewidujące i inne.

Przejrzyj użycie standardowej składni operatora REGEXP podanej poniżej -

SELECT column FROM table_name WHERE column REGEXP '[PATTERN]';

REGEXP zwraca 1 w przypadku dopasowania do wzorca lub 0 w przypadku jego braku.

Istnieje opcja przeciwna w postaci NOT REGEXP. MariaDB oferuje również synonimy REGEXP i NOT REGEXP, RLIKE i NOT RLIKE, które zostały utworzone ze względu na kompatybilność.

Porównywany wzorzec może być literałem lub czymś innym, na przykład kolumną tabeli. W łańcuchach używa składni zmiany znaczenia w C, więc podwoj wszystkie znaki „\”. REGEXP również nie rozróżnia wielkości liter, z wyjątkiem ciągów binarnych.

Poniżej znajduje się tabela możliwych wzorów, które można wykorzystać -

Sr.No	Wzór i opis
1	^ Dopasowuje początek łańcucha.
2	$ Dopasowuje koniec struny.
3	. Pasuje do pojedynczego znaku.
4	[...] Dopasowuje dowolny znak w nawiasach.
5	[^...] Pasuje do każdego znaku niewymienionego w nawiasach.
6	p1|p2|p3 Pasuje do dowolnego wzoru.
7	* Dopasowuje 0 lub więcej wystąpień poprzedniego elementu.
8	+ Dopasowuje 1 lub więcej wystąpień poprzedniego elementu.
9	{n} Dopasowuje n wystąpień poprzedniego elementu.
10	{m,n} Dopasowuje m do n wystąpień poprzedniego elementu.

Przejrzyj przykłady dopasowania wzorca podane poniżej -

Produkty zaczynające się na literę „pr” -

SELECT name FROM product_tbl WHERE name REGEXP '^pr';

Produkty kończące się na „na” -

SELECT name FROM product_tbl WHERE name REGEXP 'na$';

Produkty zaczynające się od samogłoski -

SELECT name FROM product_tbl WHERE name REGEXP '^[aeiou]';

Transakcje to sekwencyjne operacje grupowe. Działają jako pojedyncza jednostka i nie kończą się, dopóki wszystkie operacje w grupie nie zostaną pomyślnie wykonane. Pojedyncza awaria w grupie powoduje niepowodzenie całej transakcji i nie ma wpływu na bazę danych.

Transakcje zgodne z ACID (atomowość, spójność, izolacja i trwałość) -

• Atomicity - Zapewnia powodzenie wszystkich operacji poprzez przerywanie w przypadku awarii i wycofywanie zmian.

• Consistency - Zapewnia, że ​​baza danych zastosuje zmiany po pomyślnej transakcji.

• Isolation - Umożliwia niezależną obsługę transakcji.

• Durability - Zapewnia trwałość udanej transakcji w przypadku awarii systemu.

Na początku wyciągu transakcyjnego znajduje się instrukcja START TRANSACTION, po której następują instrukcje COMMIT i ROLLBACK -

• START TRANSACTION rozpoczyna transakcję.

• COMMIT zapisuje zmiany w danych.

• ROLLBACK kończy transakcję, niszcząc wszelkie zmiany.

W przypadku pomyślnej transakcji COMMIT działa. W przypadku awarii ROLLBACK działa.

Note- Niektóre instrukcje powodują niejawne zatwierdzenie, a także powodują błąd, gdy są używane w transakcjach. Przykłady takich instrukcji to między innymi CREATE, ALTER i DROP.

Transakcje MariaDB obejmują również opcje, takie jak SAVEPOINT i LOCK TABLES. SAVEPOINT ustawia punkt przywracania do wykorzystania z ROLLBACK. LOCK TABLES umożliwia kontrolowanie dostępu do tabel podczas sesji, aby zapobiec modyfikacjom w określonych przedziałach czasu.

Zmienna AUTOCOMMIT zapewnia kontrolę nad transakcjami. Ustawienie 1 wymusza uznanie wszystkich operacji za transakcje zakończone sukcesem, a ustawienie 0 powoduje, że zmiany zachodzą tylko w przypadku jawnej instrukcji COMMIT.

Struktura transakcji

Ogólna struktura wyciągu transakcyjnego polega na rozpoczęciu od START TRANSACTION. Następnym krokiem jest wstawienie jednego lub więcej poleceń / operacji, wstawienie instrukcji sprawdzających błędy, wstawienie instrukcji ROLLBACK w celu zarządzania wykrytymi błędami, a na końcu wstawienie instrukcji COMMIT w celu zastosowania zmian w operacjach zakończonych powodzeniem.

Przejrzyj przykład podany poniżej -

START TRANSACTION;
SELECT name FROM products WHERE manufacturer = 'XYZ Corp';
UPDATE spring_products SET item = name;
COMMIT;

Polecenie ALTER umożliwia zmianę struktury istniejącej tabeli, co oznacza modyfikacje, takie jak usuwanie lub dodawanie kolumn, modyfikowanie indeksów, zmiana typów danych lub zmiana nazw. ALTER również czeka na zastosowanie zmian, gdy blokada metadanych jest aktywna.

Używanie ALTER do modyfikowania kolumn

ALTER w połączeniu z DROP usuwa istniejącą kolumnę. Jednak kończy się niepowodzeniem, jeśli kolumna jest jedyną pozostałą kolumną.

Przejrzyj przykład podany poniżej -

mysql> ALTER TABLE products_tbl DROP version_num;

Użyj instrukcji ALTER ... ADD, aby dodać kolumny -

mysql> ALTER TABLE products_tbl ADD discontinued CHAR(1);

Użyj słów kluczowych FIRST i AFTER, aby określić położenie kolumny -

ALTER TABLE products_tbl ADD discontinued CHAR(1) FIRST;
ALTER TABLE products_tbl ADD discontinued CHAR(1) AFTER quantity;

Zauważ, że słowa kluczowe FIRST i AFTER mają zastosowanie tylko do instrukcji ALTER ... ADD. Ponadto musisz usunąć tabelę, a następnie dodać ją, aby zmienić jej położenie.

Zmień definicję lub nazwę kolumny, używając klauzuli MODIFY lub CHANGE w instrukcji ALTER. Klauzule mają podobne skutki, ale wykorzystują zasadniczo inną składnię.

Przejrzyj przykład ZMIANY podany poniżej -

mysql> ALTER TABLE products_tbl CHANGE discontinued status CHAR(4);

W instrukcji używającej CHANGE określ oryginalną kolumnę, a następnie nową, która ją zastąpi. Przejrzyj poniższy przykład MODIFY -

mysql> ALTER TABLE products_tbl MODIFY discontinued CHAR(4);

Polecenie ALTER umożliwia również zmianę wartości domyślnych. Przejrzyj przykład -

mysql> ALTER TABLE products_tbl ALTER discontinued SET DEFAULT N;

Możesz go również użyć do usunięcia domyślnych ograniczeń, łącząc go z klauzulą ​​DROP -

mysql> ALTER TABLE products_tbl ALTER discontinued DROP DEFAULT;

Używanie ALTER do modyfikowania tabel

Zmień typ tabeli za pomocą klauzuli TYPE -

mysql> ALTER TABLE products_tbl TYPE = INNODB;

Zmień nazwę tabeli za pomocą słowa kluczowego RENAME -

mysql> ALTER TABLE products_tbl RENAME TO products2016_tbl;

Indeksy to narzędzia przyspieszające wyszukiwanie rekordów. Indeks tworzy wpis dla każdej wartości w indeksowanej kolumnie.

Istnieją cztery typy indeksów -

• Primary (jeden rekord reprezentuje wszystkie rekordy)

• Unique (jeden rekord reprezentuje wiele rekordów)

• Plain

• Full-Text (pozwala na wiele opcji wyszukiwania tekstowego).

Pojęcia „klucz” i „indeks” są w tym zastosowaniu identyczne.

Indeksy są powiązane z jedną lub kilkoma kolumnami i umożliwiają szybkie wyszukiwanie oraz wydajną organizację rekordów. Tworząc indeks, weź pod uwagę, które kolumny są często używane w zapytaniach. Następnie utwórz na nich jeden lub wiele indeksów. Ponadto należy wyświetlać indeksy jako zasadniczo tabele kluczy podstawowych.

Chociaż indeksy przyspieszają wyszukiwanie lub instrukcje SELECT, powodują, że wstawienia i aktualizacje przeciągają się z powodu wykonywania operacji zarówno na tabelach, jak i indeksach.

Utwórz indeks

Indeks można utworzyć za pomocą instrukcji CREATE TABLE ... INDEX lub instrukcji CREATE INDEX. Najlepszą opcją wspierającą czytelność, konserwację i sprawdzone metody jest UTWÓRZ INDEKS.

Przejrzyj ogólną składnię indeksu podaną poniżej -

CREATE [UNIQUE or FULLTEXT or...] INDEX index_name ON table_name column;

Przejrzyj przykład jego użycia -

CREATE UNIQUE INDEX top_sellers ON products_tbl product;

Upuść indeks

Możesz usunąć indeks za pomocą DROP INDEX lub ALTER TABLE ... DROP. Najlepszą opcją wspierającą czytelność, konserwację i najlepsze praktyki jest DROP INDEX.

Przejrzyj ogólną składnię wskaźnika spadku podaną poniżej -

DROP INDEX index_name ON table_name;

Przejrzyj przykład jego użycia -

DROP INDEX top_sellers ON product_tbl;

Zmień nazwę indeksu

Zmień nazwę indeksu za pomocą instrukcji ALTER TABLE. Przejrzyj jego ogólną składnię podaną poniżej -

ALTER TABLE table_name DROP INDEX index_name, ADD INDEX new_index_name;

Przejrzyj przykład jego użycia -

ALTER TABLE products_tbl DROP INDEX top_sellers, ADD INDEX top_2016sellers;

Zarządzanie indeksami

Będziesz musiał zbadać i śledzić wszystkie indeksy. Użyj opcji SHOW INDEX, aby wyświetlić wszystkie istniejące indeksy skojarzone z daną tabelą. Format wyświetlanej zawartości można ustawić za pomocą opcji takiej jak „\ G”, która określa format pionowy.

Przejrzyj następujący przykład -

mysql > SHOW INDEX FROM products_tbl\G

Statystyki tabel

Indeksy są używane w dużym stopniu do optymalizacji zapytań, biorąc pod uwagę szybszy dostęp do rekordów i dostarczane statystyki. Jednak wielu użytkowników uważa, że ​​konserwacja indeksów jest kłopotliwa. MariaDB 10.0 udostępnia tabele statystyk niezależnych od silnika pamięci masowej, które obliczają statystyki danych dla każdej tabeli w każdym silniku pamięci masowej, a nawet statystyki dla kolumn, które nie są indeksowane.

Niektóre operacje mogą korzystać z tabel tymczasowych ze względu na szybkość lub jednorazowe dane. Żywotność tabeli tymczasowej kończy się wraz z zakończeniem sesji, niezależnie od tego, czy używasz ich z wiersza poleceń, skryptu PHP, czy za pośrednictwem programu klienckiego. Nie pojawia się też w systemie w typowy sposób. Polecenie SHOW TABLES nie ujawnia listy zawierającej tabele tymczasowe.

Utwórz tabelę tymczasową

Słowo kluczowe TEMPORARY w instrukcji CREATE TABLE powoduje utworzenie tabeli tymczasowej. Przejrzyj przykład podany poniżej -

mysql>CREATE TEMPORARY TABLE order (
   item_name VARCHAR(50) NOT NULL
   , price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   , quantity INT UNSIGNED NOT NULL DEFAULT 0
);

Tworząc tabelę tymczasową, możesz sklonować istniejące tabele, czyli wszystkie ich ogólne cechy, za pomocą klauzuli LIKE. Instrukcja CREATE TABLE używana do tworzenia tabeli tymczasowej nie zatwierdza transakcji w wyniku słowa kluczowego TEMPORARY.

Chociaż tabele tymczasowe różnią się od nietymczasowych i spadają pod koniec sesji, mogą mieć pewne konflikty -

• Czasami powodują konflikty z tymczasowymi tabelami widm z wygasłych sesji.

• Czasami powodują konflikty z nazwami cieni nie tymczasowych tabel.

Note - Tabele tymczasowe mogą mieć taką samą nazwę jak istniejąca tabela nie tymczasowa, ponieważ MariaDB postrzega ją jako odniesienie do różnicy.

Administracja

MariaDB wymaga nadania użytkownikom uprawnień do tworzenia tabel tymczasowych. Skorzystaj z instrukcji GRANT, aby nadać to uprawnienie użytkownikom niebędącym administratorami.

GRANT CREATE TEMPORARY TABLES ON orders TO 'machine122'@'localhost';

Upuść tabelę tymczasową

Chociaż tabele tymczasowe są zasadniczo usuwane pod koniec sesji, możesz je usunąć. Usuwanie tabeli tymczasowej wymaga użycia słowa kluczowego TEMPORARY, a najlepsze praktyki sugerują usuwanie tabel tymczasowych przed wszystkimi nietymczasowymi.

mysql> DROP TABLE order;

Niektóre sytuacje wymagają stworzenia dokładnej kopii istniejącej tabeli. Instrukcja CREATE ... SELECT nie może wygenerować tego wyniku, ponieważ pomija takie elementy, jak indeksy i wartości domyślne.

Procedura powielania tabeli jest następująca -

• Użyj polecenia SHOW CREATE TABLE, aby utworzyć instrukcję CREATE TABLE, która szczegółowo opisuje całą strukturę tabeli źródłowej.

• Edytuj instrukcję, aby nadać tabeli nową nazwę, i wykonaj ją.

• Użyj instrukcji INSERT INTO ... SELECT, jeśli chcesz również skopiować dane tabeli.

mysql> INSERT INTO inventory_copy_tbl (
   product_id,product_name,product_manufacturer,ship_date)
   
   SELECT product_id,product_name,product_manufacturer,ship_date,
   FROM inventory_tbl;

Inną metodą tworzenia duplikatu jest instrukcja CREATE TABLE AS. Instrukcja kopiuje wszystkie kolumny, definicje kolumn i wypełnia kopię danymi tabeli źródłowej.

Przejrzyj jego składnię podaną poniżej -

CREATE TABLE clone_tbl AS
   SELECT columns
   FROM original_tbl
   WHERE conditions];

Przejrzyj przykład jego użycia poniżej -

CREATE TABLE products_copy_tbl AS
   SELECT *
   FROM products_tbl;

W wersji 10.0.3 MariaDB wprowadziła mechanizm pamięci masowej znany jako sekwencja. Jego ad hoc generuje sekwencję liczb całkowitych dla operacji, a następnie kończy działanie. Sekwencja zawiera dodatnie liczby całkowite w kolejności malejącej lub rosnącej i używa wartości początkowej, końcowej i przyrostu.

Nie pozwala na użycie w wielu zapytaniach, tylko w swoim pierwotnym zapytaniu ze względu na jego wirtualną (nie zapisywaną na dysku) naturę. Jednak tabele sekwencji można konwertować na standardowe tabele za pomocą polecenia ALTER. Jeśli przekonwertowana tabela zostanie usunięta, tabela sekwencji nadal istnieje. Sekwencje nie mogą również generować liczb ujemnych ani obracać się na minimum / maksimum.

Instalowanie mechanizmu sekwencyjnego

Korzystanie z sekwencji wymaga zainstalowania silnika sekwencji, który MariaDB dystrybuuje jako wtyczkę, a nie plik binarny. Zainstaluj go za pomocą następującego polecenia -

INSTALL SONAME "ha_sequence";

Po instalacji sprawdź to -

SHOW ENGINES\G

Należy pamiętać, że po zainstalowaniu silnika nie można utworzyć standardowej tabeli z nazwą używającą składni sekwencji, ale można utworzyć tabelę tymczasową z nazwą składni sekwencji.

Tworzenie sekwencji

Istnieją dwie metody tworzenia sekwencji -

• Utwórz tabelę i użyj atrybutu AUTO_INCREMENT, aby zdefiniować kolumnę jako automatyczną inkrementację.

• Użyj istniejącej bazy danych i użyj zapytania SELECT sekwencji, aby utworzyć sekwencję. Zapytanie używa składni seq_ [FROM] _to_ [TO] lub seq_ [FROM] _to_ [TO] _step_STEP.

Najlepsze praktyki preferują użycie drugiej metody. Przejrzyj przykład tworzenia sekwencji podany poniżej -

SELECT * FROM seq_77_to_99;

Sekwencje mają wiele zastosowań -

• Zlokalizuj brakujące wartości w kolumnie, aby zabezpieczyć się przed powiązanymi problemami w operacjach -

SELECT myseq.seq FROM seq_22_to_28 myseq LEFT JOIN table1 t ON myseq.seq
   = x.y WHERE x.y IS NULL;

• Skonstruuj kombinację wartości -

SELECT x1.seq, x2.seq FROM seq_5_to_9 x1 JOIN seq_5_to_9 x2 ORDER BY 5, 6;

• Znajdź wielokrotności liczby -

SELECT seq FROM seq_3_to_100_step_4;

• Skonstruuj sekwencję dat do użycia w aplikacjach, takich jak systemy rezerwacji.
• Skonstruuj sekwencję czasową.

MariaDB, jak omówiono we wcześniejszych lekcjach, umożliwia w niektórych sytuacjach zduplikowane rekordy i tabele. Niektóre z tych duplikatów nie są w rzeczywistości duplikatami z powodu różnych typów danych lub obiektów lub w wyniku unikalnej długości życia lub przechowywania obiektu operacji. Te duplikaty również zazwyczaj nie stanowią problemu.

W niektórych sytuacjach duplikaty powodują problemy i często pojawiają się z powodu niejawnych działań lub łagodnej polityki polecenia MariaDB. Istnieją sposoby kontrolowania tego problemu, znajdowania duplikatów, usuwania duplikatów i zapobiegania tworzeniu duplikatów.

Strategie i narzędzia

Istnieją cztery kluczowe sposoby zarządzania duplikatami -

• Wyławiaj je za pomocą JOIN i usuwaj je za pomocą tymczasowej tabeli.

• Użyj INSERT ... ON DUPLICATE KEY UPDATE, aby zaktualizować po wykryciu duplikatu.

• Użyj DISTINCT, aby przyciąć wyniki instrukcji SELECT i usunąć duplikaty.

• Użyj INSERT IGNORE, aby zatrzymać wstawianie duplikatów.

Korzystanie z łączenia z tabelą tymczasową

Po prostu wykonaj sprzężenie połowiczne, takie jak sprzężenie wewnętrzne, a następnie usuń duplikaty znalezione w tabeli tymczasowej.

Korzystanie z INSERT

Kiedy INSERT ... ON DUPLICATE KEY UPDATE wykryje zduplikowany klucz unikalny lub podstawowy, przeprowadza aktualizację. Po wykryciu wielu unikalnych kluczy aktualizuje tylko pierwszy. Dlatego nie używaj go w tabelach z wieloma unikalnymi indeksami.

Zapoznaj się z poniższym przykładem, który pokazuje, co dzieje się w tabeli zawierającej indeksowane wartości po wstawieniu do wypełnionego pola -

INSERT INTO add_dupl VALUES (1,'Apple');
ERROR 1062 (23000): Duplicate entry '1' for key 'PRIMARY'

Note - Jeśli nie znajdzie klucza, instrukcja INSERT ... ON DUPLICATE KEY UPDATE jest wykonywana jak zwykła instrukcja insert.

Korzystanie z DISTINCT

Klauzule DISTINCT usuwają duplikaty z wyników. Ogólna składnia klauzuli DISTINCT jest następująca -

SELECT DISTINCT fields
FROM table
[WHERE conditions];

Note - Wyniki instrukcji z klauzulą ​​DISTINCT -

• Używając jednego wyrażenia, zwraca dla niego unikalne wartości.

• W przypadku używania wielu wyrażeń zwraca unikalne kombinacje.

• Nie ignoruje wartości NULL; w związku z tym wyniki zawierają również wartości NULL jako unikalne wartości.

Przejrzyj następującą instrukcję, używając klauzuli DISTINCT dla pojedynczego wyrażenia -

SELECT DISTINCT product_id
FROM products
WHERE product_name = 'DustBlaster 5000';

Przejrzyj poniższy przykład z użyciem wielu wyrażeń -

SELECT DISTINCT product_name, product_id
FROM products
WHERE product_id < 30

Używanie INSERT IGNORE

Instrukcja INSERT IGNORE instruuje MariaDB, aby anulowała wstawianie po wykryciu zduplikowanego rekordu. Przejrzyj przykład jego zastosowania podany poniżej -

mysql> INSERT IGNORE INTO customer_tbl (LN, FN)
   VALUES( 'Lex', 'Luther');

Zwróć także uwagę na logikę stojącą za duplikatami. Niektóre tabele wymagają duplikatów ze względu na charakter danych w tej tabeli. Uwzględnij tę potrzebę w swojej strategii zarządzania zduplikowanymi rekordami.

Prosty akt akceptacji danych wejściowych użytkownika otwiera drzwi do exploitów. Problem wynika przede wszystkim z logicznego zarządzania danymi, ale na szczęście dość łatwo jest uniknąć tych poważnych błędów.

Okazje do wstrzyknięcia SQL zwykle występują, gdy użytkownicy wprowadzają dane, takie jak nazwa, a logika kodu nie analizuje tych danych wejściowych. Kod zamiast tego umożliwia atakującemu wstawienie instrukcji MariaDB, która będzie działać w bazie danych.

Zawsze uwzględniaj dane wprowadzone przez użytkowników, podejrzewaj i wymagają silnej weryfikacji przed jakimkolwiek przetwarzaniem. Przeprowadź tę weryfikację poprzez dopasowanie wzorców. Na przykład, jeśli oczekiwanym wejściem jest nazwa użytkownika, ogranicz wprowadzane znaki do znaków alfanumerycznych i podkreśleń oraz do określonej długości. Przejrzyj przykład podany poniżej -

if(check_match("/^\w{8,20}$/", $_GET['user_name'], $matches)) {
   $result = mysql_query("SELECT * FROM system_users WHERE user_name = $matches[0]");
} else {
   echo "Invalid username";
}

Skorzystaj również z operatora REGEXP i klauzul LIKE podczas tworzenia ograniczeń wejściowych.

Rozważ wszystkie rodzaje koniecznej jawnej kontroli danych wejściowych, takie jak -

• Kontroluj używane znaki ucieczki.

• Kontroluj określone typy danych wejściowych. Ogranicz dane wejściowe do wymaganego typu i rozmiaru danych.

• Kontroluj składnię wprowadzanych danych. Nie zezwalaj na nic poza wymaganym wzorem.

• Kontroluj dozwolone warunki. Czarna lista słów kluczowych SQL.

Możesz nie znać niebezpieczeństw związanych z atakami iniekcyjnymi lub uważać je za nieistotne, ale znajdują się one na szczycie listy zagrożeń bezpieczeństwa. Ponadto weźmy pod uwagę wpływ tych dwóch wpisów -

1=1
-or-
*

Kod umożliwiający wprowadzenie któregokolwiek z nich wraz z odpowiednim poleceniem może skutkować ujawnieniem wszystkich danych użytkownika w bazie lub usunięciem wszystkich danych w bazie, a żadne z nich nie jest szczególnie sprytne. W niektórych przypadkach napastnicy nie spędzają nawet czasu na badaniu dziur; wykonują ataki na ślepo z prostym wejściem.

Weź również pod uwagę narzędzia do dopasowywania wzorców i wyrażeń regularnych oferowane przez dowolny język programowania / skryptów w połączeniu z MariaDB, które zapewniają większą kontrolę, a czasem lepszą kontrolę.

Dane służą jako podstawa biznesu i operacji, a przy różnych możliwych zagrożeniach (np. Napastnikach, awariach systemu, złych aktualizacjach i błędach konserwacji) kopie zapasowe pozostają krytyczne. Te kopie zapasowe mają wiele form i istnieje wiele opcji tworzenia ich z jeszcze szerszym zestawem opcji w ramach tych procesów. Ważne rzeczy do zapamiętania to typ bazy danych, krytyczne informacje i struktura. Te informacje określają najlepszą opcję.

OPCJE

Główne opcje kopii zapasowych obejmują kopie zapasowe logiczne i kopie fizyczne. Logiczne kopie zapasowe zawierają instrukcje SQL do przywracania danych. Fizyczne kopie zapasowe zawierają kopie danych.

• Logical backupsoferują elastyczność przywracania danych na innym komputerze o innej konfiguracji w przeciwieństwie do fizycznych kopii zapasowych, które często są ograniczone do tego samego komputera i typu bazy danych. Logiczne kopie zapasowe są tworzone na poziomie bazy danych i tabeli, a fizyczne na poziomie katalogu i pliku.

• Physical backupssą mniejsze niż logiczne, a także ich wykonanie i przywrócenie zajmuje mniej czasu. Fizyczne kopie zapasowe obejmują również pliki dziennika i pliki konfiguracyjne, ale logiczne kopie zapasowe nie.

Narzędzia do tworzenia kopii zapasowych

Głównym narzędziem używanym do tworzenia kopii zapasowych MariaDB jest mysqldump. Oferuje logiczne kopie zapasowe i elastyczność. Doskonale sprawdza się również w przypadku małych baz danych.Mysqldumpzrzuca dane do formatu SQL, CSV, XML i wielu innych formatów. Jego dane wyjściowe nie zachowują procedur składowanych, widoków i zdarzeń bez jawnych instrukcji.

Istnieją trzy opcje mysqldump kopie zapasowe -

• Raw data - Zrzuć tabelę jako nieprzetworzony plik danych za pomocą opcji --tab, która określa również miejsce docelowe pliku -

$ mysqldump -u root -p --no-create-info \
   --tab=/tmp PRODUCTS products_tbl

• Data/Definitions export- Ta opcja umożliwia wyeksportowanie jednej lub wielu tabel do pliku i obsługuje tworzenie kopii zapasowych wszystkich istniejących baz danych na komputerze głównym. Przeanalizuj przykład eksportowania zawartości lub definicji do pliku

$ mysqldump -u root -p PRODUCTS products_tbl > export_file.txt

• Transfer - Możesz także wyprowadzać bazy danych i tabele do innego hosta

$ mysqldump -u root -p database_name \
   | mysql -h other-host.com database_name

Używanie instrukcji SELECT ... INTO OUTFILE

Inna opcja eksportowania danych wykorzystuje instrukcję SELECT ... INTO OUTFILE. Ta prosta opcja umieszcza tabelę w prostym, sformatowanym pliku tekstowym -

mysql> SELECT * FROM products_tbl
   -> INTO OUTFILE '/tmp/products.txt';

Jego atrybuty umożliwiają formatowanie pliku zgodnie z preferowanymi specyfikacjami.

Zwróć uwagę na następujące cechy tego stwierdzenia -

• Nazwa pliku musi określać żądaną lokalizację danych wyjściowych.

• Do wykonania instrukcji potrzebne są uprawnienia do pliku MariaDB.

• Nazwa pliku wyjściowego musi być unikalna.

• Potrzebujesz danych logowania na hoście.

• W środowisku UNIX plik wyjściowy można odczytać na całym świecie, ale jego własność na serwerze wpływa na możliwość jego usunięcia. Upewnij się, że masz uprawnienia.

Używanie CONNECT w kopiach zapasowych

Procedura obsługi CONNECT umożliwia eksport danych. Jest to przydatne przede wszystkim w sytuacjach, gdy operacja SELECT ... INTO OUTFILE nie obsługuje formatu pliku.

Przejrzyj następujący przykład -

create table products
engine = CONNECT table_type = XML file_name = 'products.htm' header = yes
option_list = 'name = TABLE,coltype = HTML,attribute = border = 1;cellpadding = 5'

select plugin_name handler, plugin_version version, plugin_author
author, plugin_description description, plugin_maturity maturity
from information_schema.plugins where plugin_type = 'STORAGE ENGINE';

Inne narzędzia

Inne opcje kopii zapasowych są następujące -

• XtraBackup- Ta opcja jest przeznaczona dla baz danych XtraDB / InnoDB i działa z dowolnym silnikiem pamięci masowej. Dowiedz się więcej o tym narzędziu z oficjalnej strony firmy Percona.

• Snapshots- Niektóre systemy plików pozwalają na tworzenie migawek. Proces składa się z opróżnienia tabel z blokadą odczytu, zamontowania migawki, odblokowania tabel, skopiowania migawki, a następnie odmontowania migawki.

• LVM- Ta popularna metoda wykorzystuje skrypt Perla. Pobiera blokadę odczytu na każdej tabeli i opróżnia pamięć podręczną na dysk. Następnie pobiera migawkę i odblokowuje tabele. Skonsultuj się z urzędnikiemmylvmbackup aby uzyskać więcej informacji.

• TokuBackup- To rozwiązanie dostarczane przez firmę Percona zapewnia tworzenie kopii zapasowych na gorąco, biorąc pod uwagę problemy i ograniczenia opcji tworzenia kopii zapasowych InnoDB. Tworzy transakcyjną kopię dźwiękową plików, podczas gdy aplikacje nadal nimi manipulują. Więcej informacji można znaleźć w witrynie internetowej firmy Percona.

Uwagi dotyczące INNODB

InnoDB używa puli buforów do zwiększenia wydajności. Podczas tworzenia kopii zapasowej skonfiguruj InnoDB, aby uniknąć kopiowania całej tabeli do puli buforów, ponieważ logiczne kopie zapasowe zwykle wykonują pełne skanowanie tabeli.

W tym rozdziale poznamy różne metody ładowania kopii zapasowych. Przywracanie bazy danych z kopii zapasowej to prosty i czasami strasznie długi proces.

Istnieją trzy opcje ładowania danych: instrukcja LOAD DATA, mysqlimport i proste przywracanie mysqldump.

Korzystanie z LOAD DATA

Instrukcja LOAD DATA działa jako moduł ładujący zbiorczo. Zapoznaj się z przykładem jego użycia, który ładuje plik tekstowy -

mysql> LOAD DATA LOCAL INFILE 'products_copy.txt' INTO TABLE empty_tbl;

Zwróć uwagę na następujące cechy instrukcji LOAD DATA -

• Użyj słowa kluczowego LOCAL, aby uniemożliwić MariaDB wykonanie dokładnego wyszukiwania hosta i użyj bardzo określonej ścieżki.

• Instrukcja przyjmuje format składający się z wierszy zakończonych znakami nowej linii (nowe linie) i wartości danych oddzielonych tabulatorami.

• Użyj klauzuli FIELDS, aby jawnie określić formatowanie pól w wierszu. Użyj klauzuli LINES, aby określić koniec linii. Przejrzyj poniższy przykład.

mysql> LOAD DATA LOCAL INFILE 'products_copy.txt' INTO TABLE empty_tbl
   FIELDS TERMINATED BY '|'
   LINES TERMINATED BY '\n';

• Instrukcja zakłada, że ​​kolumny w pliku danych używają tej samej kolejności w tabeli. Jeśli chcesz ustawić inną kolejność, możesz załadować plik w następujący sposób -

mysql> LOAD DATA LOCAL INFILE 'products_copy.txt' INTO TABLE empty_tbl (c, b, a);

Korzystanie z MYSQLIMPORT

Narzędzie mysqlimport działa jako opakowanie LOAD DATA, pozwalając na te same operacje z wiersza poleceń.

Załaduj dane w następujący sposób -

$ mysqlimport -u root -p --local database_name source_file.txt

Określ formatowanie w następujący sposób -

$ mysqlimport -u root -p --local --fields-terminated-by="|" \
   --lines-terminated-by="\n" database_name source_file.txt

Użyj --columns możliwość określenia kolejności kolumn -

$ mysqlimport -u root -p --local --columns=c,b,a \
   database_name source_file.txt

Korzystanie z MYSQLDUMP

Przywracanie za pomocą mysqldump wymaga tej prostej instrukcji do załadowania pliku zrzutu z powrotem do hosta -

shell> mysql database_name < source_file.sql

SPECJALNE ZNAKI I CYTATY

W instrukcji LOAD DATA cudzysłowy i znaki specjalne mogą nie być poprawnie interpretowane. Instrukcja przyjmuje wartości niecytowane i traktuje ukośniki odwrotne jako znaki ucieczki. Użyj klauzuli FIELDS, aby określić formatowanie. Wskaż cudzysłowy za pomocą „ZAŁĄCZONE PRZEZ”, co powoduje usuwanie cudzysłowów z wartości danych. Zmień ucieczki za pomocą „ESCAPED BY”.

Ten rozdział zawiera listę najczęściej używanych funkcji wraz z definicjami, objaśnieniami i przykładami.

Funkcje agregujące MariaDB

Najczęściej używane funkcje agregujące podano poniżej -

Sr.No	Nazwa i opis
1	COUNT Zlicza liczbę rekordów. Example - WYBIERZ LICZBĘ (*) Z tabeli customer_table;
2	MIN Ujawnia minimalną wartość zbioru rekordów. Example - WYBIERZ organizację, MIN (konto) Z umów GRUPA WEDŁUG organizacji;
3	MAX Ujawnia maksymalną wartość zbioru rekordów. Example - WYBIERZ organizację, MAX (account_size) FROM kontraktów GROUP BY organizacja;
4	AVG Oblicza średnią wartość zbioru rekordów. Example - WYBIERZ AVG (account_size) Z umów;
5	SUM Oblicza sumę zbioru rekordów. Example - SUMA WYBORU (rozmiar_konta) z umów;

Obliczanie wieku MariaDB

Plik TIMESTAMPDIFF funkcja umożliwia obliczenie wieku -

SELECT CURDATE() AS today;
SELECT ID, DOB, TIMESTAMPDIFF(YEAR,DOB,'2015-07-01') AS age FROM officer_info;

MariaDB konkatenacja ciągów znaków

Plik CONCATfunkcja zwraca wynikowy ciąg po operacji konkatenacji. Możesz użyć jednego lub więcej argumentów. Przejrzyj jego składnię podaną poniżej -

SELECT CONCAT(item, item,...);

Przejrzyj następujący przykład -

SELECT CONCAT('Ram', 'bu', 'tan');
Output:Rambutan

Funkcje daty / godziny MariaDB

Poniżej podano ważne funkcje daty -

Sr.No	Nazwa i opis
1	CURDATE() Zwraca datę w formacie rrrr-mm-dd lub rrrrmmdd. Example - SELECT CURDATE ();
2	DATE() Zwraca datę w wielu formatach. Example −CREATE TABLE product_release_tbl (x DATA);
3	CURTIME() Zwraca czas w formacie HH: MM: SS lub HHMMSS.uuuuuu. Example - SELECT CURTIME ();
4	DATE_SUB() Dodaje lub odejmuje liczbę dni od określonej daty. Example - SELECT DATE_SUB ('2016-02-08', INTERWAŁ 60 DNI);
5	DATEDIFF() Określa dni między dwiema datami. Example - WYBIERZ DATEDIFF („2016-01-01 23:59:59”, „2016-01-03”);
6	DATE ADD() Dodaje lub odejmuje dowolną jednostkę czasu do / od daty i godziny. Example - SELECT DATE_ADD ('2016-01-04 23:59:59', INTERVAL 22 SECOND);
7	EXTRACT() Wydobywa jednostkę z daty. Example - WYBIERZ WYCIĄG (ROK OD „2016-01-08”);
8	NOW() Zwraca bieżącą datę i godzinę w formacie rrrr-mm-dd gg: mm: ss lub rrrrmmddggmmss.uuuuuu. Example - WYBIERZ TERAZ ();
9	DATE FORMAT() Formatuje datę zgodnie z określonym ciągiem formatu. Example - SELECT DATE_FORMAT ('2016-01-09 20:20:00', '% W% M% Y');

Oto kilka ważnych funkcji czasu -

Sr.No	Nazwa i opis
1	HOUR() Zwraca godzinę czasu lub godziny, które upłynęły. Example - WYBIERZ GODZINĘ ('19:17: 09');
2	LOCALTIME() Działa dokładnie tak, jak TERAZ ().
3	MICROSECOND() Zwraca mikrosekundy czasu. Example - SELECT MICROSECOND ('16: 30: 00.543876 ');
4	MINUTE() Zwraca minuty czasu. Example - WYBIERZ MINUTĘ („2016-05-22 17:22:01”);
5	SECOND() Zwraca sekundy daty. Example - SELECT SECOND ('2016-03-12 16: 30: 04.000001');
6	TIME_FORMAT() Formatuje czas zgodnie z określonym ciągiem formatu. Example - SELECT TIME_FORMAT ('22: 02: 20 ','% H% k% h% I% l ');
7	TIMESTAMP() Zawiera sygnaturę czasową działania w formacie rrrr-mm-dd gg: mm: dd. Example - TWORZENIE TABELI zamówień_ (ID INT, tmst TIMESTAMP);

Funkcje numeryczne MariaDB

Poniżej podano kilka ważnych funkcji numerycznych w MariaDB -

Sr.No	Nazwa i opis
1	TRUNCATE() Zwraca liczbę obciętą do specyfikacji miejsca dziesiętnego. Example - SELECT TRUNCATE (101.222, 1);
2	COS() Zwraca cosinus z x radianów. Example - WYBIERZ COS (PI ());
3	CEILING() Zwraca najmniejszą liczbę całkowitą nie mniejszą niż x. Example - WYBIERZ SUFIT (2.11);
4	DEGREES() Konwertuje radiany na stopnie. Example - WYBIERZ STOPNIE (PI ());
5	DIV() Wykonuje dzielenie liczb całkowitych. Example - SELECT 100 DIV 4;
6	EXP() Zwraca e do potęgi x. Example - WYBIERZ EXP (2);
7	FLOOR() Zwraca największą liczbę całkowitą nie większą niż x. Example - WYBIERZ PODŁOGĘ (2.01);
8	LN() Zwraca logarytm naturalny z x. Example - WYBIERZ LN (3);
9	LOG() Zwraca logarytm naturalny lub logarytm do zadanej podstawy. Example - WYBIERZ DZIENNIK (3);
10	SQRT() Zwraca pierwiastek kwadratowy. Example - WYBIERZ SQRT (16);

Funkcje ciągów MariaDB

Ważne funkcje ciągów podano poniżej -

Sr.No	Nazwa i opis
1	INSTR() Zwraca pozycję pierwszego wystąpienia podciągu. Example - SELECT INSTR („rambutan”, „tan”);
2	RIGHT() Zwraca skrajne prawe znaki ciągu. Example - SELECT RIGHT („rambutan”, 3);
3	LENGTH() Zwraca długość w bajtach łańcucha. Example - SELECT LENGTH („rambutan”);
4	LOCATE() Zwraca pozycję pierwszego wystąpienia podciągu. Example - SELECT LOCATE („tan”, „rambutan”);
5	INSERT() Zwraca łańcuch z określonym podciągiem na określonej pozycji, który został zmodyfikowany. Example - SELECT INSERT („ramputan”, 4, 1, „b”);
6	LEFT() Zwraca skrajne lewe znaki. Example - SELECT LEFT („rambutan”, 3);
7	UPPER() Zmienia znaki na wielkie litery. Example - SELECT UPPER (nazwisko);
8	LOWER() Zmienia znaki na małe litery. Example - SELECT LOWER (nazwisko);
9	STRCMP() Porównuje ciągi znaków i zwraca 0, gdy są równe. Example - SELECT STRCMP („jajko”, „ser”);
10	REPLACE() Zwraca łańcuch po zamianie znaków. Example - SELECT REPLACE („sully”, „l”, „n”);
11	REVERSE() Odwraca znaki w ciągu. Example - SELECT REVERSE („samochód wyścigowy”);
12	REPEAT() Zwraca łańcuch powtarzający podane znaki x razy. Example - SELECT REPEAT („ha”, 10);
13	SUBSTRING() Zwraca podciąg z łańcucha, zaczynając od pozycji x. Example - WYBIERZ PODCIĄG („rambutan”, 3);
14	TRIM() Usuwa końcowe / wiodące znaki z ciągu. Example - WYBIERZ WYKOŃCZENIE (WIODĄCY „_” Z „_rambutan”);